• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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