1 //===--- ASTReaderDecl.cpp - Decl Deserialization ---------------*- 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 implements the ASTReader::ReadDeclRecord method, which is the
11 // entrypoint for loading a decl.
12 //
13 //===----------------------------------------------------------------------===//
14 
15 #include "ASTCommon.h"
16 #include "ASTReaderInternals.h"
17 #include "clang/Serialization/ASTReader.h"
18 #include "clang/Sema/IdentifierResolver.h"
19 #include "clang/Sema/Sema.h"
20 #include "clang/Sema/SemaDiagnostic.h"
21 #include "clang/AST/ASTConsumer.h"
22 #include "clang/AST/ASTContext.h"
23 #include "clang/AST/DeclVisitor.h"
24 #include "clang/AST/DeclGroup.h"
25 #include "clang/AST/DeclCXX.h"
26 #include "clang/AST/DeclTemplate.h"
27 #include "clang/AST/Expr.h"
28 #include "llvm/Support/SaveAndRestore.h"
29 using namespace clang;
30 using namespace clang::serialization;
31 
32 //===----------------------------------------------------------------------===//
33 // Declaration deserialization
34 //===----------------------------------------------------------------------===//
35 
36 namespace clang {
37   class ASTDeclReader : public DeclVisitor<ASTDeclReader, void> {
38     ASTReader &Reader;
39     ModuleFile &F;
40     const DeclID ThisDeclID;
41     const unsigned RawLocation;
42     typedef ASTReader::RecordData RecordData;
43     const RecordData &Record;
44     unsigned &Idx;
45     TypeID TypeIDForTypeDecl;
46 
47     DeclID DeclContextIDForTemplateParmDecl;
48     DeclID LexicalDeclContextIDForTemplateParmDecl;
49 
50     uint64_t GetCurrentCursorOffset();
51 
52     SourceLocation ReadSourceLocation(const RecordData &R, unsigned &I) {
53       return Reader.ReadSourceLocation(F, R, I);
54     }
55 
56     SourceRange ReadSourceRange(const RecordData &R, unsigned &I) {
57       return Reader.ReadSourceRange(F, R, I);
58     }
59 
60     TypeSourceInfo *GetTypeSourceInfo(const RecordData &R, unsigned &I) {
61       return Reader.GetTypeSourceInfo(F, R, I);
62     }
63 
64     serialization::DeclID ReadDeclID(const RecordData &R, unsigned &I) {
65       return Reader.ReadDeclID(F, R, I);
66     }
67 
68     Decl *ReadDecl(const RecordData &R, unsigned &I) {
69       return Reader.ReadDecl(F, R, I);
70     }
71 
72     template<typename T>
73     T *ReadDeclAs(const RecordData &R, unsigned &I) {
74       return Reader.ReadDeclAs<T>(F, R, I);
75     }
76 
77     void ReadQualifierInfo(QualifierInfo &Info,
78                            const RecordData &R, unsigned &I) {
79       Reader.ReadQualifierInfo(F, Info, R, I);
80     }
81 
82     void ReadDeclarationNameLoc(DeclarationNameLoc &DNLoc, DeclarationName Name,
83                                 const RecordData &R, unsigned &I) {
84       Reader.ReadDeclarationNameLoc(F, DNLoc, Name, R, I);
85     }
86 
87     void ReadDeclarationNameInfo(DeclarationNameInfo &NameInfo,
88                                 const RecordData &R, unsigned &I) {
89       Reader.ReadDeclarationNameInfo(F, NameInfo, R, I);
90     }
91 
92     serialization::SubmoduleID readSubmoduleID(const RecordData &R,
93                                                unsigned &I) {
94       if (I >= R.size())
95         return 0;
96 
97       return Reader.getGlobalSubmoduleID(F, R[I++]);
98     }
99 
100     Module *readModule(const RecordData &R, unsigned &I) {
101       return Reader.getSubmodule(readSubmoduleID(R, I));
102     }
103 
104     void ReadCXXDefinitionData(struct CXXRecordDecl::DefinitionData &Data,
105                                const RecordData &R, unsigned &I);
106 
107     /// \brief RAII class used to capture the first ID within a redeclaration
108     /// chain and to introduce it into the list of pending redeclaration chains
109     /// on destruction.
110     ///
111     /// The caller can choose not to introduce this ID into the redeclaration
112     /// chain by calling \c suppress().
113     class RedeclarableResult {
114       ASTReader &Reader;
115       GlobalDeclID FirstID;
116       mutable bool Owning;
117 
118       void operator=(RedeclarableResult &) LLVM_DELETED_FUNCTION;
119 
120     public:
121       RedeclarableResult(ASTReader &Reader, GlobalDeclID FirstID)
122         : Reader(Reader), FirstID(FirstID), Owning(true) { }
123 
124       RedeclarableResult(const RedeclarableResult &Other)
125         : Reader(Other.Reader), FirstID(Other.FirstID), Owning(Other.Owning)
126       {
127         Other.Owning = false;
128       }
129 
130       ~RedeclarableResult() {
131         // FIXME: We want to suppress this when the declaration is local to
132         // a function, since there's no reason to search other AST files
133         // for redeclarations (they can't exist). However, this is hard to
134         // do locally because the declaration hasn't necessarily loaded its
135         // declaration context yet. Also, local externs still have the function
136         // as their (semantic) declaration context, which is wrong and would
137         // break this optimize.
138 
139         if (FirstID && Owning && Reader.PendingDeclChainsKnown.insert(FirstID))
140           Reader.PendingDeclChains.push_back(FirstID);
141       }
142 
143       /// \brief Retrieve the first ID.
144       GlobalDeclID getFirstID() const { return FirstID; }
145 
146       /// \brief Do not introduce this declaration ID into the set of pending
147       /// declaration chains.
148       void suppress() {
149         Owning = false;
150       }
151     };
152 
153     /// \brief Class used to capture the result of searching for an existing
154     /// declaration of a specific kind and name, along with the ability
155     /// to update the place where this result was found (the declaration
156     /// chain hanging off an identifier or the DeclContext we searched in)
157     /// if requested.
158     class FindExistingResult {
159       ASTReader &Reader;
160       NamedDecl *New;
161       NamedDecl *Existing;
162       mutable bool AddResult;
163 
164       void operator=(FindExistingResult&) LLVM_DELETED_FUNCTION;
165 
166     public:
167       FindExistingResult(ASTReader &Reader)
168         : Reader(Reader), New(0), Existing(0), AddResult(false) { }
169 
170       FindExistingResult(ASTReader &Reader, NamedDecl *New, NamedDecl *Existing)
171         : Reader(Reader), New(New), Existing(Existing), AddResult(true) { }
172 
173       FindExistingResult(const FindExistingResult &Other)
174         : Reader(Other.Reader), New(Other.New), Existing(Other.Existing),
175           AddResult(Other.AddResult)
176       {
177         Other.AddResult = false;
178       }
179 
180       ~FindExistingResult();
181 
182       /// \brief Suppress the addition of this result into the known set of
183       /// names.
184       void suppress() { AddResult = false; }
185 
186       operator NamedDecl*() const { return Existing; }
187 
188       template<typename T>
189       operator T*() const { return dyn_cast_or_null<T>(Existing); }
190     };
191 
192     FindExistingResult findExisting(NamedDecl *D);
193 
194   public:
195     ASTDeclReader(ASTReader &Reader, ModuleFile &F,
196                   DeclID thisDeclID,
197                   unsigned RawLocation,
198                   const RecordData &Record, unsigned &Idx)
199       : Reader(Reader), F(F), ThisDeclID(thisDeclID),
200         RawLocation(RawLocation), Record(Record), Idx(Idx),
201         TypeIDForTypeDecl(0) { }
202 
203     static void attachPreviousDecl(Decl *D, Decl *previous);
204     static void attachLatestDecl(Decl *D, Decl *latest);
205 
206     void Visit(Decl *D);
207 
208     void UpdateDecl(Decl *D, ModuleFile &ModuleFile,
209                     const RecordData &Record);
210 
211     static void setNextObjCCategory(ObjCCategoryDecl *Cat,
212                                     ObjCCategoryDecl *Next) {
213       Cat->NextClassCategory = Next;
214     }
215 
216     void VisitDecl(Decl *D);
217     void VisitTranslationUnitDecl(TranslationUnitDecl *TU);
218     void VisitNamedDecl(NamedDecl *ND);
219     void VisitLabelDecl(LabelDecl *LD);
220     void VisitNamespaceDecl(NamespaceDecl *D);
221     void VisitUsingDirectiveDecl(UsingDirectiveDecl *D);
222     void VisitNamespaceAliasDecl(NamespaceAliasDecl *D);
223     void VisitTypeDecl(TypeDecl *TD);
224     void VisitTypedefNameDecl(TypedefNameDecl *TD);
225     void VisitTypedefDecl(TypedefDecl *TD);
226     void VisitTypeAliasDecl(TypeAliasDecl *TD);
227     void VisitUnresolvedUsingTypenameDecl(UnresolvedUsingTypenameDecl *D);
228     void VisitTagDecl(TagDecl *TD);
229     void VisitEnumDecl(EnumDecl *ED);
230     void VisitRecordDecl(RecordDecl *RD);
231     void VisitCXXRecordDecl(CXXRecordDecl *D);
232     void VisitClassTemplateSpecializationDecl(
233                                             ClassTemplateSpecializationDecl *D);
234     void VisitClassTemplatePartialSpecializationDecl(
235                                      ClassTemplatePartialSpecializationDecl *D);
236     void VisitClassScopeFunctionSpecializationDecl(
237                                        ClassScopeFunctionSpecializationDecl *D);
238     void VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D);
239     void VisitValueDecl(ValueDecl *VD);
240     void VisitEnumConstantDecl(EnumConstantDecl *ECD);
241     void VisitUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *D);
242     void VisitDeclaratorDecl(DeclaratorDecl *DD);
243     void VisitFunctionDecl(FunctionDecl *FD);
244     void VisitCXXMethodDecl(CXXMethodDecl *D);
245     void VisitCXXConstructorDecl(CXXConstructorDecl *D);
246     void VisitCXXDestructorDecl(CXXDestructorDecl *D);
247     void VisitCXXConversionDecl(CXXConversionDecl *D);
248     void VisitFieldDecl(FieldDecl *FD);
249     void VisitIndirectFieldDecl(IndirectFieldDecl *FD);
250     void VisitVarDecl(VarDecl *VD);
251     void VisitImplicitParamDecl(ImplicitParamDecl *PD);
252     void VisitParmVarDecl(ParmVarDecl *PD);
253     void VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D);
254     void VisitTemplateDecl(TemplateDecl *D);
255     RedeclarableResult VisitRedeclarableTemplateDecl(RedeclarableTemplateDecl *D);
256     void VisitClassTemplateDecl(ClassTemplateDecl *D);
257     void VisitFunctionTemplateDecl(FunctionTemplateDecl *D);
258     void VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D);
259     void VisitTypeAliasTemplateDecl(TypeAliasTemplateDecl *D);
260     void VisitUsingDecl(UsingDecl *D);
261     void VisitUsingShadowDecl(UsingShadowDecl *D);
262     void VisitLinkageSpecDecl(LinkageSpecDecl *D);
263     void VisitFileScopeAsmDecl(FileScopeAsmDecl *AD);
264     void VisitImportDecl(ImportDecl *D);
265     void VisitAccessSpecDecl(AccessSpecDecl *D);
266     void VisitFriendDecl(FriendDecl *D);
267     void VisitFriendTemplateDecl(FriendTemplateDecl *D);
268     void VisitStaticAssertDecl(StaticAssertDecl *D);
269     void VisitBlockDecl(BlockDecl *BD);
270 
271     std::pair<uint64_t, uint64_t> VisitDeclContext(DeclContext *DC);
272 
273     template<typename T>
274     RedeclarableResult VisitRedeclarable(Redeclarable<T> *D);
275 
276     template<typename T>
277     void mergeRedeclarable(Redeclarable<T> *D, RedeclarableResult &Redecl);
278 
279     // FIXME: Reorder according to DeclNodes.td?
280     void VisitObjCMethodDecl(ObjCMethodDecl *D);
281     void VisitObjCContainerDecl(ObjCContainerDecl *D);
282     void VisitObjCInterfaceDecl(ObjCInterfaceDecl *D);
283     void VisitObjCIvarDecl(ObjCIvarDecl *D);
284     void VisitObjCProtocolDecl(ObjCProtocolDecl *D);
285     void VisitObjCAtDefsFieldDecl(ObjCAtDefsFieldDecl *D);
286     void VisitObjCCategoryDecl(ObjCCategoryDecl *D);
287     void VisitObjCImplDecl(ObjCImplDecl *D);
288     void VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D);
289     void VisitObjCImplementationDecl(ObjCImplementationDecl *D);
290     void VisitObjCCompatibleAliasDecl(ObjCCompatibleAliasDecl *D);
291     void VisitObjCPropertyDecl(ObjCPropertyDecl *D);
292     void VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D);
293   };
294 }
295 
296 uint64_t ASTDeclReader::GetCurrentCursorOffset() {
297   return F.DeclsCursor.GetCurrentBitNo() + F.GlobalBitOffset;
298 }
299 
300 void ASTDeclReader::Visit(Decl *D) {
301   DeclVisitor<ASTDeclReader, void>::Visit(D);
302 
303   if (DeclaratorDecl *DD = dyn_cast<DeclaratorDecl>(D)) {
304     if (DD->DeclInfo) {
305       DeclaratorDecl::ExtInfo *Info =
306           DD->DeclInfo.get<DeclaratorDecl::ExtInfo *>();
307       Info->TInfo =
308           GetTypeSourceInfo(Record, Idx);
309     }
310     else {
311       DD->DeclInfo = GetTypeSourceInfo(Record, Idx);
312     }
313   }
314 
315   if (TypeDecl *TD = dyn_cast<TypeDecl>(D)) {
316     // if we have a fully initialized TypeDecl, we can safely read its type now.
317     TD->setTypeForDecl(Reader.GetType(TypeIDForTypeDecl).getTypePtrOrNull());
318   } else if (ObjCInterfaceDecl *ID = dyn_cast<ObjCInterfaceDecl>(D)) {
319     // if we have a fully initialized TypeDecl, we can safely read its type now.
320     ID->TypeForDecl = Reader.GetType(TypeIDForTypeDecl).getTypePtrOrNull();
321   } else if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
322     // FunctionDecl's body was written last after all other Stmts/Exprs.
323     if (Record[Idx++])
324       FD->setLazyBody(GetCurrentCursorOffset());
325   } else if (D->isTemplateParameter()) {
326     // If we have a fully initialized template parameter, we can now
327     // set its DeclContext.
328     DeclContext *SemaDC = cast<DeclContext>(
329                               Reader.GetDecl(DeclContextIDForTemplateParmDecl));
330     DeclContext *LexicalDC = cast<DeclContext>(
331                        Reader.GetDecl(LexicalDeclContextIDForTemplateParmDecl));
332     D->setDeclContextsImpl(SemaDC, LexicalDC, Reader.getContext());
333   }
334 }
335 
336 void ASTDeclReader::VisitDecl(Decl *D) {
337   if (D->isTemplateParameter()) {
338     // We don't want to deserialize the DeclContext of a template
339     // parameter immediately, because the template parameter might be
340     // used in the formulation of its DeclContext. Use the translation
341     // unit DeclContext as a placeholder.
342     DeclContextIDForTemplateParmDecl = ReadDeclID(Record, Idx);
343     LexicalDeclContextIDForTemplateParmDecl = ReadDeclID(Record, Idx);
344     D->setDeclContext(Reader.getContext().getTranslationUnitDecl());
345   } else {
346     DeclContext *SemaDC = ReadDeclAs<DeclContext>(Record, Idx);
347     DeclContext *LexicalDC = ReadDeclAs<DeclContext>(Record, Idx);
348     // Avoid calling setLexicalDeclContext() directly because it uses
349     // Decl::getASTContext() internally which is unsafe during derialization.
350     D->setDeclContextsImpl(SemaDC, LexicalDC, Reader.getContext());
351   }
352   D->setLocation(Reader.ReadSourceLocation(F, RawLocation));
353   D->setInvalidDecl(Record[Idx++]);
354   if (Record[Idx++]) { // hasAttrs
355     AttrVec Attrs;
356     Reader.ReadAttributes(F, Attrs, Record, Idx);
357     // Avoid calling setAttrs() directly because it uses Decl::getASTContext()
358     // internally which is unsafe during derialization.
359     D->setAttrsImpl(Attrs, Reader.getContext());
360   }
361   D->setImplicit(Record[Idx++]);
362   D->setUsed(Record[Idx++]);
363   D->setReferenced(Record[Idx++]);
364   D->setTopLevelDeclInObjCContainer(Record[Idx++]);
365   D->setAccess((AccessSpecifier)Record[Idx++]);
366   D->FromASTFile = true;
367   D->setModulePrivate(Record[Idx++]);
368   D->Hidden = D->isModulePrivate();
369 
370   // Determine whether this declaration is part of a (sub)module. If so, it
371   // may not yet be visible.
372   if (unsigned SubmoduleID = readSubmoduleID(Record, Idx)) {
373     // Store the owning submodule ID in the declaration.
374     D->setOwningModuleID(SubmoduleID);
375 
376     // Module-private declarations are never visible, so there is no work to do.
377     if (!D->isModulePrivate()) {
378       if (Module *Owner = Reader.getSubmodule(SubmoduleID)) {
379         if (Owner->NameVisibility != Module::AllVisible) {
380           // The owning module is not visible. Mark this declaration as hidden.
381           D->Hidden = true;
382 
383           // Note that this declaration was hidden because its owning module is
384           // not yet visible.
385           Reader.HiddenNamesMap[Owner].push_back(D);
386         }
387       }
388     }
389   }
390 }
391 
392 void ASTDeclReader::VisitTranslationUnitDecl(TranslationUnitDecl *TU) {
393   llvm_unreachable("Translation units are not serialized");
394 }
395 
396 void ASTDeclReader::VisitNamedDecl(NamedDecl *ND) {
397   VisitDecl(ND);
398   ND->setDeclName(Reader.ReadDeclarationName(F, Record, Idx));
399 }
400 
401 void ASTDeclReader::VisitTypeDecl(TypeDecl *TD) {
402   VisitNamedDecl(TD);
403   TD->setLocStart(ReadSourceLocation(Record, Idx));
404   // Delay type reading until after we have fully initialized the decl.
405   TypeIDForTypeDecl = Reader.getGlobalTypeID(F, Record[Idx++]);
406 }
407 
408 void ASTDeclReader::VisitTypedefNameDecl(TypedefNameDecl *TD) {
409   RedeclarableResult Redecl = VisitRedeclarable(TD);
410   VisitTypeDecl(TD);
411 
412   TD->setTypeSourceInfo(GetTypeSourceInfo(Record, Idx));
413   mergeRedeclarable(TD, Redecl);
414 }
415 
416 void ASTDeclReader::VisitTypedefDecl(TypedefDecl *TD) {
417   VisitTypedefNameDecl(TD);
418 }
419 
420 void ASTDeclReader::VisitTypeAliasDecl(TypeAliasDecl *TD) {
421   VisitTypedefNameDecl(TD);
422 }
423 
424 void ASTDeclReader::VisitTagDecl(TagDecl *TD) {
425   RedeclarableResult Redecl = VisitRedeclarable(TD);
426   VisitTypeDecl(TD);
427 
428   TD->IdentifierNamespace = Record[Idx++];
429   TD->setTagKind((TagDecl::TagKind)Record[Idx++]);
430   TD->setCompleteDefinition(Record[Idx++]);
431   TD->setEmbeddedInDeclarator(Record[Idx++]);
432   TD->setFreeStanding(Record[Idx++]);
433   TD->setRBraceLoc(ReadSourceLocation(Record, Idx));
434 
435   if (Record[Idx++]) { // hasExtInfo
436     TagDecl::ExtInfo *Info = new (Reader.getContext()) TagDecl::ExtInfo();
437     ReadQualifierInfo(*Info, Record, Idx);
438     TD->TypedefNameDeclOrQualifier = Info;
439   } else
440     TD->setTypedefNameForAnonDecl(ReadDeclAs<TypedefNameDecl>(Record, Idx));
441 
442   mergeRedeclarable(TD, Redecl);
443 }
444 
445 void ASTDeclReader::VisitEnumDecl(EnumDecl *ED) {
446   VisitTagDecl(ED);
447   if (TypeSourceInfo *TI = Reader.GetTypeSourceInfo(F, Record, Idx))
448     ED->setIntegerTypeSourceInfo(TI);
449   else
450     ED->setIntegerType(Reader.readType(F, Record, Idx));
451   ED->setPromotionType(Reader.readType(F, Record, Idx));
452   ED->setNumPositiveBits(Record[Idx++]);
453   ED->setNumNegativeBits(Record[Idx++]);
454   ED->IsScoped = Record[Idx++];
455   ED->IsScopedUsingClassTag = Record[Idx++];
456   ED->IsFixed = Record[Idx++];
457 
458   if (EnumDecl *InstED = ReadDeclAs<EnumDecl>(Record, Idx)) {
459     TemplateSpecializationKind TSK = (TemplateSpecializationKind)Record[Idx++];
460     SourceLocation POI = ReadSourceLocation(Record, Idx);
461     ED->setInstantiationOfMemberEnum(Reader.getContext(), InstED, TSK);
462     ED->getMemberSpecializationInfo()->setPointOfInstantiation(POI);
463   }
464 }
465 
466 void ASTDeclReader::VisitRecordDecl(RecordDecl *RD) {
467   VisitTagDecl(RD);
468   RD->setHasFlexibleArrayMember(Record[Idx++]);
469   RD->setAnonymousStructOrUnion(Record[Idx++]);
470   RD->setHasObjectMember(Record[Idx++]);
471 }
472 
473 void ASTDeclReader::VisitValueDecl(ValueDecl *VD) {
474   VisitNamedDecl(VD);
475   VD->setType(Reader.readType(F, Record, Idx));
476 }
477 
478 void ASTDeclReader::VisitEnumConstantDecl(EnumConstantDecl *ECD) {
479   VisitValueDecl(ECD);
480   if (Record[Idx++])
481     ECD->setInitExpr(Reader.ReadExpr(F));
482   ECD->setInitVal(Reader.ReadAPSInt(Record, Idx));
483 }
484 
485 void ASTDeclReader::VisitDeclaratorDecl(DeclaratorDecl *DD) {
486   VisitValueDecl(DD);
487   DD->setInnerLocStart(ReadSourceLocation(Record, Idx));
488   if (Record[Idx++]) { // hasExtInfo
489     DeclaratorDecl::ExtInfo *Info
490         = new (Reader.getContext()) DeclaratorDecl::ExtInfo();
491     ReadQualifierInfo(*Info, Record, Idx);
492     DD->DeclInfo = Info;
493   }
494 }
495 
496 void ASTDeclReader::VisitFunctionDecl(FunctionDecl *FD) {
497   RedeclarableResult Redecl = VisitRedeclarable(FD);
498   VisitDeclaratorDecl(FD);
499 
500   ReadDeclarationNameLoc(FD->DNLoc, FD->getDeclName(), Record, Idx);
501   FD->IdentifierNamespace = Record[Idx++];
502 
503   // FunctionDecl's body is handled last at ASTDeclReader::Visit,
504   // after everything else is read.
505 
506   FD->SClass = (StorageClass)Record[Idx++];
507   FD->SClassAsWritten = (StorageClass)Record[Idx++];
508   FD->IsInline = Record[Idx++];
509   FD->IsInlineSpecified = Record[Idx++];
510   FD->IsVirtualAsWritten = Record[Idx++];
511   FD->IsPure = Record[Idx++];
512   FD->HasInheritedPrototype = Record[Idx++];
513   FD->HasWrittenPrototype = Record[Idx++];
514   FD->IsDeleted = Record[Idx++];
515   FD->IsTrivial = Record[Idx++];
516   FD->IsDefaulted = Record[Idx++];
517   FD->IsExplicitlyDefaulted = Record[Idx++];
518   FD->HasImplicitReturnZero = Record[Idx++];
519   FD->IsConstexpr = Record[Idx++];
520   FD->EndRangeLoc = ReadSourceLocation(Record, Idx);
521 
522   switch ((FunctionDecl::TemplatedKind)Record[Idx++]) {
523   case FunctionDecl::TK_NonTemplate:
524     mergeRedeclarable(FD, Redecl);
525     break;
526   case FunctionDecl::TK_FunctionTemplate:
527     FD->setDescribedFunctionTemplate(ReadDeclAs<FunctionTemplateDecl>(Record,
528                                                                       Idx));
529     break;
530   case FunctionDecl::TK_MemberSpecialization: {
531     FunctionDecl *InstFD = ReadDeclAs<FunctionDecl>(Record, Idx);
532     TemplateSpecializationKind TSK = (TemplateSpecializationKind)Record[Idx++];
533     SourceLocation POI = ReadSourceLocation(Record, Idx);
534     FD->setInstantiationOfMemberFunction(Reader.getContext(), InstFD, TSK);
535     FD->getMemberSpecializationInfo()->setPointOfInstantiation(POI);
536     break;
537   }
538   case FunctionDecl::TK_FunctionTemplateSpecialization: {
539     FunctionTemplateDecl *Template = ReadDeclAs<FunctionTemplateDecl>(Record,
540                                                                       Idx);
541     TemplateSpecializationKind TSK = (TemplateSpecializationKind)Record[Idx++];
542 
543     // Template arguments.
544     SmallVector<TemplateArgument, 8> TemplArgs;
545     Reader.ReadTemplateArgumentList(TemplArgs, F, Record, Idx);
546 
547     // Template args as written.
548     SmallVector<TemplateArgumentLoc, 8> TemplArgLocs;
549     SourceLocation LAngleLoc, RAngleLoc;
550     bool HasTemplateArgumentsAsWritten = Record[Idx++];
551     if (HasTemplateArgumentsAsWritten) {
552       unsigned NumTemplateArgLocs = Record[Idx++];
553       TemplArgLocs.reserve(NumTemplateArgLocs);
554       for (unsigned i=0; i != NumTemplateArgLocs; ++i)
555         TemplArgLocs.push_back(
556             Reader.ReadTemplateArgumentLoc(F, Record, Idx));
557 
558       LAngleLoc = ReadSourceLocation(Record, Idx);
559       RAngleLoc = ReadSourceLocation(Record, Idx);
560     }
561 
562     SourceLocation POI = ReadSourceLocation(Record, Idx);
563 
564     ASTContext &C = Reader.getContext();
565     TemplateArgumentList *TemplArgList
566       = TemplateArgumentList::CreateCopy(C, TemplArgs.data(), TemplArgs.size());
567     TemplateArgumentListInfo TemplArgsInfo(LAngleLoc, RAngleLoc);
568     for (unsigned i=0, e = TemplArgLocs.size(); i != e; ++i)
569       TemplArgsInfo.addArgument(TemplArgLocs[i]);
570     FunctionTemplateSpecializationInfo *FTInfo
571         = FunctionTemplateSpecializationInfo::Create(C, FD, Template, TSK,
572                                                      TemplArgList,
573                              HasTemplateArgumentsAsWritten ? &TemplArgsInfo : 0,
574                                                      POI);
575     FD->TemplateOrSpecialization = FTInfo;
576 
577     if (FD->isCanonicalDecl()) { // if canonical add to template's set.
578       // The template that contains the specializations set. It's not safe to
579       // use getCanonicalDecl on Template since it may still be initializing.
580       FunctionTemplateDecl *CanonTemplate
581         = ReadDeclAs<FunctionTemplateDecl>(Record, Idx);
582       // Get the InsertPos by FindNodeOrInsertPos() instead of calling
583       // InsertNode(FTInfo) directly to avoid the getASTContext() call in
584       // FunctionTemplateSpecializationInfo's Profile().
585       // We avoid getASTContext because a decl in the parent hierarchy may
586       // be initializing.
587       llvm::FoldingSetNodeID ID;
588       FunctionTemplateSpecializationInfo::Profile(ID, TemplArgs.data(),
589                                                   TemplArgs.size(), C);
590       void *InsertPos = 0;
591       CanonTemplate->getSpecializations().FindNodeOrInsertPos(ID, InsertPos);
592       if (InsertPos)
593         CanonTemplate->getSpecializations().InsertNode(FTInfo, InsertPos);
594       else
595         assert(0 && "Another specialization already inserted!");
596     }
597     break;
598   }
599   case FunctionDecl::TK_DependentFunctionTemplateSpecialization: {
600     // Templates.
601     UnresolvedSet<8> TemplDecls;
602     unsigned NumTemplates = Record[Idx++];
603     while (NumTemplates--)
604       TemplDecls.addDecl(ReadDeclAs<NamedDecl>(Record, Idx));
605 
606     // Templates args.
607     TemplateArgumentListInfo TemplArgs;
608     unsigned NumArgs = Record[Idx++];
609     while (NumArgs--)
610       TemplArgs.addArgument(Reader.ReadTemplateArgumentLoc(F, Record, Idx));
611     TemplArgs.setLAngleLoc(ReadSourceLocation(Record, Idx));
612     TemplArgs.setRAngleLoc(ReadSourceLocation(Record, Idx));
613 
614     FD->setDependentTemplateSpecialization(Reader.getContext(),
615                                            TemplDecls, TemplArgs);
616     break;
617   }
618   }
619 
620   // Read in the parameters.
621   unsigned NumParams = Record[Idx++];
622   SmallVector<ParmVarDecl *, 16> Params;
623   Params.reserve(NumParams);
624   for (unsigned I = 0; I != NumParams; ++I)
625     Params.push_back(ReadDeclAs<ParmVarDecl>(Record, Idx));
626   FD->setParams(Reader.getContext(), Params);
627 }
628 
629 void ASTDeclReader::VisitObjCMethodDecl(ObjCMethodDecl *MD) {
630   VisitNamedDecl(MD);
631   if (Record[Idx++]) {
632     // In practice, this won't be executed (since method definitions
633     // don't occur in header files).
634     // Switch case IDs for this method body.
635     ASTReader::SwitchCaseMapTy SwitchCaseStmtsForObjCMethod;
636     SaveAndRestore<ASTReader::SwitchCaseMapTy *>
637       SCFOM(Reader.CurrSwitchCaseStmts, &SwitchCaseStmtsForObjCMethod);
638     MD->setBody(Reader.ReadStmt(F));
639     MD->setSelfDecl(ReadDeclAs<ImplicitParamDecl>(Record, Idx));
640     MD->setCmdDecl(ReadDeclAs<ImplicitParamDecl>(Record, Idx));
641   }
642   MD->setInstanceMethod(Record[Idx++]);
643   MD->setVariadic(Record[Idx++]);
644   MD->setSynthesized(Record[Idx++]);
645   MD->setDefined(Record[Idx++]);
646   MD->IsOverriding = Record[Idx++];
647 
648   MD->IsRedeclaration = Record[Idx++];
649   MD->HasRedeclaration = Record[Idx++];
650   if (MD->HasRedeclaration)
651     Reader.getContext().setObjCMethodRedeclaration(MD,
652                                        ReadDeclAs<ObjCMethodDecl>(Record, Idx));
653 
654   MD->setDeclImplementation((ObjCMethodDecl::ImplementationControl)Record[Idx++]);
655   MD->setObjCDeclQualifier((Decl::ObjCDeclQualifier)Record[Idx++]);
656   MD->SetRelatedResultType(Record[Idx++]);
657   MD->setResultType(Reader.readType(F, Record, Idx));
658   MD->setResultTypeSourceInfo(GetTypeSourceInfo(Record, Idx));
659   MD->DeclEndLoc = ReadSourceLocation(Record, Idx);
660   unsigned NumParams = Record[Idx++];
661   SmallVector<ParmVarDecl *, 16> Params;
662   Params.reserve(NumParams);
663   for (unsigned I = 0; I != NumParams; ++I)
664     Params.push_back(ReadDeclAs<ParmVarDecl>(Record, Idx));
665 
666   MD->SelLocsKind = Record[Idx++];
667   unsigned NumStoredSelLocs = Record[Idx++];
668   SmallVector<SourceLocation, 16> SelLocs;
669   SelLocs.reserve(NumStoredSelLocs);
670   for (unsigned i = 0; i != NumStoredSelLocs; ++i)
671     SelLocs.push_back(ReadSourceLocation(Record, Idx));
672 
673   MD->setParamsAndSelLocs(Reader.getContext(), Params, SelLocs);
674 }
675 
676 void ASTDeclReader::VisitObjCContainerDecl(ObjCContainerDecl *CD) {
677   VisitNamedDecl(CD);
678   CD->setAtStartLoc(ReadSourceLocation(Record, Idx));
679   CD->setAtEndRange(ReadSourceRange(Record, Idx));
680 }
681 
682 void ASTDeclReader::VisitObjCInterfaceDecl(ObjCInterfaceDecl *ID) {
683   RedeclarableResult Redecl = VisitRedeclarable(ID);
684   VisitObjCContainerDecl(ID);
685   TypeIDForTypeDecl = Reader.getGlobalTypeID(F, Record[Idx++]);
686   mergeRedeclarable(ID, Redecl);
687 
688   if (Record[Idx++]) {
689     // Read the definition.
690     ID->allocateDefinitionData();
691 
692     // Set the definition data of the canonical declaration, so other
693     // redeclarations will see it.
694     ID->getCanonicalDecl()->Data = ID->Data;
695 
696     ObjCInterfaceDecl::DefinitionData &Data = ID->data();
697 
698     // Read the superclass.
699     Data.SuperClass = ReadDeclAs<ObjCInterfaceDecl>(Record, Idx);
700     Data.SuperClassLoc = ReadSourceLocation(Record, Idx);
701 
702     Data.EndLoc = ReadSourceLocation(Record, Idx);
703 
704     // Read the directly referenced protocols and their SourceLocations.
705     unsigned NumProtocols = Record[Idx++];
706     SmallVector<ObjCProtocolDecl *, 16> Protocols;
707     Protocols.reserve(NumProtocols);
708     for (unsigned I = 0; I != NumProtocols; ++I)
709       Protocols.push_back(ReadDeclAs<ObjCProtocolDecl>(Record, Idx));
710     SmallVector<SourceLocation, 16> ProtoLocs;
711     ProtoLocs.reserve(NumProtocols);
712     for (unsigned I = 0; I != NumProtocols; ++I)
713       ProtoLocs.push_back(ReadSourceLocation(Record, Idx));
714     ID->setProtocolList(Protocols.data(), NumProtocols, ProtoLocs.data(),
715                         Reader.getContext());
716 
717     // Read the transitive closure of protocols referenced by this class.
718     NumProtocols = Record[Idx++];
719     Protocols.clear();
720     Protocols.reserve(NumProtocols);
721     for (unsigned I = 0; I != NumProtocols; ++I)
722       Protocols.push_back(ReadDeclAs<ObjCProtocolDecl>(Record, Idx));
723     ID->data().AllReferencedProtocols.set(Protocols.data(), NumProtocols,
724                                           Reader.getContext());
725 
726     // We will rebuild this list lazily.
727     ID->setIvarList(0);
728 
729     // Note that we have deserialized a definition.
730     Reader.PendingDefinitions.insert(ID);
731 
732     // Note that we've loaded this Objective-C class.
733     Reader.ObjCClassesLoaded.push_back(ID);
734   } else {
735     ID->Data = ID->getCanonicalDecl()->Data;
736   }
737 }
738 
739 void ASTDeclReader::VisitObjCIvarDecl(ObjCIvarDecl *IVD) {
740   VisitFieldDecl(IVD);
741   IVD->setAccessControl((ObjCIvarDecl::AccessControl)Record[Idx++]);
742   // This field will be built lazily.
743   IVD->setNextIvar(0);
744   bool synth = Record[Idx++];
745   IVD->setSynthesize(synth);
746 }
747 
748 void ASTDeclReader::VisitObjCProtocolDecl(ObjCProtocolDecl *PD) {
749   RedeclarableResult Redecl = VisitRedeclarable(PD);
750   VisitObjCContainerDecl(PD);
751   mergeRedeclarable(PD, Redecl);
752 
753   if (Record[Idx++]) {
754     // Read the definition.
755     PD->allocateDefinitionData();
756 
757     // Set the definition data of the canonical declaration, so other
758     // redeclarations will see it.
759     PD->getCanonicalDecl()->Data = PD->Data;
760 
761     unsigned NumProtoRefs = Record[Idx++];
762     SmallVector<ObjCProtocolDecl *, 16> ProtoRefs;
763     ProtoRefs.reserve(NumProtoRefs);
764     for (unsigned I = 0; I != NumProtoRefs; ++I)
765       ProtoRefs.push_back(ReadDeclAs<ObjCProtocolDecl>(Record, Idx));
766     SmallVector<SourceLocation, 16> ProtoLocs;
767     ProtoLocs.reserve(NumProtoRefs);
768     for (unsigned I = 0; I != NumProtoRefs; ++I)
769       ProtoLocs.push_back(ReadSourceLocation(Record, Idx));
770     PD->setProtocolList(ProtoRefs.data(), NumProtoRefs, ProtoLocs.data(),
771                         Reader.getContext());
772 
773     // Note that we have deserialized a definition.
774     Reader.PendingDefinitions.insert(PD);
775   } else {
776     PD->Data = PD->getCanonicalDecl()->Data;
777   }
778 }
779 
780 void ASTDeclReader::VisitObjCAtDefsFieldDecl(ObjCAtDefsFieldDecl *FD) {
781   VisitFieldDecl(FD);
782 }
783 
784 void ASTDeclReader::VisitObjCCategoryDecl(ObjCCategoryDecl *CD) {
785   VisitObjCContainerDecl(CD);
786   CD->setCategoryNameLoc(ReadSourceLocation(Record, Idx));
787   CD->setIvarLBraceLoc(ReadSourceLocation(Record, Idx));
788   CD->setIvarRBraceLoc(ReadSourceLocation(Record, Idx));
789 
790   // Note that this category has been deserialized. We do this before
791   // deserializing the interface declaration, so that it will consider this
792   /// category.
793   Reader.CategoriesDeserialized.insert(CD);
794 
795   CD->ClassInterface = ReadDeclAs<ObjCInterfaceDecl>(Record, Idx);
796   unsigned NumProtoRefs = Record[Idx++];
797   SmallVector<ObjCProtocolDecl *, 16> ProtoRefs;
798   ProtoRefs.reserve(NumProtoRefs);
799   for (unsigned I = 0; I != NumProtoRefs; ++I)
800     ProtoRefs.push_back(ReadDeclAs<ObjCProtocolDecl>(Record, Idx));
801   SmallVector<SourceLocation, 16> ProtoLocs;
802   ProtoLocs.reserve(NumProtoRefs);
803   for (unsigned I = 0; I != NumProtoRefs; ++I)
804     ProtoLocs.push_back(ReadSourceLocation(Record, Idx));
805   CD->setProtocolList(ProtoRefs.data(), NumProtoRefs, ProtoLocs.data(),
806                       Reader.getContext());
807 }
808 
809 void ASTDeclReader::VisitObjCCompatibleAliasDecl(ObjCCompatibleAliasDecl *CAD) {
810   VisitNamedDecl(CAD);
811   CAD->setClassInterface(ReadDeclAs<ObjCInterfaceDecl>(Record, Idx));
812 }
813 
814 void ASTDeclReader::VisitObjCPropertyDecl(ObjCPropertyDecl *D) {
815   VisitNamedDecl(D);
816   D->setAtLoc(ReadSourceLocation(Record, Idx));
817   D->setLParenLoc(ReadSourceLocation(Record, Idx));
818   D->setType(GetTypeSourceInfo(Record, Idx));
819   // FIXME: stable encoding
820   D->setPropertyAttributes(
821                       (ObjCPropertyDecl::PropertyAttributeKind)Record[Idx++]);
822   D->setPropertyAttributesAsWritten(
823                       (ObjCPropertyDecl::PropertyAttributeKind)Record[Idx++]);
824   // FIXME: stable encoding
825   D->setPropertyImplementation(
826                             (ObjCPropertyDecl::PropertyControl)Record[Idx++]);
827   D->setGetterName(Reader.ReadDeclarationName(F,Record, Idx).getObjCSelector());
828   D->setSetterName(Reader.ReadDeclarationName(F,Record, Idx).getObjCSelector());
829   D->setGetterMethodDecl(ReadDeclAs<ObjCMethodDecl>(Record, Idx));
830   D->setSetterMethodDecl(ReadDeclAs<ObjCMethodDecl>(Record, Idx));
831   D->setPropertyIvarDecl(ReadDeclAs<ObjCIvarDecl>(Record, Idx));
832 }
833 
834 void ASTDeclReader::VisitObjCImplDecl(ObjCImplDecl *D) {
835   VisitObjCContainerDecl(D);
836   D->setClassInterface(ReadDeclAs<ObjCInterfaceDecl>(Record, Idx));
837 }
838 
839 void ASTDeclReader::VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D) {
840   VisitObjCImplDecl(D);
841   D->setIdentifier(Reader.GetIdentifierInfo(F, Record, Idx));
842   D->CategoryNameLoc = ReadSourceLocation(Record, Idx);
843 }
844 
845 void ASTDeclReader::VisitObjCImplementationDecl(ObjCImplementationDecl *D) {
846   VisitObjCImplDecl(D);
847   D->setSuperClass(ReadDeclAs<ObjCInterfaceDecl>(Record, Idx));
848   D->setIvarLBraceLoc(ReadSourceLocation(Record, Idx));
849   D->setIvarRBraceLoc(ReadSourceLocation(Record, Idx));
850   llvm::tie(D->IvarInitializers, D->NumIvarInitializers)
851       = Reader.ReadCXXCtorInitializers(F, Record, Idx);
852 }
853 
854 
855 void ASTDeclReader::VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D) {
856   VisitDecl(D);
857   D->setAtLoc(ReadSourceLocation(Record, Idx));
858   D->setPropertyDecl(ReadDeclAs<ObjCPropertyDecl>(Record, Idx));
859   D->PropertyIvarDecl = ReadDeclAs<ObjCIvarDecl>(Record, Idx);
860   D->IvarLoc = ReadSourceLocation(Record, Idx);
861   D->setGetterCXXConstructor(Reader.ReadExpr(F));
862   D->setSetterCXXAssignment(Reader.ReadExpr(F));
863 }
864 
865 void ASTDeclReader::VisitFieldDecl(FieldDecl *FD) {
866   VisitDeclaratorDecl(FD);
867   FD->Mutable = Record[Idx++];
868   if (int BitWidthOrInitializer = Record[Idx++]) {
869     FD->InitializerOrBitWidth.setInt(BitWidthOrInitializer - 1);
870     FD->InitializerOrBitWidth.setPointer(Reader.ReadExpr(F));
871   }
872   if (!FD->getDeclName()) {
873     if (FieldDecl *Tmpl = ReadDeclAs<FieldDecl>(Record, Idx))
874       Reader.getContext().setInstantiatedFromUnnamedFieldDecl(FD, Tmpl);
875   }
876 }
877 
878 void ASTDeclReader::VisitIndirectFieldDecl(IndirectFieldDecl *FD) {
879   VisitValueDecl(FD);
880 
881   FD->ChainingSize = Record[Idx++];
882   assert(FD->ChainingSize >= 2 && "Anonymous chaining must be >= 2");
883   FD->Chaining = new (Reader.getContext())NamedDecl*[FD->ChainingSize];
884 
885   for (unsigned I = 0; I != FD->ChainingSize; ++I)
886     FD->Chaining[I] = ReadDeclAs<NamedDecl>(Record, Idx);
887 }
888 
889 void ASTDeclReader::VisitVarDecl(VarDecl *VD) {
890   RedeclarableResult Redecl = VisitRedeclarable(VD);
891   VisitDeclaratorDecl(VD);
892 
893   VD->VarDeclBits.SClass = (StorageClass)Record[Idx++];
894   VD->VarDeclBits.SClassAsWritten = (StorageClass)Record[Idx++];
895   VD->VarDeclBits.ThreadSpecified = Record[Idx++];
896   VD->VarDeclBits.InitStyle = Record[Idx++];
897   VD->VarDeclBits.ExceptionVar = Record[Idx++];
898   VD->VarDeclBits.NRVOVariable = Record[Idx++];
899   VD->VarDeclBits.CXXForRangeDecl = Record[Idx++];
900   VD->VarDeclBits.ARCPseudoStrong = Record[Idx++];
901   VD->VarDeclBits.IsConstexpr = Record[Idx++];
902 
903   // Only true variables (not parameters or implicit parameters) can be merged.
904   if (VD->getKind() == Decl::Var)
905     mergeRedeclarable(VD, Redecl);
906 
907   if (uint64_t Val = Record[Idx++]) {
908     VD->setInit(Reader.ReadExpr(F));
909     if (Val > 1) {
910       EvaluatedStmt *Eval = VD->ensureEvaluatedStmt();
911       Eval->CheckedICE = true;
912       Eval->IsICE = Val == 3;
913     }
914   }
915 
916   if (Record[Idx++]) { // HasMemberSpecializationInfo.
917     VarDecl *Tmpl = ReadDeclAs<VarDecl>(Record, Idx);
918     TemplateSpecializationKind TSK = (TemplateSpecializationKind)Record[Idx++];
919     SourceLocation POI = ReadSourceLocation(Record, Idx);
920     Reader.getContext().setInstantiatedFromStaticDataMember(VD, Tmpl, TSK,POI);
921   }
922 }
923 
924 void ASTDeclReader::VisitImplicitParamDecl(ImplicitParamDecl *PD) {
925   VisitVarDecl(PD);
926 }
927 
928 void ASTDeclReader::VisitParmVarDecl(ParmVarDecl *PD) {
929   VisitVarDecl(PD);
930   unsigned isObjCMethodParam = Record[Idx++];
931   unsigned scopeDepth = Record[Idx++];
932   unsigned scopeIndex = Record[Idx++];
933   unsigned declQualifier = Record[Idx++];
934   if (isObjCMethodParam) {
935     assert(scopeDepth == 0);
936     PD->setObjCMethodScopeInfo(scopeIndex);
937     PD->ParmVarDeclBits.ScopeDepthOrObjCQuals = declQualifier;
938   } else {
939     PD->setScopeInfo(scopeDepth, scopeIndex);
940   }
941   PD->ParmVarDeclBits.IsKNRPromoted = Record[Idx++];
942   PD->ParmVarDeclBits.HasInheritedDefaultArg = Record[Idx++];
943   if (Record[Idx++]) // hasUninstantiatedDefaultArg.
944     PD->setUninstantiatedDefaultArg(Reader.ReadExpr(F));
945 }
946 
947 void ASTDeclReader::VisitFileScopeAsmDecl(FileScopeAsmDecl *AD) {
948   VisitDecl(AD);
949   AD->setAsmString(cast<StringLiteral>(Reader.ReadExpr(F)));
950   AD->setRParenLoc(ReadSourceLocation(Record, Idx));
951 }
952 
953 void ASTDeclReader::VisitBlockDecl(BlockDecl *BD) {
954   VisitDecl(BD);
955   BD->setBody(cast_or_null<CompoundStmt>(Reader.ReadStmt(F)));
956   BD->setSignatureAsWritten(GetTypeSourceInfo(Record, Idx));
957   unsigned NumParams = Record[Idx++];
958   SmallVector<ParmVarDecl *, 16> Params;
959   Params.reserve(NumParams);
960   for (unsigned I = 0; I != NumParams; ++I)
961     Params.push_back(ReadDeclAs<ParmVarDecl>(Record, Idx));
962   BD->setParams(Params);
963 
964   BD->setIsVariadic(Record[Idx++]);
965   BD->setBlockMissingReturnType(Record[Idx++]);
966   BD->setIsConversionFromLambda(Record[Idx++]);
967 
968   bool capturesCXXThis = Record[Idx++];
969   unsigned numCaptures = Record[Idx++];
970   SmallVector<BlockDecl::Capture, 16> captures;
971   captures.reserve(numCaptures);
972   for (unsigned i = 0; i != numCaptures; ++i) {
973     VarDecl *decl = ReadDeclAs<VarDecl>(Record, Idx);
974     unsigned flags = Record[Idx++];
975     bool byRef = (flags & 1);
976     bool nested = (flags & 2);
977     Expr *copyExpr = ((flags & 4) ? Reader.ReadExpr(F) : 0);
978 
979     captures.push_back(BlockDecl::Capture(decl, byRef, nested, copyExpr));
980   }
981   BD->setCaptures(Reader.getContext(), captures.begin(),
982                   captures.end(), capturesCXXThis);
983 }
984 
985 void ASTDeclReader::VisitLinkageSpecDecl(LinkageSpecDecl *D) {
986   VisitDecl(D);
987   D->setLanguage((LinkageSpecDecl::LanguageIDs)Record[Idx++]);
988   D->setExternLoc(ReadSourceLocation(Record, Idx));
989   D->setRBraceLoc(ReadSourceLocation(Record, Idx));
990 }
991 
992 void ASTDeclReader::VisitLabelDecl(LabelDecl *D) {
993   VisitNamedDecl(D);
994   D->setLocStart(ReadSourceLocation(Record, Idx));
995 }
996 
997 
998 void ASTDeclReader::VisitNamespaceDecl(NamespaceDecl *D) {
999   RedeclarableResult Redecl = VisitRedeclarable(D);
1000   VisitNamedDecl(D);
1001   D->setInline(Record[Idx++]);
1002   D->LocStart = ReadSourceLocation(Record, Idx);
1003   D->RBraceLoc = ReadSourceLocation(Record, Idx);
1004   mergeRedeclarable(D, Redecl);
1005 
1006   if (Redecl.getFirstID() == ThisDeclID) {
1007     // Each module has its own anonymous namespace, which is disjoint from
1008     // any other module's anonymous namespaces, so don't attach the anonymous
1009     // namespace at all.
1010     NamespaceDecl *Anon = ReadDeclAs<NamespaceDecl>(Record, Idx);
1011     if (F.Kind != MK_Module)
1012       D->setAnonymousNamespace(Anon);
1013   } else {
1014     // Link this namespace back to the first declaration, which has already
1015     // been deserialized.
1016     D->AnonOrFirstNamespaceAndInline.setPointer(D->getFirstDeclaration());
1017   }
1018 }
1019 
1020 void ASTDeclReader::VisitNamespaceAliasDecl(NamespaceAliasDecl *D) {
1021   VisitNamedDecl(D);
1022   D->NamespaceLoc = ReadSourceLocation(Record, Idx);
1023   D->IdentLoc = ReadSourceLocation(Record, Idx);
1024   D->QualifierLoc = Reader.ReadNestedNameSpecifierLoc(F, Record, Idx);
1025   D->Namespace = ReadDeclAs<NamedDecl>(Record, Idx);
1026 }
1027 
1028 void ASTDeclReader::VisitUsingDecl(UsingDecl *D) {
1029   VisitNamedDecl(D);
1030   D->setUsingLocation(ReadSourceLocation(Record, Idx));
1031   D->QualifierLoc = Reader.ReadNestedNameSpecifierLoc(F, Record, Idx);
1032   ReadDeclarationNameLoc(D->DNLoc, D->getDeclName(), Record, Idx);
1033   D->FirstUsingShadow.setPointer(ReadDeclAs<UsingShadowDecl>(Record, Idx));
1034   D->setTypeName(Record[Idx++]);
1035   if (NamedDecl *Pattern = ReadDeclAs<NamedDecl>(Record, Idx))
1036     Reader.getContext().setInstantiatedFromUsingDecl(D, Pattern);
1037 }
1038 
1039 void ASTDeclReader::VisitUsingShadowDecl(UsingShadowDecl *D) {
1040   VisitNamedDecl(D);
1041   D->setTargetDecl(ReadDeclAs<NamedDecl>(Record, Idx));
1042   D->UsingOrNextShadow = ReadDeclAs<NamedDecl>(Record, Idx);
1043   UsingShadowDecl *Pattern = ReadDeclAs<UsingShadowDecl>(Record, Idx);
1044   if (Pattern)
1045     Reader.getContext().setInstantiatedFromUsingShadowDecl(D, Pattern);
1046 }
1047 
1048 void ASTDeclReader::VisitUsingDirectiveDecl(UsingDirectiveDecl *D) {
1049   VisitNamedDecl(D);
1050   D->UsingLoc = ReadSourceLocation(Record, Idx);
1051   D->NamespaceLoc = ReadSourceLocation(Record, Idx);
1052   D->QualifierLoc = Reader.ReadNestedNameSpecifierLoc(F, Record, Idx);
1053   D->NominatedNamespace = ReadDeclAs<NamedDecl>(Record, Idx);
1054   D->CommonAncestor = ReadDeclAs<DeclContext>(Record, Idx);
1055 }
1056 
1057 void ASTDeclReader::VisitUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *D) {
1058   VisitValueDecl(D);
1059   D->setUsingLoc(ReadSourceLocation(Record, Idx));
1060   D->QualifierLoc = Reader.ReadNestedNameSpecifierLoc(F, Record, Idx);
1061   ReadDeclarationNameLoc(D->DNLoc, D->getDeclName(), Record, Idx);
1062 }
1063 
1064 void ASTDeclReader::VisitUnresolvedUsingTypenameDecl(
1065                                                UnresolvedUsingTypenameDecl *D) {
1066   VisitTypeDecl(D);
1067   D->TypenameLocation = ReadSourceLocation(Record, Idx);
1068   D->QualifierLoc = Reader.ReadNestedNameSpecifierLoc(F, Record, Idx);
1069 }
1070 
1071 void ASTDeclReader::ReadCXXDefinitionData(
1072                                    struct CXXRecordDecl::DefinitionData &Data,
1073                                    const RecordData &Record, unsigned &Idx) {
1074   // Note: the caller has deserialized the IsLambda bit already.
1075   Data.UserDeclaredConstructor = Record[Idx++];
1076   Data.UserDeclaredCopyConstructor = Record[Idx++];
1077   Data.UserDeclaredMoveConstructor = Record[Idx++];
1078   Data.UserDeclaredCopyAssignment = Record[Idx++];
1079   Data.UserDeclaredMoveAssignment = Record[Idx++];
1080   Data.UserDeclaredDestructor = Record[Idx++];
1081   Data.Aggregate = Record[Idx++];
1082   Data.PlainOldData = Record[Idx++];
1083   Data.Empty = Record[Idx++];
1084   Data.Polymorphic = Record[Idx++];
1085   Data.Abstract = Record[Idx++];
1086   Data.IsStandardLayout = Record[Idx++];
1087   Data.HasNoNonEmptyBases = Record[Idx++];
1088   Data.HasPrivateFields = Record[Idx++];
1089   Data.HasProtectedFields = Record[Idx++];
1090   Data.HasPublicFields = Record[Idx++];
1091   Data.HasMutableFields = Record[Idx++];
1092   Data.HasOnlyCMembers = Record[Idx++];
1093   Data.HasInClassInitializer = Record[Idx++];
1094   Data.HasTrivialDefaultConstructor = Record[Idx++];
1095   Data.HasConstexprNonCopyMoveConstructor = Record[Idx++];
1096   Data.DefaultedDefaultConstructorIsConstexpr = Record[Idx++];
1097   Data.HasConstexprDefaultConstructor = Record[Idx++];
1098   Data.HasTrivialCopyConstructor = Record[Idx++];
1099   Data.HasTrivialMoveConstructor = Record[Idx++];
1100   Data.HasTrivialCopyAssignment = Record[Idx++];
1101   Data.HasTrivialMoveAssignment = Record[Idx++];
1102   Data.HasTrivialDestructor = Record[Idx++];
1103   Data.HasIrrelevantDestructor = Record[Idx++];
1104   Data.HasNonLiteralTypeFieldsOrBases = Record[Idx++];
1105   Data.ComputedVisibleConversions = Record[Idx++];
1106   Data.UserProvidedDefaultConstructor = Record[Idx++];
1107   Data.DeclaredDefaultConstructor = Record[Idx++];
1108   Data.DeclaredCopyConstructor = Record[Idx++];
1109   Data.DeclaredMoveConstructor = Record[Idx++];
1110   Data.DeclaredCopyAssignment = Record[Idx++];
1111   Data.DeclaredMoveAssignment = Record[Idx++];
1112   Data.DeclaredDestructor = Record[Idx++];
1113   Data.FailedImplicitMoveConstructor = Record[Idx++];
1114   Data.FailedImplicitMoveAssignment = Record[Idx++];
1115 
1116   Data.NumBases = Record[Idx++];
1117   if (Data.NumBases)
1118     Data.Bases = Reader.readCXXBaseSpecifiers(F, Record, Idx);
1119   Data.NumVBases = Record[Idx++];
1120   if (Data.NumVBases)
1121     Data.VBases = Reader.readCXXBaseSpecifiers(F, Record, Idx);
1122 
1123   Reader.ReadUnresolvedSet(F, Data.Conversions, Record, Idx);
1124   Reader.ReadUnresolvedSet(F, Data.VisibleConversions, Record, Idx);
1125   assert(Data.Definition && "Data.Definition should be already set!");
1126   Data.FirstFriend = ReadDeclAs<FriendDecl>(Record, Idx);
1127 
1128   if (Data.IsLambda) {
1129     typedef LambdaExpr::Capture Capture;
1130     CXXRecordDecl::LambdaDefinitionData &Lambda
1131       = static_cast<CXXRecordDecl::LambdaDefinitionData &>(Data);
1132     Lambda.Dependent = Record[Idx++];
1133     Lambda.NumCaptures = Record[Idx++];
1134     Lambda.NumExplicitCaptures = Record[Idx++];
1135     Lambda.ManglingNumber = Record[Idx++];
1136     Lambda.ContextDecl = ReadDecl(Record, Idx);
1137     Lambda.Captures
1138       = (Capture*)Reader.Context.Allocate(sizeof(Capture)*Lambda.NumCaptures);
1139     Capture *ToCapture = Lambda.Captures;
1140     Lambda.MethodTyInfo = GetTypeSourceInfo(Record, Idx);
1141     for (unsigned I = 0, N = Lambda.NumCaptures; I != N; ++I) {
1142       SourceLocation Loc = ReadSourceLocation(Record, Idx);
1143       bool IsImplicit = Record[Idx++];
1144       LambdaCaptureKind Kind = static_cast<LambdaCaptureKind>(Record[Idx++]);
1145       VarDecl *Var = ReadDeclAs<VarDecl>(Record, Idx);
1146       SourceLocation EllipsisLoc = ReadSourceLocation(Record, Idx);
1147       *ToCapture++ = Capture(Loc, IsImplicit, Kind, Var, EllipsisLoc);
1148     }
1149   }
1150 }
1151 
1152 void ASTDeclReader::VisitCXXRecordDecl(CXXRecordDecl *D) {
1153   VisitRecordDecl(D);
1154 
1155   ASTContext &C = Reader.getContext();
1156   if (Record[Idx++]) {
1157     // Determine whether this is a lambda closure type, so that we can
1158     // allocate the appropriate DefinitionData structure.
1159     bool IsLambda = Record[Idx++];
1160     if (IsLambda)
1161       D->DefinitionData = new (C) CXXRecordDecl::LambdaDefinitionData(D, 0,
1162                                                                       false);
1163     else
1164       D->DefinitionData = new (C) struct CXXRecordDecl::DefinitionData(D);
1165 
1166     // Propagate the DefinitionData pointer to the canonical declaration, so
1167     // that all other deserialized declarations will see it.
1168     // FIXME: Complain if there already is a DefinitionData!
1169     D->getCanonicalDecl()->DefinitionData = D->DefinitionData;
1170 
1171     ReadCXXDefinitionData(*D->DefinitionData, Record, Idx);
1172 
1173     // Note that we have deserialized a definition. Any declarations
1174     // deserialized before this one will be be given the DefinitionData pointer
1175     // at the end.
1176     Reader.PendingDefinitions.insert(D);
1177   } else {
1178     // Propagate DefinitionData pointer from the canonical declaration.
1179     D->DefinitionData = D->getCanonicalDecl()->DefinitionData;
1180   }
1181 
1182   enum CXXRecKind {
1183     CXXRecNotTemplate = 0, CXXRecTemplate, CXXRecMemberSpecialization
1184   };
1185   switch ((CXXRecKind)Record[Idx++]) {
1186   case CXXRecNotTemplate:
1187     break;
1188   case CXXRecTemplate:
1189     D->TemplateOrInstantiation = ReadDeclAs<ClassTemplateDecl>(Record, Idx);
1190     break;
1191   case CXXRecMemberSpecialization: {
1192     CXXRecordDecl *RD = ReadDeclAs<CXXRecordDecl>(Record, Idx);
1193     TemplateSpecializationKind TSK = (TemplateSpecializationKind)Record[Idx++];
1194     SourceLocation POI = ReadSourceLocation(Record, Idx);
1195     MemberSpecializationInfo *MSI = new (C) MemberSpecializationInfo(RD, TSK);
1196     MSI->setPointOfInstantiation(POI);
1197     D->TemplateOrInstantiation = MSI;
1198     break;
1199   }
1200   }
1201 
1202   // Load the key function to avoid deserializing every method so we can
1203   // compute it.
1204   if (D->IsCompleteDefinition) {
1205     if (CXXMethodDecl *Key = ReadDeclAs<CXXMethodDecl>(Record, Idx))
1206       C.KeyFunctions[D] = Key;
1207   }
1208 }
1209 
1210 void ASTDeclReader::VisitCXXMethodDecl(CXXMethodDecl *D) {
1211   VisitFunctionDecl(D);
1212   unsigned NumOverridenMethods = Record[Idx++];
1213   while (NumOverridenMethods--) {
1214     // Avoid invariant checking of CXXMethodDecl::addOverriddenMethod,
1215     // MD may be initializing.
1216     if (CXXMethodDecl *MD = ReadDeclAs<CXXMethodDecl>(Record, Idx))
1217       Reader.getContext().addOverriddenMethod(D, MD);
1218   }
1219 }
1220 
1221 void ASTDeclReader::VisitCXXConstructorDecl(CXXConstructorDecl *D) {
1222   VisitCXXMethodDecl(D);
1223 
1224   D->IsExplicitSpecified = Record[Idx++];
1225   D->ImplicitlyDefined = Record[Idx++];
1226   llvm::tie(D->CtorInitializers, D->NumCtorInitializers)
1227       = Reader.ReadCXXCtorInitializers(F, Record, Idx);
1228 }
1229 
1230 void ASTDeclReader::VisitCXXDestructorDecl(CXXDestructorDecl *D) {
1231   VisitCXXMethodDecl(D);
1232 
1233   D->ImplicitlyDefined = Record[Idx++];
1234   D->OperatorDelete = ReadDeclAs<FunctionDecl>(Record, Idx);
1235 }
1236 
1237 void ASTDeclReader::VisitCXXConversionDecl(CXXConversionDecl *D) {
1238   VisitCXXMethodDecl(D);
1239   D->IsExplicitSpecified = Record[Idx++];
1240 }
1241 
1242 void ASTDeclReader::VisitImportDecl(ImportDecl *D) {
1243   VisitDecl(D);
1244   D->ImportedAndComplete.setPointer(readModule(Record, Idx));
1245   D->ImportedAndComplete.setInt(Record[Idx++]);
1246   SourceLocation *StoredLocs = reinterpret_cast<SourceLocation *>(D + 1);
1247   for (unsigned I = 0, N = Record.back(); I != N; ++I)
1248     StoredLocs[I] = ReadSourceLocation(Record, Idx);
1249   ++Idx; // The number of stored source locations.
1250 }
1251 
1252 void ASTDeclReader::VisitAccessSpecDecl(AccessSpecDecl *D) {
1253   VisitDecl(D);
1254   D->setColonLoc(ReadSourceLocation(Record, Idx));
1255 }
1256 
1257 void ASTDeclReader::VisitFriendDecl(FriendDecl *D) {
1258   VisitDecl(D);
1259   if (Record[Idx++])
1260     D->Friend = GetTypeSourceInfo(Record, Idx);
1261   else
1262     D->Friend = ReadDeclAs<NamedDecl>(Record, Idx);
1263   D->NextFriend = Record[Idx++];
1264   D->UnsupportedFriend = (Record[Idx++] != 0);
1265   D->FriendLoc = ReadSourceLocation(Record, Idx);
1266 }
1267 
1268 void ASTDeclReader::VisitFriendTemplateDecl(FriendTemplateDecl *D) {
1269   VisitDecl(D);
1270   unsigned NumParams = Record[Idx++];
1271   D->NumParams = NumParams;
1272   D->Params = new TemplateParameterList*[NumParams];
1273   for (unsigned i = 0; i != NumParams; ++i)
1274     D->Params[i] = Reader.ReadTemplateParameterList(F, Record, Idx);
1275   if (Record[Idx++]) // HasFriendDecl
1276     D->Friend = ReadDeclAs<NamedDecl>(Record, Idx);
1277   else
1278     D->Friend = GetTypeSourceInfo(Record, Idx);
1279   D->FriendLoc = ReadSourceLocation(Record, Idx);
1280 }
1281 
1282 void ASTDeclReader::VisitTemplateDecl(TemplateDecl *D) {
1283   VisitNamedDecl(D);
1284 
1285   NamedDecl *TemplatedDecl = ReadDeclAs<NamedDecl>(Record, Idx);
1286   TemplateParameterList* TemplateParams
1287       = Reader.ReadTemplateParameterList(F, Record, Idx);
1288   D->init(TemplatedDecl, TemplateParams);
1289 }
1290 
1291 ASTDeclReader::RedeclarableResult
1292 ASTDeclReader::VisitRedeclarableTemplateDecl(RedeclarableTemplateDecl *D) {
1293   RedeclarableResult Redecl = VisitRedeclarable(D);
1294 
1295   // Make sure we've allocated the Common pointer first. We do this before
1296   // VisitTemplateDecl so that getCommonPtr() can be used during initialization.
1297   RedeclarableTemplateDecl *CanonD = D->getCanonicalDecl();
1298   if (!CanonD->Common) {
1299     CanonD->Common = CanonD->newCommon(Reader.getContext());
1300     Reader.PendingDefinitions.insert(CanonD);
1301   }
1302   D->Common = CanonD->Common;
1303 
1304   // If this is the first declaration of the template, fill in the information
1305   // for the 'common' pointer.
1306   if (ThisDeclID == Redecl.getFirstID()) {
1307     if (RedeclarableTemplateDecl *RTD
1308           = ReadDeclAs<RedeclarableTemplateDecl>(Record, Idx)) {
1309       assert(RTD->getKind() == D->getKind() &&
1310              "InstantiatedFromMemberTemplate kind mismatch");
1311       D->setInstantiatedFromMemberTemplate(RTD);
1312       if (Record[Idx++])
1313         D->setMemberSpecialization();
1314     }
1315   }
1316 
1317   VisitTemplateDecl(D);
1318   D->IdentifierNamespace = Record[Idx++];
1319 
1320   mergeRedeclarable(D, Redecl);
1321 
1322   return Redecl;
1323 }
1324 
1325 void ASTDeclReader::VisitClassTemplateDecl(ClassTemplateDecl *D) {
1326   RedeclarableResult Redecl = VisitRedeclarableTemplateDecl(D);
1327 
1328   if (ThisDeclID == Redecl.getFirstID()) {
1329     // This ClassTemplateDecl owns a CommonPtr; read it to keep track of all of
1330     // the specializations.
1331     SmallVector<serialization::DeclID, 2> SpecIDs;
1332     SpecIDs.push_back(0);
1333 
1334     // Specializations.
1335     unsigned Size = Record[Idx++];
1336     SpecIDs[0] += Size;
1337     for (unsigned I = 0; I != Size; ++I)
1338       SpecIDs.push_back(ReadDeclID(Record, Idx));
1339 
1340     // Partial specializations.
1341     Size = Record[Idx++];
1342     SpecIDs[0] += Size;
1343     for (unsigned I = 0; I != Size; ++I)
1344       SpecIDs.push_back(ReadDeclID(Record, Idx));
1345 
1346     if (SpecIDs[0]) {
1347       typedef serialization::DeclID DeclID;
1348 
1349       ClassTemplateDecl::Common *CommonPtr = D->getCommonPtr();
1350       // FIXME: Append specializations!
1351       CommonPtr->LazySpecializations
1352         = new (Reader.getContext()) DeclID [SpecIDs.size()];
1353       memcpy(CommonPtr->LazySpecializations, SpecIDs.data(),
1354              SpecIDs.size() * sizeof(DeclID));
1355     }
1356 
1357     // InjectedClassNameType is computed.
1358   }
1359 }
1360 
1361 void ASTDeclReader::VisitClassTemplateSpecializationDecl(
1362                                            ClassTemplateSpecializationDecl *D) {
1363   VisitCXXRecordDecl(D);
1364 
1365   ASTContext &C = Reader.getContext();
1366   if (Decl *InstD = ReadDecl(Record, Idx)) {
1367     if (ClassTemplateDecl *CTD = dyn_cast<ClassTemplateDecl>(InstD)) {
1368       D->SpecializedTemplate = CTD;
1369     } else {
1370       SmallVector<TemplateArgument, 8> TemplArgs;
1371       Reader.ReadTemplateArgumentList(TemplArgs, F, Record, Idx);
1372       TemplateArgumentList *ArgList
1373         = TemplateArgumentList::CreateCopy(C, TemplArgs.data(),
1374                                            TemplArgs.size());
1375       ClassTemplateSpecializationDecl::SpecializedPartialSpecialization *PS
1376           = new (C) ClassTemplateSpecializationDecl::
1377                                              SpecializedPartialSpecialization();
1378       PS->PartialSpecialization
1379           = cast<ClassTemplatePartialSpecializationDecl>(InstD);
1380       PS->TemplateArgs = ArgList;
1381       D->SpecializedTemplate = PS;
1382     }
1383   }
1384 
1385   // Explicit info.
1386   if (TypeSourceInfo *TyInfo = GetTypeSourceInfo(Record, Idx)) {
1387     ClassTemplateSpecializationDecl::ExplicitSpecializationInfo *ExplicitInfo
1388         = new (C) ClassTemplateSpecializationDecl::ExplicitSpecializationInfo;
1389     ExplicitInfo->TypeAsWritten = TyInfo;
1390     ExplicitInfo->ExternLoc = ReadSourceLocation(Record, Idx);
1391     ExplicitInfo->TemplateKeywordLoc = ReadSourceLocation(Record, Idx);
1392     D->ExplicitInfo = ExplicitInfo;
1393   }
1394 
1395   SmallVector<TemplateArgument, 8> TemplArgs;
1396   Reader.ReadTemplateArgumentList(TemplArgs, F, Record, Idx);
1397   D->TemplateArgs = TemplateArgumentList::CreateCopy(C, TemplArgs.data(),
1398                                                      TemplArgs.size());
1399   D->PointOfInstantiation = ReadSourceLocation(Record, Idx);
1400   D->SpecializationKind = (TemplateSpecializationKind)Record[Idx++];
1401 
1402   bool writtenAsCanonicalDecl = Record[Idx++];
1403   if (writtenAsCanonicalDecl) {
1404     ClassTemplateDecl *CanonPattern = ReadDeclAs<ClassTemplateDecl>(Record,Idx);
1405     if (D->isCanonicalDecl()) { // It's kept in the folding set.
1406       if (ClassTemplatePartialSpecializationDecl *Partial
1407                         = dyn_cast<ClassTemplatePartialSpecializationDecl>(D)) {
1408   CanonPattern->getCommonPtr()->PartialSpecializations.GetOrInsertNode(Partial);
1409       } else {
1410         CanonPattern->getCommonPtr()->Specializations.GetOrInsertNode(D);
1411       }
1412     }
1413   }
1414 }
1415 
1416 void ASTDeclReader::VisitClassTemplatePartialSpecializationDecl(
1417                                     ClassTemplatePartialSpecializationDecl *D) {
1418   VisitClassTemplateSpecializationDecl(D);
1419 
1420   ASTContext &C = Reader.getContext();
1421   D->TemplateParams = Reader.ReadTemplateParameterList(F, Record, Idx);
1422 
1423   unsigned NumArgs = Record[Idx++];
1424   if (NumArgs) {
1425     D->NumArgsAsWritten = NumArgs;
1426     D->ArgsAsWritten = new (C) TemplateArgumentLoc[NumArgs];
1427     for (unsigned i=0; i != NumArgs; ++i)
1428       D->ArgsAsWritten[i] = Reader.ReadTemplateArgumentLoc(F, Record, Idx);
1429   }
1430 
1431   D->SequenceNumber = Record[Idx++];
1432 
1433   // These are read/set from/to the first declaration.
1434   if (D->getPreviousDecl() == 0) {
1435     D->InstantiatedFromMember.setPointer(
1436       ReadDeclAs<ClassTemplatePartialSpecializationDecl>(Record, Idx));
1437     D->InstantiatedFromMember.setInt(Record[Idx++]);
1438   }
1439 }
1440 
1441 void ASTDeclReader::VisitClassScopeFunctionSpecializationDecl(
1442                                     ClassScopeFunctionSpecializationDecl *D) {
1443   VisitDecl(D);
1444   D->Specialization = ReadDeclAs<CXXMethodDecl>(Record, Idx);
1445 }
1446 
1447 void ASTDeclReader::VisitFunctionTemplateDecl(FunctionTemplateDecl *D) {
1448   RedeclarableResult Redecl = VisitRedeclarableTemplateDecl(D);
1449 
1450   if (ThisDeclID == Redecl.getFirstID()) {
1451     // This FunctionTemplateDecl owns a CommonPtr; read it.
1452 
1453     // Read the function specialization declarations.
1454     // FunctionTemplateDecl's FunctionTemplateSpecializationInfos are filled
1455     // when reading the specialized FunctionDecl.
1456     unsigned NumSpecs = Record[Idx++];
1457     while (NumSpecs--)
1458       (void)ReadDecl(Record, Idx);
1459   }
1460 }
1461 
1462 void ASTDeclReader::VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D) {
1463   VisitTypeDecl(D);
1464 
1465   D->setDeclaredWithTypename(Record[Idx++]);
1466 
1467   bool Inherited = Record[Idx++];
1468   TypeSourceInfo *DefArg = GetTypeSourceInfo(Record, Idx);
1469   D->setDefaultArgument(DefArg, Inherited);
1470 }
1471 
1472 void ASTDeclReader::VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D) {
1473   VisitDeclaratorDecl(D);
1474   // TemplateParmPosition.
1475   D->setDepth(Record[Idx++]);
1476   D->setPosition(Record[Idx++]);
1477   if (D->isExpandedParameterPack()) {
1478     void **Data = reinterpret_cast<void **>(D + 1);
1479     for (unsigned I = 0, N = D->getNumExpansionTypes(); I != N; ++I) {
1480       Data[2*I] = Reader.readType(F, Record, Idx).getAsOpaquePtr();
1481       Data[2*I + 1] = GetTypeSourceInfo(Record, Idx);
1482     }
1483   } else {
1484     // Rest of NonTypeTemplateParmDecl.
1485     D->ParameterPack = Record[Idx++];
1486     if (Record[Idx++]) {
1487       Expr *DefArg = Reader.ReadExpr(F);
1488       bool Inherited = Record[Idx++];
1489       D->setDefaultArgument(DefArg, Inherited);
1490    }
1491   }
1492 }
1493 
1494 void ASTDeclReader::VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D) {
1495   VisitTemplateDecl(D);
1496   // TemplateParmPosition.
1497   D->setDepth(Record[Idx++]);
1498   D->setPosition(Record[Idx++]);
1499   if (D->isExpandedParameterPack()) {
1500     void **Data = reinterpret_cast<void **>(D + 1);
1501     for (unsigned I = 0, N = D->getNumExpansionTemplateParameters();
1502          I != N; ++I)
1503       Data[I] = Reader.ReadTemplateParameterList(F, Record, Idx);
1504   } else {
1505     // Rest of TemplateTemplateParmDecl.
1506     TemplateArgumentLoc Arg = Reader.ReadTemplateArgumentLoc(F, Record, Idx);
1507     bool IsInherited = Record[Idx++];
1508     D->setDefaultArgument(Arg, IsInherited);
1509     D->ParameterPack = Record[Idx++];
1510   }
1511 }
1512 
1513 void ASTDeclReader::VisitTypeAliasTemplateDecl(TypeAliasTemplateDecl *D) {
1514   VisitRedeclarableTemplateDecl(D);
1515 }
1516 
1517 void ASTDeclReader::VisitStaticAssertDecl(StaticAssertDecl *D) {
1518   VisitDecl(D);
1519   D->AssertExprAndFailed.setPointer(Reader.ReadExpr(F));
1520   D->AssertExprAndFailed.setInt(Record[Idx++]);
1521   D->Message = cast<StringLiteral>(Reader.ReadExpr(F));
1522   D->RParenLoc = ReadSourceLocation(Record, Idx);
1523 }
1524 
1525 std::pair<uint64_t, uint64_t>
1526 ASTDeclReader::VisitDeclContext(DeclContext *DC) {
1527   uint64_t LexicalOffset = Record[Idx++];
1528   uint64_t VisibleOffset = Record[Idx++];
1529   return std::make_pair(LexicalOffset, VisibleOffset);
1530 }
1531 
1532 template <typename T>
1533 ASTDeclReader::RedeclarableResult
1534 ASTDeclReader::VisitRedeclarable(Redeclarable<T> *D) {
1535   DeclID FirstDeclID = ReadDeclID(Record, Idx);
1536 
1537   // 0 indicates that this declaration was the only declaration of its entity,
1538   // and is used for space optimization.
1539   if (FirstDeclID == 0)
1540     FirstDeclID = ThisDeclID;
1541 
1542   T *FirstDecl = cast_or_null<T>(Reader.GetDecl(FirstDeclID));
1543   if (FirstDecl != D) {
1544     // We delay loading of the redeclaration chain to avoid deeply nested calls.
1545     // We temporarily set the first (canonical) declaration as the previous one
1546     // which is the one that matters and mark the real previous DeclID to be
1547     // loaded & attached later on.
1548     D->RedeclLink = Redeclarable<T>::PreviousDeclLink(FirstDecl);
1549   }
1550 
1551   // Note that this declaration has been deserialized.
1552   Reader.RedeclsDeserialized.insert(static_cast<T *>(D));
1553 
1554   // The result structure takes care to note that we need to load the
1555   // other declaration chains for this ID.
1556   return RedeclarableResult(Reader, FirstDeclID);
1557 }
1558 
1559 /// \brief Attempts to merge the given declaration (D) with another declaration
1560 /// of the same entity.
1561 template<typename T>
1562 void ASTDeclReader::mergeRedeclarable(Redeclarable<T> *D,
1563                                       RedeclarableResult &Redecl) {
1564   // If modules are not available, there is no reason to perform this merge.
1565   if (!Reader.getContext().getLangOpts().Modules)
1566     return;
1567 
1568   if (FindExistingResult ExistingRes = findExisting(static_cast<T*>(D))) {
1569     if (T *Existing = ExistingRes) {
1570       T *ExistingCanon = Existing->getCanonicalDecl();
1571       T *DCanon = static_cast<T*>(D)->getCanonicalDecl();
1572       if (ExistingCanon != DCanon) {
1573         // Have our redeclaration link point back at the canonical declaration
1574         // of the existing declaration, so that this declaration has the
1575         // appropriate canonical declaration.
1576         D->RedeclLink = Redeclarable<T>::PreviousDeclLink(ExistingCanon);
1577 
1578         // When we merge a namespace, update its pointer to the first namespace.
1579         if (NamespaceDecl *Namespace
1580               = dyn_cast<NamespaceDecl>(static_cast<T*>(D))) {
1581           Namespace->AnonOrFirstNamespaceAndInline.setPointer(
1582             static_cast<NamespaceDecl *>(static_cast<void*>(ExistingCanon)));
1583         }
1584 
1585         // Don't introduce DCanon into the set of pending declaration chains.
1586         Redecl.suppress();
1587 
1588         // Introduce ExistingCanon into the set of pending declaration chains,
1589         // if in fact it came from a module file.
1590         if (ExistingCanon->isFromASTFile()) {
1591           GlobalDeclID ExistingCanonID = ExistingCanon->getGlobalID();
1592           assert(ExistingCanonID && "Unrecorded canonical declaration ID?");
1593           if (Reader.PendingDeclChainsKnown.insert(ExistingCanonID))
1594             Reader.PendingDeclChains.push_back(ExistingCanonID);
1595         }
1596 
1597         // If this declaration was the canonical declaration, make a note of
1598         // that. We accept the linear algorithm here because the number of
1599         // unique canonical declarations of an entity should always be tiny.
1600         if (DCanon == static_cast<T*>(D)) {
1601           SmallVectorImpl<DeclID> &Merged = Reader.MergedDecls[ExistingCanon];
1602           if (std::find(Merged.begin(), Merged.end(), Redecl.getFirstID())
1603                 == Merged.end())
1604             Merged.push_back(Redecl.getFirstID());
1605 
1606           // If ExistingCanon did not come from a module file, introduce the
1607           // first declaration that *does* come from a module file to the
1608           // set of pending declaration chains, so that we merge this
1609           // declaration.
1610           if (!ExistingCanon->isFromASTFile() &&
1611               Reader.PendingDeclChainsKnown.insert(Redecl.getFirstID()))
1612             Reader.PendingDeclChains.push_back(Merged[0]);
1613         }
1614       }
1615     }
1616   }
1617 }
1618 
1619 //===----------------------------------------------------------------------===//
1620 // Attribute Reading
1621 //===----------------------------------------------------------------------===//
1622 
1623 /// \brief Reads attributes from the current stream position.
1624 void ASTReader::ReadAttributes(ModuleFile &F, AttrVec &Attrs,
1625                                const RecordData &Record, unsigned &Idx) {
1626   for (unsigned i = 0, e = Record[Idx++]; i != e; ++i) {
1627     Attr *New = 0;
1628     attr::Kind Kind = (attr::Kind)Record[Idx++];
1629     SourceRange Range = ReadSourceRange(F, Record, Idx);
1630 
1631 #include "clang/Serialization/AttrPCHRead.inc"
1632 
1633     assert(New && "Unable to decode attribute?");
1634     Attrs.push_back(New);
1635   }
1636 }
1637 
1638 //===----------------------------------------------------------------------===//
1639 // ASTReader Implementation
1640 //===----------------------------------------------------------------------===//
1641 
1642 /// \brief Note that we have loaded the declaration with the given
1643 /// Index.
1644 ///
1645 /// This routine notes that this declaration has already been loaded,
1646 /// so that future GetDecl calls will return this declaration rather
1647 /// than trying to load a new declaration.
1648 inline void ASTReader::LoadedDecl(unsigned Index, Decl *D) {
1649   assert(!DeclsLoaded[Index] && "Decl loaded twice?");
1650   DeclsLoaded[Index] = D;
1651 }
1652 
1653 
1654 /// \brief Determine whether the consumer will be interested in seeing
1655 /// this declaration (via HandleTopLevelDecl).
1656 ///
1657 /// This routine should return true for anything that might affect
1658 /// code generation, e.g., inline function definitions, Objective-C
1659 /// declarations with metadata, etc.
1660 static bool isConsumerInterestedIn(Decl *D) {
1661   // An ObjCMethodDecl is never considered as "interesting" because its
1662   // implementation container always is.
1663 
1664   if (isa<FileScopeAsmDecl>(D) ||
1665       isa<ObjCProtocolDecl>(D) ||
1666       isa<ObjCImplDecl>(D))
1667     return true;
1668   if (VarDecl *Var = dyn_cast<VarDecl>(D))
1669     return Var->isFileVarDecl() &&
1670            Var->isThisDeclarationADefinition() == VarDecl::Definition;
1671   if (FunctionDecl *Func = dyn_cast<FunctionDecl>(D))
1672     return Func->doesThisDeclarationHaveABody();
1673 
1674   return false;
1675 }
1676 
1677 /// \brief Get the correct cursor and offset for loading a declaration.
1678 ASTReader::RecordLocation
1679 ASTReader::DeclCursorForID(DeclID ID, unsigned &RawLocation) {
1680   // See if there's an override.
1681   DeclReplacementMap::iterator It = ReplacedDecls.find(ID);
1682   if (It != ReplacedDecls.end()) {
1683     RawLocation = It->second.RawLoc;
1684     return RecordLocation(It->second.Mod, It->second.Offset);
1685   }
1686 
1687   GlobalDeclMapType::iterator I = GlobalDeclMap.find(ID);
1688   assert(I != GlobalDeclMap.end() && "Corrupted global declaration map");
1689   ModuleFile *M = I->second;
1690   const DeclOffset &
1691     DOffs =  M->DeclOffsets[ID - M->BaseDeclID - NUM_PREDEF_DECL_IDS];
1692   RawLocation = DOffs.Loc;
1693   return RecordLocation(M, DOffs.BitOffset);
1694 }
1695 
1696 ASTReader::RecordLocation ASTReader::getLocalBitOffset(uint64_t GlobalOffset) {
1697   ContinuousRangeMap<uint64_t, ModuleFile*, 4>::iterator I
1698     = GlobalBitOffsetsMap.find(GlobalOffset);
1699 
1700   assert(I != GlobalBitOffsetsMap.end() && "Corrupted global bit offsets map");
1701   return RecordLocation(I->second, GlobalOffset - I->second->GlobalBitOffset);
1702 }
1703 
1704 uint64_t ASTReader::getGlobalBitOffset(ModuleFile &M, uint32_t LocalOffset) {
1705   return LocalOffset + M.GlobalBitOffset;
1706 }
1707 
1708 /// \brief Determine whether the two declarations refer to the same entity.
1709 static bool isSameEntity(NamedDecl *X, NamedDecl *Y) {
1710   assert(X->getDeclName() == Y->getDeclName() && "Declaration name mismatch!");
1711 
1712   if (X == Y)
1713     return true;
1714 
1715   // Must be in the same context.
1716   if (!X->getDeclContext()->getRedeclContext()->Equals(
1717          Y->getDeclContext()->getRedeclContext()))
1718     return false;
1719 
1720   // Two typedefs refer to the same entity if they have the same underlying
1721   // type.
1722   if (TypedefNameDecl *TypedefX = dyn_cast<TypedefNameDecl>(X))
1723     if (TypedefNameDecl *TypedefY = dyn_cast<TypedefNameDecl>(Y))
1724       return X->getASTContext().hasSameType(TypedefX->getUnderlyingType(),
1725                                             TypedefY->getUnderlyingType());
1726 
1727   // Must have the same kind.
1728   if (X->getKind() != Y->getKind())
1729     return false;
1730 
1731   // Objective-C classes and protocols with the same name always match.
1732   if (isa<ObjCInterfaceDecl>(X) || isa<ObjCProtocolDecl>(X))
1733     return true;
1734 
1735   // Compatible tags match.
1736   if (TagDecl *TagX = dyn_cast<TagDecl>(X)) {
1737     TagDecl *TagY = cast<TagDecl>(Y);
1738     return (TagX->getTagKind() == TagY->getTagKind()) ||
1739       ((TagX->getTagKind() == TTK_Struct || TagX->getTagKind() == TTK_Class ||
1740         TagX->getTagKind() == TTK_Interface) &&
1741        (TagY->getTagKind() == TTK_Struct || TagY->getTagKind() == TTK_Class ||
1742         TagY->getTagKind() == TTK_Interface));
1743   }
1744 
1745   // Functions with the same type and linkage match.
1746   // FIXME: This needs to cope with function templates, merging of
1747   //prototyped/non-prototyped functions, etc.
1748   if (FunctionDecl *FuncX = dyn_cast<FunctionDecl>(X)) {
1749     FunctionDecl *FuncY = cast<FunctionDecl>(Y);
1750     return (FuncX->getLinkage() == FuncY->getLinkage()) &&
1751       FuncX->getASTContext().hasSameType(FuncX->getType(), FuncY->getType());
1752   }
1753 
1754   // Variables with the same type and linkage match.
1755   if (VarDecl *VarX = dyn_cast<VarDecl>(X)) {
1756     VarDecl *VarY = cast<VarDecl>(Y);
1757     return (VarX->getLinkage() == VarY->getLinkage()) &&
1758       VarX->getASTContext().hasSameType(VarX->getType(), VarY->getType());
1759   }
1760 
1761   // Namespaces with the same name and inlinedness match.
1762   if (NamespaceDecl *NamespaceX = dyn_cast<NamespaceDecl>(X)) {
1763     NamespaceDecl *NamespaceY = cast<NamespaceDecl>(Y);
1764     return NamespaceX->isInline() == NamespaceY->isInline();
1765   }
1766 
1767   // Identical template names and kinds match.
1768   if (isa<TemplateDecl>(X))
1769     return true;
1770 
1771   // FIXME: Many other cases to implement.
1772   return false;
1773 }
1774 
1775 ASTDeclReader::FindExistingResult::~FindExistingResult() {
1776   if (!AddResult || Existing)
1777     return;
1778 
1779   DeclContext *DC = New->getLexicalDeclContext();
1780   if (DC->isTranslationUnit() && Reader.SemaObj) {
1781     if (Reader.SemaObj->IdResolver.tryAddTopLevelDecl(New, New->getDeclName()))
1782       Reader.RedeclsAddedToAST.insert(New);
1783   } else if (DC->isNamespace()) {
1784     DC->addDecl(New);
1785     Reader.RedeclsAddedToAST.insert(New);
1786   }
1787 }
1788 
1789 ASTDeclReader::FindExistingResult ASTDeclReader::findExisting(NamedDecl *D) {
1790   DeclarationName Name = D->getDeclName();
1791   if (!Name) {
1792     // Don't bother trying to find unnamed declarations.
1793     FindExistingResult Result(Reader, D, /*Existing=*/0);
1794     Result.suppress();
1795     return Result;
1796   }
1797 
1798   DeclContext *DC = D->getDeclContext()->getRedeclContext();
1799   if (!DC->isFileContext())
1800     return FindExistingResult(Reader);
1801 
1802   if (DC->isTranslationUnit() && Reader.SemaObj) {
1803     IdentifierResolver &IdResolver = Reader.SemaObj->IdResolver;
1804     for (IdentifierResolver::iterator I = IdResolver.begin(Name),
1805                                    IEnd = IdResolver.end();
1806          I != IEnd; ++I) {
1807       if (isSameEntity(*I, D))
1808         return FindExistingResult(Reader, D, *I);
1809     }
1810   }
1811 
1812   if (DC->isNamespace()) {
1813     for (DeclContext::lookup_result R = DC->lookup(Name);
1814          R.first != R.second; ++R.first) {
1815       if (isSameEntity(*R.first, D))
1816         return FindExistingResult(Reader, D, *R.first);
1817     }
1818   }
1819 
1820   return FindExistingResult(Reader, D, /*Existing=*/0);
1821 }
1822 
1823 void ASTDeclReader::attachPreviousDecl(Decl *D, Decl *previous) {
1824   assert(D && previous);
1825   if (TagDecl *TD = dyn_cast<TagDecl>(D)) {
1826     TD->RedeclLink.setNext(cast<TagDecl>(previous));
1827   } else if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
1828     FD->RedeclLink.setNext(cast<FunctionDecl>(previous));
1829   } else if (VarDecl *VD = dyn_cast<VarDecl>(D)) {
1830     VD->RedeclLink.setNext(cast<VarDecl>(previous));
1831   } else if (TypedefNameDecl *TD = dyn_cast<TypedefNameDecl>(D)) {
1832     TD->RedeclLink.setNext(cast<TypedefNameDecl>(previous));
1833   } else if (ObjCInterfaceDecl *ID = dyn_cast<ObjCInterfaceDecl>(D)) {
1834     ID->RedeclLink.setNext(cast<ObjCInterfaceDecl>(previous));
1835   } else if (ObjCProtocolDecl *PD = dyn_cast<ObjCProtocolDecl>(D)) {
1836     PD->RedeclLink.setNext(cast<ObjCProtocolDecl>(previous));
1837   } else if (NamespaceDecl *ND = dyn_cast<NamespaceDecl>(D)) {
1838     ND->RedeclLink.setNext(cast<NamespaceDecl>(previous));
1839   } else {
1840     RedeclarableTemplateDecl *TD = cast<RedeclarableTemplateDecl>(D);
1841     TD->RedeclLink.setNext(cast<RedeclarableTemplateDecl>(previous));
1842   }
1843 }
1844 
1845 void ASTDeclReader::attachLatestDecl(Decl *D, Decl *Latest) {
1846   assert(D && Latest);
1847   if (TagDecl *TD = dyn_cast<TagDecl>(D)) {
1848     TD->RedeclLink
1849       = Redeclarable<TagDecl>::LatestDeclLink(cast<TagDecl>(Latest));
1850   } else if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
1851     FD->RedeclLink
1852       = Redeclarable<FunctionDecl>::LatestDeclLink(cast<FunctionDecl>(Latest));
1853   } else if (VarDecl *VD = dyn_cast<VarDecl>(D)) {
1854     VD->RedeclLink
1855       = Redeclarable<VarDecl>::LatestDeclLink(cast<VarDecl>(Latest));
1856   } else if (TypedefNameDecl *TD = dyn_cast<TypedefNameDecl>(D)) {
1857     TD->RedeclLink
1858       = Redeclarable<TypedefNameDecl>::LatestDeclLink(
1859                                                 cast<TypedefNameDecl>(Latest));
1860   } else if (ObjCInterfaceDecl *ID = dyn_cast<ObjCInterfaceDecl>(D)) {
1861     ID->RedeclLink
1862       = Redeclarable<ObjCInterfaceDecl>::LatestDeclLink(
1863                                               cast<ObjCInterfaceDecl>(Latest));
1864   } else if (ObjCProtocolDecl *PD = dyn_cast<ObjCProtocolDecl>(D)) {
1865     PD->RedeclLink
1866       = Redeclarable<ObjCProtocolDecl>::LatestDeclLink(
1867                                                 cast<ObjCProtocolDecl>(Latest));
1868   } else if (NamespaceDecl *ND = dyn_cast<NamespaceDecl>(D)) {
1869     ND->RedeclLink
1870       = Redeclarable<NamespaceDecl>::LatestDeclLink(
1871                                                    cast<NamespaceDecl>(Latest));
1872   } else {
1873     RedeclarableTemplateDecl *TD = cast<RedeclarableTemplateDecl>(D);
1874     TD->RedeclLink
1875       = Redeclarable<RedeclarableTemplateDecl>::LatestDeclLink(
1876                                         cast<RedeclarableTemplateDecl>(Latest));
1877   }
1878 }
1879 
1880 ASTReader::MergedDeclsMap::iterator
1881 ASTReader::combineStoredMergedDecls(Decl *Canon, GlobalDeclID CanonID) {
1882   // If we don't have any stored merged declarations, just look in the
1883   // merged declarations set.
1884   StoredMergedDeclsMap::iterator StoredPos = StoredMergedDecls.find(CanonID);
1885   if (StoredPos == StoredMergedDecls.end())
1886     return MergedDecls.find(Canon);
1887 
1888   // Append the stored merged declarations to the merged declarations set.
1889   MergedDeclsMap::iterator Pos = MergedDecls.find(Canon);
1890   if (Pos == MergedDecls.end())
1891     Pos = MergedDecls.insert(std::make_pair(Canon,
1892                                             SmallVector<DeclID, 2>())).first;
1893   Pos->second.append(StoredPos->second.begin(), StoredPos->second.end());
1894   StoredMergedDecls.erase(StoredPos);
1895 
1896   // Sort and uniquify the set of merged declarations.
1897   llvm::array_pod_sort(Pos->second.begin(), Pos->second.end());
1898   Pos->second.erase(std::unique(Pos->second.begin(), Pos->second.end()),
1899                     Pos->second.end());
1900   return Pos;
1901 }
1902 
1903 void ASTReader::loadAndAttachPreviousDecl(Decl *D, serialization::DeclID ID) {
1904   Decl *previous = GetDecl(ID);
1905   ASTDeclReader::attachPreviousDecl(D, previous);
1906 }
1907 
1908 /// \brief Read the declaration at the given offset from the AST file.
1909 Decl *ASTReader::ReadDeclRecord(DeclID ID) {
1910   unsigned Index = ID - NUM_PREDEF_DECL_IDS;
1911   unsigned RawLocation = 0;
1912   RecordLocation Loc = DeclCursorForID(ID, RawLocation);
1913   llvm::BitstreamCursor &DeclsCursor = Loc.F->DeclsCursor;
1914   // Keep track of where we are in the stream, then jump back there
1915   // after reading this declaration.
1916   SavedStreamPosition SavedPosition(DeclsCursor);
1917 
1918   ReadingKindTracker ReadingKind(Read_Decl, *this);
1919 
1920   // Note that we are loading a declaration record.
1921   Deserializing ADecl(this);
1922 
1923   DeclsCursor.JumpToBit(Loc.Offset);
1924   RecordData Record;
1925   unsigned Code = DeclsCursor.ReadCode();
1926   unsigned Idx = 0;
1927   ASTDeclReader Reader(*this, *Loc.F, ID, RawLocation, Record,Idx);
1928 
1929   Decl *D = 0;
1930   switch ((DeclCode)DeclsCursor.ReadRecord(Code, Record)) {
1931   case DECL_CONTEXT_LEXICAL:
1932   case DECL_CONTEXT_VISIBLE:
1933     llvm_unreachable("Record cannot be de-serialized with ReadDeclRecord");
1934   case DECL_TYPEDEF:
1935     D = TypedefDecl::CreateDeserialized(Context, ID);
1936     break;
1937   case DECL_TYPEALIAS:
1938     D = TypeAliasDecl::CreateDeserialized(Context, ID);
1939     break;
1940   case DECL_ENUM:
1941     D = EnumDecl::CreateDeserialized(Context, ID);
1942     break;
1943   case DECL_RECORD:
1944     D = RecordDecl::CreateDeserialized(Context, ID);
1945     break;
1946   case DECL_ENUM_CONSTANT:
1947     D = EnumConstantDecl::CreateDeserialized(Context, ID);
1948     break;
1949   case DECL_FUNCTION:
1950     D = FunctionDecl::CreateDeserialized(Context, ID);
1951     break;
1952   case DECL_LINKAGE_SPEC:
1953     D = LinkageSpecDecl::CreateDeserialized(Context, ID);
1954     break;
1955   case DECL_LABEL:
1956     D = LabelDecl::CreateDeserialized(Context, ID);
1957     break;
1958   case DECL_NAMESPACE:
1959     D = NamespaceDecl::CreateDeserialized(Context, ID);
1960     break;
1961   case DECL_NAMESPACE_ALIAS:
1962     D = NamespaceAliasDecl::CreateDeserialized(Context, ID);
1963     break;
1964   case DECL_USING:
1965     D = UsingDecl::CreateDeserialized(Context, ID);
1966     break;
1967   case DECL_USING_SHADOW:
1968     D = UsingShadowDecl::CreateDeserialized(Context, ID);
1969     break;
1970   case DECL_USING_DIRECTIVE:
1971     D = UsingDirectiveDecl::CreateDeserialized(Context, ID);
1972     break;
1973   case DECL_UNRESOLVED_USING_VALUE:
1974     D = UnresolvedUsingValueDecl::CreateDeserialized(Context, ID);
1975     break;
1976   case DECL_UNRESOLVED_USING_TYPENAME:
1977     D = UnresolvedUsingTypenameDecl::CreateDeserialized(Context, ID);
1978     break;
1979   case DECL_CXX_RECORD:
1980     D = CXXRecordDecl::CreateDeserialized(Context, ID);
1981     break;
1982   case DECL_CXX_METHOD:
1983     D = CXXMethodDecl::CreateDeserialized(Context, ID);
1984     break;
1985   case DECL_CXX_CONSTRUCTOR:
1986     D = CXXConstructorDecl::CreateDeserialized(Context, ID);
1987     break;
1988   case DECL_CXX_DESTRUCTOR:
1989     D = CXXDestructorDecl::CreateDeserialized(Context, ID);
1990     break;
1991   case DECL_CXX_CONVERSION:
1992     D = CXXConversionDecl::CreateDeserialized(Context, ID);
1993     break;
1994   case DECL_ACCESS_SPEC:
1995     D = AccessSpecDecl::CreateDeserialized(Context, ID);
1996     break;
1997   case DECL_FRIEND:
1998     D = FriendDecl::CreateDeserialized(Context, ID);
1999     break;
2000   case DECL_FRIEND_TEMPLATE:
2001     D = FriendTemplateDecl::CreateDeserialized(Context, ID);
2002     break;
2003   case DECL_CLASS_TEMPLATE:
2004     D = ClassTemplateDecl::CreateDeserialized(Context, ID);
2005     break;
2006   case DECL_CLASS_TEMPLATE_SPECIALIZATION:
2007     D = ClassTemplateSpecializationDecl::CreateDeserialized(Context, ID);
2008     break;
2009   case DECL_CLASS_TEMPLATE_PARTIAL_SPECIALIZATION:
2010     D = ClassTemplatePartialSpecializationDecl::CreateDeserialized(Context, ID);
2011     break;
2012   case DECL_CLASS_SCOPE_FUNCTION_SPECIALIZATION:
2013     D = ClassScopeFunctionSpecializationDecl::CreateDeserialized(Context, ID);
2014     break;
2015   case DECL_FUNCTION_TEMPLATE:
2016     D = FunctionTemplateDecl::CreateDeserialized(Context, ID);
2017     break;
2018   case DECL_TEMPLATE_TYPE_PARM:
2019     D = TemplateTypeParmDecl::CreateDeserialized(Context, ID);
2020     break;
2021   case DECL_NON_TYPE_TEMPLATE_PARM:
2022     D = NonTypeTemplateParmDecl::CreateDeserialized(Context, ID);
2023     break;
2024   case DECL_EXPANDED_NON_TYPE_TEMPLATE_PARM_PACK:
2025     D = NonTypeTemplateParmDecl::CreateDeserialized(Context, ID, Record[Idx++]);
2026     break;
2027   case DECL_TEMPLATE_TEMPLATE_PARM:
2028     D = TemplateTemplateParmDecl::CreateDeserialized(Context, ID);
2029     break;
2030   case DECL_EXPANDED_TEMPLATE_TEMPLATE_PARM_PACK:
2031     D = TemplateTemplateParmDecl::CreateDeserialized(Context, ID,
2032                                                      Record[Idx++]);
2033     break;
2034   case DECL_TYPE_ALIAS_TEMPLATE:
2035     D = TypeAliasTemplateDecl::CreateDeserialized(Context, ID);
2036     break;
2037   case DECL_STATIC_ASSERT:
2038     D = StaticAssertDecl::CreateDeserialized(Context, ID);
2039     break;
2040   case DECL_OBJC_METHOD:
2041     D = ObjCMethodDecl::CreateDeserialized(Context, ID);
2042     break;
2043   case DECL_OBJC_INTERFACE:
2044     D = ObjCInterfaceDecl::CreateDeserialized(Context, ID);
2045     break;
2046   case DECL_OBJC_IVAR:
2047     D = ObjCIvarDecl::CreateDeserialized(Context, ID);
2048     break;
2049   case DECL_OBJC_PROTOCOL:
2050     D = ObjCProtocolDecl::CreateDeserialized(Context, ID);
2051     break;
2052   case DECL_OBJC_AT_DEFS_FIELD:
2053     D = ObjCAtDefsFieldDecl::CreateDeserialized(Context, ID);
2054     break;
2055   case DECL_OBJC_CATEGORY:
2056     D = ObjCCategoryDecl::CreateDeserialized(Context, ID);
2057     break;
2058   case DECL_OBJC_CATEGORY_IMPL:
2059     D = ObjCCategoryImplDecl::CreateDeserialized(Context, ID);
2060     break;
2061   case DECL_OBJC_IMPLEMENTATION:
2062     D = ObjCImplementationDecl::CreateDeserialized(Context, ID);
2063     break;
2064   case DECL_OBJC_COMPATIBLE_ALIAS:
2065     D = ObjCCompatibleAliasDecl::CreateDeserialized(Context, ID);
2066     break;
2067   case DECL_OBJC_PROPERTY:
2068     D = ObjCPropertyDecl::CreateDeserialized(Context, ID);
2069     break;
2070   case DECL_OBJC_PROPERTY_IMPL:
2071     D = ObjCPropertyImplDecl::CreateDeserialized(Context, ID);
2072     break;
2073   case DECL_FIELD:
2074     D = FieldDecl::CreateDeserialized(Context, ID);
2075     break;
2076   case DECL_INDIRECTFIELD:
2077     D = IndirectFieldDecl::CreateDeserialized(Context, ID);
2078     break;
2079   case DECL_VAR:
2080     D = VarDecl::CreateDeserialized(Context, ID);
2081     break;
2082   case DECL_IMPLICIT_PARAM:
2083     D = ImplicitParamDecl::CreateDeserialized(Context, ID);
2084     break;
2085   case DECL_PARM_VAR:
2086     D = ParmVarDecl::CreateDeserialized(Context, ID);
2087     break;
2088   case DECL_FILE_SCOPE_ASM:
2089     D = FileScopeAsmDecl::CreateDeserialized(Context, ID);
2090     break;
2091   case DECL_BLOCK:
2092     D = BlockDecl::CreateDeserialized(Context, ID);
2093     break;
2094   case DECL_CXX_BASE_SPECIFIERS:
2095     Error("attempt to read a C++ base-specifier record as a declaration");
2096     return 0;
2097   case DECL_IMPORT:
2098     // Note: last entry of the ImportDecl record is the number of stored source
2099     // locations.
2100     D = ImportDecl::CreateDeserialized(Context, ID, Record.back());
2101     break;
2102   }
2103 
2104   assert(D && "Unknown declaration reading AST file");
2105   LoadedDecl(Index, D);
2106   // Set the DeclContext before doing any deserialization, to make sure internal
2107   // calls to Decl::getASTContext() by Decl's methods will find the
2108   // TranslationUnitDecl without crashing.
2109   D->setDeclContext(Context.getTranslationUnitDecl());
2110   Reader.Visit(D);
2111 
2112   // If this declaration is also a declaration context, get the
2113   // offsets for its tables of lexical and visible declarations.
2114   if (DeclContext *DC = dyn_cast<DeclContext>(D)) {
2115     std::pair<uint64_t, uint64_t> Offsets = Reader.VisitDeclContext(DC);
2116     if (Offsets.first || Offsets.second) {
2117       if (Offsets.first != 0)
2118         DC->setHasExternalLexicalStorage(true);
2119       if (Offsets.second != 0)
2120         DC->setHasExternalVisibleStorage(true);
2121       if (ReadDeclContextStorage(*Loc.F, DeclsCursor, Offsets,
2122                                  Loc.F->DeclContextInfos[DC]))
2123         return 0;
2124     }
2125 
2126     // Now add the pending visible updates for this decl context, if it has any.
2127     DeclContextVisibleUpdatesPending::iterator I =
2128         PendingVisibleUpdates.find(ID);
2129     if (I != PendingVisibleUpdates.end()) {
2130       // There are updates. This means the context has external visible
2131       // storage, even if the original stored version didn't.
2132       DC->setHasExternalVisibleStorage(true);
2133       DeclContextVisibleUpdates &U = I->second;
2134       for (DeclContextVisibleUpdates::iterator UI = U.begin(), UE = U.end();
2135            UI != UE; ++UI) {
2136         DeclContextInfo &Info = UI->second->DeclContextInfos[DC];
2137         delete Info.NameLookupTableData;
2138         Info.NameLookupTableData = UI->first;
2139       }
2140       PendingVisibleUpdates.erase(I);
2141     }
2142 
2143     if (!DC->hasExternalVisibleStorage() && DC->hasExternalLexicalStorage())
2144       DC->setMustBuildLookupTable();
2145   }
2146   assert(Idx == Record.size());
2147 
2148   // Load any relevant update records.
2149   loadDeclUpdateRecords(ID, D);
2150 
2151   // Load the categories after recursive loading is finished.
2152   if (ObjCInterfaceDecl *Class = dyn_cast<ObjCInterfaceDecl>(D))
2153     if (Class->isThisDeclarationADefinition())
2154       loadObjCCategories(ID, Class);
2155 
2156   // If we have deserialized a declaration that has a definition the
2157   // AST consumer might need to know about, queue it.
2158   // We don't pass it to the consumer immediately because we may be in recursive
2159   // loading, and some declarations may still be initializing.
2160   if (getContext().getLangOpts().Modules) {
2161     if (RedeclsAddedToAST.count(D)) {
2162       RedeclsAddedToAST.erase(D);
2163       if (isConsumerInterestedIn(D))
2164         InterestingDecls.push_back(D);
2165     }
2166   } else if (isConsumerInterestedIn(D))
2167     InterestingDecls.push_back(D);
2168 
2169   return D;
2170 }
2171 
2172 void ASTReader::loadDeclUpdateRecords(serialization::DeclID ID, Decl *D) {
2173   // The declaration may have been modified by files later in the chain.
2174   // If this is the case, read the record containing the updates from each file
2175   // and pass it to ASTDeclReader to make the modifications.
2176   DeclUpdateOffsetsMap::iterator UpdI = DeclUpdateOffsets.find(ID);
2177   if (UpdI != DeclUpdateOffsets.end()) {
2178     FileOffsetsTy &UpdateOffsets = UpdI->second;
2179     for (FileOffsetsTy::iterator
2180          I = UpdateOffsets.begin(), E = UpdateOffsets.end(); I != E; ++I) {
2181       ModuleFile *F = I->first;
2182       uint64_t Offset = I->second;
2183       llvm::BitstreamCursor &Cursor = F->DeclsCursor;
2184       SavedStreamPosition SavedPosition(Cursor);
2185       Cursor.JumpToBit(Offset);
2186       RecordData Record;
2187       unsigned Code = Cursor.ReadCode();
2188       unsigned RecCode = Cursor.ReadRecord(Code, Record);
2189       (void)RecCode;
2190       assert(RecCode == DECL_UPDATES && "Expected DECL_UPDATES record!");
2191 
2192       unsigned Idx = 0;
2193       ASTDeclReader Reader(*this, *F, ID, 0, Record, Idx);
2194       Reader.UpdateDecl(D, *F, Record);
2195     }
2196   }
2197 }
2198 
2199 namespace {
2200   struct CompareLocalRedeclarationsInfoToID {
2201     bool operator()(const LocalRedeclarationsInfo &X, DeclID Y) {
2202       return X.FirstID < Y;
2203     }
2204 
2205     bool operator()(DeclID X, const LocalRedeclarationsInfo &Y) {
2206       return X < Y.FirstID;
2207     }
2208 
2209     bool operator()(const LocalRedeclarationsInfo &X,
2210                     const LocalRedeclarationsInfo &Y) {
2211       return X.FirstID < Y.FirstID;
2212     }
2213     bool operator()(DeclID X, DeclID Y) {
2214       return X < Y;
2215     }
2216   };
2217 
2218   /// \brief Module visitor class that finds all of the redeclarations of a
2219   ///
2220   class RedeclChainVisitor {
2221     ASTReader &Reader;
2222     SmallVectorImpl<DeclID> &SearchDecls;
2223     llvm::SmallPtrSet<Decl *, 16> &Deserialized;
2224     GlobalDeclID CanonID;
2225     llvm::SmallVector<Decl *, 4> Chain;
2226 
2227   public:
2228     RedeclChainVisitor(ASTReader &Reader, SmallVectorImpl<DeclID> &SearchDecls,
2229                        llvm::SmallPtrSet<Decl *, 16> &Deserialized,
2230                        GlobalDeclID CanonID)
2231       : Reader(Reader), SearchDecls(SearchDecls), Deserialized(Deserialized),
2232         CanonID(CanonID) {
2233       for (unsigned I = 0, N = SearchDecls.size(); I != N; ++I)
2234         addToChain(Reader.GetDecl(SearchDecls[I]));
2235     }
2236 
2237     static bool visit(ModuleFile &M, bool Preorder, void *UserData) {
2238       if (Preorder)
2239         return false;
2240 
2241       return static_cast<RedeclChainVisitor *>(UserData)->visit(M);
2242     }
2243 
2244     void addToChain(Decl *D) {
2245       if (!D)
2246         return;
2247 
2248       if (Deserialized.erase(D))
2249         Chain.push_back(D);
2250     }
2251 
2252     void searchForID(ModuleFile &M, GlobalDeclID GlobalID) {
2253       // Map global ID of the first declaration down to the local ID
2254       // used in this module file.
2255       DeclID ID = Reader.mapGlobalIDToModuleFileGlobalID(M, GlobalID);
2256       if (!ID)
2257         return;
2258 
2259       // Perform a binary search to find the local redeclarations for this
2260       // declaration (if any).
2261       const LocalRedeclarationsInfo *Result
2262         = std::lower_bound(M.RedeclarationsMap,
2263                            M.RedeclarationsMap + M.LocalNumRedeclarationsInMap,
2264                            ID, CompareLocalRedeclarationsInfoToID());
2265       if (Result == M.RedeclarationsMap + M.LocalNumRedeclarationsInMap ||
2266           Result->FirstID != ID) {
2267         // If we have a previously-canonical singleton declaration that was
2268         // merged into another redeclaration chain, create a trivial chain
2269         // for this single declaration so that it will get wired into the
2270         // complete redeclaration chain.
2271         if (GlobalID != CanonID &&
2272             GlobalID - NUM_PREDEF_DECL_IDS >= M.BaseDeclID &&
2273             GlobalID - NUM_PREDEF_DECL_IDS < M.BaseDeclID + M.LocalNumDecls) {
2274           addToChain(Reader.GetDecl(GlobalID));
2275         }
2276 
2277         return;
2278       }
2279 
2280       // Dig out all of the redeclarations.
2281       unsigned Offset = Result->Offset;
2282       unsigned N = M.RedeclarationChains[Offset];
2283       M.RedeclarationChains[Offset++] = 0; // Don't try to deserialize again
2284       for (unsigned I = 0; I != N; ++I)
2285         addToChain(Reader.GetLocalDecl(M, M.RedeclarationChains[Offset++]));
2286     }
2287 
2288     bool visit(ModuleFile &M) {
2289       // Visit each of the declarations.
2290       for (unsigned I = 0, N = SearchDecls.size(); I != N; ++I)
2291         searchForID(M, SearchDecls[I]);
2292       return false;
2293     }
2294 
2295     ArrayRef<Decl *> getChain() const {
2296       return Chain;
2297     }
2298   };
2299 }
2300 
2301 void ASTReader::loadPendingDeclChain(serialization::GlobalDeclID ID) {
2302   Decl *D = GetDecl(ID);
2303   Decl *CanonDecl = D->getCanonicalDecl();
2304 
2305   // Determine the set of declaration IDs we'll be searching for.
2306   llvm::SmallVector<DeclID, 1> SearchDecls;
2307   GlobalDeclID CanonID = 0;
2308   if (D == CanonDecl) {
2309     SearchDecls.push_back(ID); // Always first.
2310     CanonID = ID;
2311   }
2312   MergedDeclsMap::iterator MergedPos = combineStoredMergedDecls(CanonDecl, ID);
2313   if (MergedPos != MergedDecls.end())
2314     SearchDecls.append(MergedPos->second.begin(), MergedPos->second.end());
2315 
2316   // Build up the list of redeclarations.
2317   RedeclChainVisitor Visitor(*this, SearchDecls, RedeclsDeserialized, CanonID);
2318   ModuleMgr.visitDepthFirst(&RedeclChainVisitor::visit, &Visitor);
2319 
2320   // Retrieve the chains.
2321   ArrayRef<Decl *> Chain = Visitor.getChain();
2322   if (Chain.empty())
2323     return;
2324 
2325   // Hook up the chains.
2326   Decl *MostRecent = CanonDecl->getMostRecentDecl();
2327   for (unsigned I = 0, N = Chain.size(); I != N; ++I) {
2328     if (Chain[I] == CanonDecl)
2329       continue;
2330 
2331     ASTDeclReader::attachPreviousDecl(Chain[I], MostRecent);
2332     MostRecent = Chain[I];
2333   }
2334 
2335   ASTDeclReader::attachLatestDecl(CanonDecl, MostRecent);
2336 }
2337 
2338 namespace {
2339   struct CompareObjCCategoriesInfo {
2340     bool operator()(const ObjCCategoriesInfo &X, DeclID Y) {
2341       return X.DefinitionID < Y;
2342     }
2343 
2344     bool operator()(DeclID X, const ObjCCategoriesInfo &Y) {
2345       return X < Y.DefinitionID;
2346     }
2347 
2348     bool operator()(const ObjCCategoriesInfo &X,
2349                     const ObjCCategoriesInfo &Y) {
2350       return X.DefinitionID < Y.DefinitionID;
2351     }
2352     bool operator()(DeclID X, DeclID Y) {
2353       return X < Y;
2354     }
2355   };
2356 
2357   /// \brief Given an ObjC interface, goes through the modules and links to the
2358   /// interface all the categories for it.
2359   class ObjCCategoriesVisitor {
2360     ASTReader &Reader;
2361     serialization::GlobalDeclID InterfaceID;
2362     ObjCInterfaceDecl *Interface;
2363     llvm::SmallPtrSet<ObjCCategoryDecl *, 16> &Deserialized;
2364     unsigned PreviousGeneration;
2365     ObjCCategoryDecl *Tail;
2366     llvm::DenseMap<DeclarationName, ObjCCategoryDecl *> NameCategoryMap;
2367 
2368     void add(ObjCCategoryDecl *Cat) {
2369       // Only process each category once.
2370       if (!Deserialized.erase(Cat))
2371         return;
2372 
2373       // Check for duplicate categories.
2374       if (Cat->getDeclName()) {
2375         ObjCCategoryDecl *&Existing = NameCategoryMap[Cat->getDeclName()];
2376         if (Existing &&
2377             Reader.getOwningModuleFile(Existing)
2378                                           != Reader.getOwningModuleFile(Cat)) {
2379           // FIXME: We should not warn for duplicates in diamond:
2380           //
2381           //   MT     //
2382           //  /  \    //
2383           // ML  MR   //
2384           //  \  /    //
2385           //   MB     //
2386           //
2387           // If there are duplicates in ML/MR, there will be warning when
2388           // creating MB *and* when importing MB. We should not warn when
2389           // importing.
2390           Reader.Diag(Cat->getLocation(), diag::warn_dup_category_def)
2391             << Interface->getDeclName() << Cat->getDeclName();
2392           Reader.Diag(Existing->getLocation(), diag::note_previous_definition);
2393         } else if (!Existing) {
2394           // Record this category.
2395           Existing = Cat;
2396         }
2397       }
2398 
2399       // Add this category to the end of the chain.
2400       if (Tail)
2401         ASTDeclReader::setNextObjCCategory(Tail, Cat);
2402       else
2403         Interface->setCategoryList(Cat);
2404       Tail = Cat;
2405     }
2406 
2407   public:
2408     ObjCCategoriesVisitor(ASTReader &Reader,
2409                           serialization::GlobalDeclID InterfaceID,
2410                           ObjCInterfaceDecl *Interface,
2411                         llvm::SmallPtrSet<ObjCCategoryDecl *, 16> &Deserialized,
2412                           unsigned PreviousGeneration)
2413       : Reader(Reader), InterfaceID(InterfaceID), Interface(Interface),
2414         Deserialized(Deserialized), PreviousGeneration(PreviousGeneration),
2415         Tail(0)
2416     {
2417       // Populate the name -> category map with the set of known categories.
2418       for (ObjCCategoryDecl *Cat = Interface->getCategoryList(); Cat;
2419            Cat = Cat->getNextClassCategory()) {
2420         if (Cat->getDeclName())
2421           NameCategoryMap[Cat->getDeclName()] = Cat;
2422 
2423         // Keep track of the tail of the category list.
2424         Tail = Cat;
2425       }
2426     }
2427 
2428     static bool visit(ModuleFile &M, void *UserData) {
2429       return static_cast<ObjCCategoriesVisitor *>(UserData)->visit(M);
2430     }
2431 
2432     bool visit(ModuleFile &M) {
2433       // If we've loaded all of the category information we care about from
2434       // this module file, we're done.
2435       if (M.Generation <= PreviousGeneration)
2436         return true;
2437 
2438       // Map global ID of the definition down to the local ID used in this
2439       // module file. If there is no such mapping, we'll find nothing here
2440       // (or in any module it imports).
2441       DeclID LocalID = Reader.mapGlobalIDToModuleFileGlobalID(M, InterfaceID);
2442       if (!LocalID)
2443         return true;
2444 
2445       // Perform a binary search to find the local redeclarations for this
2446       // declaration (if any).
2447       const ObjCCategoriesInfo *Result
2448         = std::lower_bound(M.ObjCCategoriesMap,
2449                            M.ObjCCategoriesMap + M.LocalNumObjCCategoriesInMap,
2450                            LocalID, CompareObjCCategoriesInfo());
2451       if (Result == M.ObjCCategoriesMap + M.LocalNumObjCCategoriesInMap ||
2452           Result->DefinitionID != LocalID) {
2453         // We didn't find anything. If the class definition is in this module
2454         // file, then the module files it depends on cannot have any categories,
2455         // so suppress further lookup.
2456         return Reader.isDeclIDFromModule(InterfaceID, M);
2457       }
2458 
2459       // We found something. Dig out all of the categories.
2460       unsigned Offset = Result->Offset;
2461       unsigned N = M.ObjCCategories[Offset];
2462       M.ObjCCategories[Offset++] = 0; // Don't try to deserialize again
2463       for (unsigned I = 0; I != N; ++I)
2464         add(cast_or_null<ObjCCategoryDecl>(
2465               Reader.GetLocalDecl(M, M.ObjCCategories[Offset++])));
2466       return true;
2467     }
2468   };
2469 }
2470 
2471 void ASTReader::loadObjCCategories(serialization::GlobalDeclID ID,
2472                                    ObjCInterfaceDecl *D,
2473                                    unsigned PreviousGeneration) {
2474   ObjCCategoriesVisitor Visitor(*this, ID, D, CategoriesDeserialized,
2475                                 PreviousGeneration);
2476   ModuleMgr.visit(ObjCCategoriesVisitor::visit, &Visitor);
2477 }
2478 
2479 void ASTDeclReader::UpdateDecl(Decl *D, ModuleFile &ModuleFile,
2480                                const RecordData &Record) {
2481   unsigned Idx = 0;
2482   while (Idx < Record.size()) {
2483     switch ((DeclUpdateKind)Record[Idx++]) {
2484     case UPD_CXX_ADDED_IMPLICIT_MEMBER:
2485       cast<CXXRecordDecl>(D)->addedMember(Reader.ReadDecl(ModuleFile, Record, Idx));
2486       break;
2487 
2488     case UPD_CXX_ADDED_TEMPLATE_SPECIALIZATION:
2489       // It will be added to the template's specializations set when loaded.
2490       (void)Reader.ReadDecl(ModuleFile, Record, Idx);
2491       break;
2492 
2493     case UPD_CXX_ADDED_ANONYMOUS_NAMESPACE: {
2494       NamespaceDecl *Anon
2495         = Reader.ReadDeclAs<NamespaceDecl>(ModuleFile, Record, Idx);
2496 
2497       // Each module has its own anonymous namespace, which is disjoint from
2498       // any other module's anonymous namespaces, so don't attach the anonymous
2499       // namespace at all.
2500       if (ModuleFile.Kind != MK_Module) {
2501         if (TranslationUnitDecl *TU = dyn_cast<TranslationUnitDecl>(D))
2502           TU->setAnonymousNamespace(Anon);
2503         else
2504           cast<NamespaceDecl>(D)->setAnonymousNamespace(Anon);
2505       }
2506       break;
2507     }
2508 
2509     case UPD_CXX_INSTANTIATED_STATIC_DATA_MEMBER:
2510       cast<VarDecl>(D)->getMemberSpecializationInfo()->setPointOfInstantiation(
2511           Reader.ReadSourceLocation(ModuleFile, Record, Idx));
2512       break;
2513     }
2514   }
2515 }
2516 
2517 /// \brief Return a template specialization of ND (should be a TemplateDecl)
2518 ///  that matches FD or TD.
2519 static NamedDecl* findMatchingSpecialization(FunctionDecl* FD,
2520                                              ClassTemplateSpecializationDecl*TD,
2521                                              NamedDecl* ND) {
2522   TemplateDecl* Templt = dyn_cast<TemplateDecl>(ND);
2523   if (!Templt) return 0;
2524   if (FD) {
2525     FunctionTemplateDecl* FTD = dyn_cast<FunctionTemplateDecl>(Templt);
2526     if (!FTD) return 0;
2527     const TemplateArgumentList* TmpltArgs = FD->getTemplateSpecializationArgs();
2528     assert(TmpltArgs || "Template without arguments");
2529     void* InsertionPoint;
2530     return FTD->findSpecialization(TmpltArgs->data(), TmpltArgs->size(),
2531                                    InsertionPoint);
2532   } else {
2533     ClassTemplateDecl* CTD = dyn_cast<ClassTemplateDecl>(Templt);
2534     if (!CTD) return 0;
2535     const TemplateArgumentList& TmpltArgs = TD->getTemplateArgs();
2536     void* InsertionPoint;
2537     return CTD->findSpecialization(TmpltArgs.data(), TmpltArgs.size(),
2538                                    InsertionPoint);
2539   }
2540   return 0;
2541 }
2542 
2543 /// \brief Find out whether an instantiation (outside the module) already exists
2544 bool ASTReader::needPendingInstantiation(ValueDecl* D) const {
2545   DeclContext *DC = D->getDeclContext()->getRedeclContext();
2546   DeclarationName Name = D->getDeclName();
2547   assert(Name && "unnamed template");
2548 
2549   FunctionDecl* FD = dyn_cast<FunctionDecl>(D);
2550   ClassTemplateSpecializationDecl* CD
2551     = FD ? 0 : dyn_cast<ClassTemplateSpecializationDecl>(D);
2552 
2553   NamedDecl* FoundSpecialization = 0;
2554   if (DC->isTranslationUnit() && SemaObj) {
2555     IdentifierResolver &IdResolver = SemaObj->IdResolver;
2556     for (IdentifierResolver::iterator I = IdResolver.begin(Name),
2557            IEnd = IdResolver.end();
2558          I != IEnd && !FoundSpecialization; ++I)
2559       FoundSpecialization = findMatchingSpecialization(FD, CD, *I);
2560   } else {
2561     // templates are redeclarables, i.e. they must have been merged into
2562     // the primary context. Use localUncachedLookup to not pick up template
2563     // decls from modules again.
2564     llvm::SmallVector<NamedDecl*, 6> Results;
2565     DC->getPrimaryContext()->localUncachedLookup(Name, Results);
2566     for (llvm::SmallVector<NamedDecl *, 6>::const_iterator
2567            I = Results.begin(), E = Results.end();
2568          I != E && FoundSpecialization; ++I)
2569       FoundSpecialization = findMatchingSpecialization(FD, CD, *I);
2570   }
2571   return FoundSpecialization && isSameEntity(FoundSpecialization, D);
2572 }
2573