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