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