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