1 //===--- ASTReader.cpp - AST File Reader ------------------------*- C++ -*-===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file defines the ASTReader class, which reads AST files.
11 //
12 //===----------------------------------------------------------------------===//
13
14 #include "clang/Serialization/ASTReader.h"
15 #include "clang/Serialization/ASTDeserializationListener.h"
16 #include "clang/Serialization/ModuleManager.h"
17 #include "clang/Serialization/SerializationDiagnostic.h"
18 #include "ASTCommon.h"
19 #include "ASTReaderInternals.h"
20 #include "clang/Sema/Sema.h"
21 #include "clang/Sema/Scope.h"
22 #include "clang/AST/ASTConsumer.h"
23 #include "clang/AST/ASTContext.h"
24 #include "clang/AST/DeclTemplate.h"
25 #include "clang/AST/Expr.h"
26 #include "clang/AST/ExprCXX.h"
27 #include "clang/AST/NestedNameSpecifier.h"
28 #include "clang/AST/Type.h"
29 #include "clang/AST/TypeLocVisitor.h"
30 #include "clang/Lex/MacroInfo.h"
31 #include "clang/Lex/PreprocessingRecord.h"
32 #include "clang/Lex/Preprocessor.h"
33 #include "clang/Lex/HeaderSearch.h"
34 #include "clang/Basic/OnDiskHashTable.h"
35 #include "clang/Basic/SourceManager.h"
36 #include "clang/Basic/SourceManagerInternals.h"
37 #include "clang/Basic/FileManager.h"
38 #include "clang/Basic/FileSystemStatCache.h"
39 #include "clang/Basic/TargetInfo.h"
40 #include "clang/Basic/Version.h"
41 #include "clang/Basic/VersionTuple.h"
42 #include "llvm/ADT/StringExtras.h"
43 #include "llvm/Bitcode/BitstreamReader.h"
44 #include "llvm/Support/MemoryBuffer.h"
45 #include "llvm/Support/ErrorHandling.h"
46 #include "llvm/Support/FileSystem.h"
47 #include "llvm/Support/Path.h"
48 #include "llvm/Support/SaveAndRestore.h"
49 #include "llvm/Support/system_error.h"
50 #include <algorithm>
51 #include <iterator>
52 #include <cstdio>
53 #include <sys/stat.h>
54
55 using namespace clang;
56 using namespace clang::serialization;
57 using namespace clang::serialization::reader;
58
59 //===----------------------------------------------------------------------===//
60 // PCH validator implementation
61 //===----------------------------------------------------------------------===//
62
~ASTReaderListener()63 ASTReaderListener::~ASTReaderListener() {}
64
65 bool
ReadLanguageOptions(const LangOptions & LangOpts)66 PCHValidator::ReadLanguageOptions(const LangOptions &LangOpts) {
67 const LangOptions &PPLangOpts = PP.getLangOpts();
68
69 #define LANGOPT(Name, Bits, Default, Description) \
70 if (PPLangOpts.Name != LangOpts.Name) { \
71 Reader.Diag(diag::err_pch_langopt_mismatch) \
72 << Description << LangOpts.Name << PPLangOpts.Name; \
73 return true; \
74 }
75
76 #define VALUE_LANGOPT(Name, Bits, Default, Description) \
77 if (PPLangOpts.Name != LangOpts.Name) { \
78 Reader.Diag(diag::err_pch_langopt_value_mismatch) \
79 << Description; \
80 return true; \
81 }
82
83 #define ENUM_LANGOPT(Name, Type, Bits, Default, Description) \
84 if (PPLangOpts.get##Name() != LangOpts.get##Name()) { \
85 Reader.Diag(diag::err_pch_langopt_value_mismatch) \
86 << Description; \
87 return true; \
88 }
89
90 #define BENIGN_LANGOPT(Name, Bits, Default, Description)
91 #define BENIGN_ENUM_LANGOPT(Name, Type, Bits, Default, Description)
92 #include "clang/Basic/LangOptions.def"
93
94 return false;
95 }
96
ReadTargetTriple(StringRef Triple)97 bool PCHValidator::ReadTargetTriple(StringRef Triple) {
98 if (Triple == PP.getTargetInfo().getTriple().str())
99 return false;
100
101 Reader.Diag(diag::warn_pch_target_triple)
102 << Triple << PP.getTargetInfo().getTriple().str();
103 return true;
104 }
105
106 namespace {
107 struct EmptyStringRef {
operator ()__anon606000880111::EmptyStringRef108 bool operator ()(StringRef r) const { return r.empty(); }
109 };
110 struct EmptyBlock {
operator ()__anon606000880111::EmptyBlock111 bool operator ()(const PCHPredefinesBlock &r) const {return r.Data.empty();}
112 };
113 }
114
EqualConcatenations(SmallVector<StringRef,2> L,PCHPredefinesBlocks R)115 static bool EqualConcatenations(SmallVector<StringRef, 2> L,
116 PCHPredefinesBlocks R) {
117 // First, sum up the lengths.
118 unsigned LL = 0, RL = 0;
119 for (unsigned I = 0, N = L.size(); I != N; ++I) {
120 LL += L[I].size();
121 }
122 for (unsigned I = 0, N = R.size(); I != N; ++I) {
123 RL += R[I].Data.size();
124 }
125 if (LL != RL)
126 return false;
127 if (LL == 0 && RL == 0)
128 return true;
129
130 // Kick out empty parts, they confuse the algorithm below.
131 L.erase(std::remove_if(L.begin(), L.end(), EmptyStringRef()), L.end());
132 R.erase(std::remove_if(R.begin(), R.end(), EmptyBlock()), R.end());
133
134 // Do it the hard way. At this point, both vectors must be non-empty.
135 StringRef LR = L[0], RR = R[0].Data;
136 unsigned LI = 0, RI = 0, LN = L.size(), RN = R.size();
137 (void) RN;
138 for (;;) {
139 // Compare the current pieces.
140 if (LR.size() == RR.size()) {
141 // If they're the same length, it's pretty easy.
142 if (LR != RR)
143 return false;
144 // Both pieces are done, advance.
145 ++LI;
146 ++RI;
147 // If either string is done, they're both done, since they're the same
148 // length.
149 if (LI == LN) {
150 assert(RI == RN && "Strings not the same length after all?");
151 return true;
152 }
153 LR = L[LI];
154 RR = R[RI].Data;
155 } else if (LR.size() < RR.size()) {
156 // Right piece is longer.
157 if (!RR.startswith(LR))
158 return false;
159 ++LI;
160 assert(LI != LN && "Strings not the same length after all?");
161 RR = RR.substr(LR.size());
162 LR = L[LI];
163 } else {
164 // Left piece is longer.
165 if (!LR.startswith(RR))
166 return false;
167 ++RI;
168 assert(RI != RN && "Strings not the same length after all?");
169 LR = LR.substr(RR.size());
170 RR = R[RI].Data;
171 }
172 }
173 }
174
175 static std::pair<FileID, StringRef::size_type>
FindMacro(const PCHPredefinesBlocks & Buffers,StringRef MacroDef)176 FindMacro(const PCHPredefinesBlocks &Buffers, StringRef MacroDef) {
177 std::pair<FileID, StringRef::size_type> Res;
178 for (unsigned I = 0, N = Buffers.size(); I != N; ++I) {
179 Res.second = Buffers[I].Data.find(MacroDef);
180 if (Res.second != StringRef::npos) {
181 Res.first = Buffers[I].BufferID;
182 break;
183 }
184 }
185 return Res;
186 }
187
ReadPredefinesBuffer(const PCHPredefinesBlocks & Buffers,StringRef OriginalFileName,std::string & SuggestedPredefines,FileManager & FileMgr)188 bool PCHValidator::ReadPredefinesBuffer(const PCHPredefinesBlocks &Buffers,
189 StringRef OriginalFileName,
190 std::string &SuggestedPredefines,
191 FileManager &FileMgr) {
192 // We are in the context of an implicit include, so the predefines buffer will
193 // have a #include entry for the PCH file itself (as normalized by the
194 // preprocessor initialization). Find it and skip over it in the checking
195 // below.
196 SmallString<256> PCHInclude;
197 PCHInclude += "#include \"";
198 PCHInclude += HeaderSearch::NormalizeDashIncludePath(OriginalFileName,
199 FileMgr);
200 PCHInclude += "\"\n";
201 std::pair<StringRef,StringRef> Split =
202 StringRef(PP.getPredefines()).split(PCHInclude.str());
203 StringRef Left = Split.first, Right = Split.second;
204 if (Left == PP.getPredefines()) {
205 Error("Missing PCH include entry!");
206 return true;
207 }
208
209 // If the concatenation of all the PCH buffers is equal to the adjusted
210 // command line, we're done.
211 SmallVector<StringRef, 2> CommandLine;
212 CommandLine.push_back(Left);
213 CommandLine.push_back(Right);
214 if (EqualConcatenations(CommandLine, Buffers))
215 return false;
216
217 SourceManager &SourceMgr = PP.getSourceManager();
218
219 // The predefines buffers are different. Determine what the differences are,
220 // and whether they require us to reject the PCH file.
221 SmallVector<StringRef, 8> PCHLines;
222 for (unsigned I = 0, N = Buffers.size(); I != N; ++I)
223 Buffers[I].Data.split(PCHLines, "\n", /*MaxSplit=*/-1, /*KeepEmpty=*/false);
224
225 SmallVector<StringRef, 8> CmdLineLines;
226 Left.split(CmdLineLines, "\n", /*MaxSplit=*/-1, /*KeepEmpty=*/false);
227
228 // Pick out implicit #includes after the PCH and don't consider them for
229 // validation; we will insert them into SuggestedPredefines so that the
230 // preprocessor includes them.
231 std::string IncludesAfterPCH;
232 SmallVector<StringRef, 8> AfterPCHLines;
233 Right.split(AfterPCHLines, "\n", /*MaxSplit=*/-1, /*KeepEmpty=*/false);
234 for (unsigned i = 0, e = AfterPCHLines.size(); i != e; ++i) {
235 if (AfterPCHLines[i].startswith("#include ")) {
236 IncludesAfterPCH += AfterPCHLines[i];
237 IncludesAfterPCH += '\n';
238 } else {
239 CmdLineLines.push_back(AfterPCHLines[i]);
240 }
241 }
242
243 // Make sure we add the includes last into SuggestedPredefines before we
244 // exit this function.
245 struct AddIncludesRAII {
246 std::string &SuggestedPredefines;
247 std::string &IncludesAfterPCH;
248
249 AddIncludesRAII(std::string &SuggestedPredefines,
250 std::string &IncludesAfterPCH)
251 : SuggestedPredefines(SuggestedPredefines),
252 IncludesAfterPCH(IncludesAfterPCH) { }
253 ~AddIncludesRAII() {
254 SuggestedPredefines += IncludesAfterPCH;
255 }
256 } AddIncludes(SuggestedPredefines, IncludesAfterPCH);
257
258 // Sort both sets of predefined buffer lines, since we allow some extra
259 // definitions and they may appear at any point in the output.
260 std::sort(CmdLineLines.begin(), CmdLineLines.end());
261 std::sort(PCHLines.begin(), PCHLines.end());
262
263 // Determine which predefines that were used to build the PCH file are missing
264 // from the command line.
265 std::vector<StringRef> MissingPredefines;
266 std::set_difference(PCHLines.begin(), PCHLines.end(),
267 CmdLineLines.begin(), CmdLineLines.end(),
268 std::back_inserter(MissingPredefines));
269
270 bool MissingDefines = false;
271 bool ConflictingDefines = false;
272 for (unsigned I = 0, N = MissingPredefines.size(); I != N; ++I) {
273 StringRef Missing = MissingPredefines[I];
274 if (Missing.startswith("#include ")) {
275 // An -include was specified when generating the PCH; it is included in
276 // the PCH, just ignore it.
277 continue;
278 }
279 if (!Missing.startswith("#define ")) {
280 Reader.Diag(diag::warn_pch_compiler_options_mismatch);
281 return true;
282 }
283
284 // This is a macro definition. Determine the name of the macro we're
285 // defining.
286 std::string::size_type StartOfMacroName = strlen("#define ");
287 std::string::size_type EndOfMacroName
288 = Missing.find_first_of("( \n\r", StartOfMacroName);
289 assert(EndOfMacroName != std::string::npos &&
290 "Couldn't find the end of the macro name");
291 StringRef MacroName = Missing.slice(StartOfMacroName, EndOfMacroName);
292
293 // Determine whether this macro was given a different definition on the
294 // command line.
295 std::string MacroDefStart = "#define " + MacroName.str();
296 std::string::size_type MacroDefLen = MacroDefStart.size();
297 SmallVector<StringRef, 8>::iterator ConflictPos
298 = std::lower_bound(CmdLineLines.begin(), CmdLineLines.end(),
299 MacroDefStart);
300 for (; ConflictPos != CmdLineLines.end(); ++ConflictPos) {
301 if (!ConflictPos->startswith(MacroDefStart)) {
302 // Different macro; we're done.
303 ConflictPos = CmdLineLines.end();
304 break;
305 }
306
307 assert(ConflictPos->size() > MacroDefLen &&
308 "Invalid #define in predefines buffer?");
309 if ((*ConflictPos)[MacroDefLen] != ' ' &&
310 (*ConflictPos)[MacroDefLen] != '(')
311 continue; // Longer macro name; keep trying.
312
313 // We found a conflicting macro definition.
314 break;
315 }
316
317 if (ConflictPos != CmdLineLines.end()) {
318 Reader.Diag(diag::warn_cmdline_conflicting_macro_def)
319 << MacroName;
320
321 // Show the definition of this macro within the PCH file.
322 std::pair<FileID, StringRef::size_type> MacroLoc =
323 FindMacro(Buffers, Missing);
324 assert(MacroLoc.second!=StringRef::npos && "Unable to find macro!");
325 SourceLocation PCHMissingLoc =
326 SourceMgr.getLocForStartOfFile(MacroLoc.first)
327 .getLocWithOffset(MacroLoc.second);
328 Reader.Diag(PCHMissingLoc, diag::note_pch_macro_defined_as) << MacroName;
329
330 ConflictingDefines = true;
331 continue;
332 }
333
334 // If the macro doesn't conflict, then we'll just pick up the macro
335 // definition from the PCH file. Warn the user that they made a mistake.
336 if (ConflictingDefines)
337 continue; // Don't complain if there are already conflicting defs
338
339 if (!MissingDefines) {
340 Reader.Diag(diag::warn_cmdline_missing_macro_defs);
341 MissingDefines = true;
342 }
343
344 // Show the definition of this macro within the PCH file.
345 std::pair<FileID, StringRef::size_type> MacroLoc =
346 FindMacro(Buffers, Missing);
347 assert(MacroLoc.second!=StringRef::npos && "Unable to find macro!");
348 SourceLocation PCHMissingLoc =
349 SourceMgr.getLocForStartOfFile(MacroLoc.first)
350 .getLocWithOffset(MacroLoc.second);
351 Reader.Diag(PCHMissingLoc, diag::note_using_macro_def_from_pch);
352 }
353
354 if (ConflictingDefines)
355 return true;
356
357 // Determine what predefines were introduced based on command-line
358 // parameters that were not present when building the PCH
359 // file. Extra #defines are okay, so long as the identifiers being
360 // defined were not used within the precompiled header.
361 std::vector<StringRef> ExtraPredefines;
362 std::set_difference(CmdLineLines.begin(), CmdLineLines.end(),
363 PCHLines.begin(), PCHLines.end(),
364 std::back_inserter(ExtraPredefines));
365 for (unsigned I = 0, N = ExtraPredefines.size(); I != N; ++I) {
366 StringRef &Extra = ExtraPredefines[I];
367 if (!Extra.startswith("#define ")) {
368 Reader.Diag(diag::warn_pch_compiler_options_mismatch);
369 return true;
370 }
371
372 // This is an extra macro definition. Determine the name of the
373 // macro we're defining.
374 std::string::size_type StartOfMacroName = strlen("#define ");
375 std::string::size_type EndOfMacroName
376 = Extra.find_first_of("( \n\r", StartOfMacroName);
377 assert(EndOfMacroName != std::string::npos &&
378 "Couldn't find the end of the macro name");
379 StringRef MacroName = Extra.slice(StartOfMacroName, EndOfMacroName);
380
381 // Check whether this name was used somewhere in the PCH file. If
382 // so, defining it as a macro could change behavior, so we reject
383 // the PCH file.
384 if (IdentifierInfo *II = Reader.get(MacroName)) {
385 Reader.Diag(diag::warn_macro_name_used_in_pch) << II;
386 return true;
387 }
388
389 // Add this definition to the suggested predefines buffer.
390 SuggestedPredefines += Extra;
391 SuggestedPredefines += '\n';
392 }
393
394 // If we get here, it's because the predefines buffer had compatible
395 // contents. Accept the PCH file.
396 return false;
397 }
398
ReadHeaderFileInfo(const HeaderFileInfo & HFI,unsigned ID)399 void PCHValidator::ReadHeaderFileInfo(const HeaderFileInfo &HFI,
400 unsigned ID) {
401 PP.getHeaderSearchInfo().setHeaderFileInfoForUID(HFI, ID);
402 ++NumHeaderInfos;
403 }
404
ReadCounter(unsigned Value)405 void PCHValidator::ReadCounter(unsigned Value) {
406 PP.setCounterValue(Value);
407 }
408
409 //===----------------------------------------------------------------------===//
410 // AST reader implementation
411 //===----------------------------------------------------------------------===//
412
413 void
setDeserializationListener(ASTDeserializationListener * Listener)414 ASTReader::setDeserializationListener(ASTDeserializationListener *Listener) {
415 DeserializationListener = Listener;
416 }
417
418
419
ComputeHash(Selector Sel)420 unsigned ASTSelectorLookupTrait::ComputeHash(Selector Sel) {
421 return serialization::ComputeHash(Sel);
422 }
423
424
425 std::pair<unsigned, unsigned>
ReadKeyDataLength(const unsigned char * & d)426 ASTSelectorLookupTrait::ReadKeyDataLength(const unsigned char*& d) {
427 using namespace clang::io;
428 unsigned KeyLen = ReadUnalignedLE16(d);
429 unsigned DataLen = ReadUnalignedLE16(d);
430 return std::make_pair(KeyLen, DataLen);
431 }
432
433 ASTSelectorLookupTrait::internal_key_type
ReadKey(const unsigned char * d,unsigned)434 ASTSelectorLookupTrait::ReadKey(const unsigned char* d, unsigned) {
435 using namespace clang::io;
436 SelectorTable &SelTable = Reader.getContext().Selectors;
437 unsigned N = ReadUnalignedLE16(d);
438 IdentifierInfo *FirstII
439 = Reader.getLocalIdentifier(F, ReadUnalignedLE32(d));
440 if (N == 0)
441 return SelTable.getNullarySelector(FirstII);
442 else if (N == 1)
443 return SelTable.getUnarySelector(FirstII);
444
445 SmallVector<IdentifierInfo *, 16> Args;
446 Args.push_back(FirstII);
447 for (unsigned I = 1; I != N; ++I)
448 Args.push_back(Reader.getLocalIdentifier(F, ReadUnalignedLE32(d)));
449
450 return SelTable.getSelector(N, Args.data());
451 }
452
453 ASTSelectorLookupTrait::data_type
ReadData(Selector,const unsigned char * d,unsigned DataLen)454 ASTSelectorLookupTrait::ReadData(Selector, const unsigned char* d,
455 unsigned DataLen) {
456 using namespace clang::io;
457
458 data_type Result;
459
460 Result.ID = Reader.getGlobalSelectorID(F, ReadUnalignedLE32(d));
461 unsigned NumInstanceMethods = ReadUnalignedLE16(d);
462 unsigned NumFactoryMethods = ReadUnalignedLE16(d);
463
464 // Load instance methods
465 for (unsigned I = 0; I != NumInstanceMethods; ++I) {
466 if (ObjCMethodDecl *Method
467 = Reader.GetLocalDeclAs<ObjCMethodDecl>(F, ReadUnalignedLE32(d)))
468 Result.Instance.push_back(Method);
469 }
470
471 // Load factory methods
472 for (unsigned I = 0; I != NumFactoryMethods; ++I) {
473 if (ObjCMethodDecl *Method
474 = Reader.GetLocalDeclAs<ObjCMethodDecl>(F, ReadUnalignedLE32(d)))
475 Result.Factory.push_back(Method);
476 }
477
478 return Result;
479 }
480
ComputeHash(const internal_key_type & a)481 unsigned ASTIdentifierLookupTrait::ComputeHash(const internal_key_type& a) {
482 return llvm::HashString(StringRef(a.first, a.second));
483 }
484
485 std::pair<unsigned, unsigned>
ReadKeyDataLength(const unsigned char * & d)486 ASTIdentifierLookupTrait::ReadKeyDataLength(const unsigned char*& d) {
487 using namespace clang::io;
488 unsigned DataLen = ReadUnalignedLE16(d);
489 unsigned KeyLen = ReadUnalignedLE16(d);
490 return std::make_pair(KeyLen, DataLen);
491 }
492
493 std::pair<const char*, unsigned>
ReadKey(const unsigned char * d,unsigned n)494 ASTIdentifierLookupTrait::ReadKey(const unsigned char* d, unsigned n) {
495 assert(n >= 2 && d[n-1] == '\0');
496 return std::make_pair((const char*) d, n-1);
497 }
498
ReadData(const internal_key_type & k,const unsigned char * d,unsigned DataLen)499 IdentifierInfo *ASTIdentifierLookupTrait::ReadData(const internal_key_type& k,
500 const unsigned char* d,
501 unsigned DataLen) {
502 using namespace clang::io;
503 unsigned RawID = ReadUnalignedLE32(d);
504 bool IsInteresting = RawID & 0x01;
505
506 // Wipe out the "is interesting" bit.
507 RawID = RawID >> 1;
508
509 IdentID ID = Reader.getGlobalIdentifierID(F, RawID);
510 if (!IsInteresting) {
511 // For uninteresting identifiers, just build the IdentifierInfo
512 // and associate it with the persistent ID.
513 IdentifierInfo *II = KnownII;
514 if (!II) {
515 II = &Reader.getIdentifierTable().getOwn(StringRef(k.first, k.second));
516 KnownII = II;
517 }
518 Reader.SetIdentifierInfo(ID, II);
519 II->setIsFromAST();
520 Reader.markIdentifierUpToDate(II);
521 return II;
522 }
523
524 unsigned Bits = ReadUnalignedLE16(d);
525 bool CPlusPlusOperatorKeyword = Bits & 0x01;
526 Bits >>= 1;
527 bool HasRevertedTokenIDToIdentifier = Bits & 0x01;
528 Bits >>= 1;
529 bool Poisoned = Bits & 0x01;
530 Bits >>= 1;
531 bool ExtensionToken = Bits & 0x01;
532 Bits >>= 1;
533 bool hasMacroDefinition = Bits & 0x01;
534 Bits >>= 1;
535 unsigned ObjCOrBuiltinID = Bits & 0x7FF;
536 Bits >>= 11;
537
538 assert(Bits == 0 && "Extra bits in the identifier?");
539 DataLen -= 6;
540
541 // Build the IdentifierInfo itself and link the identifier ID with
542 // the new IdentifierInfo.
543 IdentifierInfo *II = KnownII;
544 if (!II) {
545 II = &Reader.getIdentifierTable().getOwn(StringRef(k.first, k.second));
546 KnownII = II;
547 }
548 Reader.markIdentifierUpToDate(II);
549 II->setIsFromAST();
550
551 // Set or check the various bits in the IdentifierInfo structure.
552 // Token IDs are read-only.
553 if (HasRevertedTokenIDToIdentifier)
554 II->RevertTokenIDToIdentifier();
555 II->setObjCOrBuiltinID(ObjCOrBuiltinID);
556 assert(II->isExtensionToken() == ExtensionToken &&
557 "Incorrect extension token flag");
558 (void)ExtensionToken;
559 if (Poisoned)
560 II->setIsPoisoned(true);
561 assert(II->isCPlusPlusOperatorKeyword() == CPlusPlusOperatorKeyword &&
562 "Incorrect C++ operator keyword flag");
563 (void)CPlusPlusOperatorKeyword;
564
565 // If this identifier is a macro, deserialize the macro
566 // definition.
567 if (hasMacroDefinition) {
568 // FIXME: Check for conflicts?
569 uint32_t Offset = ReadUnalignedLE32(d);
570 unsigned LocalSubmoduleID = ReadUnalignedLE32(d);
571
572 // Determine whether this macro definition should be visible now, or
573 // whether it is in a hidden submodule.
574 bool Visible = true;
575 if (SubmoduleID GlobalSubmoduleID
576 = Reader.getGlobalSubmoduleID(F, LocalSubmoduleID)) {
577 if (Module *Owner = Reader.getSubmodule(GlobalSubmoduleID)) {
578 if (Owner->NameVisibility == Module::Hidden) {
579 // The owning module is not visible, and this macro definition should
580 // not be, either.
581 Visible = false;
582
583 // Note that this macro definition was hidden because its owning
584 // module is not yet visible.
585 Reader.HiddenNamesMap[Owner].push_back(II);
586 }
587 }
588 }
589
590 Reader.setIdentifierIsMacro(II, F, Offset, Visible);
591 DataLen -= 8;
592 }
593
594 Reader.SetIdentifierInfo(ID, II);
595
596 // Read all of the declarations visible at global scope with this
597 // name.
598 if (DataLen > 0) {
599 SmallVector<uint32_t, 4> DeclIDs;
600 for (; DataLen > 0; DataLen -= 4)
601 DeclIDs.push_back(Reader.getGlobalDeclID(F, ReadUnalignedLE32(d)));
602 Reader.SetGloballyVisibleDecls(II, DeclIDs);
603 }
604
605 return II;
606 }
607
608 unsigned
ComputeHash(const DeclNameKey & Key) const609 ASTDeclContextNameLookupTrait::ComputeHash(const DeclNameKey &Key) const {
610 llvm::FoldingSetNodeID ID;
611 ID.AddInteger(Key.Kind);
612
613 switch (Key.Kind) {
614 case DeclarationName::Identifier:
615 case DeclarationName::CXXLiteralOperatorName:
616 ID.AddString(((IdentifierInfo*)Key.Data)->getName());
617 break;
618 case DeclarationName::ObjCZeroArgSelector:
619 case DeclarationName::ObjCOneArgSelector:
620 case DeclarationName::ObjCMultiArgSelector:
621 ID.AddInteger(serialization::ComputeHash(Selector(Key.Data)));
622 break;
623 case DeclarationName::CXXOperatorName:
624 ID.AddInteger((OverloadedOperatorKind)Key.Data);
625 break;
626 case DeclarationName::CXXConstructorName:
627 case DeclarationName::CXXDestructorName:
628 case DeclarationName::CXXConversionFunctionName:
629 case DeclarationName::CXXUsingDirective:
630 break;
631 }
632
633 return ID.ComputeHash();
634 }
635
636 ASTDeclContextNameLookupTrait::internal_key_type
GetInternalKey(const external_key_type & Name) const637 ASTDeclContextNameLookupTrait::GetInternalKey(
638 const external_key_type& Name) const {
639 DeclNameKey Key;
640 Key.Kind = Name.getNameKind();
641 switch (Name.getNameKind()) {
642 case DeclarationName::Identifier:
643 Key.Data = (uint64_t)Name.getAsIdentifierInfo();
644 break;
645 case DeclarationName::ObjCZeroArgSelector:
646 case DeclarationName::ObjCOneArgSelector:
647 case DeclarationName::ObjCMultiArgSelector:
648 Key.Data = (uint64_t)Name.getObjCSelector().getAsOpaquePtr();
649 break;
650 case DeclarationName::CXXOperatorName:
651 Key.Data = Name.getCXXOverloadedOperator();
652 break;
653 case DeclarationName::CXXLiteralOperatorName:
654 Key.Data = (uint64_t)Name.getCXXLiteralIdentifier();
655 break;
656 case DeclarationName::CXXConstructorName:
657 case DeclarationName::CXXDestructorName:
658 case DeclarationName::CXXConversionFunctionName:
659 case DeclarationName::CXXUsingDirective:
660 Key.Data = 0;
661 break;
662 }
663
664 return Key;
665 }
666
667 std::pair<unsigned, unsigned>
ReadKeyDataLength(const unsigned char * & d)668 ASTDeclContextNameLookupTrait::ReadKeyDataLength(const unsigned char*& d) {
669 using namespace clang::io;
670 unsigned KeyLen = ReadUnalignedLE16(d);
671 unsigned DataLen = ReadUnalignedLE16(d);
672 return std::make_pair(KeyLen, DataLen);
673 }
674
675 ASTDeclContextNameLookupTrait::internal_key_type
ReadKey(const unsigned char * d,unsigned)676 ASTDeclContextNameLookupTrait::ReadKey(const unsigned char* d, unsigned) {
677 using namespace clang::io;
678
679 DeclNameKey Key;
680 Key.Kind = (DeclarationName::NameKind)*d++;
681 switch (Key.Kind) {
682 case DeclarationName::Identifier:
683 Key.Data = (uint64_t)Reader.getLocalIdentifier(F, ReadUnalignedLE32(d));
684 break;
685 case DeclarationName::ObjCZeroArgSelector:
686 case DeclarationName::ObjCOneArgSelector:
687 case DeclarationName::ObjCMultiArgSelector:
688 Key.Data =
689 (uint64_t)Reader.getLocalSelector(F, ReadUnalignedLE32(d))
690 .getAsOpaquePtr();
691 break;
692 case DeclarationName::CXXOperatorName:
693 Key.Data = *d++; // OverloadedOperatorKind
694 break;
695 case DeclarationName::CXXLiteralOperatorName:
696 Key.Data = (uint64_t)Reader.getLocalIdentifier(F, ReadUnalignedLE32(d));
697 break;
698 case DeclarationName::CXXConstructorName:
699 case DeclarationName::CXXDestructorName:
700 case DeclarationName::CXXConversionFunctionName:
701 case DeclarationName::CXXUsingDirective:
702 Key.Data = 0;
703 break;
704 }
705
706 return Key;
707 }
708
709 ASTDeclContextNameLookupTrait::data_type
ReadData(internal_key_type,const unsigned char * d,unsigned DataLen)710 ASTDeclContextNameLookupTrait::ReadData(internal_key_type,
711 const unsigned char* d,
712 unsigned DataLen) {
713 using namespace clang::io;
714 unsigned NumDecls = ReadUnalignedLE16(d);
715 LE32DeclID *Start = (LE32DeclID *)d;
716 return std::make_pair(Start, Start + NumDecls);
717 }
718
ReadDeclContextStorage(ModuleFile & M,llvm::BitstreamCursor & Cursor,const std::pair<uint64_t,uint64_t> & Offsets,DeclContextInfo & Info)719 bool ASTReader::ReadDeclContextStorage(ModuleFile &M,
720 llvm::BitstreamCursor &Cursor,
721 const std::pair<uint64_t, uint64_t> &Offsets,
722 DeclContextInfo &Info) {
723 SavedStreamPosition SavedPosition(Cursor);
724 // First the lexical decls.
725 if (Offsets.first != 0) {
726 Cursor.JumpToBit(Offsets.first);
727
728 RecordData Record;
729 const char *Blob;
730 unsigned BlobLen;
731 unsigned Code = Cursor.ReadCode();
732 unsigned RecCode = Cursor.ReadRecord(Code, Record, &Blob, &BlobLen);
733 if (RecCode != DECL_CONTEXT_LEXICAL) {
734 Error("Expected lexical block");
735 return true;
736 }
737
738 Info.LexicalDecls = reinterpret_cast<const KindDeclIDPair*>(Blob);
739 Info.NumLexicalDecls = BlobLen / sizeof(KindDeclIDPair);
740 }
741
742 // Now the lookup table.
743 if (Offsets.second != 0) {
744 Cursor.JumpToBit(Offsets.second);
745
746 RecordData Record;
747 const char *Blob;
748 unsigned BlobLen;
749 unsigned Code = Cursor.ReadCode();
750 unsigned RecCode = Cursor.ReadRecord(Code, Record, &Blob, &BlobLen);
751 if (RecCode != DECL_CONTEXT_VISIBLE) {
752 Error("Expected visible lookup table block");
753 return true;
754 }
755 Info.NameLookupTableData
756 = ASTDeclContextNameLookupTable::Create(
757 (const unsigned char *)Blob + Record[0],
758 (const unsigned char *)Blob,
759 ASTDeclContextNameLookupTrait(*this, M));
760 }
761
762 return false;
763 }
764
Error(StringRef Msg)765 void ASTReader::Error(StringRef Msg) {
766 Error(diag::err_fe_pch_malformed, Msg);
767 }
768
Error(unsigned DiagID,StringRef Arg1,StringRef Arg2)769 void ASTReader::Error(unsigned DiagID,
770 StringRef Arg1, StringRef Arg2) {
771 if (Diags.isDiagnosticInFlight())
772 Diags.SetDelayedDiagnostic(DiagID, Arg1, Arg2);
773 else
774 Diag(DiagID) << Arg1 << Arg2;
775 }
776
777 /// \brief Tell the AST listener about the predefines buffers in the chain.
CheckPredefinesBuffers()778 bool ASTReader::CheckPredefinesBuffers() {
779 if (Listener)
780 return Listener->ReadPredefinesBuffer(PCHPredefinesBuffers,
781 ActualOriginalFileName,
782 SuggestedPredefines,
783 FileMgr);
784 return false;
785 }
786
787 //===----------------------------------------------------------------------===//
788 // Source Manager Deserialization
789 //===----------------------------------------------------------------------===//
790
791 /// \brief Read the line table in the source manager block.
792 /// \returns true if there was an error.
ParseLineTable(ModuleFile & F,SmallVectorImpl<uint64_t> & Record)793 bool ASTReader::ParseLineTable(ModuleFile &F,
794 SmallVectorImpl<uint64_t> &Record) {
795 unsigned Idx = 0;
796 LineTableInfo &LineTable = SourceMgr.getLineTable();
797
798 // Parse the file names
799 std::map<int, int> FileIDs;
800 for (int I = 0, N = Record[Idx++]; I != N; ++I) {
801 // Extract the file name
802 unsigned FilenameLen = Record[Idx++];
803 std::string Filename(&Record[Idx], &Record[Idx] + FilenameLen);
804 Idx += FilenameLen;
805 MaybeAddSystemRootToFilename(Filename);
806 FileIDs[I] = LineTable.getLineTableFilenameID(Filename);
807 }
808
809 // Parse the line entries
810 std::vector<LineEntry> Entries;
811 while (Idx < Record.size()) {
812 int FID = Record[Idx++];
813 assert(FID >= 0 && "Serialized line entries for non-local file.");
814 // Remap FileID from 1-based old view.
815 FID += F.SLocEntryBaseID - 1;
816
817 // Extract the line entries
818 unsigned NumEntries = Record[Idx++];
819 assert(NumEntries && "Numentries is 00000");
820 Entries.clear();
821 Entries.reserve(NumEntries);
822 for (unsigned I = 0; I != NumEntries; ++I) {
823 unsigned FileOffset = Record[Idx++];
824 unsigned LineNo = Record[Idx++];
825 int FilenameID = FileIDs[Record[Idx++]];
826 SrcMgr::CharacteristicKind FileKind
827 = (SrcMgr::CharacteristicKind)Record[Idx++];
828 unsigned IncludeOffset = Record[Idx++];
829 Entries.push_back(LineEntry::get(FileOffset, LineNo, FilenameID,
830 FileKind, IncludeOffset));
831 }
832 LineTable.AddEntry(FID, Entries);
833 }
834
835 return false;
836 }
837
838 namespace {
839
840 class ASTStatData {
841 public:
842 const ino_t ino;
843 const dev_t dev;
844 const mode_t mode;
845 const time_t mtime;
846 const off_t size;
847
ASTStatData(ino_t i,dev_t d,mode_t mo,time_t m,off_t s)848 ASTStatData(ino_t i, dev_t d, mode_t mo, time_t m, off_t s)
849 : ino(i), dev(d), mode(mo), mtime(m), size(s) {}
850 };
851
852 class ASTStatLookupTrait {
853 public:
854 typedef const char *external_key_type;
855 typedef const char *internal_key_type;
856
857 typedef ASTStatData data_type;
858
ComputeHash(const char * path)859 static unsigned ComputeHash(const char *path) {
860 return llvm::HashString(path);
861 }
862
GetInternalKey(const char * path)863 static internal_key_type GetInternalKey(const char *path) { return path; }
864
EqualKey(internal_key_type a,internal_key_type b)865 static bool EqualKey(internal_key_type a, internal_key_type b) {
866 return strcmp(a, b) == 0;
867 }
868
869 static std::pair<unsigned, unsigned>
ReadKeyDataLength(const unsigned char * & d)870 ReadKeyDataLength(const unsigned char*& d) {
871 unsigned KeyLen = (unsigned) clang::io::ReadUnalignedLE16(d);
872 unsigned DataLen = (unsigned) *d++;
873 return std::make_pair(KeyLen + 1, DataLen);
874 }
875
ReadKey(const unsigned char * d,unsigned)876 static internal_key_type ReadKey(const unsigned char *d, unsigned) {
877 return (const char *)d;
878 }
879
ReadData(const internal_key_type,const unsigned char * d,unsigned)880 static data_type ReadData(const internal_key_type, const unsigned char *d,
881 unsigned /*DataLen*/) {
882 using namespace clang::io;
883
884 ino_t ino = (ino_t) ReadUnalignedLE32(d);
885 dev_t dev = (dev_t) ReadUnalignedLE32(d);
886 mode_t mode = (mode_t) ReadUnalignedLE16(d);
887 time_t mtime = (time_t) ReadUnalignedLE64(d);
888 off_t size = (off_t) ReadUnalignedLE64(d);
889 return data_type(ino, dev, mode, mtime, size);
890 }
891 };
892
893 /// \brief stat() cache for precompiled headers.
894 ///
895 /// This cache is very similar to the stat cache used by pretokenized
896 /// headers.
897 class ASTStatCache : public FileSystemStatCache {
898 typedef OnDiskChainedHashTable<ASTStatLookupTrait> CacheTy;
899 CacheTy *Cache;
900
901 unsigned &NumStatHits, &NumStatMisses;
902 public:
ASTStatCache(const unsigned char * Buckets,const unsigned char * Base,unsigned & NumStatHits,unsigned & NumStatMisses)903 ASTStatCache(const unsigned char *Buckets, const unsigned char *Base,
904 unsigned &NumStatHits, unsigned &NumStatMisses)
905 : Cache(0), NumStatHits(NumStatHits), NumStatMisses(NumStatMisses) {
906 Cache = CacheTy::Create(Buckets, Base);
907 }
908
~ASTStatCache()909 ~ASTStatCache() { delete Cache; }
910
getStat(const char * Path,struct stat & StatBuf,int * FileDescriptor)911 LookupResult getStat(const char *Path, struct stat &StatBuf,
912 int *FileDescriptor) {
913 // Do the lookup for the file's data in the AST file.
914 CacheTy::iterator I = Cache->find(Path);
915
916 // If we don't get a hit in the AST file just forward to 'stat'.
917 if (I == Cache->end()) {
918 ++NumStatMisses;
919 return statChained(Path, StatBuf, FileDescriptor);
920 }
921
922 ++NumStatHits;
923 ASTStatData Data = *I;
924
925 StatBuf.st_ino = Data.ino;
926 StatBuf.st_dev = Data.dev;
927 StatBuf.st_mtime = Data.mtime;
928 StatBuf.st_mode = Data.mode;
929 StatBuf.st_size = Data.size;
930 return CacheExists;
931 }
932 };
933 } // end anonymous namespace
934
935
936 /// \brief Read a source manager block
ReadSourceManagerBlock(ModuleFile & F)937 ASTReader::ASTReadResult ASTReader::ReadSourceManagerBlock(ModuleFile &F) {
938 using namespace SrcMgr;
939
940 llvm::BitstreamCursor &SLocEntryCursor = F.SLocEntryCursor;
941
942 // Set the source-location entry cursor to the current position in
943 // the stream. This cursor will be used to read the contents of the
944 // source manager block initially, and then lazily read
945 // source-location entries as needed.
946 SLocEntryCursor = F.Stream;
947
948 // The stream itself is going to skip over the source manager block.
949 if (F.Stream.SkipBlock()) {
950 Error("malformed block record in AST file");
951 return Failure;
952 }
953
954 // Enter the source manager block.
955 if (SLocEntryCursor.EnterSubBlock(SOURCE_MANAGER_BLOCK_ID)) {
956 Error("malformed source manager block record in AST file");
957 return Failure;
958 }
959
960 RecordData Record;
961 while (true) {
962 unsigned Code = SLocEntryCursor.ReadCode();
963 if (Code == llvm::bitc::END_BLOCK) {
964 if (SLocEntryCursor.ReadBlockEnd()) {
965 Error("error at end of Source Manager block in AST file");
966 return Failure;
967 }
968 return Success;
969 }
970
971 if (Code == llvm::bitc::ENTER_SUBBLOCK) {
972 // No known subblocks, always skip them.
973 SLocEntryCursor.ReadSubBlockID();
974 if (SLocEntryCursor.SkipBlock()) {
975 Error("malformed block record in AST file");
976 return Failure;
977 }
978 continue;
979 }
980
981 if (Code == llvm::bitc::DEFINE_ABBREV) {
982 SLocEntryCursor.ReadAbbrevRecord();
983 continue;
984 }
985
986 // Read a record.
987 const char *BlobStart;
988 unsigned BlobLen;
989 Record.clear();
990 switch (SLocEntryCursor.ReadRecord(Code, Record, &BlobStart, &BlobLen)) {
991 default: // Default behavior: ignore.
992 break;
993
994 case SM_SLOC_FILE_ENTRY:
995 case SM_SLOC_BUFFER_ENTRY:
996 case SM_SLOC_EXPANSION_ENTRY:
997 // Once we hit one of the source location entries, we're done.
998 return Success;
999 }
1000 }
1001 }
1002
1003 /// \brief If a header file is not found at the path that we expect it to be
1004 /// and the PCH file was moved from its original location, try to resolve the
1005 /// file by assuming that header+PCH were moved together and the header is in
1006 /// the same place relative to the PCH.
1007 static std::string
resolveFileRelativeToOriginalDir(const std::string & Filename,const std::string & OriginalDir,const std::string & CurrDir)1008 resolveFileRelativeToOriginalDir(const std::string &Filename,
1009 const std::string &OriginalDir,
1010 const std::string &CurrDir) {
1011 assert(OriginalDir != CurrDir &&
1012 "No point trying to resolve the file if the PCH dir didn't change");
1013 using namespace llvm::sys;
1014 SmallString<128> filePath(Filename);
1015 fs::make_absolute(filePath);
1016 assert(path::is_absolute(OriginalDir));
1017 SmallString<128> currPCHPath(CurrDir);
1018
1019 path::const_iterator fileDirI = path::begin(path::parent_path(filePath)),
1020 fileDirE = path::end(path::parent_path(filePath));
1021 path::const_iterator origDirI = path::begin(OriginalDir),
1022 origDirE = path::end(OriginalDir);
1023 // Skip the common path components from filePath and OriginalDir.
1024 while (fileDirI != fileDirE && origDirI != origDirE &&
1025 *fileDirI == *origDirI) {
1026 ++fileDirI;
1027 ++origDirI;
1028 }
1029 for (; origDirI != origDirE; ++origDirI)
1030 path::append(currPCHPath, "..");
1031 path::append(currPCHPath, fileDirI, fileDirE);
1032 path::append(currPCHPath, path::filename(Filename));
1033 return currPCHPath.str();
1034 }
1035
1036 /// \brief Read in the source location entry with the given ID.
ReadSLocEntryRecord(int ID)1037 ASTReader::ASTReadResult ASTReader::ReadSLocEntryRecord(int ID) {
1038 if (ID == 0)
1039 return Success;
1040
1041 if (unsigned(-ID) - 2 >= getTotalNumSLocs() || ID > 0) {
1042 Error("source location entry ID out-of-range for AST file");
1043 return Failure;
1044 }
1045
1046 ModuleFile *F = GlobalSLocEntryMap.find(-ID)->second;
1047 F->SLocEntryCursor.JumpToBit(F->SLocEntryOffsets[ID - F->SLocEntryBaseID]);
1048 llvm::BitstreamCursor &SLocEntryCursor = F->SLocEntryCursor;
1049 unsigned BaseOffset = F->SLocEntryBaseOffset;
1050
1051 ++NumSLocEntriesRead;
1052 unsigned Code = SLocEntryCursor.ReadCode();
1053 if (Code == llvm::bitc::END_BLOCK ||
1054 Code == llvm::bitc::ENTER_SUBBLOCK ||
1055 Code == llvm::bitc::DEFINE_ABBREV) {
1056 Error("incorrectly-formatted source location entry in AST file");
1057 return Failure;
1058 }
1059
1060 RecordData Record;
1061 const char *BlobStart;
1062 unsigned BlobLen;
1063 switch (SLocEntryCursor.ReadRecord(Code, Record, &BlobStart, &BlobLen)) {
1064 default:
1065 Error("incorrectly-formatted source location entry in AST file");
1066 return Failure;
1067
1068 case SM_SLOC_FILE_ENTRY: {
1069 if (Record.size() < 7) {
1070 Error("source location entry is incorrect");
1071 return Failure;
1072 }
1073
1074 // We will detect whether a file changed and return 'Failure' for it, but
1075 // we will also try to fail gracefully by setting up the SLocEntry.
1076 ASTReader::ASTReadResult Result = Success;
1077
1078 bool OverriddenBuffer = Record[6];
1079
1080 std::string OrigFilename(BlobStart, BlobStart + BlobLen);
1081 std::string Filename = OrigFilename;
1082 MaybeAddSystemRootToFilename(Filename);
1083 const FileEntry *File =
1084 OverriddenBuffer? FileMgr.getVirtualFile(Filename, (off_t)Record[4],
1085 (time_t)Record[5])
1086 : FileMgr.getFile(Filename, /*OpenFile=*/false);
1087 if (File == 0 && !OriginalDir.empty() && !CurrentDir.empty() &&
1088 OriginalDir != CurrentDir) {
1089 std::string resolved = resolveFileRelativeToOriginalDir(Filename,
1090 OriginalDir,
1091 CurrentDir);
1092 if (!resolved.empty())
1093 File = FileMgr.getFile(resolved);
1094 }
1095 if (File == 0)
1096 File = FileMgr.getVirtualFile(Filename, (off_t)Record[4],
1097 (time_t)Record[5]);
1098 if (File == 0) {
1099 std::string ErrorStr = "could not find file '";
1100 ErrorStr += Filename;
1101 ErrorStr += "' referenced by AST file";
1102 Error(ErrorStr.c_str());
1103 return Failure;
1104 }
1105
1106 if (!DisableValidation &&
1107 ((off_t)Record[4] != File->getSize()
1108 #if !defined(LLVM_ON_WIN32)
1109 // In our regression testing, the Windows file system seems to
1110 // have inconsistent modification times that sometimes
1111 // erroneously trigger this error-handling path.
1112 || (time_t)Record[5] != File->getModificationTime()
1113 #endif
1114 )) {
1115 Error(diag::err_fe_pch_file_modified, Filename);
1116 Result = Failure;
1117 }
1118
1119 SourceLocation IncludeLoc = ReadSourceLocation(*F, Record[1]);
1120 if (IncludeLoc.isInvalid() && F->Kind != MK_MainFile) {
1121 // This is the module's main file.
1122 IncludeLoc = getImportLocation(F);
1123 }
1124 FileID FID = SourceMgr.createFileID(File, IncludeLoc,
1125 (SrcMgr::CharacteristicKind)Record[2],
1126 ID, BaseOffset + Record[0]);
1127 SrcMgr::FileInfo &FileInfo =
1128 const_cast<SrcMgr::FileInfo&>(SourceMgr.getSLocEntry(FID).getFile());
1129 FileInfo.NumCreatedFIDs = Record[7];
1130 if (Record[3])
1131 FileInfo.setHasLineDirectives();
1132
1133 const DeclID *FirstDecl = F->FileSortedDecls + Record[8];
1134 unsigned NumFileDecls = Record[9];
1135 if (NumFileDecls) {
1136 assert(F->FileSortedDecls && "FILE_SORTED_DECLS not encountered yet ?");
1137 FileDeclIDs[FID] = FileDeclsInfo(F, llvm::makeArrayRef(FirstDecl,
1138 NumFileDecls));
1139 }
1140
1141 const SrcMgr::ContentCache *ContentCache
1142 = SourceMgr.getOrCreateContentCache(File);
1143 if (OverriddenBuffer && !ContentCache->BufferOverridden &&
1144 ContentCache->ContentsEntry == ContentCache->OrigEntry) {
1145 unsigned Code = SLocEntryCursor.ReadCode();
1146 Record.clear();
1147 unsigned RecCode
1148 = SLocEntryCursor.ReadRecord(Code, Record, &BlobStart, &BlobLen);
1149
1150 if (RecCode != SM_SLOC_BUFFER_BLOB) {
1151 Error("AST record has invalid code");
1152 return Failure;
1153 }
1154
1155 llvm::MemoryBuffer *Buffer
1156 = llvm::MemoryBuffer::getMemBuffer(StringRef(BlobStart, BlobLen - 1),
1157 Filename);
1158 SourceMgr.overrideFileContents(File, Buffer);
1159 }
1160
1161 if (Result == Failure)
1162 return Failure;
1163 break;
1164 }
1165
1166 case SM_SLOC_BUFFER_ENTRY: {
1167 const char *Name = BlobStart;
1168 unsigned Offset = Record[0];
1169 unsigned Code = SLocEntryCursor.ReadCode();
1170 Record.clear();
1171 unsigned RecCode
1172 = SLocEntryCursor.ReadRecord(Code, Record, &BlobStart, &BlobLen);
1173
1174 if (RecCode != SM_SLOC_BUFFER_BLOB) {
1175 Error("AST record has invalid code");
1176 return Failure;
1177 }
1178
1179 llvm::MemoryBuffer *Buffer
1180 = llvm::MemoryBuffer::getMemBuffer(StringRef(BlobStart, BlobLen - 1),
1181 Name);
1182 FileID BufferID = SourceMgr.createFileIDForMemBuffer(Buffer, ID,
1183 BaseOffset + Offset);
1184
1185 if (strcmp(Name, "<built-in>") == 0 && F->Kind == MK_PCH) {
1186 PCHPredefinesBlock Block = {
1187 BufferID,
1188 StringRef(BlobStart, BlobLen - 1)
1189 };
1190 PCHPredefinesBuffers.push_back(Block);
1191 }
1192
1193 break;
1194 }
1195
1196 case SM_SLOC_EXPANSION_ENTRY: {
1197 SourceLocation SpellingLoc = ReadSourceLocation(*F, Record[1]);
1198 SourceMgr.createExpansionLoc(SpellingLoc,
1199 ReadSourceLocation(*F, Record[2]),
1200 ReadSourceLocation(*F, Record[3]),
1201 Record[4],
1202 ID,
1203 BaseOffset + Record[0]);
1204 break;
1205 }
1206 }
1207
1208 return Success;
1209 }
1210
1211 /// \brief Find the location where the module F is imported.
getImportLocation(ModuleFile * F)1212 SourceLocation ASTReader::getImportLocation(ModuleFile *F) {
1213 if (F->ImportLoc.isValid())
1214 return F->ImportLoc;
1215
1216 // Otherwise we have a PCH. It's considered to be "imported" at the first
1217 // location of its includer.
1218 if (F->ImportedBy.empty() || !F->ImportedBy[0]) {
1219 // Main file is the importer. We assume that it is the first entry in the
1220 // entry table. We can't ask the manager, because at the time of PCH loading
1221 // the main file entry doesn't exist yet.
1222 // The very first entry is the invalid instantiation loc, which takes up
1223 // offsets 0 and 1.
1224 return SourceLocation::getFromRawEncoding(2U);
1225 }
1226 //return F->Loaders[0]->FirstLoc;
1227 return F->ImportedBy[0]->FirstLoc;
1228 }
1229
1230 /// ReadBlockAbbrevs - Enter a subblock of the specified BlockID with the
1231 /// specified cursor. Read the abbreviations that are at the top of the block
1232 /// and then leave the cursor pointing into the block.
ReadBlockAbbrevs(llvm::BitstreamCursor & Cursor,unsigned BlockID)1233 bool ASTReader::ReadBlockAbbrevs(llvm::BitstreamCursor &Cursor,
1234 unsigned BlockID) {
1235 if (Cursor.EnterSubBlock(BlockID)) {
1236 Error("malformed block record in AST file");
1237 return Failure;
1238 }
1239
1240 while (true) {
1241 uint64_t Offset = Cursor.GetCurrentBitNo();
1242 unsigned Code = Cursor.ReadCode();
1243
1244 // We expect all abbrevs to be at the start of the block.
1245 if (Code != llvm::bitc::DEFINE_ABBREV) {
1246 Cursor.JumpToBit(Offset);
1247 return false;
1248 }
1249 Cursor.ReadAbbrevRecord();
1250 }
1251 }
1252
ReadMacroRecord(ModuleFile & F,uint64_t Offset)1253 void ASTReader::ReadMacroRecord(ModuleFile &F, uint64_t Offset) {
1254 llvm::BitstreamCursor &Stream = F.MacroCursor;
1255
1256 // Keep track of where we are in the stream, then jump back there
1257 // after reading this macro.
1258 SavedStreamPosition SavedPosition(Stream);
1259
1260 Stream.JumpToBit(Offset);
1261 RecordData Record;
1262 SmallVector<IdentifierInfo*, 16> MacroArgs;
1263 MacroInfo *Macro = 0;
1264
1265 while (true) {
1266 unsigned Code = Stream.ReadCode();
1267 switch (Code) {
1268 case llvm::bitc::END_BLOCK:
1269 return;
1270
1271 case llvm::bitc::ENTER_SUBBLOCK:
1272 // No known subblocks, always skip them.
1273 Stream.ReadSubBlockID();
1274 if (Stream.SkipBlock()) {
1275 Error("malformed block record in AST file");
1276 return;
1277 }
1278 continue;
1279
1280 case llvm::bitc::DEFINE_ABBREV:
1281 Stream.ReadAbbrevRecord();
1282 continue;
1283 default: break;
1284 }
1285
1286 // Read a record.
1287 const char *BlobStart = 0;
1288 unsigned BlobLen = 0;
1289 Record.clear();
1290 PreprocessorRecordTypes RecType =
1291 (PreprocessorRecordTypes)Stream.ReadRecord(Code, Record, BlobStart,
1292 BlobLen);
1293 switch (RecType) {
1294 case PP_MACRO_OBJECT_LIKE:
1295 case PP_MACRO_FUNCTION_LIKE: {
1296 // If we already have a macro, that means that we've hit the end
1297 // of the definition of the macro we were looking for. We're
1298 // done.
1299 if (Macro)
1300 return;
1301
1302 IdentifierInfo *II = getLocalIdentifier(F, Record[0]);
1303 if (II == 0) {
1304 Error("macro must have a name in AST file");
1305 return;
1306 }
1307
1308 SourceLocation Loc = ReadSourceLocation(F, Record[1]);
1309 bool isUsed = Record[2];
1310
1311 MacroInfo *MI = PP.AllocateMacroInfo(Loc);
1312 MI->setIsUsed(isUsed);
1313 MI->setIsFromAST();
1314
1315 bool IsPublic = Record[3];
1316 unsigned NextIndex = 4;
1317 MI->setVisibility(IsPublic, ReadSourceLocation(F, Record, NextIndex));
1318
1319 if (RecType == PP_MACRO_FUNCTION_LIKE) {
1320 // Decode function-like macro info.
1321 bool isC99VarArgs = Record[NextIndex++];
1322 bool isGNUVarArgs = Record[NextIndex++];
1323 MacroArgs.clear();
1324 unsigned NumArgs = Record[NextIndex++];
1325 for (unsigned i = 0; i != NumArgs; ++i)
1326 MacroArgs.push_back(getLocalIdentifier(F, Record[NextIndex++]));
1327
1328 // Install function-like macro info.
1329 MI->setIsFunctionLike();
1330 if (isC99VarArgs) MI->setIsC99Varargs();
1331 if (isGNUVarArgs) MI->setIsGNUVarargs();
1332 MI->setArgumentList(MacroArgs.data(), MacroArgs.size(),
1333 PP.getPreprocessorAllocator());
1334 }
1335
1336 // Finally, install the macro.
1337 PP.setMacroInfo(II, MI, /*LoadedFromAST=*/true);
1338
1339 // Remember that we saw this macro last so that we add the tokens that
1340 // form its body to it.
1341 Macro = MI;
1342
1343 if (NextIndex + 1 == Record.size() && PP.getPreprocessingRecord() &&
1344 Record[NextIndex]) {
1345 // We have a macro definition. Register the association
1346 PreprocessedEntityID
1347 GlobalID = getGlobalPreprocessedEntityID(F, Record[NextIndex]);
1348 PreprocessingRecord &PPRec = *PP.getPreprocessingRecord();
1349 PPRec.RegisterMacroDefinition(Macro,
1350 PPRec.getPPEntityID(GlobalID-1, /*isLoaded=*/true));
1351 }
1352
1353 ++NumMacrosRead;
1354 break;
1355 }
1356
1357 case PP_TOKEN: {
1358 // If we see a TOKEN before a PP_MACRO_*, then the file is
1359 // erroneous, just pretend we didn't see this.
1360 if (Macro == 0) break;
1361
1362 Token Tok;
1363 Tok.startToken();
1364 Tok.setLocation(ReadSourceLocation(F, Record[0]));
1365 Tok.setLength(Record[1]);
1366 if (IdentifierInfo *II = getLocalIdentifier(F, Record[2]))
1367 Tok.setIdentifierInfo(II);
1368 Tok.setKind((tok::TokenKind)Record[3]);
1369 Tok.setFlag((Token::TokenFlags)Record[4]);
1370 Macro->AddTokenToBody(Tok);
1371 break;
1372 }
1373 }
1374 }
1375 }
1376
1377 PreprocessedEntityID
getGlobalPreprocessedEntityID(ModuleFile & M,unsigned LocalID) const1378 ASTReader::getGlobalPreprocessedEntityID(ModuleFile &M, unsigned LocalID) const {
1379 ContinuousRangeMap<uint32_t, int, 2>::const_iterator
1380 I = M.PreprocessedEntityRemap.find(LocalID - NUM_PREDEF_PP_ENTITY_IDS);
1381 assert(I != M.PreprocessedEntityRemap.end()
1382 && "Invalid index into preprocessed entity index remap");
1383
1384 return LocalID + I->second;
1385 }
1386
ComputeHash(const char * path)1387 unsigned HeaderFileInfoTrait::ComputeHash(const char *path) {
1388 return llvm::HashString(llvm::sys::path::filename(path));
1389 }
1390
1391 HeaderFileInfoTrait::internal_key_type
GetInternalKey(const char * path)1392 HeaderFileInfoTrait::GetInternalKey(const char *path) { return path; }
1393
EqualKey(internal_key_type a,internal_key_type b)1394 bool HeaderFileInfoTrait::EqualKey(internal_key_type a, internal_key_type b) {
1395 if (strcmp(a, b) == 0)
1396 return true;
1397
1398 if (llvm::sys::path::filename(a) != llvm::sys::path::filename(b))
1399 return false;
1400
1401 // Determine whether the actual files are equivalent.
1402 bool Result = false;
1403 if (llvm::sys::fs::equivalent(a, b, Result))
1404 return false;
1405
1406 return Result;
1407 }
1408
1409 std::pair<unsigned, unsigned>
ReadKeyDataLength(const unsigned char * & d)1410 HeaderFileInfoTrait::ReadKeyDataLength(const unsigned char*& d) {
1411 unsigned KeyLen = (unsigned) clang::io::ReadUnalignedLE16(d);
1412 unsigned DataLen = (unsigned) *d++;
1413 return std::make_pair(KeyLen + 1, DataLen);
1414 }
1415
1416 HeaderFileInfoTrait::data_type
ReadData(const internal_key_type,const unsigned char * d,unsigned DataLen)1417 HeaderFileInfoTrait::ReadData(const internal_key_type, const unsigned char *d,
1418 unsigned DataLen) {
1419 const unsigned char *End = d + DataLen;
1420 using namespace clang::io;
1421 HeaderFileInfo HFI;
1422 unsigned Flags = *d++;
1423 HFI.isImport = (Flags >> 5) & 0x01;
1424 HFI.isPragmaOnce = (Flags >> 4) & 0x01;
1425 HFI.DirInfo = (Flags >> 2) & 0x03;
1426 HFI.Resolved = (Flags >> 1) & 0x01;
1427 HFI.IndexHeaderMapHeader = Flags & 0x01;
1428 HFI.NumIncludes = ReadUnalignedLE16(d);
1429 HFI.ControllingMacroID = Reader.getGlobalIdentifierID(M,
1430 ReadUnalignedLE32(d));
1431 if (unsigned FrameworkOffset = ReadUnalignedLE32(d)) {
1432 // The framework offset is 1 greater than the actual offset,
1433 // since 0 is used as an indicator for "no framework name".
1434 StringRef FrameworkName(FrameworkStrings + FrameworkOffset - 1);
1435 HFI.Framework = HS->getUniqueFrameworkName(FrameworkName);
1436 }
1437
1438 assert(End == d && "Wrong data length in HeaderFileInfo deserialization");
1439 (void)End;
1440
1441 // This HeaderFileInfo was externally loaded.
1442 HFI.External = true;
1443 return HFI;
1444 }
1445
setIdentifierIsMacro(IdentifierInfo * II,ModuleFile & F,uint64_t LocalOffset,bool Visible)1446 void ASTReader::setIdentifierIsMacro(IdentifierInfo *II, ModuleFile &F,
1447 uint64_t LocalOffset, bool Visible) {
1448 if (Visible) {
1449 // Note that this identifier has a macro definition.
1450 II->setHasMacroDefinition(true);
1451 }
1452
1453 // Adjust the offset to a global offset.
1454 UnreadMacroRecordOffsets[II] = F.GlobalBitOffset + LocalOffset;
1455 }
1456
ReadDefinedMacros()1457 void ASTReader::ReadDefinedMacros() {
1458 for (ModuleReverseIterator I = ModuleMgr.rbegin(),
1459 E = ModuleMgr.rend(); I != E; ++I) {
1460 llvm::BitstreamCursor &MacroCursor = (*I)->MacroCursor;
1461
1462 // If there was no preprocessor block, skip this file.
1463 if (!MacroCursor.getBitStreamReader())
1464 continue;
1465
1466 llvm::BitstreamCursor Cursor = MacroCursor;
1467 Cursor.JumpToBit((*I)->MacroStartOffset);
1468
1469 RecordData Record;
1470 while (true) {
1471 unsigned Code = Cursor.ReadCode();
1472 if (Code == llvm::bitc::END_BLOCK)
1473 break;
1474
1475 if (Code == llvm::bitc::ENTER_SUBBLOCK) {
1476 // No known subblocks, always skip them.
1477 Cursor.ReadSubBlockID();
1478 if (Cursor.SkipBlock()) {
1479 Error("malformed block record in AST file");
1480 return;
1481 }
1482 continue;
1483 }
1484
1485 if (Code == llvm::bitc::DEFINE_ABBREV) {
1486 Cursor.ReadAbbrevRecord();
1487 continue;
1488 }
1489
1490 // Read a record.
1491 const char *BlobStart;
1492 unsigned BlobLen;
1493 Record.clear();
1494 switch (Cursor.ReadRecord(Code, Record, &BlobStart, &BlobLen)) {
1495 default: // Default behavior: ignore.
1496 break;
1497
1498 case PP_MACRO_OBJECT_LIKE:
1499 case PP_MACRO_FUNCTION_LIKE:
1500 getLocalIdentifier(**I, Record[0]);
1501 break;
1502
1503 case PP_TOKEN:
1504 // Ignore tokens.
1505 break;
1506 }
1507 }
1508 }
1509
1510 // Drain the unread macro-record offsets map.
1511 while (!UnreadMacroRecordOffsets.empty())
1512 LoadMacroDefinition(UnreadMacroRecordOffsets.begin());
1513 }
1514
LoadMacroDefinition(llvm::DenseMap<IdentifierInfo *,uint64_t>::iterator Pos)1515 void ASTReader::LoadMacroDefinition(
1516 llvm::DenseMap<IdentifierInfo *, uint64_t>::iterator Pos) {
1517 assert(Pos != UnreadMacroRecordOffsets.end() && "Unknown macro definition");
1518 uint64_t Offset = Pos->second;
1519 UnreadMacroRecordOffsets.erase(Pos);
1520
1521 RecordLocation Loc = getLocalBitOffset(Offset);
1522 ReadMacroRecord(*Loc.F, Loc.Offset);
1523 }
1524
LoadMacroDefinition(IdentifierInfo * II)1525 void ASTReader::LoadMacroDefinition(IdentifierInfo *II) {
1526 llvm::DenseMap<IdentifierInfo *, uint64_t>::iterator Pos
1527 = UnreadMacroRecordOffsets.find(II);
1528 LoadMacroDefinition(Pos);
1529 }
1530
1531 namespace {
1532 /// \brief Visitor class used to look up identifirs in an AST file.
1533 class IdentifierLookupVisitor {
1534 StringRef Name;
1535 unsigned PriorGeneration;
1536 IdentifierInfo *Found;
1537 public:
IdentifierLookupVisitor(StringRef Name,unsigned PriorGeneration)1538 IdentifierLookupVisitor(StringRef Name, unsigned PriorGeneration)
1539 : Name(Name), PriorGeneration(PriorGeneration), Found() { }
1540
visit(ModuleFile & M,void * UserData)1541 static bool visit(ModuleFile &M, void *UserData) {
1542 IdentifierLookupVisitor *This
1543 = static_cast<IdentifierLookupVisitor *>(UserData);
1544
1545 // If we've already searched this module file, skip it now.
1546 if (M.Generation <= This->PriorGeneration)
1547 return true;
1548
1549 ASTIdentifierLookupTable *IdTable
1550 = (ASTIdentifierLookupTable *)M.IdentifierLookupTable;
1551 if (!IdTable)
1552 return false;
1553
1554 ASTIdentifierLookupTrait Trait(IdTable->getInfoObj().getReader(),
1555 M, This->Found);
1556
1557 std::pair<const char*, unsigned> Key(This->Name.begin(),
1558 This->Name.size());
1559 ASTIdentifierLookupTable::iterator Pos = IdTable->find(Key, &Trait);
1560 if (Pos == IdTable->end())
1561 return false;
1562
1563 // Dereferencing the iterator has the effect of building the
1564 // IdentifierInfo node and populating it with the various
1565 // declarations it needs.
1566 This->Found = *Pos;
1567 return true;
1568 }
1569
1570 // \brief Retrieve the identifier info found within the module
1571 // files.
getIdentifierInfo() const1572 IdentifierInfo *getIdentifierInfo() const { return Found; }
1573 };
1574 }
1575
updateOutOfDateIdentifier(IdentifierInfo & II)1576 void ASTReader::updateOutOfDateIdentifier(IdentifierInfo &II) {
1577 unsigned PriorGeneration = 0;
1578 if (getContext().getLangOpts().Modules)
1579 PriorGeneration = IdentifierGeneration[&II];
1580
1581 IdentifierLookupVisitor Visitor(II.getName(), PriorGeneration);
1582 ModuleMgr.visit(IdentifierLookupVisitor::visit, &Visitor);
1583 markIdentifierUpToDate(&II);
1584 }
1585
markIdentifierUpToDate(IdentifierInfo * II)1586 void ASTReader::markIdentifierUpToDate(IdentifierInfo *II) {
1587 if (!II)
1588 return;
1589
1590 II->setOutOfDate(false);
1591
1592 // Update the generation for this identifier.
1593 if (getContext().getLangOpts().Modules)
1594 IdentifierGeneration[II] = CurrentGeneration;
1595 }
1596
getFileEntry(StringRef filenameStrRef)1597 const FileEntry *ASTReader::getFileEntry(StringRef filenameStrRef) {
1598 std::string Filename = filenameStrRef;
1599 MaybeAddSystemRootToFilename(Filename);
1600 const FileEntry *File = FileMgr.getFile(Filename);
1601 if (File == 0 && !OriginalDir.empty() && !CurrentDir.empty() &&
1602 OriginalDir != CurrentDir) {
1603 std::string resolved = resolveFileRelativeToOriginalDir(Filename,
1604 OriginalDir,
1605 CurrentDir);
1606 if (!resolved.empty())
1607 File = FileMgr.getFile(resolved);
1608 }
1609
1610 return File;
1611 }
1612
1613 /// \brief If we are loading a relocatable PCH file, and the filename is
1614 /// not an absolute path, add the system root to the beginning of the file
1615 /// name.
MaybeAddSystemRootToFilename(std::string & Filename)1616 void ASTReader::MaybeAddSystemRootToFilename(std::string &Filename) {
1617 // If this is not a relocatable PCH file, there's nothing to do.
1618 if (!RelocatablePCH)
1619 return;
1620
1621 if (Filename.empty() || llvm::sys::path::is_absolute(Filename))
1622 return;
1623
1624 if (isysroot.empty()) {
1625 // If no system root was given, default to '/'
1626 Filename.insert(Filename.begin(), '/');
1627 return;
1628 }
1629
1630 unsigned Length = isysroot.size();
1631 if (isysroot[Length - 1] != '/')
1632 Filename.insert(Filename.begin(), '/');
1633
1634 Filename.insert(Filename.begin(), isysroot.begin(), isysroot.end());
1635 }
1636
1637 ASTReader::ASTReadResult
ReadASTBlock(ModuleFile & F)1638 ASTReader::ReadASTBlock(ModuleFile &F) {
1639 llvm::BitstreamCursor &Stream = F.Stream;
1640
1641 if (Stream.EnterSubBlock(AST_BLOCK_ID)) {
1642 Error("malformed block record in AST file");
1643 return Failure;
1644 }
1645
1646 // Read all of the records and blocks for the ASt file.
1647 RecordData Record;
1648 while (!Stream.AtEndOfStream()) {
1649 unsigned Code = Stream.ReadCode();
1650 if (Code == llvm::bitc::END_BLOCK) {
1651 if (Stream.ReadBlockEnd()) {
1652 Error("error at end of module block in AST file");
1653 return Failure;
1654 }
1655
1656 return Success;
1657 }
1658
1659 if (Code == llvm::bitc::ENTER_SUBBLOCK) {
1660 switch (Stream.ReadSubBlockID()) {
1661 case DECLTYPES_BLOCK_ID:
1662 // We lazily load the decls block, but we want to set up the
1663 // DeclsCursor cursor to point into it. Clone our current bitcode
1664 // cursor to it, enter the block and read the abbrevs in that block.
1665 // With the main cursor, we just skip over it.
1666 F.DeclsCursor = Stream;
1667 if (Stream.SkipBlock() || // Skip with the main cursor.
1668 // Read the abbrevs.
1669 ReadBlockAbbrevs(F.DeclsCursor, DECLTYPES_BLOCK_ID)) {
1670 Error("malformed block record in AST file");
1671 return Failure;
1672 }
1673 break;
1674
1675 case DECL_UPDATES_BLOCK_ID:
1676 if (Stream.SkipBlock()) {
1677 Error("malformed block record in AST file");
1678 return Failure;
1679 }
1680 break;
1681
1682 case PREPROCESSOR_BLOCK_ID:
1683 F.MacroCursor = Stream;
1684 if (!PP.getExternalSource())
1685 PP.setExternalSource(this);
1686
1687 if (Stream.SkipBlock() ||
1688 ReadBlockAbbrevs(F.MacroCursor, PREPROCESSOR_BLOCK_ID)) {
1689 Error("malformed block record in AST file");
1690 return Failure;
1691 }
1692 F.MacroStartOffset = F.MacroCursor.GetCurrentBitNo();
1693 break;
1694
1695 case PREPROCESSOR_DETAIL_BLOCK_ID:
1696 F.PreprocessorDetailCursor = Stream;
1697 if (Stream.SkipBlock() ||
1698 ReadBlockAbbrevs(F.PreprocessorDetailCursor,
1699 PREPROCESSOR_DETAIL_BLOCK_ID)) {
1700 Error("malformed preprocessor detail record in AST file");
1701 return Failure;
1702 }
1703 F.PreprocessorDetailStartOffset
1704 = F.PreprocessorDetailCursor.GetCurrentBitNo();
1705
1706 if (!PP.getPreprocessingRecord())
1707 PP.createPreprocessingRecord(/*RecordConditionalDirectives=*/false);
1708 if (!PP.getPreprocessingRecord()->getExternalSource())
1709 PP.getPreprocessingRecord()->SetExternalSource(*this);
1710 break;
1711
1712 case SOURCE_MANAGER_BLOCK_ID:
1713 switch (ReadSourceManagerBlock(F)) {
1714 case Success:
1715 break;
1716
1717 case Failure:
1718 Error("malformed source manager block in AST file");
1719 return Failure;
1720
1721 case IgnorePCH:
1722 return IgnorePCH;
1723 }
1724 break;
1725
1726 case SUBMODULE_BLOCK_ID:
1727 switch (ReadSubmoduleBlock(F)) {
1728 case Success:
1729 break;
1730
1731 case Failure:
1732 Error("malformed submodule block in AST file");
1733 return Failure;
1734
1735 case IgnorePCH:
1736 return IgnorePCH;
1737 }
1738 break;
1739
1740 default:
1741 if (!Stream.SkipBlock())
1742 break;
1743 Error("malformed block record in AST file");
1744 return Failure;
1745 }
1746 continue;
1747 }
1748
1749 if (Code == llvm::bitc::DEFINE_ABBREV) {
1750 Stream.ReadAbbrevRecord();
1751 continue;
1752 }
1753
1754 // Read and process a record.
1755 Record.clear();
1756 const char *BlobStart = 0;
1757 unsigned BlobLen = 0;
1758 switch ((ASTRecordTypes)Stream.ReadRecord(Code, Record,
1759 &BlobStart, &BlobLen)) {
1760 default: // Default behavior: ignore.
1761 break;
1762
1763 case METADATA: {
1764 if (Record[0] != VERSION_MAJOR && !DisableValidation) {
1765 Diag(Record[0] < VERSION_MAJOR? diag::warn_pch_version_too_old
1766 : diag::warn_pch_version_too_new);
1767 return IgnorePCH;
1768 }
1769
1770 bool hasErrors = Record[5];
1771 if (hasErrors && !DisableValidation && !AllowASTWithCompilerErrors) {
1772 Diag(diag::err_pch_with_compiler_errors);
1773 return IgnorePCH;
1774 }
1775
1776 RelocatablePCH = Record[4];
1777 if (Listener) {
1778 std::string TargetTriple(BlobStart, BlobLen);
1779 if (Listener->ReadTargetTriple(TargetTriple))
1780 return IgnorePCH;
1781 }
1782 break;
1783 }
1784
1785 case IMPORTS: {
1786 // Load each of the imported PCH files.
1787 unsigned Idx = 0, N = Record.size();
1788 while (Idx < N) {
1789 // Read information about the AST file.
1790 ModuleKind ImportedKind = (ModuleKind)Record[Idx++];
1791 unsigned Length = Record[Idx++];
1792 SmallString<128> ImportedFile(Record.begin() + Idx,
1793 Record.begin() + Idx + Length);
1794 Idx += Length;
1795
1796 // Load the AST file.
1797 switch(ReadASTCore(ImportedFile, ImportedKind, &F)) {
1798 case Failure: return Failure;
1799 // If we have to ignore the dependency, we'll have to ignore this too.
1800 case IgnorePCH: return IgnorePCH;
1801 case Success: break;
1802 }
1803 }
1804 break;
1805 }
1806
1807 case TYPE_OFFSET: {
1808 if (F.LocalNumTypes != 0) {
1809 Error("duplicate TYPE_OFFSET record in AST file");
1810 return Failure;
1811 }
1812 F.TypeOffsets = (const uint32_t *)BlobStart;
1813 F.LocalNumTypes = Record[0];
1814 unsigned LocalBaseTypeIndex = Record[1];
1815 F.BaseTypeIndex = getTotalNumTypes();
1816
1817 if (F.LocalNumTypes > 0) {
1818 // Introduce the global -> local mapping for types within this module.
1819 GlobalTypeMap.insert(std::make_pair(getTotalNumTypes(), &F));
1820
1821 // Introduce the local -> global mapping for types within this module.
1822 F.TypeRemap.insertOrReplace(
1823 std::make_pair(LocalBaseTypeIndex,
1824 F.BaseTypeIndex - LocalBaseTypeIndex));
1825
1826 TypesLoaded.resize(TypesLoaded.size() + F.LocalNumTypes);
1827 }
1828 break;
1829 }
1830
1831 case DECL_OFFSET: {
1832 if (F.LocalNumDecls != 0) {
1833 Error("duplicate DECL_OFFSET record in AST file");
1834 return Failure;
1835 }
1836 F.DeclOffsets = (const DeclOffset *)BlobStart;
1837 F.LocalNumDecls = Record[0];
1838 unsigned LocalBaseDeclID = Record[1];
1839 F.BaseDeclID = getTotalNumDecls();
1840
1841 if (F.LocalNumDecls > 0) {
1842 // Introduce the global -> local mapping for declarations within this
1843 // module.
1844 GlobalDeclMap.insert(
1845 std::make_pair(getTotalNumDecls() + NUM_PREDEF_DECL_IDS, &F));
1846
1847 // Introduce the local -> global mapping for declarations within this
1848 // module.
1849 F.DeclRemap.insertOrReplace(
1850 std::make_pair(LocalBaseDeclID, F.BaseDeclID - LocalBaseDeclID));
1851
1852 // Introduce the global -> local mapping for declarations within this
1853 // module.
1854 F.GlobalToLocalDeclIDs[&F] = LocalBaseDeclID;
1855
1856 DeclsLoaded.resize(DeclsLoaded.size() + F.LocalNumDecls);
1857 }
1858 break;
1859 }
1860
1861 case TU_UPDATE_LEXICAL: {
1862 DeclContext *TU = Context.getTranslationUnitDecl();
1863 DeclContextInfo &Info = F.DeclContextInfos[TU];
1864 Info.LexicalDecls = reinterpret_cast<const KindDeclIDPair *>(BlobStart);
1865 Info.NumLexicalDecls
1866 = static_cast<unsigned int>(BlobLen / sizeof(KindDeclIDPair));
1867 TU->setHasExternalLexicalStorage(true);
1868 break;
1869 }
1870
1871 case UPDATE_VISIBLE: {
1872 unsigned Idx = 0;
1873 serialization::DeclID ID = ReadDeclID(F, Record, Idx);
1874 ASTDeclContextNameLookupTable *Table =
1875 ASTDeclContextNameLookupTable::Create(
1876 (const unsigned char *)BlobStart + Record[Idx++],
1877 (const unsigned char *)BlobStart,
1878 ASTDeclContextNameLookupTrait(*this, F));
1879 if (ID == PREDEF_DECL_TRANSLATION_UNIT_ID) { // Is it the TU?
1880 DeclContext *TU = Context.getTranslationUnitDecl();
1881 F.DeclContextInfos[TU].NameLookupTableData = Table;
1882 TU->setHasExternalVisibleStorage(true);
1883 } else
1884 PendingVisibleUpdates[ID].push_back(std::make_pair(Table, &F));
1885 break;
1886 }
1887
1888 case LANGUAGE_OPTIONS:
1889 if (ParseLanguageOptions(Record) && !DisableValidation)
1890 return IgnorePCH;
1891 break;
1892
1893 case IDENTIFIER_TABLE:
1894 F.IdentifierTableData = BlobStart;
1895 if (Record[0]) {
1896 F.IdentifierLookupTable
1897 = ASTIdentifierLookupTable::Create(
1898 (const unsigned char *)F.IdentifierTableData + Record[0],
1899 (const unsigned char *)F.IdentifierTableData,
1900 ASTIdentifierLookupTrait(*this, F));
1901
1902 PP.getIdentifierTable().setExternalIdentifierLookup(this);
1903 }
1904 break;
1905
1906 case IDENTIFIER_OFFSET: {
1907 if (F.LocalNumIdentifiers != 0) {
1908 Error("duplicate IDENTIFIER_OFFSET record in AST file");
1909 return Failure;
1910 }
1911 F.IdentifierOffsets = (const uint32_t *)BlobStart;
1912 F.LocalNumIdentifiers = Record[0];
1913 unsigned LocalBaseIdentifierID = Record[1];
1914 F.BaseIdentifierID = getTotalNumIdentifiers();
1915
1916 if (F.LocalNumIdentifiers > 0) {
1917 // Introduce the global -> local mapping for identifiers within this
1918 // module.
1919 GlobalIdentifierMap.insert(std::make_pair(getTotalNumIdentifiers() + 1,
1920 &F));
1921
1922 // Introduce the local -> global mapping for identifiers within this
1923 // module.
1924 F.IdentifierRemap.insertOrReplace(
1925 std::make_pair(LocalBaseIdentifierID,
1926 F.BaseIdentifierID - LocalBaseIdentifierID));
1927
1928 IdentifiersLoaded.resize(IdentifiersLoaded.size()
1929 + F.LocalNumIdentifiers);
1930 }
1931 break;
1932 }
1933
1934 case EXTERNAL_DEFINITIONS:
1935 for (unsigned I = 0, N = Record.size(); I != N; ++I)
1936 ExternalDefinitions.push_back(getGlobalDeclID(F, Record[I]));
1937 break;
1938
1939 case SPECIAL_TYPES:
1940 for (unsigned I = 0, N = Record.size(); I != N; ++I)
1941 SpecialTypes.push_back(getGlobalTypeID(F, Record[I]));
1942 break;
1943
1944 case STATISTICS:
1945 TotalNumStatements += Record[0];
1946 TotalNumMacros += Record[1];
1947 TotalLexicalDeclContexts += Record[2];
1948 TotalVisibleDeclContexts += Record[3];
1949 break;
1950
1951 case UNUSED_FILESCOPED_DECLS:
1952 for (unsigned I = 0, N = Record.size(); I != N; ++I)
1953 UnusedFileScopedDecls.push_back(getGlobalDeclID(F, Record[I]));
1954 break;
1955
1956 case DELEGATING_CTORS:
1957 for (unsigned I = 0, N = Record.size(); I != N; ++I)
1958 DelegatingCtorDecls.push_back(getGlobalDeclID(F, Record[I]));
1959 break;
1960
1961 case WEAK_UNDECLARED_IDENTIFIERS:
1962 if (Record.size() % 4 != 0) {
1963 Error("invalid weak identifiers record");
1964 return Failure;
1965 }
1966
1967 // FIXME: Ignore weak undeclared identifiers from non-original PCH
1968 // files. This isn't the way to do it :)
1969 WeakUndeclaredIdentifiers.clear();
1970
1971 // Translate the weak, undeclared identifiers into global IDs.
1972 for (unsigned I = 0, N = Record.size(); I < N; /* in loop */) {
1973 WeakUndeclaredIdentifiers.push_back(
1974 getGlobalIdentifierID(F, Record[I++]));
1975 WeakUndeclaredIdentifiers.push_back(
1976 getGlobalIdentifierID(F, Record[I++]));
1977 WeakUndeclaredIdentifiers.push_back(
1978 ReadSourceLocation(F, Record, I).getRawEncoding());
1979 WeakUndeclaredIdentifiers.push_back(Record[I++]);
1980 }
1981 break;
1982
1983 case LOCALLY_SCOPED_EXTERNAL_DECLS:
1984 for (unsigned I = 0, N = Record.size(); I != N; ++I)
1985 LocallyScopedExternalDecls.push_back(getGlobalDeclID(F, Record[I]));
1986 break;
1987
1988 case SELECTOR_OFFSETS: {
1989 F.SelectorOffsets = (const uint32_t *)BlobStart;
1990 F.LocalNumSelectors = Record[0];
1991 unsigned LocalBaseSelectorID = Record[1];
1992 F.BaseSelectorID = getTotalNumSelectors();
1993
1994 if (F.LocalNumSelectors > 0) {
1995 // Introduce the global -> local mapping for selectors within this
1996 // module.
1997 GlobalSelectorMap.insert(std::make_pair(getTotalNumSelectors()+1, &F));
1998
1999 // Introduce the local -> global mapping for selectors within this
2000 // module.
2001 F.SelectorRemap.insertOrReplace(
2002 std::make_pair(LocalBaseSelectorID,
2003 F.BaseSelectorID - LocalBaseSelectorID));
2004
2005 SelectorsLoaded.resize(SelectorsLoaded.size() + F.LocalNumSelectors);
2006 }
2007 break;
2008 }
2009
2010 case METHOD_POOL:
2011 F.SelectorLookupTableData = (const unsigned char *)BlobStart;
2012 if (Record[0])
2013 F.SelectorLookupTable
2014 = ASTSelectorLookupTable::Create(
2015 F.SelectorLookupTableData + Record[0],
2016 F.SelectorLookupTableData,
2017 ASTSelectorLookupTrait(*this, F));
2018 TotalNumMethodPoolEntries += Record[1];
2019 break;
2020
2021 case REFERENCED_SELECTOR_POOL:
2022 if (!Record.empty()) {
2023 for (unsigned Idx = 0, N = Record.size() - 1; Idx < N; /* in loop */) {
2024 ReferencedSelectorsData.push_back(getGlobalSelectorID(F,
2025 Record[Idx++]));
2026 ReferencedSelectorsData.push_back(ReadSourceLocation(F, Record, Idx).
2027 getRawEncoding());
2028 }
2029 }
2030 break;
2031
2032 case PP_COUNTER_VALUE:
2033 if (!Record.empty() && Listener)
2034 Listener->ReadCounter(Record[0]);
2035 break;
2036
2037 case FILE_SORTED_DECLS:
2038 F.FileSortedDecls = (const DeclID *)BlobStart;
2039 break;
2040
2041 case SOURCE_LOCATION_OFFSETS: {
2042 F.SLocEntryOffsets = (const uint32_t *)BlobStart;
2043 F.LocalNumSLocEntries = Record[0];
2044 unsigned SLocSpaceSize = Record[1];
2045 llvm::tie(F.SLocEntryBaseID, F.SLocEntryBaseOffset) =
2046 SourceMgr.AllocateLoadedSLocEntries(F.LocalNumSLocEntries,
2047 SLocSpaceSize);
2048 // Make our entry in the range map. BaseID is negative and growing, so
2049 // we invert it. Because we invert it, though, we need the other end of
2050 // the range.
2051 unsigned RangeStart =
2052 unsigned(-F.SLocEntryBaseID) - F.LocalNumSLocEntries + 1;
2053 GlobalSLocEntryMap.insert(std::make_pair(RangeStart, &F));
2054 F.FirstLoc = SourceLocation::getFromRawEncoding(F.SLocEntryBaseOffset);
2055
2056 // SLocEntryBaseOffset is lower than MaxLoadedOffset and decreasing.
2057 assert((F.SLocEntryBaseOffset & (1U << 31U)) == 0);
2058 GlobalSLocOffsetMap.insert(
2059 std::make_pair(SourceManager::MaxLoadedOffset - F.SLocEntryBaseOffset
2060 - SLocSpaceSize,&F));
2061
2062 // Initialize the remapping table.
2063 // Invalid stays invalid.
2064 F.SLocRemap.insert(std::make_pair(0U, 0));
2065 // This module. Base was 2 when being compiled.
2066 F.SLocRemap.insert(std::make_pair(2U,
2067 static_cast<int>(F.SLocEntryBaseOffset - 2)));
2068
2069 TotalNumSLocEntries += F.LocalNumSLocEntries;
2070 break;
2071 }
2072
2073 case MODULE_OFFSET_MAP: {
2074 // Additional remapping information.
2075 const unsigned char *Data = (const unsigned char*)BlobStart;
2076 const unsigned char *DataEnd = Data + BlobLen;
2077
2078 // Continuous range maps we may be updating in our module.
2079 ContinuousRangeMap<uint32_t, int, 2>::Builder SLocRemap(F.SLocRemap);
2080 ContinuousRangeMap<uint32_t, int, 2>::Builder
2081 IdentifierRemap(F.IdentifierRemap);
2082 ContinuousRangeMap<uint32_t, int, 2>::Builder
2083 PreprocessedEntityRemap(F.PreprocessedEntityRemap);
2084 ContinuousRangeMap<uint32_t, int, 2>::Builder
2085 SubmoduleRemap(F.SubmoduleRemap);
2086 ContinuousRangeMap<uint32_t, int, 2>::Builder
2087 SelectorRemap(F.SelectorRemap);
2088 ContinuousRangeMap<uint32_t, int, 2>::Builder DeclRemap(F.DeclRemap);
2089 ContinuousRangeMap<uint32_t, int, 2>::Builder TypeRemap(F.TypeRemap);
2090
2091 while(Data < DataEnd) {
2092 uint16_t Len = io::ReadUnalignedLE16(Data);
2093 StringRef Name = StringRef((const char*)Data, Len);
2094 Data += Len;
2095 ModuleFile *OM = ModuleMgr.lookup(Name);
2096 if (!OM) {
2097 Error("SourceLocation remap refers to unknown module");
2098 return Failure;
2099 }
2100
2101 uint32_t SLocOffset = io::ReadUnalignedLE32(Data);
2102 uint32_t IdentifierIDOffset = io::ReadUnalignedLE32(Data);
2103 uint32_t PreprocessedEntityIDOffset = io::ReadUnalignedLE32(Data);
2104 uint32_t SubmoduleIDOffset = io::ReadUnalignedLE32(Data);
2105 uint32_t SelectorIDOffset = io::ReadUnalignedLE32(Data);
2106 uint32_t DeclIDOffset = io::ReadUnalignedLE32(Data);
2107 uint32_t TypeIndexOffset = io::ReadUnalignedLE32(Data);
2108
2109 // Source location offset is mapped to OM->SLocEntryBaseOffset.
2110 SLocRemap.insert(std::make_pair(SLocOffset,
2111 static_cast<int>(OM->SLocEntryBaseOffset - SLocOffset)));
2112 IdentifierRemap.insert(
2113 std::make_pair(IdentifierIDOffset,
2114 OM->BaseIdentifierID - IdentifierIDOffset));
2115 PreprocessedEntityRemap.insert(
2116 std::make_pair(PreprocessedEntityIDOffset,
2117 OM->BasePreprocessedEntityID - PreprocessedEntityIDOffset));
2118 SubmoduleRemap.insert(std::make_pair(SubmoduleIDOffset,
2119 OM->BaseSubmoduleID - SubmoduleIDOffset));
2120 SelectorRemap.insert(std::make_pair(SelectorIDOffset,
2121 OM->BaseSelectorID - SelectorIDOffset));
2122 DeclRemap.insert(std::make_pair(DeclIDOffset,
2123 OM->BaseDeclID - DeclIDOffset));
2124
2125 TypeRemap.insert(std::make_pair(TypeIndexOffset,
2126 OM->BaseTypeIndex - TypeIndexOffset));
2127
2128 // Global -> local mappings.
2129 F.GlobalToLocalDeclIDs[OM] = DeclIDOffset;
2130 }
2131 break;
2132 }
2133
2134 case SOURCE_MANAGER_LINE_TABLE:
2135 if (ParseLineTable(F, Record))
2136 return Failure;
2137 break;
2138
2139 case FILE_SOURCE_LOCATION_OFFSETS:
2140 F.SLocFileOffsets = (const uint32_t *)BlobStart;
2141 F.LocalNumSLocFileEntries = Record[0];
2142 break;
2143
2144 case SOURCE_LOCATION_PRELOADS: {
2145 // Need to transform from the local view (1-based IDs) to the global view,
2146 // which is based off F.SLocEntryBaseID.
2147 if (!F.PreloadSLocEntries.empty()) {
2148 Error("Multiple SOURCE_LOCATION_PRELOADS records in AST file");
2149 return Failure;
2150 }
2151
2152 F.PreloadSLocEntries.swap(Record);
2153 break;
2154 }
2155
2156 case STAT_CACHE: {
2157 if (!DisableStatCache) {
2158 ASTStatCache *MyStatCache =
2159 new ASTStatCache((const unsigned char *)BlobStart + Record[0],
2160 (const unsigned char *)BlobStart,
2161 NumStatHits, NumStatMisses);
2162 FileMgr.addStatCache(MyStatCache);
2163 F.StatCache = MyStatCache;
2164 }
2165 break;
2166 }
2167
2168 case EXT_VECTOR_DECLS:
2169 for (unsigned I = 0, N = Record.size(); I != N; ++I)
2170 ExtVectorDecls.push_back(getGlobalDeclID(F, Record[I]));
2171 break;
2172
2173 case VTABLE_USES:
2174 if (Record.size() % 3 != 0) {
2175 Error("Invalid VTABLE_USES record");
2176 return Failure;
2177 }
2178
2179 // Later tables overwrite earlier ones.
2180 // FIXME: Modules will have some trouble with this. This is clearly not
2181 // the right way to do this.
2182 VTableUses.clear();
2183
2184 for (unsigned Idx = 0, N = Record.size(); Idx != N; /* In loop */) {
2185 VTableUses.push_back(getGlobalDeclID(F, Record[Idx++]));
2186 VTableUses.push_back(
2187 ReadSourceLocation(F, Record, Idx).getRawEncoding());
2188 VTableUses.push_back(Record[Idx++]);
2189 }
2190 break;
2191
2192 case DYNAMIC_CLASSES:
2193 for (unsigned I = 0, N = Record.size(); I != N; ++I)
2194 DynamicClasses.push_back(getGlobalDeclID(F, Record[I]));
2195 break;
2196
2197 case PENDING_IMPLICIT_INSTANTIATIONS:
2198 if (PendingInstantiations.size() % 2 != 0) {
2199 Error("Invalid PENDING_IMPLICIT_INSTANTIATIONS block");
2200 return Failure;
2201 }
2202
2203 // Later lists of pending instantiations overwrite earlier ones.
2204 // FIXME: This is most certainly wrong for modules.
2205 PendingInstantiations.clear();
2206 for (unsigned I = 0, N = Record.size(); I != N; /* in loop */) {
2207 PendingInstantiations.push_back(getGlobalDeclID(F, Record[I++]));
2208 PendingInstantiations.push_back(
2209 ReadSourceLocation(F, Record, I).getRawEncoding());
2210 }
2211 break;
2212
2213 case SEMA_DECL_REFS:
2214 // Later tables overwrite earlier ones.
2215 // FIXME: Modules will have some trouble with this.
2216 SemaDeclRefs.clear();
2217 for (unsigned I = 0, N = Record.size(); I != N; ++I)
2218 SemaDeclRefs.push_back(getGlobalDeclID(F, Record[I]));
2219 break;
2220
2221 case ORIGINAL_FILE_NAME:
2222 // The primary AST will be the last to get here, so it will be the one
2223 // that's used.
2224 ActualOriginalFileName.assign(BlobStart, BlobLen);
2225 OriginalFileName = ActualOriginalFileName;
2226 MaybeAddSystemRootToFilename(OriginalFileName);
2227 break;
2228
2229 case ORIGINAL_FILE_ID:
2230 OriginalFileID = FileID::get(Record[0]);
2231 break;
2232
2233 case ORIGINAL_PCH_DIR:
2234 // The primary AST will be the last to get here, so it will be the one
2235 // that's used.
2236 OriginalDir.assign(BlobStart, BlobLen);
2237 break;
2238
2239 case VERSION_CONTROL_BRANCH_REVISION: {
2240 const std::string &CurBranch = getClangFullRepositoryVersion();
2241 StringRef ASTBranch(BlobStart, BlobLen);
2242 if (StringRef(CurBranch) != ASTBranch && !DisableValidation) {
2243 Diag(diag::warn_pch_different_branch) << ASTBranch << CurBranch;
2244 return IgnorePCH;
2245 }
2246 break;
2247 }
2248
2249 case PPD_ENTITIES_OFFSETS: {
2250 F.PreprocessedEntityOffsets = (const PPEntityOffset *)BlobStart;
2251 assert(BlobLen % sizeof(PPEntityOffset) == 0);
2252 F.NumPreprocessedEntities = BlobLen / sizeof(PPEntityOffset);
2253
2254 unsigned LocalBasePreprocessedEntityID = Record[0];
2255
2256 unsigned StartingID;
2257 if (!PP.getPreprocessingRecord())
2258 PP.createPreprocessingRecord(/*RecordConditionalDirectives=*/false);
2259 if (!PP.getPreprocessingRecord()->getExternalSource())
2260 PP.getPreprocessingRecord()->SetExternalSource(*this);
2261 StartingID
2262 = PP.getPreprocessingRecord()
2263 ->allocateLoadedEntities(F.NumPreprocessedEntities);
2264 F.BasePreprocessedEntityID = StartingID;
2265
2266 if (F.NumPreprocessedEntities > 0) {
2267 // Introduce the global -> local mapping for preprocessed entities in
2268 // this module.
2269 GlobalPreprocessedEntityMap.insert(std::make_pair(StartingID, &F));
2270
2271 // Introduce the local -> global mapping for preprocessed entities in
2272 // this module.
2273 F.PreprocessedEntityRemap.insertOrReplace(
2274 std::make_pair(LocalBasePreprocessedEntityID,
2275 F.BasePreprocessedEntityID - LocalBasePreprocessedEntityID));
2276 }
2277
2278 break;
2279 }
2280
2281 case DECL_UPDATE_OFFSETS: {
2282 if (Record.size() % 2 != 0) {
2283 Error("invalid DECL_UPDATE_OFFSETS block in AST file");
2284 return Failure;
2285 }
2286 for (unsigned I = 0, N = Record.size(); I != N; I += 2)
2287 DeclUpdateOffsets[getGlobalDeclID(F, Record[I])]
2288 .push_back(std::make_pair(&F, Record[I+1]));
2289 break;
2290 }
2291
2292 case DECL_REPLACEMENTS: {
2293 if (Record.size() % 3 != 0) {
2294 Error("invalid DECL_REPLACEMENTS block in AST file");
2295 return Failure;
2296 }
2297 for (unsigned I = 0, N = Record.size(); I != N; I += 3)
2298 ReplacedDecls[getGlobalDeclID(F, Record[I])]
2299 = ReplacedDeclInfo(&F, Record[I+1], Record[I+2]);
2300 break;
2301 }
2302
2303 case OBJC_CATEGORIES_MAP: {
2304 if (F.LocalNumObjCCategoriesInMap != 0) {
2305 Error("duplicate OBJC_CATEGORIES_MAP record in AST file");
2306 return Failure;
2307 }
2308
2309 F.LocalNumObjCCategoriesInMap = Record[0];
2310 F.ObjCCategoriesMap = (const ObjCCategoriesInfo *)BlobStart;
2311 break;
2312 }
2313
2314 case OBJC_CATEGORIES:
2315 F.ObjCCategories.swap(Record);
2316 break;
2317
2318 case CXX_BASE_SPECIFIER_OFFSETS: {
2319 if (F.LocalNumCXXBaseSpecifiers != 0) {
2320 Error("duplicate CXX_BASE_SPECIFIER_OFFSETS record in AST file");
2321 return Failure;
2322 }
2323
2324 F.LocalNumCXXBaseSpecifiers = Record[0];
2325 F.CXXBaseSpecifiersOffsets = (const uint32_t *)BlobStart;
2326 NumCXXBaseSpecifiersLoaded += F.LocalNumCXXBaseSpecifiers;
2327 break;
2328 }
2329
2330 case DIAG_PRAGMA_MAPPINGS:
2331 if (Record.size() % 2 != 0) {
2332 Error("invalid DIAG_USER_MAPPINGS block in AST file");
2333 return Failure;
2334 }
2335
2336 if (F.PragmaDiagMappings.empty())
2337 F.PragmaDiagMappings.swap(Record);
2338 else
2339 F.PragmaDiagMappings.insert(F.PragmaDiagMappings.end(),
2340 Record.begin(), Record.end());
2341 break;
2342
2343 case CUDA_SPECIAL_DECL_REFS:
2344 // Later tables overwrite earlier ones.
2345 // FIXME: Modules will have trouble with this.
2346 CUDASpecialDeclRefs.clear();
2347 for (unsigned I = 0, N = Record.size(); I != N; ++I)
2348 CUDASpecialDeclRefs.push_back(getGlobalDeclID(F, Record[I]));
2349 break;
2350
2351 case HEADER_SEARCH_TABLE: {
2352 F.HeaderFileInfoTableData = BlobStart;
2353 F.LocalNumHeaderFileInfos = Record[1];
2354 F.HeaderFileFrameworkStrings = BlobStart + Record[2];
2355 if (Record[0]) {
2356 F.HeaderFileInfoTable
2357 = HeaderFileInfoLookupTable::Create(
2358 (const unsigned char *)F.HeaderFileInfoTableData + Record[0],
2359 (const unsigned char *)F.HeaderFileInfoTableData,
2360 HeaderFileInfoTrait(*this, F,
2361 &PP.getHeaderSearchInfo(),
2362 BlobStart + Record[2]));
2363
2364 PP.getHeaderSearchInfo().SetExternalSource(this);
2365 if (!PP.getHeaderSearchInfo().getExternalLookup())
2366 PP.getHeaderSearchInfo().SetExternalLookup(this);
2367 }
2368 break;
2369 }
2370
2371 case FP_PRAGMA_OPTIONS:
2372 // Later tables overwrite earlier ones.
2373 FPPragmaOptions.swap(Record);
2374 break;
2375
2376 case OPENCL_EXTENSIONS:
2377 // Later tables overwrite earlier ones.
2378 OpenCLExtensions.swap(Record);
2379 break;
2380
2381 case TENTATIVE_DEFINITIONS:
2382 for (unsigned I = 0, N = Record.size(); I != N; ++I)
2383 TentativeDefinitions.push_back(getGlobalDeclID(F, Record[I]));
2384 break;
2385
2386 case KNOWN_NAMESPACES:
2387 for (unsigned I = 0, N = Record.size(); I != N; ++I)
2388 KnownNamespaces.push_back(getGlobalDeclID(F, Record[I]));
2389 break;
2390
2391 case IMPORTED_MODULES: {
2392 if (F.Kind != MK_Module) {
2393 // If we aren't loading a module (which has its own exports), make
2394 // all of the imported modules visible.
2395 // FIXME: Deal with macros-only imports.
2396 for (unsigned I = 0, N = Record.size(); I != N; ++I) {
2397 if (unsigned GlobalID = getGlobalSubmoduleID(F, Record[I]))
2398 ImportedModules.push_back(GlobalID);
2399 }
2400 }
2401 break;
2402 }
2403
2404 case LOCAL_REDECLARATIONS: {
2405 F.RedeclarationChains.swap(Record);
2406 break;
2407 }
2408
2409 case LOCAL_REDECLARATIONS_MAP: {
2410 if (F.LocalNumRedeclarationsInMap != 0) {
2411 Error("duplicate LOCAL_REDECLARATIONS_MAP record in AST file");
2412 return Failure;
2413 }
2414
2415 F.LocalNumRedeclarationsInMap = Record[0];
2416 F.RedeclarationsMap = (const LocalRedeclarationsInfo *)BlobStart;
2417 break;
2418 }
2419
2420 case MERGED_DECLARATIONS: {
2421 for (unsigned Idx = 0; Idx < Record.size(); /* increment in loop */) {
2422 GlobalDeclID CanonID = getGlobalDeclID(F, Record[Idx++]);
2423 SmallVectorImpl<GlobalDeclID> &Decls = StoredMergedDecls[CanonID];
2424 for (unsigned N = Record[Idx++]; N > 0; --N)
2425 Decls.push_back(getGlobalDeclID(F, Record[Idx++]));
2426 }
2427 break;
2428 }
2429 }
2430 }
2431 Error("premature end of bitstream in AST file");
2432 return Failure;
2433 }
2434
validateFileEntries(ModuleFile & M)2435 ASTReader::ASTReadResult ASTReader::validateFileEntries(ModuleFile &M) {
2436 llvm::BitstreamCursor &SLocEntryCursor = M.SLocEntryCursor;
2437
2438 for (unsigned i = 0, e = M.LocalNumSLocFileEntries; i != e; ++i) {
2439 SLocEntryCursor.JumpToBit(M.SLocFileOffsets[i]);
2440 unsigned Code = SLocEntryCursor.ReadCode();
2441 if (Code == llvm::bitc::END_BLOCK ||
2442 Code == llvm::bitc::ENTER_SUBBLOCK ||
2443 Code == llvm::bitc::DEFINE_ABBREV) {
2444 Error("incorrectly-formatted source location entry in AST file");
2445 return Failure;
2446 }
2447
2448 RecordData Record;
2449 const char *BlobStart;
2450 unsigned BlobLen;
2451 switch (SLocEntryCursor.ReadRecord(Code, Record, &BlobStart, &BlobLen)) {
2452 default:
2453 Error("incorrectly-formatted source location entry in AST file");
2454 return Failure;
2455
2456 case SM_SLOC_FILE_ENTRY: {
2457 // If the buffer was overridden, the file need not exist.
2458 if (Record[6])
2459 break;
2460
2461 StringRef Filename(BlobStart, BlobLen);
2462 const FileEntry *File = getFileEntry(Filename);
2463
2464 if (File == 0) {
2465 std::string ErrorStr = "could not find file '";
2466 ErrorStr += Filename;
2467 ErrorStr += "' referenced by AST file";
2468 Error(ErrorStr.c_str());
2469 return IgnorePCH;
2470 }
2471
2472 if (Record.size() < 7) {
2473 Error("source location entry is incorrect");
2474 return Failure;
2475 }
2476
2477 // The stat info from the FileEntry came from the cached stat
2478 // info of the PCH, so we cannot trust it.
2479 struct stat StatBuf;
2480 if (::stat(File->getName(), &StatBuf) != 0) {
2481 StatBuf.st_size = File->getSize();
2482 StatBuf.st_mtime = File->getModificationTime();
2483 }
2484
2485 if (((off_t)Record[4] != StatBuf.st_size
2486 #if !defined(LLVM_ON_WIN32)
2487 // In our regression testing, the Windows file system seems to
2488 // have inconsistent modification times that sometimes
2489 // erroneously trigger this error-handling path.
2490 || (time_t)Record[5] != StatBuf.st_mtime
2491 #endif
2492 )) {
2493 Error(diag::err_fe_pch_file_modified, Filename);
2494 return IgnorePCH;
2495 }
2496
2497 break;
2498 }
2499 }
2500 }
2501
2502 return Success;
2503 }
2504
makeNamesVisible(const HiddenNames & Names)2505 void ASTReader::makeNamesVisible(const HiddenNames &Names) {
2506 for (unsigned I = 0, N = Names.size(); I != N; ++I) {
2507 if (Decl *D = Names[I].dyn_cast<Decl *>())
2508 D->Hidden = false;
2509 else {
2510 IdentifierInfo *II = Names[I].get<IdentifierInfo *>();
2511 if (!II->hasMacroDefinition()) {
2512 II->setHasMacroDefinition(true);
2513 if (DeserializationListener)
2514 DeserializationListener->MacroVisible(II);
2515 }
2516 }
2517 }
2518 }
2519
makeModuleVisible(Module * Mod,Module::NameVisibilityKind NameVisibility)2520 void ASTReader::makeModuleVisible(Module *Mod,
2521 Module::NameVisibilityKind NameVisibility) {
2522 llvm::SmallPtrSet<Module *, 4> Visited;
2523 llvm::SmallVector<Module *, 4> Stack;
2524 Stack.push_back(Mod);
2525 while (!Stack.empty()) {
2526 Mod = Stack.back();
2527 Stack.pop_back();
2528
2529 if (NameVisibility <= Mod->NameVisibility) {
2530 // This module already has this level of visibility (or greater), so
2531 // there is nothing more to do.
2532 continue;
2533 }
2534
2535 if (!Mod->isAvailable()) {
2536 // Modules that aren't available cannot be made visible.
2537 continue;
2538 }
2539
2540 // Update the module's name visibility.
2541 Mod->NameVisibility = NameVisibility;
2542
2543 // If we've already deserialized any names from this module,
2544 // mark them as visible.
2545 HiddenNamesMapType::iterator Hidden = HiddenNamesMap.find(Mod);
2546 if (Hidden != HiddenNamesMap.end()) {
2547 makeNamesVisible(Hidden->second);
2548 HiddenNamesMap.erase(Hidden);
2549 }
2550
2551 // Push any non-explicit submodules onto the stack to be marked as
2552 // visible.
2553 for (Module::submodule_iterator Sub = Mod->submodule_begin(),
2554 SubEnd = Mod->submodule_end();
2555 Sub != SubEnd; ++Sub) {
2556 if (!(*Sub)->IsExplicit && Visited.insert(*Sub))
2557 Stack.push_back(*Sub);
2558 }
2559
2560 // Push any exported modules onto the stack to be marked as visible.
2561 bool AnyWildcard = false;
2562 bool UnrestrictedWildcard = false;
2563 llvm::SmallVector<Module *, 4> WildcardRestrictions;
2564 for (unsigned I = 0, N = Mod->Exports.size(); I != N; ++I) {
2565 Module *Exported = Mod->Exports[I].getPointer();
2566 if (!Mod->Exports[I].getInt()) {
2567 // Export a named module directly; no wildcards involved.
2568 if (Visited.insert(Exported))
2569 Stack.push_back(Exported);
2570
2571 continue;
2572 }
2573
2574 // Wildcard export: export all of the imported modules that match
2575 // the given pattern.
2576 AnyWildcard = true;
2577 if (UnrestrictedWildcard)
2578 continue;
2579
2580 if (Module *Restriction = Mod->Exports[I].getPointer())
2581 WildcardRestrictions.push_back(Restriction);
2582 else {
2583 WildcardRestrictions.clear();
2584 UnrestrictedWildcard = true;
2585 }
2586 }
2587
2588 // If there were any wildcards, push any imported modules that were
2589 // re-exported by the wildcard restriction.
2590 if (!AnyWildcard)
2591 continue;
2592
2593 for (unsigned I = 0, N = Mod->Imports.size(); I != N; ++I) {
2594 Module *Imported = Mod->Imports[I];
2595 if (Visited.count(Imported))
2596 continue;
2597
2598 bool Acceptable = UnrestrictedWildcard;
2599 if (!Acceptable) {
2600 // Check whether this module meets one of the restrictions.
2601 for (unsigned R = 0, NR = WildcardRestrictions.size(); R != NR; ++R) {
2602 Module *Restriction = WildcardRestrictions[R];
2603 if (Imported == Restriction || Imported->isSubModuleOf(Restriction)) {
2604 Acceptable = true;
2605 break;
2606 }
2607 }
2608 }
2609
2610 if (!Acceptable)
2611 continue;
2612
2613 Visited.insert(Imported);
2614 Stack.push_back(Imported);
2615 }
2616 }
2617 }
2618
ReadAST(const std::string & FileName,ModuleKind Type)2619 ASTReader::ASTReadResult ASTReader::ReadAST(const std::string &FileName,
2620 ModuleKind Type) {
2621 // Bump the generation number.
2622 unsigned PreviousGeneration = CurrentGeneration++;
2623
2624 switch(ReadASTCore(FileName, Type, /*ImportedBy=*/0)) {
2625 case Failure: return Failure;
2626 case IgnorePCH: return IgnorePCH;
2627 case Success: break;
2628 }
2629
2630 // Here comes stuff that we only do once the entire chain is loaded.
2631
2632 // Check the predefines buffers.
2633 if (!DisableValidation && Type == MK_PCH &&
2634 // FIXME: CheckPredefinesBuffers also sets the SuggestedPredefines;
2635 // if DisableValidation is true, defines that were set on command-line
2636 // but not in the PCH file will not be added to SuggestedPredefines.
2637 CheckPredefinesBuffers())
2638 return IgnorePCH;
2639
2640 // Mark all of the identifiers in the identifier table as being out of date,
2641 // so that various accessors know to check the loaded modules when the
2642 // identifier is used.
2643 for (IdentifierTable::iterator Id = PP.getIdentifierTable().begin(),
2644 IdEnd = PP.getIdentifierTable().end();
2645 Id != IdEnd; ++Id)
2646 Id->second->setOutOfDate(true);
2647
2648 // Resolve any unresolved module exports.
2649 for (unsigned I = 0, N = UnresolvedModuleImportExports.size(); I != N; ++I) {
2650 UnresolvedModuleImportExport &Unresolved = UnresolvedModuleImportExports[I];
2651 SubmoduleID GlobalID = getGlobalSubmoduleID(*Unresolved.File,Unresolved.ID);
2652 Module *ResolvedMod = getSubmodule(GlobalID);
2653
2654 if (Unresolved.IsImport) {
2655 if (ResolvedMod)
2656 Unresolved.Mod->Imports.push_back(ResolvedMod);
2657 continue;
2658 }
2659
2660 if (ResolvedMod || Unresolved.IsWildcard)
2661 Unresolved.Mod->Exports.push_back(
2662 Module::ExportDecl(ResolvedMod, Unresolved.IsWildcard));
2663 }
2664 UnresolvedModuleImportExports.clear();
2665
2666 InitializeContext();
2667
2668 if (DeserializationListener)
2669 DeserializationListener->ReaderInitialized(this);
2670
2671 if (!OriginalFileID.isInvalid()) {
2672 OriginalFileID = FileID::get(ModuleMgr.getPrimaryModule().SLocEntryBaseID
2673 + OriginalFileID.getOpaqueValue() - 1);
2674
2675 // If this AST file is a precompiled preamble, then set the preamble file ID
2676 // of the source manager to the file source file from which the preamble was
2677 // built.
2678 if (Type == MK_Preamble) {
2679 SourceMgr.setPreambleFileID(OriginalFileID);
2680 } else if (Type == MK_MainFile) {
2681 SourceMgr.setMainFileID(OriginalFileID);
2682 }
2683 }
2684
2685 // For any Objective-C class definitions we have already loaded, make sure
2686 // that we load any additional categories.
2687 for (unsigned I = 0, N = ObjCClassesLoaded.size(); I != N; ++I) {
2688 loadObjCCategories(ObjCClassesLoaded[I]->getGlobalID(),
2689 ObjCClassesLoaded[I],
2690 PreviousGeneration);
2691 }
2692
2693 return Success;
2694 }
2695
ReadASTCore(StringRef FileName,ModuleKind Type,ModuleFile * ImportedBy)2696 ASTReader::ASTReadResult ASTReader::ReadASTCore(StringRef FileName,
2697 ModuleKind Type,
2698 ModuleFile *ImportedBy) {
2699 ModuleFile *M;
2700 bool NewModule;
2701 std::string ErrorStr;
2702 llvm::tie(M, NewModule) = ModuleMgr.addModule(FileName, Type, ImportedBy,
2703 CurrentGeneration, ErrorStr);
2704
2705 if (!M) {
2706 // We couldn't load the module.
2707 std::string Msg = "Unable to load module \"" + FileName.str() + "\": "
2708 + ErrorStr;
2709 Error(Msg);
2710 return Failure;
2711 }
2712
2713 if (!NewModule) {
2714 // We've already loaded this module.
2715 return Success;
2716 }
2717
2718 // FIXME: This seems rather a hack. Should CurrentDir be part of the
2719 // module?
2720 if (FileName != "-") {
2721 CurrentDir = llvm::sys::path::parent_path(FileName);
2722 if (CurrentDir.empty()) CurrentDir = ".";
2723 }
2724
2725 ModuleFile &F = *M;
2726 llvm::BitstreamCursor &Stream = F.Stream;
2727 Stream.init(F.StreamFile);
2728 F.SizeInBits = F.Buffer->getBufferSize() * 8;
2729
2730 // Sniff for the signature.
2731 if (Stream.Read(8) != 'C' ||
2732 Stream.Read(8) != 'P' ||
2733 Stream.Read(8) != 'C' ||
2734 Stream.Read(8) != 'H') {
2735 Diag(diag::err_not_a_pch_file) << FileName;
2736 return Failure;
2737 }
2738
2739 while (!Stream.AtEndOfStream()) {
2740 unsigned Code = Stream.ReadCode();
2741
2742 if (Code != llvm::bitc::ENTER_SUBBLOCK) {
2743 Error("invalid record at top-level of AST file");
2744 return Failure;
2745 }
2746
2747 unsigned BlockID = Stream.ReadSubBlockID();
2748
2749 // We only know the AST subblock ID.
2750 switch (BlockID) {
2751 case llvm::bitc::BLOCKINFO_BLOCK_ID:
2752 if (Stream.ReadBlockInfoBlock()) {
2753 Error("malformed BlockInfoBlock in AST file");
2754 return Failure;
2755 }
2756 break;
2757 case AST_BLOCK_ID:
2758 switch (ReadASTBlock(F)) {
2759 case Success:
2760 break;
2761
2762 case Failure:
2763 return Failure;
2764
2765 case IgnorePCH:
2766 // FIXME: We could consider reading through to the end of this
2767 // AST block, skipping subblocks, to see if there are other
2768 // AST blocks elsewhere.
2769
2770 // FIXME: We can't clear loaded slocentries anymore.
2771 //SourceMgr.ClearPreallocatedSLocEntries();
2772
2773 // Remove the stat cache.
2774 if (F.StatCache)
2775 FileMgr.removeStatCache((ASTStatCache*)F.StatCache);
2776
2777 return IgnorePCH;
2778 }
2779 break;
2780 default:
2781 if (Stream.SkipBlock()) {
2782 Error("malformed block record in AST file");
2783 return Failure;
2784 }
2785 break;
2786 }
2787 }
2788
2789 // Once read, set the ModuleFile bit base offset and update the size in
2790 // bits of all files we've seen.
2791 F.GlobalBitOffset = TotalModulesSizeInBits;
2792 TotalModulesSizeInBits += F.SizeInBits;
2793 GlobalBitOffsetsMap.insert(std::make_pair(F.GlobalBitOffset, &F));
2794
2795 // Make sure that the files this module was built against are still available.
2796 if (!DisableValidation) {
2797 switch(validateFileEntries(*M)) {
2798 case Failure: return Failure;
2799 case IgnorePCH: return IgnorePCH;
2800 case Success: break;
2801 }
2802 }
2803
2804 // Preload SLocEntries.
2805 for (unsigned I = 0, N = M->PreloadSLocEntries.size(); I != N; ++I) {
2806 int Index = int(M->PreloadSLocEntries[I] - 1) + F.SLocEntryBaseID;
2807 // Load it through the SourceManager and don't call ReadSLocEntryRecord()
2808 // directly because the entry may have already been loaded in which case
2809 // calling ReadSLocEntryRecord() directly would trigger an assertion in
2810 // SourceManager.
2811 SourceMgr.getLoadedSLocEntryByID(Index);
2812 }
2813
2814
2815 return Success;
2816 }
2817
InitializeContext()2818 void ASTReader::InitializeContext() {
2819 // If there's a listener, notify them that we "read" the translation unit.
2820 if (DeserializationListener)
2821 DeserializationListener->DeclRead(PREDEF_DECL_TRANSLATION_UNIT_ID,
2822 Context.getTranslationUnitDecl());
2823
2824 // Make sure we load the declaration update records for the translation unit,
2825 // if there are any.
2826 loadDeclUpdateRecords(PREDEF_DECL_TRANSLATION_UNIT_ID,
2827 Context.getTranslationUnitDecl());
2828
2829 // FIXME: Find a better way to deal with collisions between these
2830 // built-in types. Right now, we just ignore the problem.
2831
2832 // Load the special types.
2833 if (SpecialTypes.size() >= NumSpecialTypeIDs) {
2834 if (Context.getBuiltinVaListType().isNull()) {
2835 Context.setBuiltinVaListType(
2836 GetType(SpecialTypes[SPECIAL_TYPE_BUILTIN_VA_LIST]));
2837 }
2838
2839 if (unsigned String = SpecialTypes[SPECIAL_TYPE_CF_CONSTANT_STRING]) {
2840 if (!Context.CFConstantStringTypeDecl)
2841 Context.setCFConstantStringType(GetType(String));
2842 }
2843
2844 if (unsigned File = SpecialTypes[SPECIAL_TYPE_FILE]) {
2845 QualType FileType = GetType(File);
2846 if (FileType.isNull()) {
2847 Error("FILE type is NULL");
2848 return;
2849 }
2850
2851 if (!Context.FILEDecl) {
2852 if (const TypedefType *Typedef = FileType->getAs<TypedefType>())
2853 Context.setFILEDecl(Typedef->getDecl());
2854 else {
2855 const TagType *Tag = FileType->getAs<TagType>();
2856 if (!Tag) {
2857 Error("Invalid FILE type in AST file");
2858 return;
2859 }
2860 Context.setFILEDecl(Tag->getDecl());
2861 }
2862 }
2863 }
2864
2865 if (unsigned Jmp_buf = SpecialTypes[SPECIAL_TYPE_JMP_BUF]) {
2866 QualType Jmp_bufType = GetType(Jmp_buf);
2867 if (Jmp_bufType.isNull()) {
2868 Error("jmp_buf type is NULL");
2869 return;
2870 }
2871
2872 if (!Context.jmp_bufDecl) {
2873 if (const TypedefType *Typedef = Jmp_bufType->getAs<TypedefType>())
2874 Context.setjmp_bufDecl(Typedef->getDecl());
2875 else {
2876 const TagType *Tag = Jmp_bufType->getAs<TagType>();
2877 if (!Tag) {
2878 Error("Invalid jmp_buf type in AST file");
2879 return;
2880 }
2881 Context.setjmp_bufDecl(Tag->getDecl());
2882 }
2883 }
2884 }
2885
2886 if (unsigned Sigjmp_buf = SpecialTypes[SPECIAL_TYPE_SIGJMP_BUF]) {
2887 QualType Sigjmp_bufType = GetType(Sigjmp_buf);
2888 if (Sigjmp_bufType.isNull()) {
2889 Error("sigjmp_buf type is NULL");
2890 return;
2891 }
2892
2893 if (!Context.sigjmp_bufDecl) {
2894 if (const TypedefType *Typedef = Sigjmp_bufType->getAs<TypedefType>())
2895 Context.setsigjmp_bufDecl(Typedef->getDecl());
2896 else {
2897 const TagType *Tag = Sigjmp_bufType->getAs<TagType>();
2898 assert(Tag && "Invalid sigjmp_buf type in AST file");
2899 Context.setsigjmp_bufDecl(Tag->getDecl());
2900 }
2901 }
2902 }
2903
2904 if (unsigned ObjCIdRedef
2905 = SpecialTypes[SPECIAL_TYPE_OBJC_ID_REDEFINITION]) {
2906 if (Context.ObjCIdRedefinitionType.isNull())
2907 Context.ObjCIdRedefinitionType = GetType(ObjCIdRedef);
2908 }
2909
2910 if (unsigned ObjCClassRedef
2911 = SpecialTypes[SPECIAL_TYPE_OBJC_CLASS_REDEFINITION]) {
2912 if (Context.ObjCClassRedefinitionType.isNull())
2913 Context.ObjCClassRedefinitionType = GetType(ObjCClassRedef);
2914 }
2915
2916 if (unsigned ObjCSelRedef
2917 = SpecialTypes[SPECIAL_TYPE_OBJC_SEL_REDEFINITION]) {
2918 if (Context.ObjCSelRedefinitionType.isNull())
2919 Context.ObjCSelRedefinitionType = GetType(ObjCSelRedef);
2920 }
2921
2922 if (unsigned Ucontext_t = SpecialTypes[SPECIAL_TYPE_UCONTEXT_T]) {
2923 QualType Ucontext_tType = GetType(Ucontext_t);
2924 if (Ucontext_tType.isNull()) {
2925 Error("ucontext_t type is NULL");
2926 return;
2927 }
2928
2929 if (!Context.ucontext_tDecl) {
2930 if (const TypedefType *Typedef = Ucontext_tType->getAs<TypedefType>())
2931 Context.setucontext_tDecl(Typedef->getDecl());
2932 else {
2933 const TagType *Tag = Ucontext_tType->getAs<TagType>();
2934 assert(Tag && "Invalid ucontext_t type in AST file");
2935 Context.setucontext_tDecl(Tag->getDecl());
2936 }
2937 }
2938 }
2939 }
2940
2941 ReadPragmaDiagnosticMappings(Context.getDiagnostics());
2942
2943 // If there were any CUDA special declarations, deserialize them.
2944 if (!CUDASpecialDeclRefs.empty()) {
2945 assert(CUDASpecialDeclRefs.size() == 1 && "More decl refs than expected!");
2946 Context.setcudaConfigureCallDecl(
2947 cast<FunctionDecl>(GetDecl(CUDASpecialDeclRefs[0])));
2948 }
2949
2950 // Re-export any modules that were imported by a non-module AST file.
2951 for (unsigned I = 0, N = ImportedModules.size(); I != N; ++I) {
2952 if (Module *Imported = getSubmodule(ImportedModules[I]))
2953 makeModuleVisible(Imported, Module::AllVisible);
2954 }
2955 ImportedModules.clear();
2956 }
2957
finalizeForWriting()2958 void ASTReader::finalizeForWriting() {
2959 for (HiddenNamesMapType::iterator Hidden = HiddenNamesMap.begin(),
2960 HiddenEnd = HiddenNamesMap.end();
2961 Hidden != HiddenEnd; ++Hidden) {
2962 makeNamesVisible(Hidden->second);
2963 }
2964 HiddenNamesMap.clear();
2965 }
2966
2967 /// \brief Retrieve the name of the original source file name
2968 /// directly from the AST file, without actually loading the AST
2969 /// file.
getOriginalSourceFile(const std::string & ASTFileName,FileManager & FileMgr,DiagnosticsEngine & Diags)2970 std::string ASTReader::getOriginalSourceFile(const std::string &ASTFileName,
2971 FileManager &FileMgr,
2972 DiagnosticsEngine &Diags) {
2973 // Open the AST file.
2974 std::string ErrStr;
2975 OwningPtr<llvm::MemoryBuffer> Buffer;
2976 Buffer.reset(FileMgr.getBufferForFile(ASTFileName, &ErrStr));
2977 if (!Buffer) {
2978 Diags.Report(diag::err_fe_unable_to_read_pch_file) << ErrStr;
2979 return std::string();
2980 }
2981
2982 // Initialize the stream
2983 llvm::BitstreamReader StreamFile;
2984 llvm::BitstreamCursor Stream;
2985 StreamFile.init((const unsigned char *)Buffer->getBufferStart(),
2986 (const unsigned char *)Buffer->getBufferEnd());
2987 Stream.init(StreamFile);
2988
2989 // Sniff for the signature.
2990 if (Stream.Read(8) != 'C' ||
2991 Stream.Read(8) != 'P' ||
2992 Stream.Read(8) != 'C' ||
2993 Stream.Read(8) != 'H') {
2994 Diags.Report(diag::err_fe_not_a_pch_file) << ASTFileName;
2995 return std::string();
2996 }
2997
2998 RecordData Record;
2999 while (!Stream.AtEndOfStream()) {
3000 unsigned Code = Stream.ReadCode();
3001
3002 if (Code == llvm::bitc::ENTER_SUBBLOCK) {
3003 unsigned BlockID = Stream.ReadSubBlockID();
3004
3005 // We only know the AST subblock ID.
3006 switch (BlockID) {
3007 case AST_BLOCK_ID:
3008 if (Stream.EnterSubBlock(AST_BLOCK_ID)) {
3009 Diags.Report(diag::err_fe_pch_malformed_block) << ASTFileName;
3010 return std::string();
3011 }
3012 break;
3013
3014 default:
3015 if (Stream.SkipBlock()) {
3016 Diags.Report(diag::err_fe_pch_malformed_block) << ASTFileName;
3017 return std::string();
3018 }
3019 break;
3020 }
3021 continue;
3022 }
3023
3024 if (Code == llvm::bitc::END_BLOCK) {
3025 if (Stream.ReadBlockEnd()) {
3026 Diags.Report(diag::err_fe_pch_error_at_end_block) << ASTFileName;
3027 return std::string();
3028 }
3029 continue;
3030 }
3031
3032 if (Code == llvm::bitc::DEFINE_ABBREV) {
3033 Stream.ReadAbbrevRecord();
3034 continue;
3035 }
3036
3037 Record.clear();
3038 const char *BlobStart = 0;
3039 unsigned BlobLen = 0;
3040 if (Stream.ReadRecord(Code, Record, &BlobStart, &BlobLen)
3041 == ORIGINAL_FILE_NAME)
3042 return std::string(BlobStart, BlobLen);
3043 }
3044
3045 return std::string();
3046 }
3047
ReadSubmoduleBlock(ModuleFile & F)3048 ASTReader::ASTReadResult ASTReader::ReadSubmoduleBlock(ModuleFile &F) {
3049 // Enter the submodule block.
3050 if (F.Stream.EnterSubBlock(SUBMODULE_BLOCK_ID)) {
3051 Error("malformed submodule block record in AST file");
3052 return Failure;
3053 }
3054
3055 ModuleMap &ModMap = PP.getHeaderSearchInfo().getModuleMap();
3056 bool First = true;
3057 Module *CurrentModule = 0;
3058 RecordData Record;
3059 while (true) {
3060 unsigned Code = F.Stream.ReadCode();
3061 if (Code == llvm::bitc::END_BLOCK) {
3062 if (F.Stream.ReadBlockEnd()) {
3063 Error("error at end of submodule block in AST file");
3064 return Failure;
3065 }
3066 return Success;
3067 }
3068
3069 if (Code == llvm::bitc::ENTER_SUBBLOCK) {
3070 // No known subblocks, always skip them.
3071 F.Stream.ReadSubBlockID();
3072 if (F.Stream.SkipBlock()) {
3073 Error("malformed block record in AST file");
3074 return Failure;
3075 }
3076 continue;
3077 }
3078
3079 if (Code == llvm::bitc::DEFINE_ABBREV) {
3080 F.Stream.ReadAbbrevRecord();
3081 continue;
3082 }
3083
3084 // Read a record.
3085 const char *BlobStart;
3086 unsigned BlobLen;
3087 Record.clear();
3088 switch (F.Stream.ReadRecord(Code, Record, &BlobStart, &BlobLen)) {
3089 default: // Default behavior: ignore.
3090 break;
3091
3092 case SUBMODULE_DEFINITION: {
3093 if (First) {
3094 Error("missing submodule metadata record at beginning of block");
3095 return Failure;
3096 }
3097
3098 if (Record.size() < 7) {
3099 Error("malformed module definition");
3100 return Failure;
3101 }
3102
3103 StringRef Name(BlobStart, BlobLen);
3104 SubmoduleID GlobalID = getGlobalSubmoduleID(F, Record[0]);
3105 SubmoduleID Parent = getGlobalSubmoduleID(F, Record[1]);
3106 bool IsFramework = Record[2];
3107 bool IsExplicit = Record[3];
3108 bool IsSystem = Record[4];
3109 bool InferSubmodules = Record[5];
3110 bool InferExplicitSubmodules = Record[6];
3111 bool InferExportWildcard = Record[7];
3112
3113 Module *ParentModule = 0;
3114 if (Parent)
3115 ParentModule = getSubmodule(Parent);
3116
3117 // Retrieve this (sub)module from the module map, creating it if
3118 // necessary.
3119 CurrentModule = ModMap.findOrCreateModule(Name, ParentModule,
3120 IsFramework,
3121 IsExplicit).first;
3122 SubmoduleID GlobalIndex = GlobalID - NUM_PREDEF_SUBMODULE_IDS;
3123 if (GlobalIndex >= SubmodulesLoaded.size() ||
3124 SubmodulesLoaded[GlobalIndex]) {
3125 Error("too many submodules");
3126 return Failure;
3127 }
3128
3129 CurrentModule->IsFromModuleFile = true;
3130 CurrentModule->IsSystem = IsSystem || CurrentModule->IsSystem;
3131 CurrentModule->InferSubmodules = InferSubmodules;
3132 CurrentModule->InferExplicitSubmodules = InferExplicitSubmodules;
3133 CurrentModule->InferExportWildcard = InferExportWildcard;
3134 if (DeserializationListener)
3135 DeserializationListener->ModuleRead(GlobalID, CurrentModule);
3136
3137 SubmodulesLoaded[GlobalIndex] = CurrentModule;
3138 break;
3139 }
3140
3141 case SUBMODULE_UMBRELLA_HEADER: {
3142 if (First) {
3143 Error("missing submodule metadata record at beginning of block");
3144 return Failure;
3145 }
3146
3147 if (!CurrentModule)
3148 break;
3149
3150 StringRef FileName(BlobStart, BlobLen);
3151 if (const FileEntry *Umbrella = PP.getFileManager().getFile(FileName)) {
3152 if (!CurrentModule->getUmbrellaHeader())
3153 ModMap.setUmbrellaHeader(CurrentModule, Umbrella);
3154 else if (CurrentModule->getUmbrellaHeader() != Umbrella) {
3155 Error("mismatched umbrella headers in submodule");
3156 return Failure;
3157 }
3158 }
3159 break;
3160 }
3161
3162 case SUBMODULE_HEADER: {
3163 if (First) {
3164 Error("missing submodule metadata record at beginning of block");
3165 return Failure;
3166 }
3167
3168 if (!CurrentModule)
3169 break;
3170
3171 // FIXME: Be more lazy about this!
3172 StringRef FileName(BlobStart, BlobLen);
3173 if (const FileEntry *File = PP.getFileManager().getFile(FileName)) {
3174 if (std::find(CurrentModule->Headers.begin(),
3175 CurrentModule->Headers.end(),
3176 File) == CurrentModule->Headers.end())
3177 ModMap.addHeader(CurrentModule, File);
3178 }
3179 break;
3180 }
3181
3182 case SUBMODULE_UMBRELLA_DIR: {
3183 if (First) {
3184 Error("missing submodule metadata record at beginning of block");
3185 return Failure;
3186 }
3187
3188 if (!CurrentModule)
3189 break;
3190
3191 StringRef DirName(BlobStart, BlobLen);
3192 if (const DirectoryEntry *Umbrella
3193 = PP.getFileManager().getDirectory(DirName)) {
3194 if (!CurrentModule->getUmbrellaDir())
3195 ModMap.setUmbrellaDir(CurrentModule, Umbrella);
3196 else if (CurrentModule->getUmbrellaDir() != Umbrella) {
3197 Error("mismatched umbrella directories in submodule");
3198 return Failure;
3199 }
3200 }
3201 break;
3202 }
3203
3204 case SUBMODULE_METADATA: {
3205 if (!First) {
3206 Error("submodule metadata record not at beginning of block");
3207 return Failure;
3208 }
3209 First = false;
3210
3211 F.BaseSubmoduleID = getTotalNumSubmodules();
3212 F.LocalNumSubmodules = Record[0];
3213 unsigned LocalBaseSubmoduleID = Record[1];
3214 if (F.LocalNumSubmodules > 0) {
3215 // Introduce the global -> local mapping for submodules within this
3216 // module.
3217 GlobalSubmoduleMap.insert(std::make_pair(getTotalNumSubmodules()+1,&F));
3218
3219 // Introduce the local -> global mapping for submodules within this
3220 // module.
3221 F.SubmoduleRemap.insertOrReplace(
3222 std::make_pair(LocalBaseSubmoduleID,
3223 F.BaseSubmoduleID - LocalBaseSubmoduleID));
3224
3225 SubmodulesLoaded.resize(SubmodulesLoaded.size() + F.LocalNumSubmodules);
3226 }
3227 break;
3228 }
3229
3230 case SUBMODULE_IMPORTS: {
3231 if (First) {
3232 Error("missing submodule metadata record at beginning of block");
3233 return Failure;
3234 }
3235
3236 if (!CurrentModule)
3237 break;
3238
3239 for (unsigned Idx = 0; Idx != Record.size(); ++Idx) {
3240 UnresolvedModuleImportExport Unresolved;
3241 Unresolved.File = &F;
3242 Unresolved.Mod = CurrentModule;
3243 Unresolved.ID = Record[Idx];
3244 Unresolved.IsImport = true;
3245 Unresolved.IsWildcard = false;
3246 UnresolvedModuleImportExports.push_back(Unresolved);
3247 }
3248 break;
3249 }
3250
3251 case SUBMODULE_EXPORTS: {
3252 if (First) {
3253 Error("missing submodule metadata record at beginning of block");
3254 return Failure;
3255 }
3256
3257 if (!CurrentModule)
3258 break;
3259
3260 for (unsigned Idx = 0; Idx + 1 < Record.size(); Idx += 2) {
3261 UnresolvedModuleImportExport Unresolved;
3262 Unresolved.File = &F;
3263 Unresolved.Mod = CurrentModule;
3264 Unresolved.ID = Record[Idx];
3265 Unresolved.IsImport = false;
3266 Unresolved.IsWildcard = Record[Idx + 1];
3267 UnresolvedModuleImportExports.push_back(Unresolved);
3268 }
3269
3270 // Once we've loaded the set of exports, there's no reason to keep
3271 // the parsed, unresolved exports around.
3272 CurrentModule->UnresolvedExports.clear();
3273 break;
3274 }
3275 case SUBMODULE_REQUIRES: {
3276 if (First) {
3277 Error("missing submodule metadata record at beginning of block");
3278 return Failure;
3279 }
3280
3281 if (!CurrentModule)
3282 break;
3283
3284 CurrentModule->addRequirement(StringRef(BlobStart, BlobLen),
3285 Context.getLangOpts(),
3286 Context.getTargetInfo());
3287 break;
3288 }
3289 }
3290 }
3291 }
3292
3293 /// \brief Parse the record that corresponds to a LangOptions data
3294 /// structure.
3295 ///
3296 /// This routine parses the language options from the AST file and then gives
3297 /// them to the AST listener if one is set.
3298 ///
3299 /// \returns true if the listener deems the file unacceptable, false otherwise.
ParseLanguageOptions(const SmallVectorImpl<uint64_t> & Record)3300 bool ASTReader::ParseLanguageOptions(
3301 const SmallVectorImpl<uint64_t> &Record) {
3302 if (Listener) {
3303 LangOptions LangOpts;
3304 unsigned Idx = 0;
3305 #define LANGOPT(Name, Bits, Default, Description) \
3306 LangOpts.Name = Record[Idx++];
3307 #define ENUM_LANGOPT(Name, Type, Bits, Default, Description) \
3308 LangOpts.set##Name(static_cast<LangOptions::Type>(Record[Idx++]));
3309 #include "clang/Basic/LangOptions.def"
3310
3311 unsigned Length = Record[Idx++];
3312 LangOpts.CurrentModule.assign(Record.begin() + Idx,
3313 Record.begin() + Idx + Length);
3314 return Listener->ReadLanguageOptions(LangOpts);
3315 }
3316
3317 return false;
3318 }
3319
3320 std::pair<ModuleFile *, unsigned>
getModulePreprocessedEntity(unsigned GlobalIndex)3321 ASTReader::getModulePreprocessedEntity(unsigned GlobalIndex) {
3322 GlobalPreprocessedEntityMapType::iterator
3323 I = GlobalPreprocessedEntityMap.find(GlobalIndex);
3324 assert(I != GlobalPreprocessedEntityMap.end() &&
3325 "Corrupted global preprocessed entity map");
3326 ModuleFile *M = I->second;
3327 unsigned LocalIndex = GlobalIndex - M->BasePreprocessedEntityID;
3328 return std::make_pair(M, LocalIndex);
3329 }
3330
ReadPreprocessedEntity(unsigned Index)3331 PreprocessedEntity *ASTReader::ReadPreprocessedEntity(unsigned Index) {
3332 PreprocessedEntityID PPID = Index+1;
3333 std::pair<ModuleFile *, unsigned> PPInfo = getModulePreprocessedEntity(Index);
3334 ModuleFile &M = *PPInfo.first;
3335 unsigned LocalIndex = PPInfo.second;
3336 const PPEntityOffset &PPOffs = M.PreprocessedEntityOffsets[LocalIndex];
3337
3338 SavedStreamPosition SavedPosition(M.PreprocessorDetailCursor);
3339 M.PreprocessorDetailCursor.JumpToBit(PPOffs.BitOffset);
3340
3341 unsigned Code = M.PreprocessorDetailCursor.ReadCode();
3342 switch (Code) {
3343 case llvm::bitc::END_BLOCK:
3344 return 0;
3345
3346 case llvm::bitc::ENTER_SUBBLOCK:
3347 Error("unexpected subblock record in preprocessor detail block");
3348 return 0;
3349
3350 case llvm::bitc::DEFINE_ABBREV:
3351 Error("unexpected abbrevation record in preprocessor detail block");
3352 return 0;
3353
3354 default:
3355 break;
3356 }
3357
3358 if (!PP.getPreprocessingRecord()) {
3359 Error("no preprocessing record");
3360 return 0;
3361 }
3362
3363 // Read the record.
3364 SourceRange Range(ReadSourceLocation(M, PPOffs.Begin),
3365 ReadSourceLocation(M, PPOffs.End));
3366 PreprocessingRecord &PPRec = *PP.getPreprocessingRecord();
3367 const char *BlobStart = 0;
3368 unsigned BlobLen = 0;
3369 RecordData Record;
3370 PreprocessorDetailRecordTypes RecType =
3371 (PreprocessorDetailRecordTypes)M.PreprocessorDetailCursor.ReadRecord(
3372 Code, Record, BlobStart, BlobLen);
3373 switch (RecType) {
3374 case PPD_MACRO_EXPANSION: {
3375 bool isBuiltin = Record[0];
3376 IdentifierInfo *Name = 0;
3377 MacroDefinition *Def = 0;
3378 if (isBuiltin)
3379 Name = getLocalIdentifier(M, Record[1]);
3380 else {
3381 PreprocessedEntityID
3382 GlobalID = getGlobalPreprocessedEntityID(M, Record[1]);
3383 Def =cast<MacroDefinition>(PPRec.getLoadedPreprocessedEntity(GlobalID-1));
3384 }
3385
3386 MacroExpansion *ME;
3387 if (isBuiltin)
3388 ME = new (PPRec) MacroExpansion(Name, Range);
3389 else
3390 ME = new (PPRec) MacroExpansion(Def, Range);
3391
3392 return ME;
3393 }
3394
3395 case PPD_MACRO_DEFINITION: {
3396 // Decode the identifier info and then check again; if the macro is
3397 // still defined and associated with the identifier,
3398 IdentifierInfo *II = getLocalIdentifier(M, Record[0]);
3399 MacroDefinition *MD
3400 = new (PPRec) MacroDefinition(II, Range);
3401
3402 if (DeserializationListener)
3403 DeserializationListener->MacroDefinitionRead(PPID, MD);
3404
3405 return MD;
3406 }
3407
3408 case PPD_INCLUSION_DIRECTIVE: {
3409 const char *FullFileNameStart = BlobStart + Record[0];
3410 StringRef FullFileName(FullFileNameStart, BlobLen - Record[0]);
3411 const FileEntry *File = 0;
3412 if (!FullFileName.empty())
3413 File = PP.getFileManager().getFile(FullFileName);
3414
3415 // FIXME: Stable encoding
3416 InclusionDirective::InclusionKind Kind
3417 = static_cast<InclusionDirective::InclusionKind>(Record[2]);
3418 InclusionDirective *ID
3419 = new (PPRec) InclusionDirective(PPRec, Kind,
3420 StringRef(BlobStart, Record[0]),
3421 Record[1],
3422 File,
3423 Range);
3424 return ID;
3425 }
3426 }
3427
3428 llvm_unreachable("Invalid PreprocessorDetailRecordTypes");
3429 }
3430
3431 /// \brief \arg SLocMapI points at a chunk of a module that contains no
3432 /// preprocessed entities or the entities it contains are not the ones we are
3433 /// looking for. Find the next module that contains entities and return the ID
3434 /// of the first entry.
findNextPreprocessedEntity(GlobalSLocOffsetMapType::const_iterator SLocMapI) const3435 PreprocessedEntityID ASTReader::findNextPreprocessedEntity(
3436 GlobalSLocOffsetMapType::const_iterator SLocMapI) const {
3437 ++SLocMapI;
3438 for (GlobalSLocOffsetMapType::const_iterator
3439 EndI = GlobalSLocOffsetMap.end(); SLocMapI != EndI; ++SLocMapI) {
3440 ModuleFile &M = *SLocMapI->second;
3441 if (M.NumPreprocessedEntities)
3442 return getGlobalPreprocessedEntityID(M, M.BasePreprocessedEntityID);
3443 }
3444
3445 return getTotalNumPreprocessedEntities();
3446 }
3447
3448 namespace {
3449
3450 template <unsigned PPEntityOffset::*PPLoc>
3451 struct PPEntityComp {
3452 const ASTReader &Reader;
3453 ModuleFile &M;
3454
PPEntityComp__anon606000880411::PPEntityComp3455 PPEntityComp(const ASTReader &Reader, ModuleFile &M) : Reader(Reader), M(M) { }
3456
operator ()__anon606000880411::PPEntityComp3457 bool operator()(const PPEntityOffset &L, const PPEntityOffset &R) const {
3458 SourceLocation LHS = getLoc(L);
3459 SourceLocation RHS = getLoc(R);
3460 return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS);
3461 }
3462
operator ()__anon606000880411::PPEntityComp3463 bool operator()(const PPEntityOffset &L, SourceLocation RHS) const {
3464 SourceLocation LHS = getLoc(L);
3465 return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS);
3466 }
3467
operator ()__anon606000880411::PPEntityComp3468 bool operator()(SourceLocation LHS, const PPEntityOffset &R) const {
3469 SourceLocation RHS = getLoc(R);
3470 return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS);
3471 }
3472
getLoc__anon606000880411::PPEntityComp3473 SourceLocation getLoc(const PPEntityOffset &PPE) const {
3474 return Reader.ReadSourceLocation(M, PPE.*PPLoc);
3475 }
3476 };
3477
3478 }
3479
3480 /// \brief Returns the first preprocessed entity ID that ends after \arg BLoc.
3481 PreprocessedEntityID
findBeginPreprocessedEntity(SourceLocation BLoc) const3482 ASTReader::findBeginPreprocessedEntity(SourceLocation BLoc) const {
3483 if (SourceMgr.isLocalSourceLocation(BLoc))
3484 return getTotalNumPreprocessedEntities();
3485
3486 GlobalSLocOffsetMapType::const_iterator
3487 SLocMapI = GlobalSLocOffsetMap.find(SourceManager::MaxLoadedOffset -
3488 BLoc.getOffset());
3489 assert(SLocMapI != GlobalSLocOffsetMap.end() &&
3490 "Corrupted global sloc offset map");
3491
3492 if (SLocMapI->second->NumPreprocessedEntities == 0)
3493 return findNextPreprocessedEntity(SLocMapI);
3494
3495 ModuleFile &M = *SLocMapI->second;
3496 typedef const PPEntityOffset *pp_iterator;
3497 pp_iterator pp_begin = M.PreprocessedEntityOffsets;
3498 pp_iterator pp_end = pp_begin + M.NumPreprocessedEntities;
3499
3500 size_t Count = M.NumPreprocessedEntities;
3501 size_t Half;
3502 pp_iterator First = pp_begin;
3503 pp_iterator PPI;
3504
3505 // Do a binary search manually instead of using std::lower_bound because
3506 // The end locations of entities may be unordered (when a macro expansion
3507 // is inside another macro argument), but for this case it is not important
3508 // whether we get the first macro expansion or its containing macro.
3509 while (Count > 0) {
3510 Half = Count/2;
3511 PPI = First;
3512 std::advance(PPI, Half);
3513 if (SourceMgr.isBeforeInTranslationUnit(ReadSourceLocation(M, PPI->End),
3514 BLoc)){
3515 First = PPI;
3516 ++First;
3517 Count = Count - Half - 1;
3518 } else
3519 Count = Half;
3520 }
3521
3522 if (PPI == pp_end)
3523 return findNextPreprocessedEntity(SLocMapI);
3524
3525 return getGlobalPreprocessedEntityID(M,
3526 M.BasePreprocessedEntityID + (PPI - pp_begin));
3527 }
3528
3529 /// \brief Returns the first preprocessed entity ID that begins after \arg ELoc.
3530 PreprocessedEntityID
findEndPreprocessedEntity(SourceLocation ELoc) const3531 ASTReader::findEndPreprocessedEntity(SourceLocation ELoc) const {
3532 if (SourceMgr.isLocalSourceLocation(ELoc))
3533 return getTotalNumPreprocessedEntities();
3534
3535 GlobalSLocOffsetMapType::const_iterator
3536 SLocMapI = GlobalSLocOffsetMap.find(SourceManager::MaxLoadedOffset -
3537 ELoc.getOffset());
3538 assert(SLocMapI != GlobalSLocOffsetMap.end() &&
3539 "Corrupted global sloc offset map");
3540
3541 if (SLocMapI->second->NumPreprocessedEntities == 0)
3542 return findNextPreprocessedEntity(SLocMapI);
3543
3544 ModuleFile &M = *SLocMapI->second;
3545 typedef const PPEntityOffset *pp_iterator;
3546 pp_iterator pp_begin = M.PreprocessedEntityOffsets;
3547 pp_iterator pp_end = pp_begin + M.NumPreprocessedEntities;
3548 pp_iterator PPI =
3549 std::upper_bound(pp_begin, pp_end, ELoc,
3550 PPEntityComp<&PPEntityOffset::Begin>(*this, M));
3551
3552 if (PPI == pp_end)
3553 return findNextPreprocessedEntity(SLocMapI);
3554
3555 return getGlobalPreprocessedEntityID(M,
3556 M.BasePreprocessedEntityID + (PPI - pp_begin));
3557 }
3558
3559 /// \brief Returns a pair of [Begin, End) indices of preallocated
3560 /// preprocessed entities that \arg Range encompasses.
3561 std::pair<unsigned, unsigned>
findPreprocessedEntitiesInRange(SourceRange Range)3562 ASTReader::findPreprocessedEntitiesInRange(SourceRange Range) {
3563 if (Range.isInvalid())
3564 return std::make_pair(0,0);
3565 assert(!SourceMgr.isBeforeInTranslationUnit(Range.getEnd(),Range.getBegin()));
3566
3567 PreprocessedEntityID BeginID = findBeginPreprocessedEntity(Range.getBegin());
3568 PreprocessedEntityID EndID = findEndPreprocessedEntity(Range.getEnd());
3569 return std::make_pair(BeginID, EndID);
3570 }
3571
3572 /// \brief Optionally returns true or false if the preallocated preprocessed
3573 /// entity with index \arg Index came from file \arg FID.
isPreprocessedEntityInFileID(unsigned Index,FileID FID)3574 llvm::Optional<bool> ASTReader::isPreprocessedEntityInFileID(unsigned Index,
3575 FileID FID) {
3576 if (FID.isInvalid())
3577 return false;
3578
3579 std::pair<ModuleFile *, unsigned> PPInfo = getModulePreprocessedEntity(Index);
3580 ModuleFile &M = *PPInfo.first;
3581 unsigned LocalIndex = PPInfo.second;
3582 const PPEntityOffset &PPOffs = M.PreprocessedEntityOffsets[LocalIndex];
3583
3584 SourceLocation Loc = ReadSourceLocation(M, PPOffs.Begin);
3585 if (Loc.isInvalid())
3586 return false;
3587
3588 if (SourceMgr.isInFileID(SourceMgr.getFileLoc(Loc), FID))
3589 return true;
3590 else
3591 return false;
3592 }
3593
3594 namespace {
3595 /// \brief Visitor used to search for information about a header file.
3596 class HeaderFileInfoVisitor {
3597 ASTReader &Reader;
3598 const FileEntry *FE;
3599
3600 llvm::Optional<HeaderFileInfo> HFI;
3601
3602 public:
HeaderFileInfoVisitor(ASTReader & Reader,const FileEntry * FE)3603 HeaderFileInfoVisitor(ASTReader &Reader, const FileEntry *FE)
3604 : Reader(Reader), FE(FE) { }
3605
visit(ModuleFile & M,void * UserData)3606 static bool visit(ModuleFile &M, void *UserData) {
3607 HeaderFileInfoVisitor *This
3608 = static_cast<HeaderFileInfoVisitor *>(UserData);
3609
3610 HeaderFileInfoTrait Trait(This->Reader, M,
3611 &This->Reader.getPreprocessor().getHeaderSearchInfo(),
3612 M.HeaderFileFrameworkStrings,
3613 This->FE->getName());
3614
3615 HeaderFileInfoLookupTable *Table
3616 = static_cast<HeaderFileInfoLookupTable *>(M.HeaderFileInfoTable);
3617 if (!Table)
3618 return false;
3619
3620 // Look in the on-disk hash table for an entry for this file name.
3621 HeaderFileInfoLookupTable::iterator Pos = Table->find(This->FE->getName(),
3622 &Trait);
3623 if (Pos == Table->end())
3624 return false;
3625
3626 This->HFI = *Pos;
3627 return true;
3628 }
3629
getHeaderFileInfo() const3630 llvm::Optional<HeaderFileInfo> getHeaderFileInfo() const { return HFI; }
3631 };
3632 }
3633
GetHeaderFileInfo(const FileEntry * FE)3634 HeaderFileInfo ASTReader::GetHeaderFileInfo(const FileEntry *FE) {
3635 HeaderFileInfoVisitor Visitor(*this, FE);
3636 ModuleMgr.visit(&HeaderFileInfoVisitor::visit, &Visitor);
3637 if (llvm::Optional<HeaderFileInfo> HFI = Visitor.getHeaderFileInfo()) {
3638 if (Listener)
3639 Listener->ReadHeaderFileInfo(*HFI, FE->getUID());
3640 return *HFI;
3641 }
3642
3643 return HeaderFileInfo();
3644 }
3645
ReadPragmaDiagnosticMappings(DiagnosticsEngine & Diag)3646 void ASTReader::ReadPragmaDiagnosticMappings(DiagnosticsEngine &Diag) {
3647 for (ModuleIterator I = ModuleMgr.begin(), E = ModuleMgr.end(); I != E; ++I) {
3648 ModuleFile &F = *(*I);
3649 unsigned Idx = 0;
3650 while (Idx < F.PragmaDiagMappings.size()) {
3651 SourceLocation Loc = ReadSourceLocation(F, F.PragmaDiagMappings[Idx++]);
3652 Diag.DiagStates.push_back(*Diag.GetCurDiagState());
3653 Diag.DiagStatePoints.push_back(
3654 DiagnosticsEngine::DiagStatePoint(&Diag.DiagStates.back(),
3655 FullSourceLoc(Loc, SourceMgr)));
3656 while (1) {
3657 assert(Idx < F.PragmaDiagMappings.size() &&
3658 "Invalid data, didn't find '-1' marking end of diag/map pairs");
3659 if (Idx >= F.PragmaDiagMappings.size()) {
3660 break; // Something is messed up but at least avoid infinite loop in
3661 // release build.
3662 }
3663 unsigned DiagID = F.PragmaDiagMappings[Idx++];
3664 if (DiagID == (unsigned)-1) {
3665 break; // no more diag/map pairs for this location.
3666 }
3667 diag::Mapping Map = (diag::Mapping)F.PragmaDiagMappings[Idx++];
3668 DiagnosticMappingInfo MappingInfo = Diag.makeMappingInfo(Map, Loc);
3669 Diag.GetCurDiagState()->setMappingInfo(DiagID, MappingInfo);
3670 }
3671 }
3672 }
3673 }
3674
3675 /// \brief Get the correct cursor and offset for loading a type.
TypeCursorForIndex(unsigned Index)3676 ASTReader::RecordLocation ASTReader::TypeCursorForIndex(unsigned Index) {
3677 GlobalTypeMapType::iterator I = GlobalTypeMap.find(Index);
3678 assert(I != GlobalTypeMap.end() && "Corrupted global type map");
3679 ModuleFile *M = I->second;
3680 return RecordLocation(M, M->TypeOffsets[Index - M->BaseTypeIndex]);
3681 }
3682
3683 /// \brief Read and return the type with the given index..
3684 ///
3685 /// The index is the type ID, shifted and minus the number of predefs. This
3686 /// routine actually reads the record corresponding to the type at the given
3687 /// location. It is a helper routine for GetType, which deals with reading type
3688 /// IDs.
readTypeRecord(unsigned Index)3689 QualType ASTReader::readTypeRecord(unsigned Index) {
3690 RecordLocation Loc = TypeCursorForIndex(Index);
3691 llvm::BitstreamCursor &DeclsCursor = Loc.F->DeclsCursor;
3692
3693 // Keep track of where we are in the stream, then jump back there
3694 // after reading this type.
3695 SavedStreamPosition SavedPosition(DeclsCursor);
3696
3697 ReadingKindTracker ReadingKind(Read_Type, *this);
3698
3699 // Note that we are loading a type record.
3700 Deserializing AType(this);
3701
3702 unsigned Idx = 0;
3703 DeclsCursor.JumpToBit(Loc.Offset);
3704 RecordData Record;
3705 unsigned Code = DeclsCursor.ReadCode();
3706 switch ((TypeCode)DeclsCursor.ReadRecord(Code, Record)) {
3707 case TYPE_EXT_QUAL: {
3708 if (Record.size() != 2) {
3709 Error("Incorrect encoding of extended qualifier type");
3710 return QualType();
3711 }
3712 QualType Base = readType(*Loc.F, Record, Idx);
3713 Qualifiers Quals = Qualifiers::fromOpaqueValue(Record[Idx++]);
3714 return Context.getQualifiedType(Base, Quals);
3715 }
3716
3717 case TYPE_COMPLEX: {
3718 if (Record.size() != 1) {
3719 Error("Incorrect encoding of complex type");
3720 return QualType();
3721 }
3722 QualType ElemType = readType(*Loc.F, Record, Idx);
3723 return Context.getComplexType(ElemType);
3724 }
3725
3726 case TYPE_POINTER: {
3727 if (Record.size() != 1) {
3728 Error("Incorrect encoding of pointer type");
3729 return QualType();
3730 }
3731 QualType PointeeType = readType(*Loc.F, Record, Idx);
3732 return Context.getPointerType(PointeeType);
3733 }
3734
3735 case TYPE_BLOCK_POINTER: {
3736 if (Record.size() != 1) {
3737 Error("Incorrect encoding of block pointer type");
3738 return QualType();
3739 }
3740 QualType PointeeType = readType(*Loc.F, Record, Idx);
3741 return Context.getBlockPointerType(PointeeType);
3742 }
3743
3744 case TYPE_LVALUE_REFERENCE: {
3745 if (Record.size() != 2) {
3746 Error("Incorrect encoding of lvalue reference type");
3747 return QualType();
3748 }
3749 QualType PointeeType = readType(*Loc.F, Record, Idx);
3750 return Context.getLValueReferenceType(PointeeType, Record[1]);
3751 }
3752
3753 case TYPE_RVALUE_REFERENCE: {
3754 if (Record.size() != 1) {
3755 Error("Incorrect encoding of rvalue reference type");
3756 return QualType();
3757 }
3758 QualType PointeeType = readType(*Loc.F, Record, Idx);
3759 return Context.getRValueReferenceType(PointeeType);
3760 }
3761
3762 case TYPE_MEMBER_POINTER: {
3763 if (Record.size() != 2) {
3764 Error("Incorrect encoding of member pointer type");
3765 return QualType();
3766 }
3767 QualType PointeeType = readType(*Loc.F, Record, Idx);
3768 QualType ClassType = readType(*Loc.F, Record, Idx);
3769 if (PointeeType.isNull() || ClassType.isNull())
3770 return QualType();
3771
3772 return Context.getMemberPointerType(PointeeType, ClassType.getTypePtr());
3773 }
3774
3775 case TYPE_CONSTANT_ARRAY: {
3776 QualType ElementType = readType(*Loc.F, Record, Idx);
3777 ArrayType::ArraySizeModifier ASM = (ArrayType::ArraySizeModifier)Record[1];
3778 unsigned IndexTypeQuals = Record[2];
3779 unsigned Idx = 3;
3780 llvm::APInt Size = ReadAPInt(Record, Idx);
3781 return Context.getConstantArrayType(ElementType, Size,
3782 ASM, IndexTypeQuals);
3783 }
3784
3785 case TYPE_INCOMPLETE_ARRAY: {
3786 QualType ElementType = readType(*Loc.F, Record, Idx);
3787 ArrayType::ArraySizeModifier ASM = (ArrayType::ArraySizeModifier)Record[1];
3788 unsigned IndexTypeQuals = Record[2];
3789 return Context.getIncompleteArrayType(ElementType, ASM, IndexTypeQuals);
3790 }
3791
3792 case TYPE_VARIABLE_ARRAY: {
3793 QualType ElementType = readType(*Loc.F, Record, Idx);
3794 ArrayType::ArraySizeModifier ASM = (ArrayType::ArraySizeModifier)Record[1];
3795 unsigned IndexTypeQuals = Record[2];
3796 SourceLocation LBLoc = ReadSourceLocation(*Loc.F, Record[3]);
3797 SourceLocation RBLoc = ReadSourceLocation(*Loc.F, Record[4]);
3798 return Context.getVariableArrayType(ElementType, ReadExpr(*Loc.F),
3799 ASM, IndexTypeQuals,
3800 SourceRange(LBLoc, RBLoc));
3801 }
3802
3803 case TYPE_VECTOR: {
3804 if (Record.size() != 3) {
3805 Error("incorrect encoding of vector type in AST file");
3806 return QualType();
3807 }
3808
3809 QualType ElementType = readType(*Loc.F, Record, Idx);
3810 unsigned NumElements = Record[1];
3811 unsigned VecKind = Record[2];
3812 return Context.getVectorType(ElementType, NumElements,
3813 (VectorType::VectorKind)VecKind);
3814 }
3815
3816 case TYPE_EXT_VECTOR: {
3817 if (Record.size() != 3) {
3818 Error("incorrect encoding of extended vector type in AST file");
3819 return QualType();
3820 }
3821
3822 QualType ElementType = readType(*Loc.F, Record, Idx);
3823 unsigned NumElements = Record[1];
3824 return Context.getExtVectorType(ElementType, NumElements);
3825 }
3826
3827 case TYPE_FUNCTION_NO_PROTO: {
3828 if (Record.size() != 6) {
3829 Error("incorrect encoding of no-proto function type");
3830 return QualType();
3831 }
3832 QualType ResultType = readType(*Loc.F, Record, Idx);
3833 FunctionType::ExtInfo Info(Record[1], Record[2], Record[3],
3834 (CallingConv)Record[4], Record[5]);
3835 return Context.getFunctionNoProtoType(ResultType, Info);
3836 }
3837
3838 case TYPE_FUNCTION_PROTO: {
3839 QualType ResultType = readType(*Loc.F, Record, Idx);
3840
3841 FunctionProtoType::ExtProtoInfo EPI;
3842 EPI.ExtInfo = FunctionType::ExtInfo(/*noreturn*/ Record[1],
3843 /*hasregparm*/ Record[2],
3844 /*regparm*/ Record[3],
3845 static_cast<CallingConv>(Record[4]),
3846 /*produces*/ Record[5]);
3847
3848 unsigned Idx = 6;
3849 unsigned NumParams = Record[Idx++];
3850 SmallVector<QualType, 16> ParamTypes;
3851 for (unsigned I = 0; I != NumParams; ++I)
3852 ParamTypes.push_back(readType(*Loc.F, Record, Idx));
3853
3854 EPI.Variadic = Record[Idx++];
3855 EPI.HasTrailingReturn = Record[Idx++];
3856 EPI.TypeQuals = Record[Idx++];
3857 EPI.RefQualifier = static_cast<RefQualifierKind>(Record[Idx++]);
3858 ExceptionSpecificationType EST =
3859 static_cast<ExceptionSpecificationType>(Record[Idx++]);
3860 EPI.ExceptionSpecType = EST;
3861 SmallVector<QualType, 2> Exceptions;
3862 if (EST == EST_Dynamic) {
3863 EPI.NumExceptions = Record[Idx++];
3864 for (unsigned I = 0; I != EPI.NumExceptions; ++I)
3865 Exceptions.push_back(readType(*Loc.F, Record, Idx));
3866 EPI.Exceptions = Exceptions.data();
3867 } else if (EST == EST_ComputedNoexcept) {
3868 EPI.NoexceptExpr = ReadExpr(*Loc.F);
3869 }
3870 return Context.getFunctionType(ResultType, ParamTypes.data(), NumParams,
3871 EPI);
3872 }
3873
3874 case TYPE_UNRESOLVED_USING: {
3875 unsigned Idx = 0;
3876 return Context.getTypeDeclType(
3877 ReadDeclAs<UnresolvedUsingTypenameDecl>(*Loc.F, Record, Idx));
3878 }
3879
3880 case TYPE_TYPEDEF: {
3881 if (Record.size() != 2) {
3882 Error("incorrect encoding of typedef type");
3883 return QualType();
3884 }
3885 unsigned Idx = 0;
3886 TypedefNameDecl *Decl = ReadDeclAs<TypedefNameDecl>(*Loc.F, Record, Idx);
3887 QualType Canonical = readType(*Loc.F, Record, Idx);
3888 if (!Canonical.isNull())
3889 Canonical = Context.getCanonicalType(Canonical);
3890 return Context.getTypedefType(Decl, Canonical);
3891 }
3892
3893 case TYPE_TYPEOF_EXPR:
3894 return Context.getTypeOfExprType(ReadExpr(*Loc.F));
3895
3896 case TYPE_TYPEOF: {
3897 if (Record.size() != 1) {
3898 Error("incorrect encoding of typeof(type) in AST file");
3899 return QualType();
3900 }
3901 QualType UnderlyingType = readType(*Loc.F, Record, Idx);
3902 return Context.getTypeOfType(UnderlyingType);
3903 }
3904
3905 case TYPE_DECLTYPE: {
3906 QualType UnderlyingType = readType(*Loc.F, Record, Idx);
3907 return Context.getDecltypeType(ReadExpr(*Loc.F), UnderlyingType);
3908 }
3909
3910 case TYPE_UNARY_TRANSFORM: {
3911 QualType BaseType = readType(*Loc.F, Record, Idx);
3912 QualType UnderlyingType = readType(*Loc.F, Record, Idx);
3913 UnaryTransformType::UTTKind UKind = (UnaryTransformType::UTTKind)Record[2];
3914 return Context.getUnaryTransformType(BaseType, UnderlyingType, UKind);
3915 }
3916
3917 case TYPE_AUTO:
3918 return Context.getAutoType(readType(*Loc.F, Record, Idx));
3919
3920 case TYPE_RECORD: {
3921 if (Record.size() != 2) {
3922 Error("incorrect encoding of record type");
3923 return QualType();
3924 }
3925 unsigned Idx = 0;
3926 bool IsDependent = Record[Idx++];
3927 RecordDecl *RD = ReadDeclAs<RecordDecl>(*Loc.F, Record, Idx);
3928 RD = cast_or_null<RecordDecl>(RD->getCanonicalDecl());
3929 QualType T = Context.getRecordType(RD);
3930 const_cast<Type*>(T.getTypePtr())->setDependent(IsDependent);
3931 return T;
3932 }
3933
3934 case TYPE_ENUM: {
3935 if (Record.size() != 2) {
3936 Error("incorrect encoding of enum type");
3937 return QualType();
3938 }
3939 unsigned Idx = 0;
3940 bool IsDependent = Record[Idx++];
3941 QualType T
3942 = Context.getEnumType(ReadDeclAs<EnumDecl>(*Loc.F, Record, Idx));
3943 const_cast<Type*>(T.getTypePtr())->setDependent(IsDependent);
3944 return T;
3945 }
3946
3947 case TYPE_ATTRIBUTED: {
3948 if (Record.size() != 3) {
3949 Error("incorrect encoding of attributed type");
3950 return QualType();
3951 }
3952 QualType modifiedType = readType(*Loc.F, Record, Idx);
3953 QualType equivalentType = readType(*Loc.F, Record, Idx);
3954 AttributedType::Kind kind = static_cast<AttributedType::Kind>(Record[2]);
3955 return Context.getAttributedType(kind, modifiedType, equivalentType);
3956 }
3957
3958 case TYPE_PAREN: {
3959 if (Record.size() != 1) {
3960 Error("incorrect encoding of paren type");
3961 return QualType();
3962 }
3963 QualType InnerType = readType(*Loc.F, Record, Idx);
3964 return Context.getParenType(InnerType);
3965 }
3966
3967 case TYPE_PACK_EXPANSION: {
3968 if (Record.size() != 2) {
3969 Error("incorrect encoding of pack expansion type");
3970 return QualType();
3971 }
3972 QualType Pattern = readType(*Loc.F, Record, Idx);
3973 if (Pattern.isNull())
3974 return QualType();
3975 llvm::Optional<unsigned> NumExpansions;
3976 if (Record[1])
3977 NumExpansions = Record[1] - 1;
3978 return Context.getPackExpansionType(Pattern, NumExpansions);
3979 }
3980
3981 case TYPE_ELABORATED: {
3982 unsigned Idx = 0;
3983 ElaboratedTypeKeyword Keyword = (ElaboratedTypeKeyword)Record[Idx++];
3984 NestedNameSpecifier *NNS = ReadNestedNameSpecifier(*Loc.F, Record, Idx);
3985 QualType NamedType = readType(*Loc.F, Record, Idx);
3986 return Context.getElaboratedType(Keyword, NNS, NamedType);
3987 }
3988
3989 case TYPE_OBJC_INTERFACE: {
3990 unsigned Idx = 0;
3991 ObjCInterfaceDecl *ItfD
3992 = ReadDeclAs<ObjCInterfaceDecl>(*Loc.F, Record, Idx);
3993 return Context.getObjCInterfaceType(ItfD->getCanonicalDecl());
3994 }
3995
3996 case TYPE_OBJC_OBJECT: {
3997 unsigned Idx = 0;
3998 QualType Base = readType(*Loc.F, Record, Idx);
3999 unsigned NumProtos = Record[Idx++];
4000 SmallVector<ObjCProtocolDecl*, 4> Protos;
4001 for (unsigned I = 0; I != NumProtos; ++I)
4002 Protos.push_back(ReadDeclAs<ObjCProtocolDecl>(*Loc.F, Record, Idx));
4003 return Context.getObjCObjectType(Base, Protos.data(), NumProtos);
4004 }
4005
4006 case TYPE_OBJC_OBJECT_POINTER: {
4007 unsigned Idx = 0;
4008 QualType Pointee = readType(*Loc.F, Record, Idx);
4009 return Context.getObjCObjectPointerType(Pointee);
4010 }
4011
4012 case TYPE_SUBST_TEMPLATE_TYPE_PARM: {
4013 unsigned Idx = 0;
4014 QualType Parm = readType(*Loc.F, Record, Idx);
4015 QualType Replacement = readType(*Loc.F, Record, Idx);
4016 return
4017 Context.getSubstTemplateTypeParmType(cast<TemplateTypeParmType>(Parm),
4018 Replacement);
4019 }
4020
4021 case TYPE_SUBST_TEMPLATE_TYPE_PARM_PACK: {
4022 unsigned Idx = 0;
4023 QualType Parm = readType(*Loc.F, Record, Idx);
4024 TemplateArgument ArgPack = ReadTemplateArgument(*Loc.F, Record, Idx);
4025 return Context.getSubstTemplateTypeParmPackType(
4026 cast<TemplateTypeParmType>(Parm),
4027 ArgPack);
4028 }
4029
4030 case TYPE_INJECTED_CLASS_NAME: {
4031 CXXRecordDecl *D = ReadDeclAs<CXXRecordDecl>(*Loc.F, Record, Idx);
4032 QualType TST = readType(*Loc.F, Record, Idx); // probably derivable
4033 // FIXME: ASTContext::getInjectedClassNameType is not currently suitable
4034 // for AST reading, too much interdependencies.
4035 return
4036 QualType(new (Context, TypeAlignment) InjectedClassNameType(D, TST), 0);
4037 }
4038
4039 case TYPE_TEMPLATE_TYPE_PARM: {
4040 unsigned Idx = 0;
4041 unsigned Depth = Record[Idx++];
4042 unsigned Index = Record[Idx++];
4043 bool Pack = Record[Idx++];
4044 TemplateTypeParmDecl *D
4045 = ReadDeclAs<TemplateTypeParmDecl>(*Loc.F, Record, Idx);
4046 return Context.getTemplateTypeParmType(Depth, Index, Pack, D);
4047 }
4048
4049 case TYPE_DEPENDENT_NAME: {
4050 unsigned Idx = 0;
4051 ElaboratedTypeKeyword Keyword = (ElaboratedTypeKeyword)Record[Idx++];
4052 NestedNameSpecifier *NNS = ReadNestedNameSpecifier(*Loc.F, Record, Idx);
4053 const IdentifierInfo *Name = this->GetIdentifierInfo(*Loc.F, Record, Idx);
4054 QualType Canon = readType(*Loc.F, Record, Idx);
4055 if (!Canon.isNull())
4056 Canon = Context.getCanonicalType(Canon);
4057 return Context.getDependentNameType(Keyword, NNS, Name, Canon);
4058 }
4059
4060 case TYPE_DEPENDENT_TEMPLATE_SPECIALIZATION: {
4061 unsigned Idx = 0;
4062 ElaboratedTypeKeyword Keyword = (ElaboratedTypeKeyword)Record[Idx++];
4063 NestedNameSpecifier *NNS = ReadNestedNameSpecifier(*Loc.F, Record, Idx);
4064 const IdentifierInfo *Name = this->GetIdentifierInfo(*Loc.F, Record, Idx);
4065 unsigned NumArgs = Record[Idx++];
4066 SmallVector<TemplateArgument, 8> Args;
4067 Args.reserve(NumArgs);
4068 while (NumArgs--)
4069 Args.push_back(ReadTemplateArgument(*Loc.F, Record, Idx));
4070 return Context.getDependentTemplateSpecializationType(Keyword, NNS, Name,
4071 Args.size(), Args.data());
4072 }
4073
4074 case TYPE_DEPENDENT_SIZED_ARRAY: {
4075 unsigned Idx = 0;
4076
4077 // ArrayType
4078 QualType ElementType = readType(*Loc.F, Record, Idx);
4079 ArrayType::ArraySizeModifier ASM
4080 = (ArrayType::ArraySizeModifier)Record[Idx++];
4081 unsigned IndexTypeQuals = Record[Idx++];
4082
4083 // DependentSizedArrayType
4084 Expr *NumElts = ReadExpr(*Loc.F);
4085 SourceRange Brackets = ReadSourceRange(*Loc.F, Record, Idx);
4086
4087 return Context.getDependentSizedArrayType(ElementType, NumElts, ASM,
4088 IndexTypeQuals, Brackets);
4089 }
4090
4091 case TYPE_TEMPLATE_SPECIALIZATION: {
4092 unsigned Idx = 0;
4093 bool IsDependent = Record[Idx++];
4094 TemplateName Name = ReadTemplateName(*Loc.F, Record, Idx);
4095 SmallVector<TemplateArgument, 8> Args;
4096 ReadTemplateArgumentList(Args, *Loc.F, Record, Idx);
4097 QualType Underlying = readType(*Loc.F, Record, Idx);
4098 QualType T;
4099 if (Underlying.isNull())
4100 T = Context.getCanonicalTemplateSpecializationType(Name, Args.data(),
4101 Args.size());
4102 else
4103 T = Context.getTemplateSpecializationType(Name, Args.data(),
4104 Args.size(), Underlying);
4105 const_cast<Type*>(T.getTypePtr())->setDependent(IsDependent);
4106 return T;
4107 }
4108
4109 case TYPE_ATOMIC: {
4110 if (Record.size() != 1) {
4111 Error("Incorrect encoding of atomic type");
4112 return QualType();
4113 }
4114 QualType ValueType = readType(*Loc.F, Record, Idx);
4115 return Context.getAtomicType(ValueType);
4116 }
4117 }
4118 llvm_unreachable("Invalid TypeCode!");
4119 }
4120
4121 class clang::TypeLocReader : public TypeLocVisitor<TypeLocReader> {
4122 ASTReader &Reader;
4123 ModuleFile &F;
4124 llvm::BitstreamCursor &DeclsCursor;
4125 const ASTReader::RecordData &Record;
4126 unsigned &Idx;
4127
ReadSourceLocation(const ASTReader::RecordData & R,unsigned & I)4128 SourceLocation ReadSourceLocation(const ASTReader::RecordData &R,
4129 unsigned &I) {
4130 return Reader.ReadSourceLocation(F, R, I);
4131 }
4132
4133 template<typename T>
ReadDeclAs(const ASTReader::RecordData & Record,unsigned & Idx)4134 T *ReadDeclAs(const ASTReader::RecordData &Record, unsigned &Idx) {
4135 return Reader.ReadDeclAs<T>(F, Record, Idx);
4136 }
4137
4138 public:
TypeLocReader(ASTReader & Reader,ModuleFile & F,const ASTReader::RecordData & Record,unsigned & Idx)4139 TypeLocReader(ASTReader &Reader, ModuleFile &F,
4140 const ASTReader::RecordData &Record, unsigned &Idx)
4141 : Reader(Reader), F(F), DeclsCursor(F.DeclsCursor), Record(Record), Idx(Idx)
4142 { }
4143
4144 // We want compile-time assurance that we've enumerated all of
4145 // these, so unfortunately we have to declare them first, then
4146 // define them out-of-line.
4147 #define ABSTRACT_TYPELOC(CLASS, PARENT)
4148 #define TYPELOC(CLASS, PARENT) \
4149 void Visit##CLASS##TypeLoc(CLASS##TypeLoc TyLoc);
4150 #include "clang/AST/TypeLocNodes.def"
4151
4152 void VisitFunctionTypeLoc(FunctionTypeLoc);
4153 void VisitArrayTypeLoc(ArrayTypeLoc);
4154 };
4155
VisitQualifiedTypeLoc(QualifiedTypeLoc TL)4156 void TypeLocReader::VisitQualifiedTypeLoc(QualifiedTypeLoc TL) {
4157 // nothing to do
4158 }
VisitBuiltinTypeLoc(BuiltinTypeLoc TL)4159 void TypeLocReader::VisitBuiltinTypeLoc(BuiltinTypeLoc TL) {
4160 TL.setBuiltinLoc(ReadSourceLocation(Record, Idx));
4161 if (TL.needsExtraLocalData()) {
4162 TL.setWrittenTypeSpec(static_cast<DeclSpec::TST>(Record[Idx++]));
4163 TL.setWrittenSignSpec(static_cast<DeclSpec::TSS>(Record[Idx++]));
4164 TL.setWrittenWidthSpec(static_cast<DeclSpec::TSW>(Record[Idx++]));
4165 TL.setModeAttr(Record[Idx++]);
4166 }
4167 }
VisitComplexTypeLoc(ComplexTypeLoc TL)4168 void TypeLocReader::VisitComplexTypeLoc(ComplexTypeLoc TL) {
4169 TL.setNameLoc(ReadSourceLocation(Record, Idx));
4170 }
VisitPointerTypeLoc(PointerTypeLoc TL)4171 void TypeLocReader::VisitPointerTypeLoc(PointerTypeLoc TL) {
4172 TL.setStarLoc(ReadSourceLocation(Record, Idx));
4173 }
VisitBlockPointerTypeLoc(BlockPointerTypeLoc TL)4174 void TypeLocReader::VisitBlockPointerTypeLoc(BlockPointerTypeLoc TL) {
4175 TL.setCaretLoc(ReadSourceLocation(Record, Idx));
4176 }
VisitLValueReferenceTypeLoc(LValueReferenceTypeLoc TL)4177 void TypeLocReader::VisitLValueReferenceTypeLoc(LValueReferenceTypeLoc TL) {
4178 TL.setAmpLoc(ReadSourceLocation(Record, Idx));
4179 }
VisitRValueReferenceTypeLoc(RValueReferenceTypeLoc TL)4180 void TypeLocReader::VisitRValueReferenceTypeLoc(RValueReferenceTypeLoc TL) {
4181 TL.setAmpAmpLoc(ReadSourceLocation(Record, Idx));
4182 }
VisitMemberPointerTypeLoc(MemberPointerTypeLoc TL)4183 void TypeLocReader::VisitMemberPointerTypeLoc(MemberPointerTypeLoc TL) {
4184 TL.setStarLoc(ReadSourceLocation(Record, Idx));
4185 TL.setClassTInfo(Reader.GetTypeSourceInfo(F, Record, Idx));
4186 }
VisitArrayTypeLoc(ArrayTypeLoc TL)4187 void TypeLocReader::VisitArrayTypeLoc(ArrayTypeLoc TL) {
4188 TL.setLBracketLoc(ReadSourceLocation(Record, Idx));
4189 TL.setRBracketLoc(ReadSourceLocation(Record, Idx));
4190 if (Record[Idx++])
4191 TL.setSizeExpr(Reader.ReadExpr(F));
4192 else
4193 TL.setSizeExpr(0);
4194 }
VisitConstantArrayTypeLoc(ConstantArrayTypeLoc TL)4195 void TypeLocReader::VisitConstantArrayTypeLoc(ConstantArrayTypeLoc TL) {
4196 VisitArrayTypeLoc(TL);
4197 }
VisitIncompleteArrayTypeLoc(IncompleteArrayTypeLoc TL)4198 void TypeLocReader::VisitIncompleteArrayTypeLoc(IncompleteArrayTypeLoc TL) {
4199 VisitArrayTypeLoc(TL);
4200 }
VisitVariableArrayTypeLoc(VariableArrayTypeLoc TL)4201 void TypeLocReader::VisitVariableArrayTypeLoc(VariableArrayTypeLoc TL) {
4202 VisitArrayTypeLoc(TL);
4203 }
VisitDependentSizedArrayTypeLoc(DependentSizedArrayTypeLoc TL)4204 void TypeLocReader::VisitDependentSizedArrayTypeLoc(
4205 DependentSizedArrayTypeLoc TL) {
4206 VisitArrayTypeLoc(TL);
4207 }
VisitDependentSizedExtVectorTypeLoc(DependentSizedExtVectorTypeLoc TL)4208 void TypeLocReader::VisitDependentSizedExtVectorTypeLoc(
4209 DependentSizedExtVectorTypeLoc TL) {
4210 TL.setNameLoc(ReadSourceLocation(Record, Idx));
4211 }
VisitVectorTypeLoc(VectorTypeLoc TL)4212 void TypeLocReader::VisitVectorTypeLoc(VectorTypeLoc TL) {
4213 TL.setNameLoc(ReadSourceLocation(Record, Idx));
4214 }
VisitExtVectorTypeLoc(ExtVectorTypeLoc TL)4215 void TypeLocReader::VisitExtVectorTypeLoc(ExtVectorTypeLoc TL) {
4216 TL.setNameLoc(ReadSourceLocation(Record, Idx));
4217 }
VisitFunctionTypeLoc(FunctionTypeLoc TL)4218 void TypeLocReader::VisitFunctionTypeLoc(FunctionTypeLoc TL) {
4219 TL.setLocalRangeBegin(ReadSourceLocation(Record, Idx));
4220 TL.setLocalRangeEnd(ReadSourceLocation(Record, Idx));
4221 TL.setTrailingReturn(Record[Idx++]);
4222 for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i) {
4223 TL.setArg(i, ReadDeclAs<ParmVarDecl>(Record, Idx));
4224 }
4225 }
VisitFunctionProtoTypeLoc(FunctionProtoTypeLoc TL)4226 void TypeLocReader::VisitFunctionProtoTypeLoc(FunctionProtoTypeLoc TL) {
4227 VisitFunctionTypeLoc(TL);
4228 }
VisitFunctionNoProtoTypeLoc(FunctionNoProtoTypeLoc TL)4229 void TypeLocReader::VisitFunctionNoProtoTypeLoc(FunctionNoProtoTypeLoc TL) {
4230 VisitFunctionTypeLoc(TL);
4231 }
VisitUnresolvedUsingTypeLoc(UnresolvedUsingTypeLoc TL)4232 void TypeLocReader::VisitUnresolvedUsingTypeLoc(UnresolvedUsingTypeLoc TL) {
4233 TL.setNameLoc(ReadSourceLocation(Record, Idx));
4234 }
VisitTypedefTypeLoc(TypedefTypeLoc TL)4235 void TypeLocReader::VisitTypedefTypeLoc(TypedefTypeLoc TL) {
4236 TL.setNameLoc(ReadSourceLocation(Record, Idx));
4237 }
VisitTypeOfExprTypeLoc(TypeOfExprTypeLoc TL)4238 void TypeLocReader::VisitTypeOfExprTypeLoc(TypeOfExprTypeLoc TL) {
4239 TL.setTypeofLoc(ReadSourceLocation(Record, Idx));
4240 TL.setLParenLoc(ReadSourceLocation(Record, Idx));
4241 TL.setRParenLoc(ReadSourceLocation(Record, Idx));
4242 }
VisitTypeOfTypeLoc(TypeOfTypeLoc TL)4243 void TypeLocReader::VisitTypeOfTypeLoc(TypeOfTypeLoc TL) {
4244 TL.setTypeofLoc(ReadSourceLocation(Record, Idx));
4245 TL.setLParenLoc(ReadSourceLocation(Record, Idx));
4246 TL.setRParenLoc(ReadSourceLocation(Record, Idx));
4247 TL.setUnderlyingTInfo(Reader.GetTypeSourceInfo(F, Record, Idx));
4248 }
VisitDecltypeTypeLoc(DecltypeTypeLoc TL)4249 void TypeLocReader::VisitDecltypeTypeLoc(DecltypeTypeLoc TL) {
4250 TL.setNameLoc(ReadSourceLocation(Record, Idx));
4251 }
VisitUnaryTransformTypeLoc(UnaryTransformTypeLoc TL)4252 void TypeLocReader::VisitUnaryTransformTypeLoc(UnaryTransformTypeLoc TL) {
4253 TL.setKWLoc(ReadSourceLocation(Record, Idx));
4254 TL.setLParenLoc(ReadSourceLocation(Record, Idx));
4255 TL.setRParenLoc(ReadSourceLocation(Record, Idx));
4256 TL.setUnderlyingTInfo(Reader.GetTypeSourceInfo(F, Record, Idx));
4257 }
VisitAutoTypeLoc(AutoTypeLoc TL)4258 void TypeLocReader::VisitAutoTypeLoc(AutoTypeLoc TL) {
4259 TL.setNameLoc(ReadSourceLocation(Record, Idx));
4260 }
VisitRecordTypeLoc(RecordTypeLoc TL)4261 void TypeLocReader::VisitRecordTypeLoc(RecordTypeLoc TL) {
4262 TL.setNameLoc(ReadSourceLocation(Record, Idx));
4263 }
VisitEnumTypeLoc(EnumTypeLoc TL)4264 void TypeLocReader::VisitEnumTypeLoc(EnumTypeLoc TL) {
4265 TL.setNameLoc(ReadSourceLocation(Record, Idx));
4266 }
VisitAttributedTypeLoc(AttributedTypeLoc TL)4267 void TypeLocReader::VisitAttributedTypeLoc(AttributedTypeLoc TL) {
4268 TL.setAttrNameLoc(ReadSourceLocation(Record, Idx));
4269 if (TL.hasAttrOperand()) {
4270 SourceRange range;
4271 range.setBegin(ReadSourceLocation(Record, Idx));
4272 range.setEnd(ReadSourceLocation(Record, Idx));
4273 TL.setAttrOperandParensRange(range);
4274 }
4275 if (TL.hasAttrExprOperand()) {
4276 if (Record[Idx++])
4277 TL.setAttrExprOperand(Reader.ReadExpr(F));
4278 else
4279 TL.setAttrExprOperand(0);
4280 } else if (TL.hasAttrEnumOperand())
4281 TL.setAttrEnumOperandLoc(ReadSourceLocation(Record, Idx));
4282 }
VisitTemplateTypeParmTypeLoc(TemplateTypeParmTypeLoc TL)4283 void TypeLocReader::VisitTemplateTypeParmTypeLoc(TemplateTypeParmTypeLoc TL) {
4284 TL.setNameLoc(ReadSourceLocation(Record, Idx));
4285 }
VisitSubstTemplateTypeParmTypeLoc(SubstTemplateTypeParmTypeLoc TL)4286 void TypeLocReader::VisitSubstTemplateTypeParmTypeLoc(
4287 SubstTemplateTypeParmTypeLoc TL) {
4288 TL.setNameLoc(ReadSourceLocation(Record, Idx));
4289 }
VisitSubstTemplateTypeParmPackTypeLoc(SubstTemplateTypeParmPackTypeLoc TL)4290 void TypeLocReader::VisitSubstTemplateTypeParmPackTypeLoc(
4291 SubstTemplateTypeParmPackTypeLoc TL) {
4292 TL.setNameLoc(ReadSourceLocation(Record, Idx));
4293 }
VisitTemplateSpecializationTypeLoc(TemplateSpecializationTypeLoc TL)4294 void TypeLocReader::VisitTemplateSpecializationTypeLoc(
4295 TemplateSpecializationTypeLoc TL) {
4296 TL.setTemplateKeywordLoc(ReadSourceLocation(Record, Idx));
4297 TL.setTemplateNameLoc(ReadSourceLocation(Record, Idx));
4298 TL.setLAngleLoc(ReadSourceLocation(Record, Idx));
4299 TL.setRAngleLoc(ReadSourceLocation(Record, Idx));
4300 for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i)
4301 TL.setArgLocInfo(i,
4302 Reader.GetTemplateArgumentLocInfo(F,
4303 TL.getTypePtr()->getArg(i).getKind(),
4304 Record, Idx));
4305 }
VisitParenTypeLoc(ParenTypeLoc TL)4306 void TypeLocReader::VisitParenTypeLoc(ParenTypeLoc TL) {
4307 TL.setLParenLoc(ReadSourceLocation(Record, Idx));
4308 TL.setRParenLoc(ReadSourceLocation(Record, Idx));
4309 }
VisitElaboratedTypeLoc(ElaboratedTypeLoc TL)4310 void TypeLocReader::VisitElaboratedTypeLoc(ElaboratedTypeLoc TL) {
4311 TL.setElaboratedKeywordLoc(ReadSourceLocation(Record, Idx));
4312 TL.setQualifierLoc(Reader.ReadNestedNameSpecifierLoc(F, Record, Idx));
4313 }
VisitInjectedClassNameTypeLoc(InjectedClassNameTypeLoc TL)4314 void TypeLocReader::VisitInjectedClassNameTypeLoc(InjectedClassNameTypeLoc TL) {
4315 TL.setNameLoc(ReadSourceLocation(Record, Idx));
4316 }
VisitDependentNameTypeLoc(DependentNameTypeLoc TL)4317 void TypeLocReader::VisitDependentNameTypeLoc(DependentNameTypeLoc TL) {
4318 TL.setElaboratedKeywordLoc(ReadSourceLocation(Record, Idx));
4319 TL.setQualifierLoc(Reader.ReadNestedNameSpecifierLoc(F, Record, Idx));
4320 TL.setNameLoc(ReadSourceLocation(Record, Idx));
4321 }
VisitDependentTemplateSpecializationTypeLoc(DependentTemplateSpecializationTypeLoc TL)4322 void TypeLocReader::VisitDependentTemplateSpecializationTypeLoc(
4323 DependentTemplateSpecializationTypeLoc TL) {
4324 TL.setElaboratedKeywordLoc(ReadSourceLocation(Record, Idx));
4325 TL.setQualifierLoc(Reader.ReadNestedNameSpecifierLoc(F, Record, Idx));
4326 TL.setTemplateKeywordLoc(ReadSourceLocation(Record, Idx));
4327 TL.setTemplateNameLoc(ReadSourceLocation(Record, Idx));
4328 TL.setLAngleLoc(ReadSourceLocation(Record, Idx));
4329 TL.setRAngleLoc(ReadSourceLocation(Record, Idx));
4330 for (unsigned I = 0, E = TL.getNumArgs(); I != E; ++I)
4331 TL.setArgLocInfo(I,
4332 Reader.GetTemplateArgumentLocInfo(F,
4333 TL.getTypePtr()->getArg(I).getKind(),
4334 Record, Idx));
4335 }
VisitPackExpansionTypeLoc(PackExpansionTypeLoc TL)4336 void TypeLocReader::VisitPackExpansionTypeLoc(PackExpansionTypeLoc TL) {
4337 TL.setEllipsisLoc(ReadSourceLocation(Record, Idx));
4338 }
VisitObjCInterfaceTypeLoc(ObjCInterfaceTypeLoc TL)4339 void TypeLocReader::VisitObjCInterfaceTypeLoc(ObjCInterfaceTypeLoc TL) {
4340 TL.setNameLoc(ReadSourceLocation(Record, Idx));
4341 }
VisitObjCObjectTypeLoc(ObjCObjectTypeLoc TL)4342 void TypeLocReader::VisitObjCObjectTypeLoc(ObjCObjectTypeLoc TL) {
4343 TL.setHasBaseTypeAsWritten(Record[Idx++]);
4344 TL.setLAngleLoc(ReadSourceLocation(Record, Idx));
4345 TL.setRAngleLoc(ReadSourceLocation(Record, Idx));
4346 for (unsigned i = 0, e = TL.getNumProtocols(); i != e; ++i)
4347 TL.setProtocolLoc(i, ReadSourceLocation(Record, Idx));
4348 }
VisitObjCObjectPointerTypeLoc(ObjCObjectPointerTypeLoc TL)4349 void TypeLocReader::VisitObjCObjectPointerTypeLoc(ObjCObjectPointerTypeLoc TL) {
4350 TL.setStarLoc(ReadSourceLocation(Record, Idx));
4351 }
VisitAtomicTypeLoc(AtomicTypeLoc TL)4352 void TypeLocReader::VisitAtomicTypeLoc(AtomicTypeLoc TL) {
4353 TL.setKWLoc(ReadSourceLocation(Record, Idx));
4354 TL.setLParenLoc(ReadSourceLocation(Record, Idx));
4355 TL.setRParenLoc(ReadSourceLocation(Record, Idx));
4356 }
4357
GetTypeSourceInfo(ModuleFile & F,const RecordData & Record,unsigned & Idx)4358 TypeSourceInfo *ASTReader::GetTypeSourceInfo(ModuleFile &F,
4359 const RecordData &Record,
4360 unsigned &Idx) {
4361 QualType InfoTy = readType(F, Record, Idx);
4362 if (InfoTy.isNull())
4363 return 0;
4364
4365 TypeSourceInfo *TInfo = getContext().CreateTypeSourceInfo(InfoTy);
4366 TypeLocReader TLR(*this, F, Record, Idx);
4367 for (TypeLoc TL = TInfo->getTypeLoc(); !TL.isNull(); TL = TL.getNextTypeLoc())
4368 TLR.Visit(TL);
4369 return TInfo;
4370 }
4371
GetType(TypeID ID)4372 QualType ASTReader::GetType(TypeID ID) {
4373 unsigned FastQuals = ID & Qualifiers::FastMask;
4374 unsigned Index = ID >> Qualifiers::FastWidth;
4375
4376 if (Index < NUM_PREDEF_TYPE_IDS) {
4377 QualType T;
4378 switch ((PredefinedTypeIDs)Index) {
4379 case PREDEF_TYPE_NULL_ID: return QualType();
4380 case PREDEF_TYPE_VOID_ID: T = Context.VoidTy; break;
4381 case PREDEF_TYPE_BOOL_ID: T = Context.BoolTy; break;
4382
4383 case PREDEF_TYPE_CHAR_U_ID:
4384 case PREDEF_TYPE_CHAR_S_ID:
4385 // FIXME: Check that the signedness of CharTy is correct!
4386 T = Context.CharTy;
4387 break;
4388
4389 case PREDEF_TYPE_UCHAR_ID: T = Context.UnsignedCharTy; break;
4390 case PREDEF_TYPE_USHORT_ID: T = Context.UnsignedShortTy; break;
4391 case PREDEF_TYPE_UINT_ID: T = Context.UnsignedIntTy; break;
4392 case PREDEF_TYPE_ULONG_ID: T = Context.UnsignedLongTy; break;
4393 case PREDEF_TYPE_ULONGLONG_ID: T = Context.UnsignedLongLongTy; break;
4394 case PREDEF_TYPE_UINT128_ID: T = Context.UnsignedInt128Ty; break;
4395 case PREDEF_TYPE_SCHAR_ID: T = Context.SignedCharTy; break;
4396 case PREDEF_TYPE_WCHAR_ID: T = Context.WCharTy; break;
4397 case PREDEF_TYPE_SHORT_ID: T = Context.ShortTy; break;
4398 case PREDEF_TYPE_INT_ID: T = Context.IntTy; break;
4399 case PREDEF_TYPE_LONG_ID: T = Context.LongTy; break;
4400 case PREDEF_TYPE_LONGLONG_ID: T = Context.LongLongTy; break;
4401 case PREDEF_TYPE_INT128_ID: T = Context.Int128Ty; break;
4402 case PREDEF_TYPE_HALF_ID: T = Context.HalfTy; break;
4403 case PREDEF_TYPE_FLOAT_ID: T = Context.FloatTy; break;
4404 case PREDEF_TYPE_DOUBLE_ID: T = Context.DoubleTy; break;
4405 case PREDEF_TYPE_LONGDOUBLE_ID: T = Context.LongDoubleTy; break;
4406 case PREDEF_TYPE_OVERLOAD_ID: T = Context.OverloadTy; break;
4407 case PREDEF_TYPE_BOUND_MEMBER: T = Context.BoundMemberTy; break;
4408 case PREDEF_TYPE_PSEUDO_OBJECT: T = Context.PseudoObjectTy; break;
4409 case PREDEF_TYPE_DEPENDENT_ID: T = Context.DependentTy; break;
4410 case PREDEF_TYPE_UNKNOWN_ANY: T = Context.UnknownAnyTy; break;
4411 case PREDEF_TYPE_NULLPTR_ID: T = Context.NullPtrTy; break;
4412 case PREDEF_TYPE_CHAR16_ID: T = Context.Char16Ty; break;
4413 case PREDEF_TYPE_CHAR32_ID: T = Context.Char32Ty; break;
4414 case PREDEF_TYPE_OBJC_ID: T = Context.ObjCBuiltinIdTy; break;
4415 case PREDEF_TYPE_OBJC_CLASS: T = Context.ObjCBuiltinClassTy; break;
4416 case PREDEF_TYPE_OBJC_SEL: T = Context.ObjCBuiltinSelTy; break;
4417 case PREDEF_TYPE_AUTO_DEDUCT: T = Context.getAutoDeductType(); break;
4418
4419 case PREDEF_TYPE_AUTO_RREF_DEDUCT:
4420 T = Context.getAutoRRefDeductType();
4421 break;
4422
4423 case PREDEF_TYPE_ARC_UNBRIDGED_CAST:
4424 T = Context.ARCUnbridgedCastTy;
4425 break;
4426
4427 }
4428
4429 assert(!T.isNull() && "Unknown predefined type");
4430 return T.withFastQualifiers(FastQuals);
4431 }
4432
4433 Index -= NUM_PREDEF_TYPE_IDS;
4434 assert(Index < TypesLoaded.size() && "Type index out-of-range");
4435 if (TypesLoaded[Index].isNull()) {
4436 TypesLoaded[Index] = readTypeRecord(Index);
4437 if (TypesLoaded[Index].isNull())
4438 return QualType();
4439
4440 TypesLoaded[Index]->setFromAST();
4441 if (DeserializationListener)
4442 DeserializationListener->TypeRead(TypeIdx::fromTypeID(ID),
4443 TypesLoaded[Index]);
4444 }
4445
4446 return TypesLoaded[Index].withFastQualifiers(FastQuals);
4447 }
4448
getLocalType(ModuleFile & F,unsigned LocalID)4449 QualType ASTReader::getLocalType(ModuleFile &F, unsigned LocalID) {
4450 return GetType(getGlobalTypeID(F, LocalID));
4451 }
4452
4453 serialization::TypeID
getGlobalTypeID(ModuleFile & F,unsigned LocalID) const4454 ASTReader::getGlobalTypeID(ModuleFile &F, unsigned LocalID) const {
4455 unsigned FastQuals = LocalID & Qualifiers::FastMask;
4456 unsigned LocalIndex = LocalID >> Qualifiers::FastWidth;
4457
4458 if (LocalIndex < NUM_PREDEF_TYPE_IDS)
4459 return LocalID;
4460
4461 ContinuousRangeMap<uint32_t, int, 2>::iterator I
4462 = F.TypeRemap.find(LocalIndex - NUM_PREDEF_TYPE_IDS);
4463 assert(I != F.TypeRemap.end() && "Invalid index into type index remap");
4464
4465 unsigned GlobalIndex = LocalIndex + I->second;
4466 return (GlobalIndex << Qualifiers::FastWidth) | FastQuals;
4467 }
4468
4469 TemplateArgumentLocInfo
GetTemplateArgumentLocInfo(ModuleFile & F,TemplateArgument::ArgKind Kind,const RecordData & Record,unsigned & Index)4470 ASTReader::GetTemplateArgumentLocInfo(ModuleFile &F,
4471 TemplateArgument::ArgKind Kind,
4472 const RecordData &Record,
4473 unsigned &Index) {
4474 switch (Kind) {
4475 case TemplateArgument::Expression:
4476 return ReadExpr(F);
4477 case TemplateArgument::Type:
4478 return GetTypeSourceInfo(F, Record, Index);
4479 case TemplateArgument::Template: {
4480 NestedNameSpecifierLoc QualifierLoc = ReadNestedNameSpecifierLoc(F, Record,
4481 Index);
4482 SourceLocation TemplateNameLoc = ReadSourceLocation(F, Record, Index);
4483 return TemplateArgumentLocInfo(QualifierLoc, TemplateNameLoc,
4484 SourceLocation());
4485 }
4486 case TemplateArgument::TemplateExpansion: {
4487 NestedNameSpecifierLoc QualifierLoc = ReadNestedNameSpecifierLoc(F, Record,
4488 Index);
4489 SourceLocation TemplateNameLoc = ReadSourceLocation(F, Record, Index);
4490 SourceLocation EllipsisLoc = ReadSourceLocation(F, Record, Index);
4491 return TemplateArgumentLocInfo(QualifierLoc, TemplateNameLoc,
4492 EllipsisLoc);
4493 }
4494 case TemplateArgument::Null:
4495 case TemplateArgument::Integral:
4496 case TemplateArgument::Declaration:
4497 case TemplateArgument::Pack:
4498 return TemplateArgumentLocInfo();
4499 }
4500 llvm_unreachable("unexpected template argument loc");
4501 }
4502
4503 TemplateArgumentLoc
ReadTemplateArgumentLoc(ModuleFile & F,const RecordData & Record,unsigned & Index)4504 ASTReader::ReadTemplateArgumentLoc(ModuleFile &F,
4505 const RecordData &Record, unsigned &Index) {
4506 TemplateArgument Arg = ReadTemplateArgument(F, Record, Index);
4507
4508 if (Arg.getKind() == TemplateArgument::Expression) {
4509 if (Record[Index++]) // bool InfoHasSameExpr.
4510 return TemplateArgumentLoc(Arg, TemplateArgumentLocInfo(Arg.getAsExpr()));
4511 }
4512 return TemplateArgumentLoc(Arg, GetTemplateArgumentLocInfo(F, Arg.getKind(),
4513 Record, Index));
4514 }
4515
GetExternalDecl(uint32_t ID)4516 Decl *ASTReader::GetExternalDecl(uint32_t ID) {
4517 return GetDecl(ID);
4518 }
4519
readCXXBaseSpecifiers(ModuleFile & M,const RecordData & Record,unsigned & Idx)4520 uint64_t ASTReader::readCXXBaseSpecifiers(ModuleFile &M, const RecordData &Record,
4521 unsigned &Idx){
4522 if (Idx >= Record.size())
4523 return 0;
4524
4525 unsigned LocalID = Record[Idx++];
4526 return getGlobalBitOffset(M, M.CXXBaseSpecifiersOffsets[LocalID - 1]);
4527 }
4528
GetExternalCXXBaseSpecifiers(uint64_t Offset)4529 CXXBaseSpecifier *ASTReader::GetExternalCXXBaseSpecifiers(uint64_t Offset) {
4530 RecordLocation Loc = getLocalBitOffset(Offset);
4531 llvm::BitstreamCursor &Cursor = Loc.F->DeclsCursor;
4532 SavedStreamPosition SavedPosition(Cursor);
4533 Cursor.JumpToBit(Loc.Offset);
4534 ReadingKindTracker ReadingKind(Read_Decl, *this);
4535 RecordData Record;
4536 unsigned Code = Cursor.ReadCode();
4537 unsigned RecCode = Cursor.ReadRecord(Code, Record);
4538 if (RecCode != DECL_CXX_BASE_SPECIFIERS) {
4539 Error("Malformed AST file: missing C++ base specifiers");
4540 return 0;
4541 }
4542
4543 unsigned Idx = 0;
4544 unsigned NumBases = Record[Idx++];
4545 void *Mem = Context.Allocate(sizeof(CXXBaseSpecifier) * NumBases);
4546 CXXBaseSpecifier *Bases = new (Mem) CXXBaseSpecifier [NumBases];
4547 for (unsigned I = 0; I != NumBases; ++I)
4548 Bases[I] = ReadCXXBaseSpecifier(*Loc.F, Record, Idx);
4549 return Bases;
4550 }
4551
4552 serialization::DeclID
getGlobalDeclID(ModuleFile & F,unsigned LocalID) const4553 ASTReader::getGlobalDeclID(ModuleFile &F, unsigned LocalID) const {
4554 if (LocalID < NUM_PREDEF_DECL_IDS)
4555 return LocalID;
4556
4557 ContinuousRangeMap<uint32_t, int, 2>::iterator I
4558 = F.DeclRemap.find(LocalID - NUM_PREDEF_DECL_IDS);
4559 assert(I != F.DeclRemap.end() && "Invalid index into decl index remap");
4560
4561 return LocalID + I->second;
4562 }
4563
isDeclIDFromModule(serialization::GlobalDeclID ID,ModuleFile & M) const4564 bool ASTReader::isDeclIDFromModule(serialization::GlobalDeclID ID,
4565 ModuleFile &M) const {
4566 GlobalDeclMapType::const_iterator I = GlobalDeclMap.find(ID);
4567 assert(I != GlobalDeclMap.end() && "Corrupted global declaration map");
4568 return &M == I->second;
4569 }
4570
getOwningModuleFile(Decl * D)4571 ModuleFile *ASTReader::getOwningModuleFile(Decl *D) {
4572 if (!D->isFromASTFile())
4573 return 0;
4574 GlobalDeclMapType::const_iterator I = GlobalDeclMap.find(D->getGlobalID());
4575 assert(I != GlobalDeclMap.end() && "Corrupted global declaration map");
4576 return I->second;
4577 }
4578
getSourceLocationForDeclID(GlobalDeclID ID)4579 SourceLocation ASTReader::getSourceLocationForDeclID(GlobalDeclID ID) {
4580 if (ID < NUM_PREDEF_DECL_IDS)
4581 return SourceLocation();
4582
4583 unsigned Index = ID - NUM_PREDEF_DECL_IDS;
4584
4585 if (Index > DeclsLoaded.size()) {
4586 Error("declaration ID out-of-range for AST file");
4587 return SourceLocation();
4588 }
4589
4590 if (Decl *D = DeclsLoaded[Index])
4591 return D->getLocation();
4592
4593 unsigned RawLocation = 0;
4594 RecordLocation Rec = DeclCursorForID(ID, RawLocation);
4595 return ReadSourceLocation(*Rec.F, RawLocation);
4596 }
4597
GetDecl(DeclID ID)4598 Decl *ASTReader::GetDecl(DeclID ID) {
4599 if (ID < NUM_PREDEF_DECL_IDS) {
4600 switch ((PredefinedDeclIDs)ID) {
4601 case PREDEF_DECL_NULL_ID:
4602 return 0;
4603
4604 case PREDEF_DECL_TRANSLATION_UNIT_ID:
4605 return Context.getTranslationUnitDecl();
4606
4607 case PREDEF_DECL_OBJC_ID_ID:
4608 return Context.getObjCIdDecl();
4609
4610 case PREDEF_DECL_OBJC_SEL_ID:
4611 return Context.getObjCSelDecl();
4612
4613 case PREDEF_DECL_OBJC_CLASS_ID:
4614 return Context.getObjCClassDecl();
4615
4616 case PREDEF_DECL_OBJC_PROTOCOL_ID:
4617 return Context.getObjCProtocolDecl();
4618
4619 case PREDEF_DECL_INT_128_ID:
4620 return Context.getInt128Decl();
4621
4622 case PREDEF_DECL_UNSIGNED_INT_128_ID:
4623 return Context.getUInt128Decl();
4624
4625 case PREDEF_DECL_OBJC_INSTANCETYPE_ID:
4626 return Context.getObjCInstanceTypeDecl();
4627 }
4628 }
4629
4630 unsigned Index = ID - NUM_PREDEF_DECL_IDS;
4631
4632 if (Index >= DeclsLoaded.size()) {
4633 Error("declaration ID out-of-range for AST file");
4634 }
4635
4636 if (!DeclsLoaded[Index]) {
4637 ReadDeclRecord(ID);
4638 if (DeserializationListener)
4639 DeserializationListener->DeclRead(ID, DeclsLoaded[Index]);
4640 }
4641
4642 return DeclsLoaded[Index];
4643 }
4644
mapGlobalIDToModuleFileGlobalID(ModuleFile & M,DeclID GlobalID)4645 DeclID ASTReader::mapGlobalIDToModuleFileGlobalID(ModuleFile &M,
4646 DeclID GlobalID) {
4647 if (GlobalID < NUM_PREDEF_DECL_IDS)
4648 return GlobalID;
4649
4650 GlobalDeclMapType::const_iterator I = GlobalDeclMap.find(GlobalID);
4651 assert(I != GlobalDeclMap.end() && "Corrupted global declaration map");
4652 ModuleFile *Owner = I->second;
4653
4654 llvm::DenseMap<ModuleFile *, serialization::DeclID>::iterator Pos
4655 = M.GlobalToLocalDeclIDs.find(Owner);
4656 if (Pos == M.GlobalToLocalDeclIDs.end())
4657 return 0;
4658
4659 return GlobalID - Owner->BaseDeclID + Pos->second;
4660 }
4661
ReadDeclID(ModuleFile & F,const RecordData & Record,unsigned & Idx)4662 serialization::DeclID ASTReader::ReadDeclID(ModuleFile &F,
4663 const RecordData &Record,
4664 unsigned &Idx) {
4665 if (Idx >= Record.size()) {
4666 Error("Corrupted AST file");
4667 return 0;
4668 }
4669
4670 return getGlobalDeclID(F, Record[Idx++]);
4671 }
4672
4673 /// \brief Resolve the offset of a statement into a statement.
4674 ///
4675 /// This operation will read a new statement from the external
4676 /// source each time it is called, and is meant to be used via a
4677 /// LazyOffsetPtr (which is used by Decls for the body of functions, etc).
GetExternalDeclStmt(uint64_t Offset)4678 Stmt *ASTReader::GetExternalDeclStmt(uint64_t Offset) {
4679 // Switch case IDs are per Decl.
4680 ClearSwitchCaseIDs();
4681
4682 // Offset here is a global offset across the entire chain.
4683 RecordLocation Loc = getLocalBitOffset(Offset);
4684 Loc.F->DeclsCursor.JumpToBit(Loc.Offset);
4685 return ReadStmtFromStream(*Loc.F);
4686 }
4687
4688 namespace {
4689 class FindExternalLexicalDeclsVisitor {
4690 ASTReader &Reader;
4691 const DeclContext *DC;
4692 bool (*isKindWeWant)(Decl::Kind);
4693
4694 SmallVectorImpl<Decl*> &Decls;
4695 bool PredefsVisited[NUM_PREDEF_DECL_IDS];
4696
4697 public:
FindExternalLexicalDeclsVisitor(ASTReader & Reader,const DeclContext * DC,bool (* isKindWeWant)(Decl::Kind),SmallVectorImpl<Decl * > & Decls)4698 FindExternalLexicalDeclsVisitor(ASTReader &Reader, const DeclContext *DC,
4699 bool (*isKindWeWant)(Decl::Kind),
4700 SmallVectorImpl<Decl*> &Decls)
4701 : Reader(Reader), DC(DC), isKindWeWant(isKindWeWant), Decls(Decls)
4702 {
4703 for (unsigned I = 0; I != NUM_PREDEF_DECL_IDS; ++I)
4704 PredefsVisited[I] = false;
4705 }
4706
visit(ModuleFile & M,bool Preorder,void * UserData)4707 static bool visit(ModuleFile &M, bool Preorder, void *UserData) {
4708 if (Preorder)
4709 return false;
4710
4711 FindExternalLexicalDeclsVisitor *This
4712 = static_cast<FindExternalLexicalDeclsVisitor *>(UserData);
4713
4714 ModuleFile::DeclContextInfosMap::iterator Info
4715 = M.DeclContextInfos.find(This->DC);
4716 if (Info == M.DeclContextInfos.end() || !Info->second.LexicalDecls)
4717 return false;
4718
4719 // Load all of the declaration IDs
4720 for (const KindDeclIDPair *ID = Info->second.LexicalDecls,
4721 *IDE = ID + Info->second.NumLexicalDecls;
4722 ID != IDE; ++ID) {
4723 if (This->isKindWeWant && !This->isKindWeWant((Decl::Kind)ID->first))
4724 continue;
4725
4726 // Don't add predefined declarations to the lexical context more
4727 // than once.
4728 if (ID->second < NUM_PREDEF_DECL_IDS) {
4729 if (This->PredefsVisited[ID->second])
4730 continue;
4731
4732 This->PredefsVisited[ID->second] = true;
4733 }
4734
4735 if (Decl *D = This->Reader.GetLocalDecl(M, ID->second)) {
4736 if (!This->DC->isDeclInLexicalTraversal(D))
4737 This->Decls.push_back(D);
4738 }
4739 }
4740
4741 return false;
4742 }
4743 };
4744 }
4745
FindExternalLexicalDecls(const DeclContext * DC,bool (* isKindWeWant)(Decl::Kind),SmallVectorImpl<Decl * > & Decls)4746 ExternalLoadResult ASTReader::FindExternalLexicalDecls(const DeclContext *DC,
4747 bool (*isKindWeWant)(Decl::Kind),
4748 SmallVectorImpl<Decl*> &Decls) {
4749 // There might be lexical decls in multiple modules, for the TU at
4750 // least. Walk all of the modules in the order they were loaded.
4751 FindExternalLexicalDeclsVisitor Visitor(*this, DC, isKindWeWant, Decls);
4752 ModuleMgr.visitDepthFirst(&FindExternalLexicalDeclsVisitor::visit, &Visitor);
4753 ++NumLexicalDeclContextsRead;
4754 return ELR_Success;
4755 }
4756
4757 namespace {
4758
4759 class DeclIDComp {
4760 ASTReader &Reader;
4761 ModuleFile &Mod;
4762
4763 public:
DeclIDComp(ASTReader & Reader,ModuleFile & M)4764 DeclIDComp(ASTReader &Reader, ModuleFile &M) : Reader(Reader), Mod(M) {}
4765
operator ()(LocalDeclID L,LocalDeclID R) const4766 bool operator()(LocalDeclID L, LocalDeclID R) const {
4767 SourceLocation LHS = getLocation(L);
4768 SourceLocation RHS = getLocation(R);
4769 return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS);
4770 }
4771
operator ()(SourceLocation LHS,LocalDeclID R) const4772 bool operator()(SourceLocation LHS, LocalDeclID R) const {
4773 SourceLocation RHS = getLocation(R);
4774 return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS);
4775 }
4776
operator ()(LocalDeclID L,SourceLocation RHS) const4777 bool operator()(LocalDeclID L, SourceLocation RHS) const {
4778 SourceLocation LHS = getLocation(L);
4779 return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS);
4780 }
4781
getLocation(LocalDeclID ID) const4782 SourceLocation getLocation(LocalDeclID ID) const {
4783 return Reader.getSourceManager().getFileLoc(
4784 Reader.getSourceLocationForDeclID(Reader.getGlobalDeclID(Mod, ID)));
4785 }
4786 };
4787
4788 }
4789
FindFileRegionDecls(FileID File,unsigned Offset,unsigned Length,SmallVectorImpl<Decl * > & Decls)4790 void ASTReader::FindFileRegionDecls(FileID File,
4791 unsigned Offset, unsigned Length,
4792 SmallVectorImpl<Decl *> &Decls) {
4793 SourceManager &SM = getSourceManager();
4794
4795 llvm::DenseMap<FileID, FileDeclsInfo>::iterator I = FileDeclIDs.find(File);
4796 if (I == FileDeclIDs.end())
4797 return;
4798
4799 FileDeclsInfo &DInfo = I->second;
4800 if (DInfo.Decls.empty())
4801 return;
4802
4803 SourceLocation
4804 BeginLoc = SM.getLocForStartOfFile(File).getLocWithOffset(Offset);
4805 SourceLocation EndLoc = BeginLoc.getLocWithOffset(Length);
4806
4807 DeclIDComp DIDComp(*this, *DInfo.Mod);
4808 ArrayRef<serialization::LocalDeclID>::iterator
4809 BeginIt = std::lower_bound(DInfo.Decls.begin(), DInfo.Decls.end(),
4810 BeginLoc, DIDComp);
4811 if (BeginIt != DInfo.Decls.begin())
4812 --BeginIt;
4813
4814 // If we are pointing at a top-level decl inside an objc container, we need
4815 // to backtrack until we find it otherwise we will fail to report that the
4816 // region overlaps with an objc container.
4817 while (BeginIt != DInfo.Decls.begin() &&
4818 GetDecl(getGlobalDeclID(*DInfo.Mod, *BeginIt))
4819 ->isTopLevelDeclInObjCContainer())
4820 --BeginIt;
4821
4822 ArrayRef<serialization::LocalDeclID>::iterator
4823 EndIt = std::upper_bound(DInfo.Decls.begin(), DInfo.Decls.end(),
4824 EndLoc, DIDComp);
4825 if (EndIt != DInfo.Decls.end())
4826 ++EndIt;
4827
4828 for (ArrayRef<serialization::LocalDeclID>::iterator
4829 DIt = BeginIt; DIt != EndIt; ++DIt)
4830 Decls.push_back(GetDecl(getGlobalDeclID(*DInfo.Mod, *DIt)));
4831 }
4832
4833 namespace {
4834 /// \brief ModuleFile visitor used to perform name lookup into a
4835 /// declaration context.
4836 class DeclContextNameLookupVisitor {
4837 ASTReader &Reader;
4838 llvm::SmallVectorImpl<const DeclContext *> &Contexts;
4839 const DeclContext *DC;
4840 DeclarationName Name;
4841 SmallVectorImpl<NamedDecl *> &Decls;
4842
4843 public:
DeclContextNameLookupVisitor(ASTReader & Reader,SmallVectorImpl<const DeclContext * > & Contexts,DeclarationName Name,SmallVectorImpl<NamedDecl * > & Decls)4844 DeclContextNameLookupVisitor(ASTReader &Reader,
4845 SmallVectorImpl<const DeclContext *> &Contexts,
4846 DeclarationName Name,
4847 SmallVectorImpl<NamedDecl *> &Decls)
4848 : Reader(Reader), Contexts(Contexts), Name(Name), Decls(Decls) { }
4849
visit(ModuleFile & M,void * UserData)4850 static bool visit(ModuleFile &M, void *UserData) {
4851 DeclContextNameLookupVisitor *This
4852 = static_cast<DeclContextNameLookupVisitor *>(UserData);
4853
4854 // Check whether we have any visible declaration information for
4855 // this context in this module.
4856 ModuleFile::DeclContextInfosMap::iterator Info;
4857 bool FoundInfo = false;
4858 for (unsigned I = 0, N = This->Contexts.size(); I != N; ++I) {
4859 Info = M.DeclContextInfos.find(This->Contexts[I]);
4860 if (Info != M.DeclContextInfos.end() &&
4861 Info->second.NameLookupTableData) {
4862 FoundInfo = true;
4863 break;
4864 }
4865 }
4866
4867 if (!FoundInfo)
4868 return false;
4869
4870 // Look for this name within this module.
4871 ASTDeclContextNameLookupTable *LookupTable =
4872 Info->second.NameLookupTableData;
4873 ASTDeclContextNameLookupTable::iterator Pos
4874 = LookupTable->find(This->Name);
4875 if (Pos == LookupTable->end())
4876 return false;
4877
4878 bool FoundAnything = false;
4879 ASTDeclContextNameLookupTrait::data_type Data = *Pos;
4880 for (; Data.first != Data.second; ++Data.first) {
4881 NamedDecl *ND = This->Reader.GetLocalDeclAs<NamedDecl>(M, *Data.first);
4882 if (!ND)
4883 continue;
4884
4885 if (ND->getDeclName() != This->Name) {
4886 assert(!This->Name.getCXXNameType().isNull() &&
4887 "Name mismatch without a type");
4888 continue;
4889 }
4890
4891 // Record this declaration.
4892 FoundAnything = true;
4893 This->Decls.push_back(ND);
4894 }
4895
4896 return FoundAnything;
4897 }
4898 };
4899 }
4900
4901 DeclContext::lookup_result
FindExternalVisibleDeclsByName(const DeclContext * DC,DeclarationName Name)4902 ASTReader::FindExternalVisibleDeclsByName(const DeclContext *DC,
4903 DeclarationName Name) {
4904 assert(DC->hasExternalVisibleStorage() &&
4905 "DeclContext has no visible decls in storage");
4906 if (!Name)
4907 return DeclContext::lookup_result(DeclContext::lookup_iterator(0),
4908 DeclContext::lookup_iterator(0));
4909
4910 SmallVector<NamedDecl *, 64> Decls;
4911
4912 // Compute the declaration contexts we need to look into. Multiple such
4913 // declaration contexts occur when two declaration contexts from disjoint
4914 // modules get merged, e.g., when two namespaces with the same name are
4915 // independently defined in separate modules.
4916 SmallVector<const DeclContext *, 2> Contexts;
4917 Contexts.push_back(DC);
4918
4919 if (DC->isNamespace()) {
4920 MergedDeclsMap::iterator Merged
4921 = MergedDecls.find(const_cast<Decl *>(cast<Decl>(DC)));
4922 if (Merged != MergedDecls.end()) {
4923 for (unsigned I = 0, N = Merged->second.size(); I != N; ++I)
4924 Contexts.push_back(cast<DeclContext>(GetDecl(Merged->second[I])));
4925 }
4926 }
4927
4928 DeclContextNameLookupVisitor Visitor(*this, Contexts, Name, Decls);
4929 ModuleMgr.visit(&DeclContextNameLookupVisitor::visit, &Visitor);
4930 ++NumVisibleDeclContextsRead;
4931 SetExternalVisibleDeclsForName(DC, Name, Decls);
4932 return const_cast<DeclContext*>(DC)->lookup(Name);
4933 }
4934
4935 namespace {
4936 /// \brief ModuleFile visitor used to retrieve all visible names in a
4937 /// declaration context.
4938 class DeclContextAllNamesVisitor {
4939 ASTReader &Reader;
4940 llvm::SmallVectorImpl<const DeclContext *> &Contexts;
4941 const DeclContext *DC;
4942 llvm::DenseMap<DeclarationName, SmallVector<NamedDecl *, 8> > &Decls;
4943
4944 public:
DeclContextAllNamesVisitor(ASTReader & Reader,SmallVectorImpl<const DeclContext * > & Contexts,llvm::DenseMap<DeclarationName,SmallVector<NamedDecl *,8>> & Decls)4945 DeclContextAllNamesVisitor(ASTReader &Reader,
4946 SmallVectorImpl<const DeclContext *> &Contexts,
4947 llvm::DenseMap<DeclarationName,
4948 SmallVector<NamedDecl *, 8> > &Decls)
4949 : Reader(Reader), Contexts(Contexts), Decls(Decls) { }
4950
visit(ModuleFile & M,void * UserData)4951 static bool visit(ModuleFile &M, void *UserData) {
4952 DeclContextAllNamesVisitor *This
4953 = static_cast<DeclContextAllNamesVisitor *>(UserData);
4954
4955 // Check whether we have any visible declaration information for
4956 // this context in this module.
4957 ModuleFile::DeclContextInfosMap::iterator Info;
4958 bool FoundInfo = false;
4959 for (unsigned I = 0, N = This->Contexts.size(); I != N; ++I) {
4960 Info = M.DeclContextInfos.find(This->Contexts[I]);
4961 if (Info != M.DeclContextInfos.end() &&
4962 Info->second.NameLookupTableData) {
4963 FoundInfo = true;
4964 break;
4965 }
4966 }
4967
4968 if (!FoundInfo)
4969 return false;
4970
4971 ASTDeclContextNameLookupTable *LookupTable =
4972 Info->second.NameLookupTableData;
4973 bool FoundAnything = false;
4974 for (ASTDeclContextNameLookupTable::data_iterator
4975 I = LookupTable->data_begin(), E = LookupTable->data_end();
4976 I != E; ++I) {
4977 ASTDeclContextNameLookupTrait::data_type Data = *I;
4978 for (; Data.first != Data.second; ++Data.first) {
4979 NamedDecl *ND = This->Reader.GetLocalDeclAs<NamedDecl>(M,
4980 *Data.first);
4981 if (!ND)
4982 continue;
4983
4984 // Record this declaration.
4985 FoundAnything = true;
4986 This->Decls[ND->getDeclName()].push_back(ND);
4987 }
4988 }
4989
4990 return FoundAnything;
4991 }
4992 };
4993 }
4994
completeVisibleDeclsMap(const DeclContext * DC)4995 void ASTReader::completeVisibleDeclsMap(const DeclContext *DC) {
4996 if (!DC->hasExternalVisibleStorage())
4997 return;
4998 llvm::DenseMap<DeclarationName, llvm::SmallVector<NamedDecl*, 8> > Decls;
4999
5000 // Compute the declaration contexts we need to look into. Multiple such
5001 // declaration contexts occur when two declaration contexts from disjoint
5002 // modules get merged, e.g., when two namespaces with the same name are
5003 // independently defined in separate modules.
5004 SmallVector<const DeclContext *, 2> Contexts;
5005 Contexts.push_back(DC);
5006
5007 if (DC->isNamespace()) {
5008 MergedDeclsMap::iterator Merged
5009 = MergedDecls.find(const_cast<Decl *>(cast<Decl>(DC)));
5010 if (Merged != MergedDecls.end()) {
5011 for (unsigned I = 0, N = Merged->second.size(); I != N; ++I)
5012 Contexts.push_back(cast<DeclContext>(GetDecl(Merged->second[I])));
5013 }
5014 }
5015
5016 DeclContextAllNamesVisitor Visitor(*this, Contexts, Decls);
5017 ModuleMgr.visit(&DeclContextAllNamesVisitor::visit, &Visitor);
5018 ++NumVisibleDeclContextsRead;
5019
5020 for (llvm::DenseMap<DeclarationName,
5021 llvm::SmallVector<NamedDecl*, 8> >::iterator
5022 I = Decls.begin(), E = Decls.end(); I != E; ++I) {
5023 SetExternalVisibleDeclsForName(DC, I->first, I->second);
5024 }
5025 }
5026
5027 /// \brief Under non-PCH compilation the consumer receives the objc methods
5028 /// before receiving the implementation, and codegen depends on this.
5029 /// We simulate this by deserializing and passing to consumer the methods of the
5030 /// implementation before passing the deserialized implementation decl.
PassObjCImplDeclToConsumer(ObjCImplDecl * ImplD,ASTConsumer * Consumer)5031 static void PassObjCImplDeclToConsumer(ObjCImplDecl *ImplD,
5032 ASTConsumer *Consumer) {
5033 assert(ImplD && Consumer);
5034
5035 for (ObjCImplDecl::method_iterator
5036 I = ImplD->meth_begin(), E = ImplD->meth_end(); I != E; ++I)
5037 Consumer->HandleInterestingDecl(DeclGroupRef(*I));
5038
5039 Consumer->HandleInterestingDecl(DeclGroupRef(ImplD));
5040 }
5041
PassInterestingDeclsToConsumer()5042 void ASTReader::PassInterestingDeclsToConsumer() {
5043 assert(Consumer);
5044 while (!InterestingDecls.empty()) {
5045 Decl *D = InterestingDecls.front();
5046 InterestingDecls.pop_front();
5047
5048 PassInterestingDeclToConsumer(D);
5049 }
5050 }
5051
PassInterestingDeclToConsumer(Decl * D)5052 void ASTReader::PassInterestingDeclToConsumer(Decl *D) {
5053 if (ObjCImplDecl *ImplD = dyn_cast<ObjCImplDecl>(D))
5054 PassObjCImplDeclToConsumer(ImplD, Consumer);
5055 else
5056 Consumer->HandleInterestingDecl(DeclGroupRef(D));
5057 }
5058
StartTranslationUnit(ASTConsumer * Consumer)5059 void ASTReader::StartTranslationUnit(ASTConsumer *Consumer) {
5060 this->Consumer = Consumer;
5061
5062 if (!Consumer)
5063 return;
5064
5065 for (unsigned I = 0, N = ExternalDefinitions.size(); I != N; ++I) {
5066 // Force deserialization of this decl, which will cause it to be queued for
5067 // passing to the consumer.
5068 GetDecl(ExternalDefinitions[I]);
5069 }
5070 ExternalDefinitions.clear();
5071
5072 PassInterestingDeclsToConsumer();
5073 }
5074
PrintStats()5075 void ASTReader::PrintStats() {
5076 std::fprintf(stderr, "*** AST File Statistics:\n");
5077
5078 unsigned NumTypesLoaded
5079 = TypesLoaded.size() - std::count(TypesLoaded.begin(), TypesLoaded.end(),
5080 QualType());
5081 unsigned NumDeclsLoaded
5082 = DeclsLoaded.size() - std::count(DeclsLoaded.begin(), DeclsLoaded.end(),
5083 (Decl *)0);
5084 unsigned NumIdentifiersLoaded
5085 = IdentifiersLoaded.size() - std::count(IdentifiersLoaded.begin(),
5086 IdentifiersLoaded.end(),
5087 (IdentifierInfo *)0);
5088 unsigned NumSelectorsLoaded
5089 = SelectorsLoaded.size() - std::count(SelectorsLoaded.begin(),
5090 SelectorsLoaded.end(),
5091 Selector());
5092
5093 std::fprintf(stderr, " %u stat cache hits\n", NumStatHits);
5094 std::fprintf(stderr, " %u stat cache misses\n", NumStatMisses);
5095 if (unsigned TotalNumSLocEntries = getTotalNumSLocs())
5096 std::fprintf(stderr, " %u/%u source location entries read (%f%%)\n",
5097 NumSLocEntriesRead, TotalNumSLocEntries,
5098 ((float)NumSLocEntriesRead/TotalNumSLocEntries * 100));
5099 if (!TypesLoaded.empty())
5100 std::fprintf(stderr, " %u/%u types read (%f%%)\n",
5101 NumTypesLoaded, (unsigned)TypesLoaded.size(),
5102 ((float)NumTypesLoaded/TypesLoaded.size() * 100));
5103 if (!DeclsLoaded.empty())
5104 std::fprintf(stderr, " %u/%u declarations read (%f%%)\n",
5105 NumDeclsLoaded, (unsigned)DeclsLoaded.size(),
5106 ((float)NumDeclsLoaded/DeclsLoaded.size() * 100));
5107 if (!IdentifiersLoaded.empty())
5108 std::fprintf(stderr, " %u/%u identifiers read (%f%%)\n",
5109 NumIdentifiersLoaded, (unsigned)IdentifiersLoaded.size(),
5110 ((float)NumIdentifiersLoaded/IdentifiersLoaded.size() * 100));
5111 if (!SelectorsLoaded.empty())
5112 std::fprintf(stderr, " %u/%u selectors read (%f%%)\n",
5113 NumSelectorsLoaded, (unsigned)SelectorsLoaded.size(),
5114 ((float)NumSelectorsLoaded/SelectorsLoaded.size() * 100));
5115 if (TotalNumStatements)
5116 std::fprintf(stderr, " %u/%u statements read (%f%%)\n",
5117 NumStatementsRead, TotalNumStatements,
5118 ((float)NumStatementsRead/TotalNumStatements * 100));
5119 if (TotalNumMacros)
5120 std::fprintf(stderr, " %u/%u macros read (%f%%)\n",
5121 NumMacrosRead, TotalNumMacros,
5122 ((float)NumMacrosRead/TotalNumMacros * 100));
5123 if (TotalLexicalDeclContexts)
5124 std::fprintf(stderr, " %u/%u lexical declcontexts read (%f%%)\n",
5125 NumLexicalDeclContextsRead, TotalLexicalDeclContexts,
5126 ((float)NumLexicalDeclContextsRead/TotalLexicalDeclContexts
5127 * 100));
5128 if (TotalVisibleDeclContexts)
5129 std::fprintf(stderr, " %u/%u visible declcontexts read (%f%%)\n",
5130 NumVisibleDeclContextsRead, TotalVisibleDeclContexts,
5131 ((float)NumVisibleDeclContextsRead/TotalVisibleDeclContexts
5132 * 100));
5133 if (TotalNumMethodPoolEntries) {
5134 std::fprintf(stderr, " %u/%u method pool entries read (%f%%)\n",
5135 NumMethodPoolEntriesRead, TotalNumMethodPoolEntries,
5136 ((float)NumMethodPoolEntriesRead/TotalNumMethodPoolEntries
5137 * 100));
5138 std::fprintf(stderr, " %u method pool misses\n", NumMethodPoolMisses);
5139 }
5140 std::fprintf(stderr, "\n");
5141 dump();
5142 std::fprintf(stderr, "\n");
5143 }
5144
5145 template<typename Key, typename ModuleFile, unsigned InitialCapacity>
5146 static void
dumpModuleIDMap(StringRef Name,const ContinuousRangeMap<Key,ModuleFile *,InitialCapacity> & Map)5147 dumpModuleIDMap(StringRef Name,
5148 const ContinuousRangeMap<Key, ModuleFile *,
5149 InitialCapacity> &Map) {
5150 if (Map.begin() == Map.end())
5151 return;
5152
5153 typedef ContinuousRangeMap<Key, ModuleFile *, InitialCapacity> MapType;
5154 llvm::errs() << Name << ":\n";
5155 for (typename MapType::const_iterator I = Map.begin(), IEnd = Map.end();
5156 I != IEnd; ++I) {
5157 llvm::errs() << " " << I->first << " -> " << I->second->FileName
5158 << "\n";
5159 }
5160 }
5161
dump()5162 void ASTReader::dump() {
5163 llvm::errs() << "*** PCH/ModuleFile Remappings:\n";
5164 dumpModuleIDMap("Global bit offset map", GlobalBitOffsetsMap);
5165 dumpModuleIDMap("Global source location entry map", GlobalSLocEntryMap);
5166 dumpModuleIDMap("Global type map", GlobalTypeMap);
5167 dumpModuleIDMap("Global declaration map", GlobalDeclMap);
5168 dumpModuleIDMap("Global identifier map", GlobalIdentifierMap);
5169 dumpModuleIDMap("Global submodule map", GlobalSubmoduleMap);
5170 dumpModuleIDMap("Global selector map", GlobalSelectorMap);
5171 dumpModuleIDMap("Global preprocessed entity map",
5172 GlobalPreprocessedEntityMap);
5173
5174 llvm::errs() << "\n*** PCH/Modules Loaded:";
5175 for (ModuleManager::ModuleConstIterator M = ModuleMgr.begin(),
5176 MEnd = ModuleMgr.end();
5177 M != MEnd; ++M)
5178 (*M)->dump();
5179 }
5180
5181 /// Return the amount of memory used by memory buffers, breaking down
5182 /// by heap-backed versus mmap'ed memory.
getMemoryBufferSizes(MemoryBufferSizes & sizes) const5183 void ASTReader::getMemoryBufferSizes(MemoryBufferSizes &sizes) const {
5184 for (ModuleConstIterator I = ModuleMgr.begin(),
5185 E = ModuleMgr.end(); I != E; ++I) {
5186 if (llvm::MemoryBuffer *buf = (*I)->Buffer.get()) {
5187 size_t bytes = buf->getBufferSize();
5188 switch (buf->getBufferKind()) {
5189 case llvm::MemoryBuffer::MemoryBuffer_Malloc:
5190 sizes.malloc_bytes += bytes;
5191 break;
5192 case llvm::MemoryBuffer::MemoryBuffer_MMap:
5193 sizes.mmap_bytes += bytes;
5194 break;
5195 }
5196 }
5197 }
5198 }
5199
InitializeSema(Sema & S)5200 void ASTReader::InitializeSema(Sema &S) {
5201 SemaObj = &S;
5202 S.ExternalSource = this;
5203
5204 // Makes sure any declarations that were deserialized "too early"
5205 // still get added to the identifier's declaration chains.
5206 for (unsigned I = 0, N = PreloadedDecls.size(); I != N; ++I) {
5207 SemaObj->pushExternalDeclIntoScope(PreloadedDecls[I],
5208 PreloadedDecls[I]->getDeclName());
5209 }
5210 PreloadedDecls.clear();
5211
5212 // Load the offsets of the declarations that Sema references.
5213 // They will be lazily deserialized when needed.
5214 if (!SemaDeclRefs.empty()) {
5215 assert(SemaDeclRefs.size() == 2 && "More decl refs than expected!");
5216 if (!SemaObj->StdNamespace)
5217 SemaObj->StdNamespace = SemaDeclRefs[0];
5218 if (!SemaObj->StdBadAlloc)
5219 SemaObj->StdBadAlloc = SemaDeclRefs[1];
5220 }
5221
5222 if (!FPPragmaOptions.empty()) {
5223 assert(FPPragmaOptions.size() == 1 && "Wrong number of FP_PRAGMA_OPTIONS");
5224 SemaObj->FPFeatures.fp_contract = FPPragmaOptions[0];
5225 }
5226
5227 if (!OpenCLExtensions.empty()) {
5228 unsigned I = 0;
5229 #define OPENCLEXT(nm) SemaObj->OpenCLFeatures.nm = OpenCLExtensions[I++];
5230 #include "clang/Basic/OpenCLExtensions.def"
5231
5232 assert(OpenCLExtensions.size() == I && "Wrong number of OPENCL_EXTENSIONS");
5233 }
5234 }
5235
get(const char * NameStart,const char * NameEnd)5236 IdentifierInfo* ASTReader::get(const char *NameStart, const char *NameEnd) {
5237 IdentifierLookupVisitor Visitor(StringRef(NameStart, NameEnd - NameStart),
5238 /*PriorGeneration=*/0);
5239 ModuleMgr.visit(IdentifierLookupVisitor::visit, &Visitor);
5240 IdentifierInfo *II = Visitor.getIdentifierInfo();
5241 markIdentifierUpToDate(II);
5242 return II;
5243 }
5244
5245 namespace clang {
5246 /// \brief An identifier-lookup iterator that enumerates all of the
5247 /// identifiers stored within a set of AST files.
5248 class ASTIdentifierIterator : public IdentifierIterator {
5249 /// \brief The AST reader whose identifiers are being enumerated.
5250 const ASTReader &Reader;
5251
5252 /// \brief The current index into the chain of AST files stored in
5253 /// the AST reader.
5254 unsigned Index;
5255
5256 /// \brief The current position within the identifier lookup table
5257 /// of the current AST file.
5258 ASTIdentifierLookupTable::key_iterator Current;
5259
5260 /// \brief The end position within the identifier lookup table of
5261 /// the current AST file.
5262 ASTIdentifierLookupTable::key_iterator End;
5263
5264 public:
5265 explicit ASTIdentifierIterator(const ASTReader &Reader);
5266
5267 virtual StringRef Next();
5268 };
5269 }
5270
ASTIdentifierIterator(const ASTReader & Reader)5271 ASTIdentifierIterator::ASTIdentifierIterator(const ASTReader &Reader)
5272 : Reader(Reader), Index(Reader.ModuleMgr.size() - 1) {
5273 ASTIdentifierLookupTable *IdTable
5274 = (ASTIdentifierLookupTable *)Reader.ModuleMgr[Index].IdentifierLookupTable;
5275 Current = IdTable->key_begin();
5276 End = IdTable->key_end();
5277 }
5278
Next()5279 StringRef ASTIdentifierIterator::Next() {
5280 while (Current == End) {
5281 // If we have exhausted all of our AST files, we're done.
5282 if (Index == 0)
5283 return StringRef();
5284
5285 --Index;
5286 ASTIdentifierLookupTable *IdTable
5287 = (ASTIdentifierLookupTable *)Reader.ModuleMgr[Index].
5288 IdentifierLookupTable;
5289 Current = IdTable->key_begin();
5290 End = IdTable->key_end();
5291 }
5292
5293 // We have any identifiers remaining in the current AST file; return
5294 // the next one.
5295 std::pair<const char*, unsigned> Key = *Current;
5296 ++Current;
5297 return StringRef(Key.first, Key.second);
5298 }
5299
getIdentifiers() const5300 IdentifierIterator *ASTReader::getIdentifiers() const {
5301 return new ASTIdentifierIterator(*this);
5302 }
5303
5304 namespace clang { namespace serialization {
5305 class ReadMethodPoolVisitor {
5306 ASTReader &Reader;
5307 Selector Sel;
5308 unsigned PriorGeneration;
5309 llvm::SmallVector<ObjCMethodDecl *, 4> InstanceMethods;
5310 llvm::SmallVector<ObjCMethodDecl *, 4> FactoryMethods;
5311
5312 public:
ReadMethodPoolVisitor(ASTReader & Reader,Selector Sel,unsigned PriorGeneration)5313 ReadMethodPoolVisitor(ASTReader &Reader, Selector Sel,
5314 unsigned PriorGeneration)
5315 : Reader(Reader), Sel(Sel), PriorGeneration(PriorGeneration) { }
5316
visit(ModuleFile & M,void * UserData)5317 static bool visit(ModuleFile &M, void *UserData) {
5318 ReadMethodPoolVisitor *This
5319 = static_cast<ReadMethodPoolVisitor *>(UserData);
5320
5321 if (!M.SelectorLookupTable)
5322 return false;
5323
5324 // If we've already searched this module file, skip it now.
5325 if (M.Generation <= This->PriorGeneration)
5326 return true;
5327
5328 ASTSelectorLookupTable *PoolTable
5329 = (ASTSelectorLookupTable*)M.SelectorLookupTable;
5330 ASTSelectorLookupTable::iterator Pos = PoolTable->find(This->Sel);
5331 if (Pos == PoolTable->end())
5332 return false;
5333
5334 ++This->Reader.NumSelectorsRead;
5335 // FIXME: Not quite happy with the statistics here. We probably should
5336 // disable this tracking when called via LoadSelector.
5337 // Also, should entries without methods count as misses?
5338 ++This->Reader.NumMethodPoolEntriesRead;
5339 ASTSelectorLookupTrait::data_type Data = *Pos;
5340 if (This->Reader.DeserializationListener)
5341 This->Reader.DeserializationListener->SelectorRead(Data.ID,
5342 This->Sel);
5343
5344 This->InstanceMethods.append(Data.Instance.begin(), Data.Instance.end());
5345 This->FactoryMethods.append(Data.Factory.begin(), Data.Factory.end());
5346 return true;
5347 }
5348
5349 /// \brief Retrieve the instance methods found by this visitor.
getInstanceMethods() const5350 ArrayRef<ObjCMethodDecl *> getInstanceMethods() const {
5351 return InstanceMethods;
5352 }
5353
5354 /// \brief Retrieve the instance methods found by this visitor.
getFactoryMethods() const5355 ArrayRef<ObjCMethodDecl *> getFactoryMethods() const {
5356 return FactoryMethods;
5357 }
5358 };
5359 } } // end namespace clang::serialization
5360
5361 /// \brief Add the given set of methods to the method list.
addMethodsToPool(Sema & S,ArrayRef<ObjCMethodDecl * > Methods,ObjCMethodList & List)5362 static void addMethodsToPool(Sema &S, ArrayRef<ObjCMethodDecl *> Methods,
5363 ObjCMethodList &List) {
5364 for (unsigned I = 0, N = Methods.size(); I != N; ++I) {
5365 S.addMethodToGlobalList(&List, Methods[I]);
5366 }
5367 }
5368
ReadMethodPool(Selector Sel)5369 void ASTReader::ReadMethodPool(Selector Sel) {
5370 // Get the selector generation and update it to the current generation.
5371 unsigned &Generation = SelectorGeneration[Sel];
5372 unsigned PriorGeneration = Generation;
5373 Generation = CurrentGeneration;
5374
5375 // Search for methods defined with this selector.
5376 ReadMethodPoolVisitor Visitor(*this, Sel, PriorGeneration);
5377 ModuleMgr.visit(&ReadMethodPoolVisitor::visit, &Visitor);
5378
5379 if (Visitor.getInstanceMethods().empty() &&
5380 Visitor.getFactoryMethods().empty()) {
5381 ++NumMethodPoolMisses;
5382 return;
5383 }
5384
5385 if (!getSema())
5386 return;
5387
5388 Sema &S = *getSema();
5389 Sema::GlobalMethodPool::iterator Pos
5390 = S.MethodPool.insert(std::make_pair(Sel, Sema::GlobalMethods())).first;
5391
5392 addMethodsToPool(S, Visitor.getInstanceMethods(), Pos->second.first);
5393 addMethodsToPool(S, Visitor.getFactoryMethods(), Pos->second.second);
5394 }
5395
ReadKnownNamespaces(SmallVectorImpl<NamespaceDecl * > & Namespaces)5396 void ASTReader::ReadKnownNamespaces(
5397 SmallVectorImpl<NamespaceDecl *> &Namespaces) {
5398 Namespaces.clear();
5399
5400 for (unsigned I = 0, N = KnownNamespaces.size(); I != N; ++I) {
5401 if (NamespaceDecl *Namespace
5402 = dyn_cast_or_null<NamespaceDecl>(GetDecl(KnownNamespaces[I])))
5403 Namespaces.push_back(Namespace);
5404 }
5405 }
5406
ReadTentativeDefinitions(SmallVectorImpl<VarDecl * > & TentativeDefs)5407 void ASTReader::ReadTentativeDefinitions(
5408 SmallVectorImpl<VarDecl *> &TentativeDefs) {
5409 for (unsigned I = 0, N = TentativeDefinitions.size(); I != N; ++I) {
5410 VarDecl *Var = dyn_cast_or_null<VarDecl>(GetDecl(TentativeDefinitions[I]));
5411 if (Var)
5412 TentativeDefs.push_back(Var);
5413 }
5414 TentativeDefinitions.clear();
5415 }
5416
ReadUnusedFileScopedDecls(SmallVectorImpl<const DeclaratorDecl * > & Decls)5417 void ASTReader::ReadUnusedFileScopedDecls(
5418 SmallVectorImpl<const DeclaratorDecl *> &Decls) {
5419 for (unsigned I = 0, N = UnusedFileScopedDecls.size(); I != N; ++I) {
5420 DeclaratorDecl *D
5421 = dyn_cast_or_null<DeclaratorDecl>(GetDecl(UnusedFileScopedDecls[I]));
5422 if (D)
5423 Decls.push_back(D);
5424 }
5425 UnusedFileScopedDecls.clear();
5426 }
5427
ReadDelegatingConstructors(SmallVectorImpl<CXXConstructorDecl * > & Decls)5428 void ASTReader::ReadDelegatingConstructors(
5429 SmallVectorImpl<CXXConstructorDecl *> &Decls) {
5430 for (unsigned I = 0, N = DelegatingCtorDecls.size(); I != N; ++I) {
5431 CXXConstructorDecl *D
5432 = dyn_cast_or_null<CXXConstructorDecl>(GetDecl(DelegatingCtorDecls[I]));
5433 if (D)
5434 Decls.push_back(D);
5435 }
5436 DelegatingCtorDecls.clear();
5437 }
5438
ReadExtVectorDecls(SmallVectorImpl<TypedefNameDecl * > & Decls)5439 void ASTReader::ReadExtVectorDecls(SmallVectorImpl<TypedefNameDecl *> &Decls) {
5440 for (unsigned I = 0, N = ExtVectorDecls.size(); I != N; ++I) {
5441 TypedefNameDecl *D
5442 = dyn_cast_or_null<TypedefNameDecl>(GetDecl(ExtVectorDecls[I]));
5443 if (D)
5444 Decls.push_back(D);
5445 }
5446 ExtVectorDecls.clear();
5447 }
5448
ReadDynamicClasses(SmallVectorImpl<CXXRecordDecl * > & Decls)5449 void ASTReader::ReadDynamicClasses(SmallVectorImpl<CXXRecordDecl *> &Decls) {
5450 for (unsigned I = 0, N = DynamicClasses.size(); I != N; ++I) {
5451 CXXRecordDecl *D
5452 = dyn_cast_or_null<CXXRecordDecl>(GetDecl(DynamicClasses[I]));
5453 if (D)
5454 Decls.push_back(D);
5455 }
5456 DynamicClasses.clear();
5457 }
5458
5459 void
ReadLocallyScopedExternalDecls(SmallVectorImpl<NamedDecl * > & Decls)5460 ASTReader::ReadLocallyScopedExternalDecls(SmallVectorImpl<NamedDecl *> &Decls) {
5461 for (unsigned I = 0, N = LocallyScopedExternalDecls.size(); I != N; ++I) {
5462 NamedDecl *D
5463 = dyn_cast_or_null<NamedDecl>(GetDecl(LocallyScopedExternalDecls[I]));
5464 if (D)
5465 Decls.push_back(D);
5466 }
5467 LocallyScopedExternalDecls.clear();
5468 }
5469
ReadReferencedSelectors(SmallVectorImpl<std::pair<Selector,SourceLocation>> & Sels)5470 void ASTReader::ReadReferencedSelectors(
5471 SmallVectorImpl<std::pair<Selector, SourceLocation> > &Sels) {
5472 if (ReferencedSelectorsData.empty())
5473 return;
5474
5475 // If there are @selector references added them to its pool. This is for
5476 // implementation of -Wselector.
5477 unsigned int DataSize = ReferencedSelectorsData.size()-1;
5478 unsigned I = 0;
5479 while (I < DataSize) {
5480 Selector Sel = DecodeSelector(ReferencedSelectorsData[I++]);
5481 SourceLocation SelLoc
5482 = SourceLocation::getFromRawEncoding(ReferencedSelectorsData[I++]);
5483 Sels.push_back(std::make_pair(Sel, SelLoc));
5484 }
5485 ReferencedSelectorsData.clear();
5486 }
5487
ReadWeakUndeclaredIdentifiers(SmallVectorImpl<std::pair<IdentifierInfo *,WeakInfo>> & WeakIDs)5488 void ASTReader::ReadWeakUndeclaredIdentifiers(
5489 SmallVectorImpl<std::pair<IdentifierInfo *, WeakInfo> > &WeakIDs) {
5490 if (WeakUndeclaredIdentifiers.empty())
5491 return;
5492
5493 for (unsigned I = 0, N = WeakUndeclaredIdentifiers.size(); I < N; /*none*/) {
5494 IdentifierInfo *WeakId
5495 = DecodeIdentifierInfo(WeakUndeclaredIdentifiers[I++]);
5496 IdentifierInfo *AliasId
5497 = DecodeIdentifierInfo(WeakUndeclaredIdentifiers[I++]);
5498 SourceLocation Loc
5499 = SourceLocation::getFromRawEncoding(WeakUndeclaredIdentifiers[I++]);
5500 bool Used = WeakUndeclaredIdentifiers[I++];
5501 WeakInfo WI(AliasId, Loc);
5502 WI.setUsed(Used);
5503 WeakIDs.push_back(std::make_pair(WeakId, WI));
5504 }
5505 WeakUndeclaredIdentifiers.clear();
5506 }
5507
ReadUsedVTables(SmallVectorImpl<ExternalVTableUse> & VTables)5508 void ASTReader::ReadUsedVTables(SmallVectorImpl<ExternalVTableUse> &VTables) {
5509 for (unsigned Idx = 0, N = VTableUses.size(); Idx < N; /* In loop */) {
5510 ExternalVTableUse VT;
5511 VT.Record = dyn_cast_or_null<CXXRecordDecl>(GetDecl(VTableUses[Idx++]));
5512 VT.Location = SourceLocation::getFromRawEncoding(VTableUses[Idx++]);
5513 VT.DefinitionRequired = VTableUses[Idx++];
5514 VTables.push_back(VT);
5515 }
5516
5517 VTableUses.clear();
5518 }
5519
ReadPendingInstantiations(SmallVectorImpl<std::pair<ValueDecl *,SourceLocation>> & Pending)5520 void ASTReader::ReadPendingInstantiations(
5521 SmallVectorImpl<std::pair<ValueDecl *, SourceLocation> > &Pending) {
5522 for (unsigned Idx = 0, N = PendingInstantiations.size(); Idx < N;) {
5523 ValueDecl *D = cast<ValueDecl>(GetDecl(PendingInstantiations[Idx++]));
5524 SourceLocation Loc
5525 = SourceLocation::getFromRawEncoding(PendingInstantiations[Idx++]);
5526 Pending.push_back(std::make_pair(D, Loc));
5527 }
5528 PendingInstantiations.clear();
5529 }
5530
LoadSelector(Selector Sel)5531 void ASTReader::LoadSelector(Selector Sel) {
5532 // It would be complicated to avoid reading the methods anyway. So don't.
5533 ReadMethodPool(Sel);
5534 }
5535
SetIdentifierInfo(IdentifierID ID,IdentifierInfo * II)5536 void ASTReader::SetIdentifierInfo(IdentifierID ID, IdentifierInfo *II) {
5537 assert(ID && "Non-zero identifier ID required");
5538 assert(ID <= IdentifiersLoaded.size() && "identifier ID out of range");
5539 IdentifiersLoaded[ID - 1] = II;
5540 if (DeserializationListener)
5541 DeserializationListener->IdentifierRead(ID, II);
5542 }
5543
5544 /// \brief Set the globally-visible declarations associated with the given
5545 /// identifier.
5546 ///
5547 /// If the AST reader is currently in a state where the given declaration IDs
5548 /// cannot safely be resolved, they are queued until it is safe to resolve
5549 /// them.
5550 ///
5551 /// \param II an IdentifierInfo that refers to one or more globally-visible
5552 /// declarations.
5553 ///
5554 /// \param DeclIDs the set of declaration IDs with the name @p II that are
5555 /// visible at global scope.
5556 ///
5557 /// \param Nonrecursive should be true to indicate that the caller knows that
5558 /// this call is non-recursive, and therefore the globally-visible declarations
5559 /// will not be placed onto the pending queue.
5560 void
SetGloballyVisibleDecls(IdentifierInfo * II,const SmallVectorImpl<uint32_t> & DeclIDs,bool Nonrecursive)5561 ASTReader::SetGloballyVisibleDecls(IdentifierInfo *II,
5562 const SmallVectorImpl<uint32_t> &DeclIDs,
5563 bool Nonrecursive) {
5564 if (NumCurrentElementsDeserializing && !Nonrecursive) {
5565 PendingIdentifierInfos.push_back(PendingIdentifierInfo());
5566 PendingIdentifierInfo &PII = PendingIdentifierInfos.back();
5567 PII.II = II;
5568 PII.DeclIDs.append(DeclIDs.begin(), DeclIDs.end());
5569 return;
5570 }
5571
5572 for (unsigned I = 0, N = DeclIDs.size(); I != N; ++I) {
5573 NamedDecl *D = cast<NamedDecl>(GetDecl(DeclIDs[I]));
5574 if (SemaObj) {
5575 // Introduce this declaration into the translation-unit scope
5576 // and add it to the declaration chain for this identifier, so
5577 // that (unqualified) name lookup will find it.
5578 SemaObj->pushExternalDeclIntoScope(D, II);
5579 } else {
5580 // Queue this declaration so that it will be added to the
5581 // translation unit scope and identifier's declaration chain
5582 // once a Sema object is known.
5583 PreloadedDecls.push_back(D);
5584 }
5585 }
5586 }
5587
DecodeIdentifierInfo(IdentifierID ID)5588 IdentifierInfo *ASTReader::DecodeIdentifierInfo(IdentifierID ID) {
5589 if (ID == 0)
5590 return 0;
5591
5592 if (IdentifiersLoaded.empty()) {
5593 Error("no identifier table in AST file");
5594 return 0;
5595 }
5596
5597 ID -= 1;
5598 if (!IdentifiersLoaded[ID]) {
5599 GlobalIdentifierMapType::iterator I = GlobalIdentifierMap.find(ID + 1);
5600 assert(I != GlobalIdentifierMap.end() && "Corrupted global identifier map");
5601 ModuleFile *M = I->second;
5602 unsigned Index = ID - M->BaseIdentifierID;
5603 const char *Str = M->IdentifierTableData + M->IdentifierOffsets[Index];
5604
5605 // All of the strings in the AST file are preceded by a 16-bit length.
5606 // Extract that 16-bit length to avoid having to execute strlen().
5607 // NOTE: 'StrLenPtr' is an 'unsigned char*' so that we load bytes as
5608 // unsigned integers. This is important to avoid integer overflow when
5609 // we cast them to 'unsigned'.
5610 const unsigned char *StrLenPtr = (const unsigned char*) Str - 2;
5611 unsigned StrLen = (((unsigned) StrLenPtr[0])
5612 | (((unsigned) StrLenPtr[1]) << 8)) - 1;
5613 IdentifiersLoaded[ID]
5614 = &PP.getIdentifierTable().get(StringRef(Str, StrLen));
5615 if (DeserializationListener)
5616 DeserializationListener->IdentifierRead(ID + 1, IdentifiersLoaded[ID]);
5617 }
5618
5619 return IdentifiersLoaded[ID];
5620 }
5621
getLocalIdentifier(ModuleFile & M,unsigned LocalID)5622 IdentifierInfo *ASTReader::getLocalIdentifier(ModuleFile &M, unsigned LocalID) {
5623 return DecodeIdentifierInfo(getGlobalIdentifierID(M, LocalID));
5624 }
5625
getGlobalIdentifierID(ModuleFile & M,unsigned LocalID)5626 IdentifierID ASTReader::getGlobalIdentifierID(ModuleFile &M, unsigned LocalID) {
5627 if (LocalID < NUM_PREDEF_IDENT_IDS)
5628 return LocalID;
5629
5630 ContinuousRangeMap<uint32_t, int, 2>::iterator I
5631 = M.IdentifierRemap.find(LocalID - NUM_PREDEF_IDENT_IDS);
5632 assert(I != M.IdentifierRemap.end()
5633 && "Invalid index into identifier index remap");
5634
5635 return LocalID + I->second;
5636 }
5637
ReadSLocEntry(int ID)5638 bool ASTReader::ReadSLocEntry(int ID) {
5639 return ReadSLocEntryRecord(ID) != Success;
5640 }
5641
5642 serialization::SubmoduleID
getGlobalSubmoduleID(ModuleFile & M,unsigned LocalID)5643 ASTReader::getGlobalSubmoduleID(ModuleFile &M, unsigned LocalID) {
5644 if (LocalID < NUM_PREDEF_SUBMODULE_IDS)
5645 return LocalID;
5646
5647 ContinuousRangeMap<uint32_t, int, 2>::iterator I
5648 = M.SubmoduleRemap.find(LocalID - NUM_PREDEF_SUBMODULE_IDS);
5649 assert(I != M.SubmoduleRemap.end()
5650 && "Invalid index into identifier index remap");
5651
5652 return LocalID + I->second;
5653 }
5654
getSubmodule(SubmoduleID GlobalID)5655 Module *ASTReader::getSubmodule(SubmoduleID GlobalID) {
5656 if (GlobalID < NUM_PREDEF_SUBMODULE_IDS) {
5657 assert(GlobalID == 0 && "Unhandled global submodule ID");
5658 return 0;
5659 }
5660
5661 if (GlobalID > SubmodulesLoaded.size()) {
5662 Error("submodule ID out of range in AST file");
5663 return 0;
5664 }
5665
5666 return SubmodulesLoaded[GlobalID - NUM_PREDEF_SUBMODULE_IDS];
5667 }
5668
getLocalSelector(ModuleFile & M,unsigned LocalID)5669 Selector ASTReader::getLocalSelector(ModuleFile &M, unsigned LocalID) {
5670 return DecodeSelector(getGlobalSelectorID(M, LocalID));
5671 }
5672
DecodeSelector(serialization::SelectorID ID)5673 Selector ASTReader::DecodeSelector(serialization::SelectorID ID) {
5674 if (ID == 0)
5675 return Selector();
5676
5677 if (ID > SelectorsLoaded.size()) {
5678 Error("selector ID out of range in AST file");
5679 return Selector();
5680 }
5681
5682 if (SelectorsLoaded[ID - 1].getAsOpaquePtr() == 0) {
5683 // Load this selector from the selector table.
5684 GlobalSelectorMapType::iterator I = GlobalSelectorMap.find(ID);
5685 assert(I != GlobalSelectorMap.end() && "Corrupted global selector map");
5686 ModuleFile &M = *I->second;
5687 ASTSelectorLookupTrait Trait(*this, M);
5688 unsigned Idx = ID - M.BaseSelectorID - NUM_PREDEF_SELECTOR_IDS;
5689 SelectorsLoaded[ID - 1] =
5690 Trait.ReadKey(M.SelectorLookupTableData + M.SelectorOffsets[Idx], 0);
5691 if (DeserializationListener)
5692 DeserializationListener->SelectorRead(ID, SelectorsLoaded[ID - 1]);
5693 }
5694
5695 return SelectorsLoaded[ID - 1];
5696 }
5697
GetExternalSelector(serialization::SelectorID ID)5698 Selector ASTReader::GetExternalSelector(serialization::SelectorID ID) {
5699 return DecodeSelector(ID);
5700 }
5701
GetNumExternalSelectors()5702 uint32_t ASTReader::GetNumExternalSelectors() {
5703 // ID 0 (the null selector) is considered an external selector.
5704 return getTotalNumSelectors() + 1;
5705 }
5706
5707 serialization::SelectorID
getGlobalSelectorID(ModuleFile & M,unsigned LocalID) const5708 ASTReader::getGlobalSelectorID(ModuleFile &M, unsigned LocalID) const {
5709 if (LocalID < NUM_PREDEF_SELECTOR_IDS)
5710 return LocalID;
5711
5712 ContinuousRangeMap<uint32_t, int, 2>::iterator I
5713 = M.SelectorRemap.find(LocalID - NUM_PREDEF_SELECTOR_IDS);
5714 assert(I != M.SelectorRemap.end()
5715 && "Invalid index into identifier index remap");
5716
5717 return LocalID + I->second;
5718 }
5719
5720 DeclarationName
ReadDeclarationName(ModuleFile & F,const RecordData & Record,unsigned & Idx)5721 ASTReader::ReadDeclarationName(ModuleFile &F,
5722 const RecordData &Record, unsigned &Idx) {
5723 DeclarationName::NameKind Kind = (DeclarationName::NameKind)Record[Idx++];
5724 switch (Kind) {
5725 case DeclarationName::Identifier:
5726 return DeclarationName(GetIdentifierInfo(F, Record, Idx));
5727
5728 case DeclarationName::ObjCZeroArgSelector:
5729 case DeclarationName::ObjCOneArgSelector:
5730 case DeclarationName::ObjCMultiArgSelector:
5731 return DeclarationName(ReadSelector(F, Record, Idx));
5732
5733 case DeclarationName::CXXConstructorName:
5734 return Context.DeclarationNames.getCXXConstructorName(
5735 Context.getCanonicalType(readType(F, Record, Idx)));
5736
5737 case DeclarationName::CXXDestructorName:
5738 return Context.DeclarationNames.getCXXDestructorName(
5739 Context.getCanonicalType(readType(F, Record, Idx)));
5740
5741 case DeclarationName::CXXConversionFunctionName:
5742 return Context.DeclarationNames.getCXXConversionFunctionName(
5743 Context.getCanonicalType(readType(F, Record, Idx)));
5744
5745 case DeclarationName::CXXOperatorName:
5746 return Context.DeclarationNames.getCXXOperatorName(
5747 (OverloadedOperatorKind)Record[Idx++]);
5748
5749 case DeclarationName::CXXLiteralOperatorName:
5750 return Context.DeclarationNames.getCXXLiteralOperatorName(
5751 GetIdentifierInfo(F, Record, Idx));
5752
5753 case DeclarationName::CXXUsingDirective:
5754 return DeclarationName::getUsingDirectiveName();
5755 }
5756
5757 llvm_unreachable("Invalid NameKind!");
5758 }
5759
ReadDeclarationNameLoc(ModuleFile & F,DeclarationNameLoc & DNLoc,DeclarationName Name,const RecordData & Record,unsigned & Idx)5760 void ASTReader::ReadDeclarationNameLoc(ModuleFile &F,
5761 DeclarationNameLoc &DNLoc,
5762 DeclarationName Name,
5763 const RecordData &Record, unsigned &Idx) {
5764 switch (Name.getNameKind()) {
5765 case DeclarationName::CXXConstructorName:
5766 case DeclarationName::CXXDestructorName:
5767 case DeclarationName::CXXConversionFunctionName:
5768 DNLoc.NamedType.TInfo = GetTypeSourceInfo(F, Record, Idx);
5769 break;
5770
5771 case DeclarationName::CXXOperatorName:
5772 DNLoc.CXXOperatorName.BeginOpNameLoc
5773 = ReadSourceLocation(F, Record, Idx).getRawEncoding();
5774 DNLoc.CXXOperatorName.EndOpNameLoc
5775 = ReadSourceLocation(F, Record, Idx).getRawEncoding();
5776 break;
5777
5778 case DeclarationName::CXXLiteralOperatorName:
5779 DNLoc.CXXLiteralOperatorName.OpNameLoc
5780 = ReadSourceLocation(F, Record, Idx).getRawEncoding();
5781 break;
5782
5783 case DeclarationName::Identifier:
5784 case DeclarationName::ObjCZeroArgSelector:
5785 case DeclarationName::ObjCOneArgSelector:
5786 case DeclarationName::ObjCMultiArgSelector:
5787 case DeclarationName::CXXUsingDirective:
5788 break;
5789 }
5790 }
5791
ReadDeclarationNameInfo(ModuleFile & F,DeclarationNameInfo & NameInfo,const RecordData & Record,unsigned & Idx)5792 void ASTReader::ReadDeclarationNameInfo(ModuleFile &F,
5793 DeclarationNameInfo &NameInfo,
5794 const RecordData &Record, unsigned &Idx) {
5795 NameInfo.setName(ReadDeclarationName(F, Record, Idx));
5796 NameInfo.setLoc(ReadSourceLocation(F, Record, Idx));
5797 DeclarationNameLoc DNLoc;
5798 ReadDeclarationNameLoc(F, DNLoc, NameInfo.getName(), Record, Idx);
5799 NameInfo.setInfo(DNLoc);
5800 }
5801
ReadQualifierInfo(ModuleFile & F,QualifierInfo & Info,const RecordData & Record,unsigned & Idx)5802 void ASTReader::ReadQualifierInfo(ModuleFile &F, QualifierInfo &Info,
5803 const RecordData &Record, unsigned &Idx) {
5804 Info.QualifierLoc = ReadNestedNameSpecifierLoc(F, Record, Idx);
5805 unsigned NumTPLists = Record[Idx++];
5806 Info.NumTemplParamLists = NumTPLists;
5807 if (NumTPLists) {
5808 Info.TemplParamLists = new (Context) TemplateParameterList*[NumTPLists];
5809 for (unsigned i=0; i != NumTPLists; ++i)
5810 Info.TemplParamLists[i] = ReadTemplateParameterList(F, Record, Idx);
5811 }
5812 }
5813
5814 TemplateName
ReadTemplateName(ModuleFile & F,const RecordData & Record,unsigned & Idx)5815 ASTReader::ReadTemplateName(ModuleFile &F, const RecordData &Record,
5816 unsigned &Idx) {
5817 TemplateName::NameKind Kind = (TemplateName::NameKind)Record[Idx++];
5818 switch (Kind) {
5819 case TemplateName::Template:
5820 return TemplateName(ReadDeclAs<TemplateDecl>(F, Record, Idx));
5821
5822 case TemplateName::OverloadedTemplate: {
5823 unsigned size = Record[Idx++];
5824 UnresolvedSet<8> Decls;
5825 while (size--)
5826 Decls.addDecl(ReadDeclAs<NamedDecl>(F, Record, Idx));
5827
5828 return Context.getOverloadedTemplateName(Decls.begin(), Decls.end());
5829 }
5830
5831 case TemplateName::QualifiedTemplate: {
5832 NestedNameSpecifier *NNS = ReadNestedNameSpecifier(F, Record, Idx);
5833 bool hasTemplKeyword = Record[Idx++];
5834 TemplateDecl *Template = ReadDeclAs<TemplateDecl>(F, Record, Idx);
5835 return Context.getQualifiedTemplateName(NNS, hasTemplKeyword, Template);
5836 }
5837
5838 case TemplateName::DependentTemplate: {
5839 NestedNameSpecifier *NNS = ReadNestedNameSpecifier(F, Record, Idx);
5840 if (Record[Idx++]) // isIdentifier
5841 return Context.getDependentTemplateName(NNS,
5842 GetIdentifierInfo(F, Record,
5843 Idx));
5844 return Context.getDependentTemplateName(NNS,
5845 (OverloadedOperatorKind)Record[Idx++]);
5846 }
5847
5848 case TemplateName::SubstTemplateTemplateParm: {
5849 TemplateTemplateParmDecl *param
5850 = ReadDeclAs<TemplateTemplateParmDecl>(F, Record, Idx);
5851 if (!param) return TemplateName();
5852 TemplateName replacement = ReadTemplateName(F, Record, Idx);
5853 return Context.getSubstTemplateTemplateParm(param, replacement);
5854 }
5855
5856 case TemplateName::SubstTemplateTemplateParmPack: {
5857 TemplateTemplateParmDecl *Param
5858 = ReadDeclAs<TemplateTemplateParmDecl>(F, Record, Idx);
5859 if (!Param)
5860 return TemplateName();
5861
5862 TemplateArgument ArgPack = ReadTemplateArgument(F, Record, Idx);
5863 if (ArgPack.getKind() != TemplateArgument::Pack)
5864 return TemplateName();
5865
5866 return Context.getSubstTemplateTemplateParmPack(Param, ArgPack);
5867 }
5868 }
5869
5870 llvm_unreachable("Unhandled template name kind!");
5871 }
5872
5873 TemplateArgument
ReadTemplateArgument(ModuleFile & F,const RecordData & Record,unsigned & Idx)5874 ASTReader::ReadTemplateArgument(ModuleFile &F,
5875 const RecordData &Record, unsigned &Idx) {
5876 TemplateArgument::ArgKind Kind = (TemplateArgument::ArgKind)Record[Idx++];
5877 switch (Kind) {
5878 case TemplateArgument::Null:
5879 return TemplateArgument();
5880 case TemplateArgument::Type:
5881 return TemplateArgument(readType(F, Record, Idx));
5882 case TemplateArgument::Declaration:
5883 return TemplateArgument(ReadDecl(F, Record, Idx));
5884 case TemplateArgument::Integral: {
5885 llvm::APSInt Value = ReadAPSInt(Record, Idx);
5886 QualType T = readType(F, Record, Idx);
5887 return TemplateArgument(Value, T);
5888 }
5889 case TemplateArgument::Template:
5890 return TemplateArgument(ReadTemplateName(F, Record, Idx));
5891 case TemplateArgument::TemplateExpansion: {
5892 TemplateName Name = ReadTemplateName(F, Record, Idx);
5893 llvm::Optional<unsigned> NumTemplateExpansions;
5894 if (unsigned NumExpansions = Record[Idx++])
5895 NumTemplateExpansions = NumExpansions - 1;
5896 return TemplateArgument(Name, NumTemplateExpansions);
5897 }
5898 case TemplateArgument::Expression:
5899 return TemplateArgument(ReadExpr(F));
5900 case TemplateArgument::Pack: {
5901 unsigned NumArgs = Record[Idx++];
5902 TemplateArgument *Args = new (Context) TemplateArgument[NumArgs];
5903 for (unsigned I = 0; I != NumArgs; ++I)
5904 Args[I] = ReadTemplateArgument(F, Record, Idx);
5905 return TemplateArgument(Args, NumArgs);
5906 }
5907 }
5908
5909 llvm_unreachable("Unhandled template argument kind!");
5910 }
5911
5912 TemplateParameterList *
ReadTemplateParameterList(ModuleFile & F,const RecordData & Record,unsigned & Idx)5913 ASTReader::ReadTemplateParameterList(ModuleFile &F,
5914 const RecordData &Record, unsigned &Idx) {
5915 SourceLocation TemplateLoc = ReadSourceLocation(F, Record, Idx);
5916 SourceLocation LAngleLoc = ReadSourceLocation(F, Record, Idx);
5917 SourceLocation RAngleLoc = ReadSourceLocation(F, Record, Idx);
5918
5919 unsigned NumParams = Record[Idx++];
5920 SmallVector<NamedDecl *, 16> Params;
5921 Params.reserve(NumParams);
5922 while (NumParams--)
5923 Params.push_back(ReadDeclAs<NamedDecl>(F, Record, Idx));
5924
5925 TemplateParameterList* TemplateParams =
5926 TemplateParameterList::Create(Context, TemplateLoc, LAngleLoc,
5927 Params.data(), Params.size(), RAngleLoc);
5928 return TemplateParams;
5929 }
5930
5931 void
5932 ASTReader::
ReadTemplateArgumentList(SmallVector<TemplateArgument,8> & TemplArgs,ModuleFile & F,const RecordData & Record,unsigned & Idx)5933 ReadTemplateArgumentList(SmallVector<TemplateArgument, 8> &TemplArgs,
5934 ModuleFile &F, const RecordData &Record,
5935 unsigned &Idx) {
5936 unsigned NumTemplateArgs = Record[Idx++];
5937 TemplArgs.reserve(NumTemplateArgs);
5938 while (NumTemplateArgs--)
5939 TemplArgs.push_back(ReadTemplateArgument(F, Record, Idx));
5940 }
5941
5942 /// \brief Read a UnresolvedSet structure.
ReadUnresolvedSet(ModuleFile & F,UnresolvedSetImpl & Set,const RecordData & Record,unsigned & Idx)5943 void ASTReader::ReadUnresolvedSet(ModuleFile &F, UnresolvedSetImpl &Set,
5944 const RecordData &Record, unsigned &Idx) {
5945 unsigned NumDecls = Record[Idx++];
5946 while (NumDecls--) {
5947 NamedDecl *D = ReadDeclAs<NamedDecl>(F, Record, Idx);
5948 AccessSpecifier AS = (AccessSpecifier)Record[Idx++];
5949 Set.addDecl(D, AS);
5950 }
5951 }
5952
5953 CXXBaseSpecifier
ReadCXXBaseSpecifier(ModuleFile & F,const RecordData & Record,unsigned & Idx)5954 ASTReader::ReadCXXBaseSpecifier(ModuleFile &F,
5955 const RecordData &Record, unsigned &Idx) {
5956 bool isVirtual = static_cast<bool>(Record[Idx++]);
5957 bool isBaseOfClass = static_cast<bool>(Record[Idx++]);
5958 AccessSpecifier AS = static_cast<AccessSpecifier>(Record[Idx++]);
5959 bool inheritConstructors = static_cast<bool>(Record[Idx++]);
5960 TypeSourceInfo *TInfo = GetTypeSourceInfo(F, Record, Idx);
5961 SourceRange Range = ReadSourceRange(F, Record, Idx);
5962 SourceLocation EllipsisLoc = ReadSourceLocation(F, Record, Idx);
5963 CXXBaseSpecifier Result(Range, isVirtual, isBaseOfClass, AS, TInfo,
5964 EllipsisLoc);
5965 Result.setInheritConstructors(inheritConstructors);
5966 return Result;
5967 }
5968
5969 std::pair<CXXCtorInitializer **, unsigned>
ReadCXXCtorInitializers(ModuleFile & F,const RecordData & Record,unsigned & Idx)5970 ASTReader::ReadCXXCtorInitializers(ModuleFile &F, const RecordData &Record,
5971 unsigned &Idx) {
5972 CXXCtorInitializer **CtorInitializers = 0;
5973 unsigned NumInitializers = Record[Idx++];
5974 if (NumInitializers) {
5975 CtorInitializers
5976 = new (Context) CXXCtorInitializer*[NumInitializers];
5977 for (unsigned i=0; i != NumInitializers; ++i) {
5978 TypeSourceInfo *TInfo = 0;
5979 bool IsBaseVirtual = false;
5980 FieldDecl *Member = 0;
5981 IndirectFieldDecl *IndirectMember = 0;
5982
5983 CtorInitializerType Type = (CtorInitializerType)Record[Idx++];
5984 switch (Type) {
5985 case CTOR_INITIALIZER_BASE:
5986 TInfo = GetTypeSourceInfo(F, Record, Idx);
5987 IsBaseVirtual = Record[Idx++];
5988 break;
5989
5990 case CTOR_INITIALIZER_DELEGATING:
5991 TInfo = GetTypeSourceInfo(F, Record, Idx);
5992 break;
5993
5994 case CTOR_INITIALIZER_MEMBER:
5995 Member = ReadDeclAs<FieldDecl>(F, Record, Idx);
5996 break;
5997
5998 case CTOR_INITIALIZER_INDIRECT_MEMBER:
5999 IndirectMember = ReadDeclAs<IndirectFieldDecl>(F, Record, Idx);
6000 break;
6001 }
6002
6003 SourceLocation MemberOrEllipsisLoc = ReadSourceLocation(F, Record, Idx);
6004 Expr *Init = ReadExpr(F);
6005 SourceLocation LParenLoc = ReadSourceLocation(F, Record, Idx);
6006 SourceLocation RParenLoc = ReadSourceLocation(F, Record, Idx);
6007 bool IsWritten = Record[Idx++];
6008 unsigned SourceOrderOrNumArrayIndices;
6009 SmallVector<VarDecl *, 8> Indices;
6010 if (IsWritten) {
6011 SourceOrderOrNumArrayIndices = Record[Idx++];
6012 } else {
6013 SourceOrderOrNumArrayIndices = Record[Idx++];
6014 Indices.reserve(SourceOrderOrNumArrayIndices);
6015 for (unsigned i=0; i != SourceOrderOrNumArrayIndices; ++i)
6016 Indices.push_back(ReadDeclAs<VarDecl>(F, Record, Idx));
6017 }
6018
6019 CXXCtorInitializer *BOMInit;
6020 if (Type == CTOR_INITIALIZER_BASE) {
6021 BOMInit = new (Context) CXXCtorInitializer(Context, TInfo, IsBaseVirtual,
6022 LParenLoc, Init, RParenLoc,
6023 MemberOrEllipsisLoc);
6024 } else if (Type == CTOR_INITIALIZER_DELEGATING) {
6025 BOMInit = new (Context) CXXCtorInitializer(Context, TInfo, LParenLoc,
6026 Init, RParenLoc);
6027 } else if (IsWritten) {
6028 if (Member)
6029 BOMInit = new (Context) CXXCtorInitializer(Context, Member, MemberOrEllipsisLoc,
6030 LParenLoc, Init, RParenLoc);
6031 else
6032 BOMInit = new (Context) CXXCtorInitializer(Context, IndirectMember,
6033 MemberOrEllipsisLoc, LParenLoc,
6034 Init, RParenLoc);
6035 } else {
6036 BOMInit = CXXCtorInitializer::Create(Context, Member, MemberOrEllipsisLoc,
6037 LParenLoc, Init, RParenLoc,
6038 Indices.data(), Indices.size());
6039 }
6040
6041 if (IsWritten)
6042 BOMInit->setSourceOrder(SourceOrderOrNumArrayIndices);
6043 CtorInitializers[i] = BOMInit;
6044 }
6045 }
6046
6047 return std::make_pair(CtorInitializers, NumInitializers);
6048 }
6049
6050 NestedNameSpecifier *
ReadNestedNameSpecifier(ModuleFile & F,const RecordData & Record,unsigned & Idx)6051 ASTReader::ReadNestedNameSpecifier(ModuleFile &F,
6052 const RecordData &Record, unsigned &Idx) {
6053 unsigned N = Record[Idx++];
6054 NestedNameSpecifier *NNS = 0, *Prev = 0;
6055 for (unsigned I = 0; I != N; ++I) {
6056 NestedNameSpecifier::SpecifierKind Kind
6057 = (NestedNameSpecifier::SpecifierKind)Record[Idx++];
6058 switch (Kind) {
6059 case NestedNameSpecifier::Identifier: {
6060 IdentifierInfo *II = GetIdentifierInfo(F, Record, Idx);
6061 NNS = NestedNameSpecifier::Create(Context, Prev, II);
6062 break;
6063 }
6064
6065 case NestedNameSpecifier::Namespace: {
6066 NamespaceDecl *NS = ReadDeclAs<NamespaceDecl>(F, Record, Idx);
6067 NNS = NestedNameSpecifier::Create(Context, Prev, NS);
6068 break;
6069 }
6070
6071 case NestedNameSpecifier::NamespaceAlias: {
6072 NamespaceAliasDecl *Alias =ReadDeclAs<NamespaceAliasDecl>(F, Record, Idx);
6073 NNS = NestedNameSpecifier::Create(Context, Prev, Alias);
6074 break;
6075 }
6076
6077 case NestedNameSpecifier::TypeSpec:
6078 case NestedNameSpecifier::TypeSpecWithTemplate: {
6079 const Type *T = readType(F, Record, Idx).getTypePtrOrNull();
6080 if (!T)
6081 return 0;
6082
6083 bool Template = Record[Idx++];
6084 NNS = NestedNameSpecifier::Create(Context, Prev, Template, T);
6085 break;
6086 }
6087
6088 case NestedNameSpecifier::Global: {
6089 NNS = NestedNameSpecifier::GlobalSpecifier(Context);
6090 // No associated value, and there can't be a prefix.
6091 break;
6092 }
6093 }
6094 Prev = NNS;
6095 }
6096 return NNS;
6097 }
6098
6099 NestedNameSpecifierLoc
ReadNestedNameSpecifierLoc(ModuleFile & F,const RecordData & Record,unsigned & Idx)6100 ASTReader::ReadNestedNameSpecifierLoc(ModuleFile &F, const RecordData &Record,
6101 unsigned &Idx) {
6102 unsigned N = Record[Idx++];
6103 NestedNameSpecifierLocBuilder Builder;
6104 for (unsigned I = 0; I != N; ++I) {
6105 NestedNameSpecifier::SpecifierKind Kind
6106 = (NestedNameSpecifier::SpecifierKind)Record[Idx++];
6107 switch (Kind) {
6108 case NestedNameSpecifier::Identifier: {
6109 IdentifierInfo *II = GetIdentifierInfo(F, Record, Idx);
6110 SourceRange Range = ReadSourceRange(F, Record, Idx);
6111 Builder.Extend(Context, II, Range.getBegin(), Range.getEnd());
6112 break;
6113 }
6114
6115 case NestedNameSpecifier::Namespace: {
6116 NamespaceDecl *NS = ReadDeclAs<NamespaceDecl>(F, Record, Idx);
6117 SourceRange Range = ReadSourceRange(F, Record, Idx);
6118 Builder.Extend(Context, NS, Range.getBegin(), Range.getEnd());
6119 break;
6120 }
6121
6122 case NestedNameSpecifier::NamespaceAlias: {
6123 NamespaceAliasDecl *Alias =ReadDeclAs<NamespaceAliasDecl>(F, Record, Idx);
6124 SourceRange Range = ReadSourceRange(F, Record, Idx);
6125 Builder.Extend(Context, Alias, Range.getBegin(), Range.getEnd());
6126 break;
6127 }
6128
6129 case NestedNameSpecifier::TypeSpec:
6130 case NestedNameSpecifier::TypeSpecWithTemplate: {
6131 bool Template = Record[Idx++];
6132 TypeSourceInfo *T = GetTypeSourceInfo(F, Record, Idx);
6133 if (!T)
6134 return NestedNameSpecifierLoc();
6135 SourceLocation ColonColonLoc = ReadSourceLocation(F, Record, Idx);
6136
6137 // FIXME: 'template' keyword location not saved anywhere, so we fake it.
6138 Builder.Extend(Context,
6139 Template? T->getTypeLoc().getBeginLoc() : SourceLocation(),
6140 T->getTypeLoc(), ColonColonLoc);
6141 break;
6142 }
6143
6144 case NestedNameSpecifier::Global: {
6145 SourceLocation ColonColonLoc = ReadSourceLocation(F, Record, Idx);
6146 Builder.MakeGlobal(Context, ColonColonLoc);
6147 break;
6148 }
6149 }
6150 }
6151
6152 return Builder.getWithLocInContext(Context);
6153 }
6154
6155 SourceRange
ReadSourceRange(ModuleFile & F,const RecordData & Record,unsigned & Idx)6156 ASTReader::ReadSourceRange(ModuleFile &F, const RecordData &Record,
6157 unsigned &Idx) {
6158 SourceLocation beg = ReadSourceLocation(F, Record, Idx);
6159 SourceLocation end = ReadSourceLocation(F, Record, Idx);
6160 return SourceRange(beg, end);
6161 }
6162
6163 /// \brief Read an integral value
ReadAPInt(const RecordData & Record,unsigned & Idx)6164 llvm::APInt ASTReader::ReadAPInt(const RecordData &Record, unsigned &Idx) {
6165 unsigned BitWidth = Record[Idx++];
6166 unsigned NumWords = llvm::APInt::getNumWords(BitWidth);
6167 llvm::APInt Result(BitWidth, NumWords, &Record[Idx]);
6168 Idx += NumWords;
6169 return Result;
6170 }
6171
6172 /// \brief Read a signed integral value
ReadAPSInt(const RecordData & Record,unsigned & Idx)6173 llvm::APSInt ASTReader::ReadAPSInt(const RecordData &Record, unsigned &Idx) {
6174 bool isUnsigned = Record[Idx++];
6175 return llvm::APSInt(ReadAPInt(Record, Idx), isUnsigned);
6176 }
6177
6178 /// \brief Read a floating-point value
ReadAPFloat(const RecordData & Record,unsigned & Idx)6179 llvm::APFloat ASTReader::ReadAPFloat(const RecordData &Record, unsigned &Idx) {
6180 return llvm::APFloat(ReadAPInt(Record, Idx));
6181 }
6182
6183 // \brief Read a string
ReadString(const RecordData & Record,unsigned & Idx)6184 std::string ASTReader::ReadString(const RecordData &Record, unsigned &Idx) {
6185 unsigned Len = Record[Idx++];
6186 std::string Result(Record.data() + Idx, Record.data() + Idx + Len);
6187 Idx += Len;
6188 return Result;
6189 }
6190
ReadVersionTuple(const RecordData & Record,unsigned & Idx)6191 VersionTuple ASTReader::ReadVersionTuple(const RecordData &Record,
6192 unsigned &Idx) {
6193 unsigned Major = Record[Idx++];
6194 unsigned Minor = Record[Idx++];
6195 unsigned Subminor = Record[Idx++];
6196 if (Minor == 0)
6197 return VersionTuple(Major);
6198 if (Subminor == 0)
6199 return VersionTuple(Major, Minor - 1);
6200 return VersionTuple(Major, Minor - 1, Subminor - 1);
6201 }
6202
ReadCXXTemporary(ModuleFile & F,const RecordData & Record,unsigned & Idx)6203 CXXTemporary *ASTReader::ReadCXXTemporary(ModuleFile &F,
6204 const RecordData &Record,
6205 unsigned &Idx) {
6206 CXXDestructorDecl *Decl = ReadDeclAs<CXXDestructorDecl>(F, Record, Idx);
6207 return CXXTemporary::Create(Context, Decl);
6208 }
6209
Diag(unsigned DiagID)6210 DiagnosticBuilder ASTReader::Diag(unsigned DiagID) {
6211 return Diag(SourceLocation(), DiagID);
6212 }
6213
Diag(SourceLocation Loc,unsigned DiagID)6214 DiagnosticBuilder ASTReader::Diag(SourceLocation Loc, unsigned DiagID) {
6215 return Diags.Report(Loc, DiagID);
6216 }
6217
6218 /// \brief Retrieve the identifier table associated with the
6219 /// preprocessor.
getIdentifierTable()6220 IdentifierTable &ASTReader::getIdentifierTable() {
6221 return PP.getIdentifierTable();
6222 }
6223
6224 /// \brief Record that the given ID maps to the given switch-case
6225 /// statement.
RecordSwitchCaseID(SwitchCase * SC,unsigned ID)6226 void ASTReader::RecordSwitchCaseID(SwitchCase *SC, unsigned ID) {
6227 assert(SwitchCaseStmts[ID] == 0 && "Already have a SwitchCase with this ID");
6228 SwitchCaseStmts[ID] = SC;
6229 }
6230
6231 /// \brief Retrieve the switch-case statement with the given ID.
getSwitchCaseWithID(unsigned ID)6232 SwitchCase *ASTReader::getSwitchCaseWithID(unsigned ID) {
6233 assert(SwitchCaseStmts[ID] != 0 && "No SwitchCase with this ID");
6234 return SwitchCaseStmts[ID];
6235 }
6236
ClearSwitchCaseIDs()6237 void ASTReader::ClearSwitchCaseIDs() {
6238 SwitchCaseStmts.clear();
6239 }
6240
finishPendingActions()6241 void ASTReader::finishPendingActions() {
6242 while (!PendingIdentifierInfos.empty() || !PendingDeclChains.empty()) {
6243 // If any identifiers with corresponding top-level declarations have
6244 // been loaded, load those declarations now.
6245 while (!PendingIdentifierInfos.empty()) {
6246 SetGloballyVisibleDecls(PendingIdentifierInfos.front().II,
6247 PendingIdentifierInfos.front().DeclIDs, true);
6248 PendingIdentifierInfos.pop_front();
6249 }
6250
6251 // Load pending declaration chains.
6252 for (unsigned I = 0; I != PendingDeclChains.size(); ++I) {
6253 loadPendingDeclChain(PendingDeclChains[I]);
6254 PendingDeclChainsKnown.erase(PendingDeclChains[I]);
6255 }
6256 PendingDeclChains.clear();
6257 }
6258
6259 // If we deserialized any C++ or Objective-C class definitions, any
6260 // Objective-C protocol definitions, or any redeclarable templates, make sure
6261 // that all redeclarations point to the definitions. Note that this can only
6262 // happen now, after the redeclaration chains have been fully wired.
6263 for (llvm::SmallPtrSet<Decl *, 4>::iterator D = PendingDefinitions.begin(),
6264 DEnd = PendingDefinitions.end();
6265 D != DEnd; ++D) {
6266 if (TagDecl *TD = dyn_cast<TagDecl>(*D)) {
6267 if (const TagType *TagT = dyn_cast<TagType>(TD->TypeForDecl)) {
6268 // Make sure that the TagType points at the definition.
6269 const_cast<TagType*>(TagT)->decl = TD;
6270 }
6271
6272 if (CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(*D)) {
6273 for (CXXRecordDecl::redecl_iterator R = RD->redecls_begin(),
6274 REnd = RD->redecls_end();
6275 R != REnd; ++R)
6276 cast<CXXRecordDecl>(*R)->DefinitionData = RD->DefinitionData;
6277
6278 }
6279
6280 continue;
6281 }
6282
6283 if (ObjCInterfaceDecl *ID = dyn_cast<ObjCInterfaceDecl>(*D)) {
6284 // Make sure that the ObjCInterfaceType points at the definition.
6285 const_cast<ObjCInterfaceType *>(cast<ObjCInterfaceType>(ID->TypeForDecl))
6286 ->Decl = ID;
6287
6288 for (ObjCInterfaceDecl::redecl_iterator R = ID->redecls_begin(),
6289 REnd = ID->redecls_end();
6290 R != REnd; ++R)
6291 R->Data = ID->Data;
6292
6293 continue;
6294 }
6295
6296 if (ObjCProtocolDecl *PD = dyn_cast<ObjCProtocolDecl>(*D)) {
6297 for (ObjCProtocolDecl::redecl_iterator R = PD->redecls_begin(),
6298 REnd = PD->redecls_end();
6299 R != REnd; ++R)
6300 R->Data = PD->Data;
6301
6302 continue;
6303 }
6304
6305 RedeclarableTemplateDecl *RTD
6306 = cast<RedeclarableTemplateDecl>(*D)->getCanonicalDecl();
6307 for (RedeclarableTemplateDecl::redecl_iterator R = RTD->redecls_begin(),
6308 REnd = RTD->redecls_end();
6309 R != REnd; ++R)
6310 R->Common = RTD->Common;
6311 }
6312 PendingDefinitions.clear();
6313 }
6314
FinishedDeserializing()6315 void ASTReader::FinishedDeserializing() {
6316 assert(NumCurrentElementsDeserializing &&
6317 "FinishedDeserializing not paired with StartedDeserializing");
6318 if (NumCurrentElementsDeserializing == 1) {
6319 // We decrease NumCurrentElementsDeserializing only after pending actions
6320 // are finished, to avoid recursively re-calling finishPendingActions().
6321 finishPendingActions();
6322 }
6323 --NumCurrentElementsDeserializing;
6324
6325 if (NumCurrentElementsDeserializing == 0 &&
6326 Consumer && !PassingDeclsToConsumer) {
6327 // Guard variable to avoid recursively redoing the process of passing
6328 // decls to consumer.
6329 SaveAndRestore<bool> GuardPassingDeclsToConsumer(PassingDeclsToConsumer,
6330 true);
6331
6332 while (!InterestingDecls.empty()) {
6333 // We are not in recursive loading, so it's safe to pass the "interesting"
6334 // decls to the consumer.
6335 Decl *D = InterestingDecls.front();
6336 InterestingDecls.pop_front();
6337 PassInterestingDeclToConsumer(D);
6338 }
6339 }
6340 }
6341
ASTReader(Preprocessor & PP,ASTContext & Context,StringRef isysroot,bool DisableValidation,bool DisableStatCache,bool AllowASTWithCompilerErrors)6342 ASTReader::ASTReader(Preprocessor &PP, ASTContext &Context,
6343 StringRef isysroot, bool DisableValidation,
6344 bool DisableStatCache, bool AllowASTWithCompilerErrors)
6345 : Listener(new PCHValidator(PP, *this)), DeserializationListener(0),
6346 SourceMgr(PP.getSourceManager()), FileMgr(PP.getFileManager()),
6347 Diags(PP.getDiagnostics()), SemaObj(0), PP(PP), Context(Context),
6348 Consumer(0), ModuleMgr(FileMgr.getFileSystemOptions()),
6349 RelocatablePCH(false), isysroot(isysroot),
6350 DisableValidation(DisableValidation),
6351 DisableStatCache(DisableStatCache),
6352 AllowASTWithCompilerErrors(AllowASTWithCompilerErrors),
6353 CurrentGeneration(0), NumStatHits(0), NumStatMisses(0),
6354 NumSLocEntriesRead(0), TotalNumSLocEntries(0),
6355 NumStatementsRead(0), TotalNumStatements(0), NumMacrosRead(0),
6356 TotalNumMacros(0), NumSelectorsRead(0), NumMethodPoolEntriesRead(0),
6357 NumMethodPoolMisses(0), TotalNumMethodPoolEntries(0),
6358 NumLexicalDeclContextsRead(0), TotalLexicalDeclContexts(0),
6359 NumVisibleDeclContextsRead(0), TotalVisibleDeclContexts(0),
6360 TotalModulesSizeInBits(0), NumCurrentElementsDeserializing(0),
6361 PassingDeclsToConsumer(false),
6362 NumCXXBaseSpecifiersLoaded(0)
6363 {
6364 SourceMgr.setExternalSLocEntrySource(this);
6365 }
6366
~ASTReader()6367 ASTReader::~ASTReader() {
6368 for (DeclContextVisibleUpdatesPending::iterator
6369 I = PendingVisibleUpdates.begin(),
6370 E = PendingVisibleUpdates.end();
6371 I != E; ++I) {
6372 for (DeclContextVisibleUpdates::iterator J = I->second.begin(),
6373 F = I->second.end();
6374 J != F; ++J)
6375 delete J->first;
6376 }
6377 }
6378