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 "clang/Serialization/ASTReader.h"
17#include "clang/Sema/SemaDiagnostic.h"
18#include "clang/AST/ASTConsumer.h"
19#include "clang/AST/ASTContext.h"
20#include "clang/AST/DeclVisitor.h"
21#include "clang/AST/DeclGroup.h"
22#include "clang/AST/DeclCXX.h"
23#include "clang/AST/DeclTemplate.h"
24#include "clang/AST/Expr.h"
25using namespace clang;
26using namespace clang::serialization;
27
28//===----------------------------------------------------------------------===//
29// Declaration deserialization
30//===----------------------------------------------------------------------===//
31
32namespace clang {
33  class ASTDeclReader : public DeclVisitor<ASTDeclReader, void> {
34    ASTReader &Reader;
35    Module &F;
36    llvm::BitstreamCursor &Cursor;
37    const DeclID ThisDeclID;
38    typedef ASTReader::RecordData RecordData;
39    const RecordData &Record;
40    unsigned &Idx;
41    TypeID TypeIDForTypeDecl;
42
43    DeclID DeclContextIDForTemplateParmDecl;
44    DeclID LexicalDeclContextIDForTemplateParmDecl;
45
46    uint64_t GetCurrentCursorOffset();
47
48    SourceLocation ReadSourceLocation(const RecordData &R, unsigned &I) {
49      return Reader.ReadSourceLocation(F, R, I);
50    }
51
52    SourceRange ReadSourceRange(const RecordData &R, unsigned &I) {
53      return Reader.ReadSourceRange(F, R, I);
54    }
55
56    TypeSourceInfo *GetTypeSourceInfo(const RecordData &R, unsigned &I) {
57      return Reader.GetTypeSourceInfo(F, R, I);
58    }
59
60    serialization::DeclID ReadDeclID(const RecordData &R, unsigned &I) {
61      return Reader.ReadDeclID(F, R, I);
62    }
63
64    Decl *ReadDecl(const RecordData &R, unsigned &I) {
65      return Reader.ReadDecl(F, R, I);
66    }
67
68    template<typename T>
69    T *ReadDeclAs(const RecordData &R, unsigned &I) {
70      return Reader.ReadDeclAs<T>(F, R, I);
71    }
72
73    void ReadQualifierInfo(QualifierInfo &Info,
74                           const RecordData &R, unsigned &I) {
75      Reader.ReadQualifierInfo(F, Info, R, I);
76    }
77
78    void ReadDeclarationNameLoc(DeclarationNameLoc &DNLoc, DeclarationName Name,
79                                const RecordData &R, unsigned &I) {
80      Reader.ReadDeclarationNameLoc(F, DNLoc, Name, R, I);
81    }
82
83    void ReadDeclarationNameInfo(DeclarationNameInfo &NameInfo,
84                                const RecordData &R, unsigned &I) {
85      Reader.ReadDeclarationNameInfo(F, NameInfo, R, I);
86    }
87
88    void ReadCXXDefinitionData(struct CXXRecordDecl::DefinitionData &Data,
89                               const RecordData &R, unsigned &I);
90
91    void InitializeCXXDefinitionData(CXXRecordDecl *D,
92                                     CXXRecordDecl *DefinitionDecl,
93                                     const RecordData &Record, unsigned &Idx);
94  public:
95    ASTDeclReader(ASTReader &Reader, Module &F,
96                  llvm::BitstreamCursor &Cursor, DeclID thisDeclID,
97                  const RecordData &Record, unsigned &Idx)
98      : Reader(Reader), F(F), Cursor(Cursor), ThisDeclID(thisDeclID),
99        Record(Record), Idx(Idx), TypeIDForTypeDecl(0) { }
100
101    static void attachPreviousDecl(Decl *D, Decl *previous);
102
103    void Visit(Decl *D);
104
105    void UpdateDecl(Decl *D, Module &Module,
106                    const RecordData &Record);
107
108    static void setNextObjCCategory(ObjCCategoryDecl *Cat,
109                                    ObjCCategoryDecl *Next) {
110      Cat->NextClassCategory = Next;
111    }
112
113    void VisitDecl(Decl *D);
114    void VisitTranslationUnitDecl(TranslationUnitDecl *TU);
115    void VisitNamedDecl(NamedDecl *ND);
116    void VisitLabelDecl(LabelDecl *LD);
117    void VisitNamespaceDecl(NamespaceDecl *D);
118    void VisitUsingDirectiveDecl(UsingDirectiveDecl *D);
119    void VisitNamespaceAliasDecl(NamespaceAliasDecl *D);
120    void VisitTypeDecl(TypeDecl *TD);
121    void VisitTypedefDecl(TypedefDecl *TD);
122    void VisitTypeAliasDecl(TypeAliasDecl *TD);
123    void VisitUnresolvedUsingTypenameDecl(UnresolvedUsingTypenameDecl *D);
124    void VisitTagDecl(TagDecl *TD);
125    void VisitEnumDecl(EnumDecl *ED);
126    void VisitRecordDecl(RecordDecl *RD);
127    void VisitCXXRecordDecl(CXXRecordDecl *D);
128    void VisitClassTemplateSpecializationDecl(
129                                            ClassTemplateSpecializationDecl *D);
130    void VisitClassTemplatePartialSpecializationDecl(
131                                     ClassTemplatePartialSpecializationDecl *D);
132    void VisitClassScopeFunctionSpecializationDecl(
133                                       ClassScopeFunctionSpecializationDecl *D);
134    void VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D);
135    void VisitValueDecl(ValueDecl *VD);
136    void VisitEnumConstantDecl(EnumConstantDecl *ECD);
137    void VisitUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *D);
138    void VisitDeclaratorDecl(DeclaratorDecl *DD);
139    void VisitFunctionDecl(FunctionDecl *FD);
140    void VisitCXXMethodDecl(CXXMethodDecl *D);
141    void VisitCXXConstructorDecl(CXXConstructorDecl *D);
142    void VisitCXXDestructorDecl(CXXDestructorDecl *D);
143    void VisitCXXConversionDecl(CXXConversionDecl *D);
144    void VisitFieldDecl(FieldDecl *FD);
145    void VisitIndirectFieldDecl(IndirectFieldDecl *FD);
146    void VisitVarDecl(VarDecl *VD);
147    void VisitImplicitParamDecl(ImplicitParamDecl *PD);
148    void VisitParmVarDecl(ParmVarDecl *PD);
149    void VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D);
150    void VisitTemplateDecl(TemplateDecl *D);
151    void VisitRedeclarableTemplateDecl(RedeclarableTemplateDecl *D);
152    void VisitClassTemplateDecl(ClassTemplateDecl *D);
153    void VisitFunctionTemplateDecl(FunctionTemplateDecl *D);
154    void VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D);
155    void VisitTypeAliasTemplateDecl(TypeAliasTemplateDecl *D);
156    void VisitUsingDecl(UsingDecl *D);
157    void VisitUsingShadowDecl(UsingShadowDecl *D);
158    void VisitLinkageSpecDecl(LinkageSpecDecl *D);
159    void VisitFileScopeAsmDecl(FileScopeAsmDecl *AD);
160    void VisitAccessSpecDecl(AccessSpecDecl *D);
161    void VisitFriendDecl(FriendDecl *D);
162    void VisitFriendTemplateDecl(FriendTemplateDecl *D);
163    void VisitStaticAssertDecl(StaticAssertDecl *D);
164    void VisitBlockDecl(BlockDecl *BD);
165
166    std::pair<uint64_t, uint64_t> VisitDeclContext(DeclContext *DC);
167    template <typename T> void VisitRedeclarable(Redeclarable<T> *D);
168
169    // FIXME: Reorder according to DeclNodes.td?
170    void VisitObjCMethodDecl(ObjCMethodDecl *D);
171    void VisitObjCContainerDecl(ObjCContainerDecl *D);
172    void VisitObjCInterfaceDecl(ObjCInterfaceDecl *D);
173    void VisitObjCIvarDecl(ObjCIvarDecl *D);
174    void VisitObjCProtocolDecl(ObjCProtocolDecl *D);
175    void VisitObjCAtDefsFieldDecl(ObjCAtDefsFieldDecl *D);
176    void VisitObjCClassDecl(ObjCClassDecl *D);
177    void VisitObjCForwardProtocolDecl(ObjCForwardProtocolDecl *D);
178    void VisitObjCCategoryDecl(ObjCCategoryDecl *D);
179    void VisitObjCImplDecl(ObjCImplDecl *D);
180    void VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D);
181    void VisitObjCImplementationDecl(ObjCImplementationDecl *D);
182    void VisitObjCCompatibleAliasDecl(ObjCCompatibleAliasDecl *D);
183    void VisitObjCPropertyDecl(ObjCPropertyDecl *D);
184    void VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D);
185  };
186}
187
188uint64_t ASTDeclReader::GetCurrentCursorOffset() {
189  return F.DeclsCursor.GetCurrentBitNo() + F.GlobalBitOffset;
190}
191
192void ASTDeclReader::Visit(Decl *D) {
193  DeclVisitor<ASTDeclReader, void>::Visit(D);
194
195  if (DeclaratorDecl *DD = dyn_cast<DeclaratorDecl>(D)) {
196    if (DD->DeclInfo) {
197      DeclaratorDecl::ExtInfo *Info =
198          DD->DeclInfo.get<DeclaratorDecl::ExtInfo *>();
199      Info->TInfo =
200          GetTypeSourceInfo(Record, Idx);
201    }
202    else {
203      DD->DeclInfo = GetTypeSourceInfo(Record, Idx);
204    }
205  }
206
207  if (TypeDecl *TD = dyn_cast<TypeDecl>(D)) {
208    // if we have a fully initialized TypeDecl, we can safely read its type now.
209    TD->setTypeForDecl(Reader.GetType(TypeIDForTypeDecl).getTypePtrOrNull());
210  } else if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
211    // FunctionDecl's body was written last after all other Stmts/Exprs.
212    if (Record[Idx++])
213      FD->setLazyBody(GetCurrentCursorOffset());
214  } else if (D->isTemplateParameter()) {
215    // If we have a fully initialized template parameter, we can now
216    // set its DeclContext.
217    D->setDeclContext(
218          cast_or_null<DeclContext>(
219                            Reader.GetDecl(DeclContextIDForTemplateParmDecl)));
220    D->setLexicalDeclContext(
221          cast_or_null<DeclContext>(
222                      Reader.GetDecl(LexicalDeclContextIDForTemplateParmDecl)));
223  }
224}
225
226void ASTDeclReader::VisitDecl(Decl *D) {
227  if (D->isTemplateParameter()) {
228    // We don't want to deserialize the DeclContext of a template
229    // parameter immediately, because the template parameter might be
230    // used in the formulation of its DeclContext. Use the translation
231    // unit DeclContext as a placeholder.
232    DeclContextIDForTemplateParmDecl = ReadDeclID(Record, Idx);
233    LexicalDeclContextIDForTemplateParmDecl = ReadDeclID(Record, Idx);
234    D->setDeclContext(Reader.getContext().getTranslationUnitDecl());
235  } else {
236    D->setDeclContext(ReadDeclAs<DeclContext>(Record, Idx));
237    D->setLexicalDeclContext(ReadDeclAs<DeclContext>(Record, Idx));
238  }
239  D->setLocation(ReadSourceLocation(Record, Idx));
240  D->setInvalidDecl(Record[Idx++]);
241  if (Record[Idx++]) { // hasAttrs
242    AttrVec Attrs;
243    Reader.ReadAttributes(F, Attrs, Record, Idx);
244    D->setAttrs(Attrs);
245  }
246  D->setImplicit(Record[Idx++]);
247  D->setUsed(Record[Idx++]);
248  D->setReferenced(Record[Idx++]);
249  D->setAccess((AccessSpecifier)Record[Idx++]);
250  D->FromASTFile = true;
251  D->ModulePrivate = Record[Idx++];
252}
253
254void ASTDeclReader::VisitTranslationUnitDecl(TranslationUnitDecl *TU) {
255  llvm_unreachable("Translation units are not serialized");
256}
257
258void ASTDeclReader::VisitNamedDecl(NamedDecl *ND) {
259  VisitDecl(ND);
260  ND->setDeclName(Reader.ReadDeclarationName(F, Record, Idx));
261}
262
263void ASTDeclReader::VisitTypeDecl(TypeDecl *TD) {
264  VisitNamedDecl(TD);
265  TD->setLocStart(ReadSourceLocation(Record, Idx));
266  // Delay type reading until after we have fully initialized the decl.
267  TypeIDForTypeDecl = Reader.getGlobalTypeID(F, Record[Idx++]);
268}
269
270void ASTDeclReader::VisitTypedefDecl(TypedefDecl *TD) {
271  VisitTypeDecl(TD);
272  TD->setTypeSourceInfo(GetTypeSourceInfo(Record, Idx));
273}
274
275void ASTDeclReader::VisitTypeAliasDecl(TypeAliasDecl *TD) {
276  VisitTypeDecl(TD);
277  TD->setTypeSourceInfo(GetTypeSourceInfo(Record, Idx));
278}
279
280void ASTDeclReader::VisitTagDecl(TagDecl *TD) {
281  VisitTypeDecl(TD);
282  VisitRedeclarable(TD);
283  TD->IdentifierNamespace = Record[Idx++];
284  TD->setTagKind((TagDecl::TagKind)Record[Idx++]);
285  TD->setCompleteDefinition(Record[Idx++]);
286  TD->setEmbeddedInDeclarator(Record[Idx++]);
287  TD->setFreeStanding(Record[Idx++]);
288  TD->setRBraceLoc(ReadSourceLocation(Record, Idx));
289  if (Record[Idx++]) { // hasExtInfo
290    TagDecl::ExtInfo *Info = new (Reader.getContext()) TagDecl::ExtInfo();
291    ReadQualifierInfo(*Info, Record, Idx);
292    TD->TypedefNameDeclOrQualifier = Info;
293  } else
294    TD->setTypedefNameForAnonDecl(ReadDeclAs<TypedefNameDecl>(Record, Idx));
295}
296
297void ASTDeclReader::VisitEnumDecl(EnumDecl *ED) {
298  VisitTagDecl(ED);
299  if (TypeSourceInfo *TI = Reader.GetTypeSourceInfo(F, Record, Idx))
300    ED->setIntegerTypeSourceInfo(TI);
301  else
302    ED->setIntegerType(Reader.readType(F, Record, Idx));
303  ED->setPromotionType(Reader.readType(F, Record, Idx));
304  ED->setNumPositiveBits(Record[Idx++]);
305  ED->setNumNegativeBits(Record[Idx++]);
306  ED->IsScoped = Record[Idx++];
307  ED->IsScopedUsingClassTag = Record[Idx++];
308  ED->IsFixed = Record[Idx++];
309  ED->setInstantiationOfMemberEnum(ReadDeclAs<EnumDecl>(Record, Idx));
310}
311
312void ASTDeclReader::VisitRecordDecl(RecordDecl *RD) {
313  VisitTagDecl(RD);
314  RD->setHasFlexibleArrayMember(Record[Idx++]);
315  RD->setAnonymousStructOrUnion(Record[Idx++]);
316  RD->setHasObjectMember(Record[Idx++]);
317}
318
319void ASTDeclReader::VisitValueDecl(ValueDecl *VD) {
320  VisitNamedDecl(VD);
321  VD->setType(Reader.readType(F, Record, Idx));
322}
323
324void ASTDeclReader::VisitEnumConstantDecl(EnumConstantDecl *ECD) {
325  VisitValueDecl(ECD);
326  if (Record[Idx++])
327    ECD->setInitExpr(Reader.ReadExpr(F));
328  ECD->setInitVal(Reader.ReadAPSInt(Record, Idx));
329}
330
331void ASTDeclReader::VisitDeclaratorDecl(DeclaratorDecl *DD) {
332  VisitValueDecl(DD);
333  DD->setInnerLocStart(ReadSourceLocation(Record, Idx));
334  if (Record[Idx++]) { // hasExtInfo
335    DeclaratorDecl::ExtInfo *Info
336        = new (Reader.getContext()) DeclaratorDecl::ExtInfo();
337    ReadQualifierInfo(*Info, Record, Idx);
338    DD->DeclInfo = Info;
339  }
340}
341
342void ASTDeclReader::VisitFunctionDecl(FunctionDecl *FD) {
343  VisitDeclaratorDecl(FD);
344  VisitRedeclarable(FD);
345
346  ReadDeclarationNameLoc(FD->DNLoc, FD->getDeclName(), Record, Idx);
347  FD->IdentifierNamespace = Record[Idx++];
348  switch ((FunctionDecl::TemplatedKind)Record[Idx++]) {
349  default: llvm_unreachable("Unhandled TemplatedKind!");
350  case FunctionDecl::TK_NonTemplate:
351    break;
352  case FunctionDecl::TK_FunctionTemplate:
353    FD->setDescribedFunctionTemplate(ReadDeclAs<FunctionTemplateDecl>(Record,
354                                                                      Idx));
355    break;
356  case FunctionDecl::TK_MemberSpecialization: {
357    FunctionDecl *InstFD = ReadDeclAs<FunctionDecl>(Record, Idx);
358    TemplateSpecializationKind TSK = (TemplateSpecializationKind)Record[Idx++];
359    SourceLocation POI = ReadSourceLocation(Record, Idx);
360    FD->setInstantiationOfMemberFunction(Reader.getContext(), InstFD, TSK);
361    FD->getMemberSpecializationInfo()->setPointOfInstantiation(POI);
362    break;
363  }
364  case FunctionDecl::TK_FunctionTemplateSpecialization: {
365    FunctionTemplateDecl *Template = ReadDeclAs<FunctionTemplateDecl>(Record,
366                                                                      Idx);
367    TemplateSpecializationKind TSK = (TemplateSpecializationKind)Record[Idx++];
368
369    // Template arguments.
370    SmallVector<TemplateArgument, 8> TemplArgs;
371    Reader.ReadTemplateArgumentList(TemplArgs, F, Record, Idx);
372
373    // Template args as written.
374    SmallVector<TemplateArgumentLoc, 8> TemplArgLocs;
375    SourceLocation LAngleLoc, RAngleLoc;
376    bool HasTemplateArgumentsAsWritten = Record[Idx++];
377    if (HasTemplateArgumentsAsWritten) {
378      unsigned NumTemplateArgLocs = Record[Idx++];
379      TemplArgLocs.reserve(NumTemplateArgLocs);
380      for (unsigned i=0; i != NumTemplateArgLocs; ++i)
381        TemplArgLocs.push_back(
382            Reader.ReadTemplateArgumentLoc(F, Record, Idx));
383
384      LAngleLoc = ReadSourceLocation(Record, Idx);
385      RAngleLoc = ReadSourceLocation(Record, Idx);
386    }
387
388    SourceLocation POI = ReadSourceLocation(Record, Idx);
389
390    ASTContext &C = Reader.getContext();
391    TemplateArgumentList *TemplArgList
392      = TemplateArgumentList::CreateCopy(C, TemplArgs.data(), TemplArgs.size());
393    TemplateArgumentListInfo TemplArgsInfo(LAngleLoc, RAngleLoc);
394    for (unsigned i=0, e = TemplArgLocs.size(); i != e; ++i)
395      TemplArgsInfo.addArgument(TemplArgLocs[i]);
396    FunctionTemplateSpecializationInfo *FTInfo
397        = FunctionTemplateSpecializationInfo::Create(C, FD, Template, TSK,
398                                                     TemplArgList,
399                             HasTemplateArgumentsAsWritten ? &TemplArgsInfo : 0,
400                                                     POI);
401    FD->TemplateOrSpecialization = FTInfo;
402
403    if (FD->isCanonicalDecl()) { // if canonical add to template's set.
404      // The template that contains the specializations set. It's not safe to
405      // use getCanonicalDecl on Template since it may still be initializing.
406      FunctionTemplateDecl *CanonTemplate
407        = ReadDeclAs<FunctionTemplateDecl>(Record, Idx);
408      // Get the InsertPos by FindNodeOrInsertPos() instead of calling
409      // InsertNode(FTInfo) directly to avoid the getASTContext() call in
410      // FunctionTemplateSpecializationInfo's Profile().
411      // We avoid getASTContext because a decl in the parent hierarchy may
412      // be initializing.
413      llvm::FoldingSetNodeID ID;
414      FunctionTemplateSpecializationInfo::Profile(ID, TemplArgs.data(),
415                                                  TemplArgs.size(), C);
416      void *InsertPos = 0;
417      CanonTemplate->getSpecializations().FindNodeOrInsertPos(ID, InsertPos);
418      assert(InsertPos && "Another specialization already inserted!");
419      CanonTemplate->getSpecializations().InsertNode(FTInfo, InsertPos);
420    }
421    break;
422  }
423  case FunctionDecl::TK_DependentFunctionTemplateSpecialization: {
424    // Templates.
425    UnresolvedSet<8> TemplDecls;
426    unsigned NumTemplates = Record[Idx++];
427    while (NumTemplates--)
428      TemplDecls.addDecl(ReadDeclAs<NamedDecl>(Record, Idx));
429
430    // Templates args.
431    TemplateArgumentListInfo TemplArgs;
432    unsigned NumArgs = Record[Idx++];
433    while (NumArgs--)
434      TemplArgs.addArgument(Reader.ReadTemplateArgumentLoc(F, Record, Idx));
435    TemplArgs.setLAngleLoc(ReadSourceLocation(Record, Idx));
436    TemplArgs.setRAngleLoc(ReadSourceLocation(Record, Idx));
437
438    FD->setDependentTemplateSpecialization(Reader.getContext(),
439                                           TemplDecls, TemplArgs);
440    break;
441  }
442  }
443
444  // FunctionDecl's body is handled last at ASTDeclReader::Visit,
445  // after everything else is read.
446
447  FD->SClass = (StorageClass)Record[Idx++];
448  FD->SClassAsWritten = (StorageClass)Record[Idx++];
449  FD->IsInline = Record[Idx++];
450  FD->IsInlineSpecified = Record[Idx++];
451  FD->IsVirtualAsWritten = Record[Idx++];
452  FD->IsPure = Record[Idx++];
453  FD->HasInheritedPrototype = Record[Idx++];
454  FD->HasWrittenPrototype = Record[Idx++];
455  FD->IsDeleted = Record[Idx++];
456  FD->IsTrivial = Record[Idx++];
457  FD->IsDefaulted = Record[Idx++];
458  FD->IsExplicitlyDefaulted = Record[Idx++];
459  FD->HasImplicitReturnZero = Record[Idx++];
460  FD->IsConstexpr = Record[Idx++];
461  FD->EndRangeLoc = ReadSourceLocation(Record, Idx);
462
463  // Read in the parameters.
464  unsigned NumParams = Record[Idx++];
465  SmallVector<ParmVarDecl *, 16> Params;
466  Params.reserve(NumParams);
467  for (unsigned I = 0; I != NumParams; ++I)
468    Params.push_back(ReadDeclAs<ParmVarDecl>(Record, Idx));
469  FD->setParams(Reader.getContext(), Params);
470}
471
472void ASTDeclReader::VisitObjCMethodDecl(ObjCMethodDecl *MD) {
473  VisitNamedDecl(MD);
474  if (Record[Idx++]) {
475    // In practice, this won't be executed (since method definitions
476    // don't occur in header files).
477    MD->setBody(Reader.ReadStmt(F));
478    MD->setSelfDecl(ReadDeclAs<ImplicitParamDecl>(Record, Idx));
479    MD->setCmdDecl(ReadDeclAs<ImplicitParamDecl>(Record, Idx));
480  }
481  MD->setInstanceMethod(Record[Idx++]);
482  MD->setVariadic(Record[Idx++]);
483  MD->setSynthesized(Record[Idx++]);
484  MD->setDefined(Record[Idx++]);
485
486  MD->IsRedeclaration = Record[Idx++];
487  MD->HasRedeclaration = Record[Idx++];
488  if (MD->HasRedeclaration)
489    Reader.getContext().setObjCMethodRedeclaration(MD,
490                                       ReadDeclAs<ObjCMethodDecl>(Record, Idx));
491
492  MD->setDeclImplementation((ObjCMethodDecl::ImplementationControl)Record[Idx++]);
493  MD->setObjCDeclQualifier((Decl::ObjCDeclQualifier)Record[Idx++]);
494  MD->SetRelatedResultType(Record[Idx++]);
495  MD->setResultType(Reader.readType(F, Record, Idx));
496  MD->setResultTypeSourceInfo(GetTypeSourceInfo(Record, Idx));
497  MD->setEndLoc(ReadSourceLocation(Record, Idx));
498  unsigned NumParams = Record[Idx++];
499  SmallVector<ParmVarDecl *, 16> Params;
500  Params.reserve(NumParams);
501  for (unsigned I = 0; I != NumParams; ++I)
502    Params.push_back(ReadDeclAs<ParmVarDecl>(Record, Idx));
503
504  MD->SelLocsKind = Record[Idx++];
505  unsigned NumStoredSelLocs = Record[Idx++];
506  SmallVector<SourceLocation, 16> SelLocs;
507  SelLocs.reserve(NumStoredSelLocs);
508  for (unsigned i = 0; i != NumStoredSelLocs; ++i)
509    SelLocs.push_back(ReadSourceLocation(Record, Idx));
510
511  MD->setParamsAndSelLocs(Reader.getContext(), Params, SelLocs);
512}
513
514void ASTDeclReader::VisitObjCContainerDecl(ObjCContainerDecl *CD) {
515  VisitNamedDecl(CD);
516  CD->setAtStartLoc(ReadSourceLocation(Record, Idx));
517  CD->setAtEndRange(ReadSourceRange(Record, Idx));
518}
519
520void ASTDeclReader::VisitObjCInterfaceDecl(ObjCInterfaceDecl *ID) {
521  VisitObjCContainerDecl(ID);
522  ID->setTypeForDecl(Reader.readType(F, Record, Idx).getTypePtrOrNull());
523  ID->setSuperClass(ReadDeclAs<ObjCInterfaceDecl>(Record, Idx));
524
525  // Read the directly referenced protocols and their SourceLocations.
526  unsigned NumProtocols = Record[Idx++];
527  SmallVector<ObjCProtocolDecl *, 16> Protocols;
528  Protocols.reserve(NumProtocols);
529  for (unsigned I = 0; I != NumProtocols; ++I)
530    Protocols.push_back(ReadDeclAs<ObjCProtocolDecl>(Record, Idx));
531  SmallVector<SourceLocation, 16> ProtoLocs;
532  ProtoLocs.reserve(NumProtocols);
533  for (unsigned I = 0; I != NumProtocols; ++I)
534    ProtoLocs.push_back(ReadSourceLocation(Record, Idx));
535  ID->setProtocolList(Protocols.data(), NumProtocols, ProtoLocs.data(),
536                      Reader.getContext());
537
538  // Read the transitive closure of protocols referenced by this class.
539  NumProtocols = Record[Idx++];
540  Protocols.clear();
541  Protocols.reserve(NumProtocols);
542  for (unsigned I = 0; I != NumProtocols; ++I)
543    Protocols.push_back(ReadDeclAs<ObjCProtocolDecl>(Record, Idx));
544  ID->AllReferencedProtocols.set(Protocols.data(), NumProtocols,
545                                 Reader.getContext());
546
547  // Read the ivars.
548  unsigned NumIvars = Record[Idx++];
549  SmallVector<ObjCIvarDecl *, 16> IVars;
550  IVars.reserve(NumIvars);
551  for (unsigned I = 0; I != NumIvars; ++I)
552    IVars.push_back(ReadDeclAs<ObjCIvarDecl>(Record, Idx));
553  ID->setCategoryList(ReadDeclAs<ObjCCategoryDecl>(Record, Idx));
554
555  // We will rebuild this list lazily.
556  ID->setIvarList(0);
557  ID->InitiallyForwardDecl = Record[Idx++];
558  ID->setForwardDecl(Record[Idx++]);
559  ID->setImplicitInterfaceDecl(Record[Idx++]);
560  ID->setSuperClassLoc(ReadSourceLocation(Record, Idx));
561  ID->setLocEnd(ReadSourceLocation(Record, Idx));
562}
563
564void ASTDeclReader::VisitObjCIvarDecl(ObjCIvarDecl *IVD) {
565  VisitFieldDecl(IVD);
566  IVD->setAccessControl((ObjCIvarDecl::AccessControl)Record[Idx++]);
567  // This field will be built lazily.
568  IVD->setNextIvar(0);
569  bool synth = Record[Idx++];
570  IVD->setSynthesize(synth);
571}
572
573void ASTDeclReader::VisitObjCProtocolDecl(ObjCProtocolDecl *PD) {
574  VisitObjCContainerDecl(PD);
575  PD->InitiallyForwardDecl = Record[Idx++];
576  PD->setForwardDecl(Record[Idx++]);
577  PD->setLocEnd(ReadSourceLocation(Record, Idx));
578  unsigned NumProtoRefs = Record[Idx++];
579  SmallVector<ObjCProtocolDecl *, 16> ProtoRefs;
580  ProtoRefs.reserve(NumProtoRefs);
581  for (unsigned I = 0; I != NumProtoRefs; ++I)
582    ProtoRefs.push_back(ReadDeclAs<ObjCProtocolDecl>(Record, Idx));
583  SmallVector<SourceLocation, 16> ProtoLocs;
584  ProtoLocs.reserve(NumProtoRefs);
585  for (unsigned I = 0; I != NumProtoRefs; ++I)
586    ProtoLocs.push_back(ReadSourceLocation(Record, Idx));
587  PD->setProtocolList(ProtoRefs.data(), NumProtoRefs, ProtoLocs.data(),
588                      Reader.getContext());
589}
590
591void ASTDeclReader::VisitObjCAtDefsFieldDecl(ObjCAtDefsFieldDecl *FD) {
592  VisitFieldDecl(FD);
593}
594
595void ASTDeclReader::VisitObjCClassDecl(ObjCClassDecl *CD) {
596  VisitDecl(CD);
597  ObjCInterfaceDecl *ClassRef = ReadDeclAs<ObjCInterfaceDecl>(Record, Idx);
598  SourceLocation SLoc = ReadSourceLocation(Record, Idx);
599  CD->setClass(Reader.getContext(), ClassRef, SLoc);
600}
601
602void ASTDeclReader::VisitObjCForwardProtocolDecl(ObjCForwardProtocolDecl *FPD) {
603  VisitDecl(FPD);
604  unsigned NumProtoRefs = Record[Idx++];
605  SmallVector<ObjCProtocolDecl *, 16> ProtoRefs;
606  ProtoRefs.reserve(NumProtoRefs);
607  for (unsigned I = 0; I != NumProtoRefs; ++I)
608    ProtoRefs.push_back(ReadDeclAs<ObjCProtocolDecl>(Record, Idx));
609  SmallVector<SourceLocation, 16> ProtoLocs;
610  ProtoLocs.reserve(NumProtoRefs);
611  for (unsigned I = 0; I != NumProtoRefs; ++I)
612    ProtoLocs.push_back(ReadSourceLocation(Record, Idx));
613  FPD->setProtocolList(ProtoRefs.data(), NumProtoRefs, ProtoLocs.data(),
614                       Reader.getContext());
615}
616
617void ASTDeclReader::VisitObjCCategoryDecl(ObjCCategoryDecl *CD) {
618  VisitObjCContainerDecl(CD);
619  CD->ClassInterface = ReadDeclAs<ObjCInterfaceDecl>(Record, Idx);
620  unsigned NumProtoRefs = Record[Idx++];
621  SmallVector<ObjCProtocolDecl *, 16> ProtoRefs;
622  ProtoRefs.reserve(NumProtoRefs);
623  for (unsigned I = 0; I != NumProtoRefs; ++I)
624    ProtoRefs.push_back(ReadDeclAs<ObjCProtocolDecl>(Record, Idx));
625  SmallVector<SourceLocation, 16> ProtoLocs;
626  ProtoLocs.reserve(NumProtoRefs);
627  for (unsigned I = 0; I != NumProtoRefs; ++I)
628    ProtoLocs.push_back(ReadSourceLocation(Record, Idx));
629  CD->setProtocolList(ProtoRefs.data(), NumProtoRefs, ProtoLocs.data(),
630                      Reader.getContext());
631  CD->NextClassCategory = ReadDeclAs<ObjCCategoryDecl>(Record, Idx);
632  CD->setHasSynthBitfield(Record[Idx++]);
633  CD->setCategoryNameLoc(ReadSourceLocation(Record, Idx));
634}
635
636void ASTDeclReader::VisitObjCCompatibleAliasDecl(ObjCCompatibleAliasDecl *CAD) {
637  VisitNamedDecl(CAD);
638  CAD->setClassInterface(ReadDeclAs<ObjCInterfaceDecl>(Record, Idx));
639}
640
641void ASTDeclReader::VisitObjCPropertyDecl(ObjCPropertyDecl *D) {
642  VisitNamedDecl(D);
643  D->setAtLoc(ReadSourceLocation(Record, Idx));
644  D->setType(GetTypeSourceInfo(Record, Idx));
645  // FIXME: stable encoding
646  D->setPropertyAttributes(
647                      (ObjCPropertyDecl::PropertyAttributeKind)Record[Idx++]);
648  D->setPropertyAttributesAsWritten(
649                      (ObjCPropertyDecl::PropertyAttributeKind)Record[Idx++]);
650  // FIXME: stable encoding
651  D->setPropertyImplementation(
652                            (ObjCPropertyDecl::PropertyControl)Record[Idx++]);
653  D->setGetterName(Reader.ReadDeclarationName(F,Record, Idx).getObjCSelector());
654  D->setSetterName(Reader.ReadDeclarationName(F,Record, Idx).getObjCSelector());
655  D->setGetterMethodDecl(ReadDeclAs<ObjCMethodDecl>(Record, Idx));
656  D->setSetterMethodDecl(ReadDeclAs<ObjCMethodDecl>(Record, Idx));
657  D->setPropertyIvarDecl(ReadDeclAs<ObjCIvarDecl>(Record, Idx));
658}
659
660void ASTDeclReader::VisitObjCImplDecl(ObjCImplDecl *D) {
661  VisitObjCContainerDecl(D);
662  D->setClassInterface(ReadDeclAs<ObjCInterfaceDecl>(Record, Idx));
663}
664
665void ASTDeclReader::VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D) {
666  VisitObjCImplDecl(D);
667  D->setIdentifier(Reader.GetIdentifierInfo(F, Record, Idx));
668}
669
670void ASTDeclReader::VisitObjCImplementationDecl(ObjCImplementationDecl *D) {
671  VisitObjCImplDecl(D);
672  D->setSuperClass(ReadDeclAs<ObjCInterfaceDecl>(Record, Idx));
673  llvm::tie(D->IvarInitializers, D->NumIvarInitializers)
674      = Reader.ReadCXXCtorInitializers(F, Record, Idx);
675  D->setHasSynthBitfield(Record[Idx++]);
676}
677
678
679void ASTDeclReader::VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D) {
680  VisitDecl(D);
681  D->setAtLoc(ReadSourceLocation(Record, Idx));
682  D->setPropertyDecl(ReadDeclAs<ObjCPropertyDecl>(Record, Idx));
683  D->PropertyIvarDecl = ReadDeclAs<ObjCIvarDecl>(Record, Idx);
684  D->IvarLoc = ReadSourceLocation(Record, Idx);
685  D->setGetterCXXConstructor(Reader.ReadExpr(F));
686  D->setSetterCXXAssignment(Reader.ReadExpr(F));
687}
688
689void ASTDeclReader::VisitFieldDecl(FieldDecl *FD) {
690  VisitDeclaratorDecl(FD);
691  FD->setMutable(Record[Idx++]);
692  int BitWidthOrInitializer = Record[Idx++];
693  if (BitWidthOrInitializer == 1)
694    FD->setBitWidth(Reader.ReadExpr(F));
695  else if (BitWidthOrInitializer == 2)
696    FD->setInClassInitializer(Reader.ReadExpr(F));
697  if (!FD->getDeclName()) {
698    if (FieldDecl *Tmpl = ReadDeclAs<FieldDecl>(Record, Idx))
699      Reader.getContext().setInstantiatedFromUnnamedFieldDecl(FD, Tmpl);
700  }
701}
702
703void ASTDeclReader::VisitIndirectFieldDecl(IndirectFieldDecl *FD) {
704  VisitValueDecl(FD);
705
706  FD->ChainingSize = Record[Idx++];
707  assert(FD->ChainingSize >= 2 && "Anonymous chaining must be >= 2");
708  FD->Chaining = new (Reader.getContext())NamedDecl*[FD->ChainingSize];
709
710  for (unsigned I = 0; I != FD->ChainingSize; ++I)
711    FD->Chaining[I] = ReadDeclAs<NamedDecl>(Record, Idx);
712}
713
714void ASTDeclReader::VisitVarDecl(VarDecl *VD) {
715  VisitDeclaratorDecl(VD);
716  VisitRedeclarable(VD);
717  VD->VarDeclBits.SClass = (StorageClass)Record[Idx++];
718  VD->VarDeclBits.SClassAsWritten = (StorageClass)Record[Idx++];
719  VD->VarDeclBits.ThreadSpecified = Record[Idx++];
720  VD->VarDeclBits.HasCXXDirectInit = Record[Idx++];
721  VD->VarDeclBits.ExceptionVar = Record[Idx++];
722  VD->VarDeclBits.NRVOVariable = Record[Idx++];
723  VD->VarDeclBits.CXXForRangeDecl = Record[Idx++];
724  VD->VarDeclBits.ARCPseudoStrong = Record[Idx++];
725  if (Record[Idx++])
726    VD->setInit(Reader.ReadExpr(F));
727
728  if (Record[Idx++]) { // HasMemberSpecializationInfo.
729    VarDecl *Tmpl = ReadDeclAs<VarDecl>(Record, Idx);
730    TemplateSpecializationKind TSK = (TemplateSpecializationKind)Record[Idx++];
731    SourceLocation POI = ReadSourceLocation(Record, Idx);
732    Reader.getContext().setInstantiatedFromStaticDataMember(VD, Tmpl, TSK,POI);
733  }
734}
735
736void ASTDeclReader::VisitImplicitParamDecl(ImplicitParamDecl *PD) {
737  VisitVarDecl(PD);
738}
739
740void ASTDeclReader::VisitParmVarDecl(ParmVarDecl *PD) {
741  VisitVarDecl(PD);
742  unsigned isObjCMethodParam = Record[Idx++];
743  unsigned scopeDepth = Record[Idx++];
744  unsigned scopeIndex = Record[Idx++];
745  unsigned declQualifier = Record[Idx++];
746  if (isObjCMethodParam) {
747    assert(scopeDepth == 0);
748    PD->setObjCMethodScopeInfo(scopeIndex);
749    PD->ParmVarDeclBits.ScopeDepthOrObjCQuals = declQualifier;
750  } else {
751    PD->setScopeInfo(scopeDepth, scopeIndex);
752  }
753  PD->ParmVarDeclBits.IsKNRPromoted = Record[Idx++];
754  PD->ParmVarDeclBits.HasInheritedDefaultArg = Record[Idx++];
755  if (Record[Idx++]) // hasUninstantiatedDefaultArg.
756    PD->setUninstantiatedDefaultArg(Reader.ReadExpr(F));
757}
758
759void ASTDeclReader::VisitFileScopeAsmDecl(FileScopeAsmDecl *AD) {
760  VisitDecl(AD);
761  AD->setAsmString(cast<StringLiteral>(Reader.ReadExpr(F)));
762  AD->setRParenLoc(ReadSourceLocation(Record, Idx));
763}
764
765void ASTDeclReader::VisitBlockDecl(BlockDecl *BD) {
766  VisitDecl(BD);
767  BD->setBody(cast_or_null<CompoundStmt>(Reader.ReadStmt(F)));
768  BD->setSignatureAsWritten(GetTypeSourceInfo(Record, Idx));
769  unsigned NumParams = Record[Idx++];
770  SmallVector<ParmVarDecl *, 16> Params;
771  Params.reserve(NumParams);
772  for (unsigned I = 0; I != NumParams; ++I)
773    Params.push_back(ReadDeclAs<ParmVarDecl>(Record, Idx));
774  BD->setParams(Params);
775
776  bool capturesCXXThis = Record[Idx++];
777  unsigned numCaptures = Record[Idx++];
778  SmallVector<BlockDecl::Capture, 16> captures;
779  captures.reserve(numCaptures);
780  for (unsigned i = 0; i != numCaptures; ++i) {
781    VarDecl *decl = ReadDeclAs<VarDecl>(Record, Idx);
782    unsigned flags = Record[Idx++];
783    bool byRef = (flags & 1);
784    bool nested = (flags & 2);
785    Expr *copyExpr = ((flags & 4) ? Reader.ReadExpr(F) : 0);
786
787    captures.push_back(BlockDecl::Capture(decl, byRef, nested, copyExpr));
788  }
789  BD->setCaptures(Reader.getContext(), captures.begin(),
790                  captures.end(), capturesCXXThis);
791}
792
793void ASTDeclReader::VisitLinkageSpecDecl(LinkageSpecDecl *D) {
794  VisitDecl(D);
795  D->setLanguage((LinkageSpecDecl::LanguageIDs)Record[Idx++]);
796  D->setExternLoc(ReadSourceLocation(Record, Idx));
797  D->setRBraceLoc(ReadSourceLocation(Record, Idx));
798}
799
800void ASTDeclReader::VisitLabelDecl(LabelDecl *D) {
801  VisitNamedDecl(D);
802  D->setLocStart(ReadSourceLocation(Record, Idx));
803}
804
805
806void ASTDeclReader::VisitNamespaceDecl(NamespaceDecl *D) {
807  VisitNamedDecl(D);
808  D->IsInline = Record[Idx++];
809  D->LocStart = ReadSourceLocation(Record, Idx);
810  D->RBraceLoc = ReadSourceLocation(Record, Idx);
811  D->NextNamespace = Record[Idx++];
812
813  bool IsOriginal = Record[Idx++];
814  // FIXME: Modules will likely have trouble with pointing directly at
815  // the original namespace.
816  D->OrigOrAnonNamespace.setInt(IsOriginal);
817  D->OrigOrAnonNamespace.setPointer(ReadDeclAs<NamespaceDecl>(Record, Idx));
818}
819
820void ASTDeclReader::VisitNamespaceAliasDecl(NamespaceAliasDecl *D) {
821  VisitNamedDecl(D);
822  D->NamespaceLoc = ReadSourceLocation(Record, Idx);
823  D->IdentLoc = ReadSourceLocation(Record, Idx);
824  D->QualifierLoc = Reader.ReadNestedNameSpecifierLoc(F, Record, Idx);
825  D->Namespace = ReadDeclAs<NamedDecl>(Record, Idx);
826}
827
828void ASTDeclReader::VisitUsingDecl(UsingDecl *D) {
829  VisitNamedDecl(D);
830  D->setUsingLocation(ReadSourceLocation(Record, Idx));
831  D->QualifierLoc = Reader.ReadNestedNameSpecifierLoc(F, Record, Idx);
832  ReadDeclarationNameLoc(D->DNLoc, D->getDeclName(), Record, Idx);
833  D->FirstUsingShadow = ReadDeclAs<UsingShadowDecl>(Record, Idx);
834  D->setTypeName(Record[Idx++]);
835  if (NamedDecl *Pattern = ReadDeclAs<NamedDecl>(Record, Idx))
836    Reader.getContext().setInstantiatedFromUsingDecl(D, Pattern);
837}
838
839void ASTDeclReader::VisitUsingShadowDecl(UsingShadowDecl *D) {
840  VisitNamedDecl(D);
841  D->setTargetDecl(ReadDeclAs<NamedDecl>(Record, Idx));
842  D->UsingOrNextShadow = ReadDeclAs<NamedDecl>(Record, Idx);
843  UsingShadowDecl *Pattern = ReadDeclAs<UsingShadowDecl>(Record, Idx);
844  if (Pattern)
845    Reader.getContext().setInstantiatedFromUsingShadowDecl(D, Pattern);
846}
847
848void ASTDeclReader::VisitUsingDirectiveDecl(UsingDirectiveDecl *D) {
849  VisitNamedDecl(D);
850  D->UsingLoc = ReadSourceLocation(Record, Idx);
851  D->NamespaceLoc = ReadSourceLocation(Record, Idx);
852  D->QualifierLoc = Reader.ReadNestedNameSpecifierLoc(F, Record, Idx);
853  D->NominatedNamespace = ReadDeclAs<NamedDecl>(Record, Idx);
854  D->CommonAncestor = ReadDeclAs<DeclContext>(Record, Idx);
855}
856
857void ASTDeclReader::VisitUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *D) {
858  VisitValueDecl(D);
859  D->setUsingLoc(ReadSourceLocation(Record, Idx));
860  D->QualifierLoc = Reader.ReadNestedNameSpecifierLoc(F, Record, Idx);
861  ReadDeclarationNameLoc(D->DNLoc, D->getDeclName(), Record, Idx);
862}
863
864void ASTDeclReader::VisitUnresolvedUsingTypenameDecl(
865                                               UnresolvedUsingTypenameDecl *D) {
866  VisitTypeDecl(D);
867  D->TypenameLocation = ReadSourceLocation(Record, Idx);
868  D->QualifierLoc = Reader.ReadNestedNameSpecifierLoc(F, Record, Idx);
869}
870
871void ASTDeclReader::ReadCXXDefinitionData(
872                                   struct CXXRecordDecl::DefinitionData &Data,
873                                   const RecordData &Record, unsigned &Idx) {
874  Data.UserDeclaredConstructor = Record[Idx++];
875  Data.UserDeclaredCopyConstructor = Record[Idx++];
876  Data.UserDeclaredMoveConstructor = Record[Idx++];
877  Data.UserDeclaredCopyAssignment = Record[Idx++];
878  Data.UserDeclaredMoveAssignment = Record[Idx++];
879  Data.UserDeclaredDestructor = Record[Idx++];
880  Data.Aggregate = Record[Idx++];
881  Data.PlainOldData = Record[Idx++];
882  Data.Empty = Record[Idx++];
883  Data.Polymorphic = Record[Idx++];
884  Data.Abstract = Record[Idx++];
885  Data.IsStandardLayout = Record[Idx++];
886  Data.HasNoNonEmptyBases = Record[Idx++];
887  Data.HasPrivateFields = Record[Idx++];
888  Data.HasProtectedFields = Record[Idx++];
889  Data.HasPublicFields = Record[Idx++];
890  Data.HasMutableFields = Record[Idx++];
891  Data.HasTrivialDefaultConstructor = Record[Idx++];
892  Data.HasConstexprNonCopyMoveConstructor = Record[Idx++];
893  Data.HasTrivialCopyConstructor = Record[Idx++];
894  Data.HasTrivialMoveConstructor = Record[Idx++];
895  Data.HasTrivialCopyAssignment = Record[Idx++];
896  Data.HasTrivialMoveAssignment = Record[Idx++];
897  Data.HasTrivialDestructor = Record[Idx++];
898  Data.HasNonLiteralTypeFieldsOrBases = Record[Idx++];
899  Data.ComputedVisibleConversions = Record[Idx++];
900  Data.UserProvidedDefaultConstructor = Record[Idx++];
901  Data.DeclaredDefaultConstructor = Record[Idx++];
902  Data.DeclaredCopyConstructor = Record[Idx++];
903  Data.DeclaredMoveConstructor = Record[Idx++];
904  Data.DeclaredCopyAssignment = Record[Idx++];
905  Data.DeclaredMoveAssignment = Record[Idx++];
906  Data.DeclaredDestructor = Record[Idx++];
907  Data.FailedImplicitMoveConstructor = Record[Idx++];
908  Data.FailedImplicitMoveAssignment = Record[Idx++];
909
910  Data.NumBases = Record[Idx++];
911  if (Data.NumBases)
912    Data.Bases = Reader.readCXXBaseSpecifiers(F, Record, Idx);
913  Data.NumVBases = Record[Idx++];
914  if (Data.NumVBases)
915    Data.VBases = Reader.readCXXBaseSpecifiers(F, Record, Idx);
916
917  Reader.ReadUnresolvedSet(F, Data.Conversions, Record, Idx);
918  Reader.ReadUnresolvedSet(F, Data.VisibleConversions, Record, Idx);
919  assert(Data.Definition && "Data.Definition should be already set!");
920  Data.FirstFriend = ReadDeclAs<FriendDecl>(Record, Idx);
921}
922
923void ASTDeclReader::InitializeCXXDefinitionData(CXXRecordDecl *D,
924                                                CXXRecordDecl *DefinitionDecl,
925                                                const RecordData &Record,
926                                                unsigned &Idx) {
927  ASTContext &C = Reader.getContext();
928
929  if (D == DefinitionDecl) {
930    D->DefinitionData = new (C) struct CXXRecordDecl::DefinitionData(D);
931    ReadCXXDefinitionData(*D->DefinitionData, Record, Idx);
932    // We read the definition info. Check if there are pending forward
933    // references that need to point to this DefinitionData pointer.
934    ASTReader::PendingForwardRefsMap::iterator
935        FindI = Reader.PendingForwardRefs.find(D);
936    if (FindI != Reader.PendingForwardRefs.end()) {
937      ASTReader::ForwardRefs &Refs = FindI->second;
938      for (ASTReader::ForwardRefs::iterator
939             I = Refs.begin(), E = Refs.end(); I != E; ++I)
940        (*I)->DefinitionData = D->DefinitionData;
941#ifndef NDEBUG
942      // We later check whether PendingForwardRefs is empty to make sure all
943      // pending references were linked.
944      Reader.PendingForwardRefs.erase(D);
945#endif
946    }
947  } else if (DefinitionDecl) {
948    if (DefinitionDecl->DefinitionData) {
949      D->DefinitionData = DefinitionDecl->DefinitionData;
950    } else {
951      // The definition is still initializing.
952      Reader.PendingForwardRefs[DefinitionDecl].push_back(D);
953    }
954  }
955}
956
957void ASTDeclReader::VisitCXXRecordDecl(CXXRecordDecl *D) {
958  VisitRecordDecl(D);
959
960  CXXRecordDecl *DefinitionDecl = ReadDeclAs<CXXRecordDecl>(Record, Idx);
961  InitializeCXXDefinitionData(D, DefinitionDecl, Record, Idx);
962
963  ASTContext &C = Reader.getContext();
964
965  enum CXXRecKind {
966    CXXRecNotTemplate = 0, CXXRecTemplate, CXXRecMemberSpecialization
967  };
968  switch ((CXXRecKind)Record[Idx++]) {
969  default:
970    llvm_unreachable("Out of sync with ASTDeclWriter::VisitCXXRecordDecl?");
971  case CXXRecNotTemplate:
972    break;
973  case CXXRecTemplate:
974    D->TemplateOrInstantiation = ReadDeclAs<ClassTemplateDecl>(Record, Idx);
975    break;
976  case CXXRecMemberSpecialization: {
977    CXXRecordDecl *RD = ReadDeclAs<CXXRecordDecl>(Record, Idx);
978    TemplateSpecializationKind TSK = (TemplateSpecializationKind)Record[Idx++];
979    SourceLocation POI = ReadSourceLocation(Record, Idx);
980    MemberSpecializationInfo *MSI = new (C) MemberSpecializationInfo(RD, TSK);
981    MSI->setPointOfInstantiation(POI);
982    D->TemplateOrInstantiation = MSI;
983    break;
984  }
985  }
986
987  // Load the key function to avoid deserializing every method so we can
988  // compute it.
989  if (D->IsCompleteDefinition) {
990    if (CXXMethodDecl *Key = ReadDeclAs<CXXMethodDecl>(Record, Idx))
991      C.KeyFunctions[D] = Key;
992  }
993}
994
995void ASTDeclReader::VisitCXXMethodDecl(CXXMethodDecl *D) {
996  VisitFunctionDecl(D);
997  unsigned NumOverridenMethods = Record[Idx++];
998  while (NumOverridenMethods--) {
999    // Avoid invariant checking of CXXMethodDecl::addOverriddenMethod,
1000    // MD may be initializing.
1001    if (CXXMethodDecl *MD = ReadDeclAs<CXXMethodDecl>(Record, Idx))
1002      Reader.getContext().addOverriddenMethod(D, MD);
1003  }
1004}
1005
1006void ASTDeclReader::VisitCXXConstructorDecl(CXXConstructorDecl *D) {
1007  VisitCXXMethodDecl(D);
1008
1009  D->IsExplicitSpecified = Record[Idx++];
1010  D->ImplicitlyDefined = Record[Idx++];
1011  llvm::tie(D->CtorInitializers, D->NumCtorInitializers)
1012      = Reader.ReadCXXCtorInitializers(F, Record, Idx);
1013}
1014
1015void ASTDeclReader::VisitCXXDestructorDecl(CXXDestructorDecl *D) {
1016  VisitCXXMethodDecl(D);
1017
1018  D->ImplicitlyDefined = Record[Idx++];
1019  D->OperatorDelete = ReadDeclAs<FunctionDecl>(Record, Idx);
1020}
1021
1022void ASTDeclReader::VisitCXXConversionDecl(CXXConversionDecl *D) {
1023  VisitCXXMethodDecl(D);
1024  D->IsExplicitSpecified = Record[Idx++];
1025}
1026
1027void ASTDeclReader::VisitAccessSpecDecl(AccessSpecDecl *D) {
1028  VisitDecl(D);
1029  D->setColonLoc(ReadSourceLocation(Record, Idx));
1030}
1031
1032void ASTDeclReader::VisitFriendDecl(FriendDecl *D) {
1033  VisitDecl(D);
1034  if (Record[Idx++])
1035    D->Friend = GetTypeSourceInfo(Record, Idx);
1036  else
1037    D->Friend = ReadDeclAs<NamedDecl>(Record, Idx);
1038  D->NextFriend = Record[Idx++];
1039  D->UnsupportedFriend = (Record[Idx++] != 0);
1040  D->FriendLoc = ReadSourceLocation(Record, Idx);
1041}
1042
1043void ASTDeclReader::VisitFriendTemplateDecl(FriendTemplateDecl *D) {
1044  VisitDecl(D);
1045  unsigned NumParams = Record[Idx++];
1046  D->NumParams = NumParams;
1047  D->Params = new TemplateParameterList*[NumParams];
1048  for (unsigned i = 0; i != NumParams; ++i)
1049    D->Params[i] = Reader.ReadTemplateParameterList(F, Record, Idx);
1050  if (Record[Idx++]) // HasFriendDecl
1051    D->Friend = ReadDeclAs<NamedDecl>(Record, Idx);
1052  else
1053    D->Friend = GetTypeSourceInfo(Record, Idx);
1054  D->FriendLoc = ReadSourceLocation(Record, Idx);
1055}
1056
1057void ASTDeclReader::VisitTemplateDecl(TemplateDecl *D) {
1058  VisitNamedDecl(D);
1059
1060  NamedDecl *TemplatedDecl = ReadDeclAs<NamedDecl>(Record, Idx);
1061  TemplateParameterList* TemplateParams
1062      = Reader.ReadTemplateParameterList(F, Record, Idx);
1063  D->init(TemplatedDecl, TemplateParams);
1064}
1065
1066void ASTDeclReader::VisitRedeclarableTemplateDecl(RedeclarableTemplateDecl *D) {
1067  // Initialize CommonOrPrev before VisitTemplateDecl so that getCommonPtr()
1068  // can be used while this is still initializing.
1069
1070  assert(D->CommonOrPrev.isNull() && "getCommonPtr was called earlier on this");
1071  DeclID PreviousDeclID = ReadDeclID(Record, Idx);
1072  DeclID FirstDeclID =  PreviousDeclID ? ReadDeclID(Record, Idx) : 0;
1073  // We delay loading of the redeclaration chain to avoid deeply nested calls.
1074  // We temporarily set the first (canonical) declaration as the previous one
1075  // which is the one that matters and mark the real previous DeclID to be
1076  // loaded & attached later on.
1077  RedeclarableTemplateDecl *FirstDecl =
1078      cast_or_null<RedeclarableTemplateDecl>(Reader.GetDecl(FirstDeclID));
1079  assert((FirstDecl == 0 || FirstDecl->getKind() == D->getKind()) &&
1080         "FirstDecl kind mismatch");
1081  if (FirstDecl) {
1082    D->CommonOrPrev = FirstDecl;
1083    // Mark the real previous DeclID to be loaded & attached later on.
1084    if (PreviousDeclID != FirstDeclID)
1085      Reader.PendingPreviousDecls.push_back(std::make_pair(D, PreviousDeclID));
1086  } else {
1087    D->CommonOrPrev = D->newCommon(Reader.getContext());
1088    if (RedeclarableTemplateDecl *RTD
1089          = ReadDeclAs<RedeclarableTemplateDecl>(Record, Idx)) {
1090      assert(RTD->getKind() == D->getKind() &&
1091             "InstantiatedFromMemberTemplate kind mismatch");
1092      D->setInstantiatedFromMemberTemplateImpl(RTD);
1093      if (Record[Idx++])
1094        D->setMemberSpecialization();
1095    }
1096
1097    RedeclarableTemplateDecl *LatestDecl
1098      = ReadDeclAs<RedeclarableTemplateDecl>(Record, Idx);
1099
1100    // This decl is a first one and the latest declaration that it points to is
1101    // in the same AST file. However, if this actually needs to point to a
1102    // redeclaration in another AST file, we need to update it by checking
1103    // the FirstLatestDeclIDs map which tracks this kind of decls.
1104    assert(Reader.GetDecl(ThisDeclID) == D && "Invalid ThisDeclID ?");
1105    ASTReader::FirstLatestDeclIDMap::iterator I
1106        = Reader.FirstLatestDeclIDs.find(ThisDeclID);
1107    if (I != Reader.FirstLatestDeclIDs.end()) {
1108      if (Decl *NewLatest = Reader.GetDecl(I->second))
1109        LatestDecl = cast<RedeclarableTemplateDecl>(NewLatest);
1110    }
1111
1112    assert(LatestDecl->getKind() == D->getKind() && "Latest kind mismatch");
1113    D->getCommonPtr()->Latest = LatestDecl;
1114  }
1115
1116  VisitTemplateDecl(D);
1117  D->IdentifierNamespace = Record[Idx++];
1118}
1119
1120void ASTDeclReader::VisitClassTemplateDecl(ClassTemplateDecl *D) {
1121  VisitRedeclarableTemplateDecl(D);
1122
1123  if (D->getPreviousDeclaration() == 0) {
1124    // This ClassTemplateDecl owns a CommonPtr; read it to keep track of all of
1125    // the specializations.
1126    SmallVector<serialization::DeclID, 2> SpecIDs;
1127    SpecIDs.push_back(0);
1128
1129    // Specializations.
1130    unsigned Size = Record[Idx++];
1131    SpecIDs[0] += Size;
1132    for (unsigned I = 0; I != Size; ++I)
1133      SpecIDs.push_back(ReadDeclID(Record, Idx));
1134
1135    // Partial specializations.
1136    Size = Record[Idx++];
1137    SpecIDs[0] += Size;
1138    for (unsigned I = 0; I != Size; ++I)
1139      SpecIDs.push_back(ReadDeclID(Record, Idx));
1140
1141    if (SpecIDs[0]) {
1142      typedef serialization::DeclID DeclID;
1143
1144      ClassTemplateDecl::Common *CommonPtr = D->getCommonPtr();
1145      CommonPtr->LazySpecializations
1146        = new (Reader.getContext()) DeclID [SpecIDs.size()];
1147      memcpy(CommonPtr->LazySpecializations, SpecIDs.data(),
1148             SpecIDs.size() * sizeof(DeclID));
1149    }
1150
1151    // InjectedClassNameType is computed.
1152  }
1153}
1154
1155void ASTDeclReader::VisitClassTemplateSpecializationDecl(
1156                                           ClassTemplateSpecializationDecl *D) {
1157  VisitCXXRecordDecl(D);
1158
1159  ASTContext &C = Reader.getContext();
1160  if (Decl *InstD = ReadDecl(Record, Idx)) {
1161    if (ClassTemplateDecl *CTD = dyn_cast<ClassTemplateDecl>(InstD)) {
1162      D->SpecializedTemplate = CTD;
1163    } else {
1164      SmallVector<TemplateArgument, 8> TemplArgs;
1165      Reader.ReadTemplateArgumentList(TemplArgs, F, Record, Idx);
1166      TemplateArgumentList *ArgList
1167        = TemplateArgumentList::CreateCopy(C, TemplArgs.data(),
1168                                           TemplArgs.size());
1169      ClassTemplateSpecializationDecl::SpecializedPartialSpecialization *PS
1170          = new (C) ClassTemplateSpecializationDecl::
1171                                             SpecializedPartialSpecialization();
1172      PS->PartialSpecialization
1173          = cast<ClassTemplatePartialSpecializationDecl>(InstD);
1174      PS->TemplateArgs = ArgList;
1175      D->SpecializedTemplate = PS;
1176    }
1177  }
1178
1179  // Explicit info.
1180  if (TypeSourceInfo *TyInfo = GetTypeSourceInfo(Record, Idx)) {
1181    ClassTemplateSpecializationDecl::ExplicitSpecializationInfo *ExplicitInfo
1182        = new (C) ClassTemplateSpecializationDecl::ExplicitSpecializationInfo;
1183    ExplicitInfo->TypeAsWritten = TyInfo;
1184    ExplicitInfo->ExternLoc = ReadSourceLocation(Record, Idx);
1185    ExplicitInfo->TemplateKeywordLoc = ReadSourceLocation(Record, Idx);
1186    D->ExplicitInfo = ExplicitInfo;
1187  }
1188
1189  SmallVector<TemplateArgument, 8> TemplArgs;
1190  Reader.ReadTemplateArgumentList(TemplArgs, F, Record, Idx);
1191  D->TemplateArgs = TemplateArgumentList::CreateCopy(C, TemplArgs.data(),
1192                                                     TemplArgs.size());
1193  D->PointOfInstantiation = ReadSourceLocation(Record, Idx);
1194  D->SpecializationKind = (TemplateSpecializationKind)Record[Idx++];
1195
1196  if (D->isCanonicalDecl()) { // It's kept in the folding set.
1197    ClassTemplateDecl *CanonPattern = ReadDeclAs<ClassTemplateDecl>(Record,Idx);
1198    if (ClassTemplatePartialSpecializationDecl *Partial
1199                       = dyn_cast<ClassTemplatePartialSpecializationDecl>(D)) {
1200      CanonPattern->getCommonPtr()->PartialSpecializations.InsertNode(Partial);
1201    } else {
1202      CanonPattern->getCommonPtr()->Specializations.InsertNode(D);
1203    }
1204  }
1205}
1206
1207void ASTDeclReader::VisitClassTemplatePartialSpecializationDecl(
1208                                    ClassTemplatePartialSpecializationDecl *D) {
1209  VisitClassTemplateSpecializationDecl(D);
1210
1211  ASTContext &C = Reader.getContext();
1212  D->TemplateParams = Reader.ReadTemplateParameterList(F, Record, Idx);
1213
1214  unsigned NumArgs = Record[Idx++];
1215  if (NumArgs) {
1216    D->NumArgsAsWritten = NumArgs;
1217    D->ArgsAsWritten = new (C) TemplateArgumentLoc[NumArgs];
1218    for (unsigned i=0; i != NumArgs; ++i)
1219      D->ArgsAsWritten[i] = Reader.ReadTemplateArgumentLoc(F, Record, Idx);
1220  }
1221
1222  D->SequenceNumber = Record[Idx++];
1223
1224  // These are read/set from/to the first declaration.
1225  if (D->getPreviousDeclaration() == 0) {
1226    D->InstantiatedFromMember.setPointer(
1227      ReadDeclAs<ClassTemplatePartialSpecializationDecl>(Record, Idx));
1228    D->InstantiatedFromMember.setInt(Record[Idx++]);
1229  }
1230}
1231
1232void ASTDeclReader::VisitClassScopeFunctionSpecializationDecl(
1233                                    ClassScopeFunctionSpecializationDecl *D) {
1234  VisitDecl(D);
1235  D->Specialization = ReadDeclAs<CXXMethodDecl>(Record, Idx);
1236}
1237
1238void ASTDeclReader::VisitFunctionTemplateDecl(FunctionTemplateDecl *D) {
1239  VisitRedeclarableTemplateDecl(D);
1240
1241  if (D->getPreviousDeclaration() == 0) {
1242    // This FunctionTemplateDecl owns a CommonPtr; read it.
1243
1244    // Read the function specialization declarations.
1245    // FunctionTemplateDecl's FunctionTemplateSpecializationInfos are filled
1246    // when reading the specialized FunctionDecl.
1247    unsigned NumSpecs = Record[Idx++];
1248    while (NumSpecs--)
1249      (void)ReadDecl(Record, Idx);
1250  }
1251}
1252
1253void ASTDeclReader::VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D) {
1254  VisitTypeDecl(D);
1255
1256  D->setDeclaredWithTypename(Record[Idx++]);
1257
1258  bool Inherited = Record[Idx++];
1259  TypeSourceInfo *DefArg = GetTypeSourceInfo(Record, Idx);
1260  D->setDefaultArgument(DefArg, Inherited);
1261}
1262
1263void ASTDeclReader::VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D) {
1264  VisitDeclaratorDecl(D);
1265  // TemplateParmPosition.
1266  D->setDepth(Record[Idx++]);
1267  D->setPosition(Record[Idx++]);
1268  if (D->isExpandedParameterPack()) {
1269    void **Data = reinterpret_cast<void **>(D + 1);
1270    for (unsigned I = 0, N = D->getNumExpansionTypes(); I != N; ++I) {
1271      Data[2*I] = Reader.readType(F, Record, Idx).getAsOpaquePtr();
1272      Data[2*I + 1] = GetTypeSourceInfo(Record, Idx);
1273    }
1274  } else {
1275    // Rest of NonTypeTemplateParmDecl.
1276    D->ParameterPack = Record[Idx++];
1277    if (Record[Idx++]) {
1278      Expr *DefArg = Reader.ReadExpr(F);
1279      bool Inherited = Record[Idx++];
1280      D->setDefaultArgument(DefArg, Inherited);
1281   }
1282  }
1283}
1284
1285void ASTDeclReader::VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D) {
1286  VisitTemplateDecl(D);
1287  // TemplateParmPosition.
1288  D->setDepth(Record[Idx++]);
1289  D->setPosition(Record[Idx++]);
1290  // Rest of TemplateTemplateParmDecl.
1291  TemplateArgumentLoc Arg = Reader.ReadTemplateArgumentLoc(F, Record, Idx);
1292  bool IsInherited = Record[Idx++];
1293  D->setDefaultArgument(Arg, IsInherited);
1294  D->ParameterPack = Record[Idx++];
1295}
1296
1297void ASTDeclReader::VisitTypeAliasTemplateDecl(TypeAliasTemplateDecl *D) {
1298  VisitRedeclarableTemplateDecl(D);
1299}
1300
1301void ASTDeclReader::VisitStaticAssertDecl(StaticAssertDecl *D) {
1302  VisitDecl(D);
1303  D->AssertExpr = Reader.ReadExpr(F);
1304  D->Message = cast<StringLiteral>(Reader.ReadExpr(F));
1305  D->RParenLoc = ReadSourceLocation(Record, Idx);
1306}
1307
1308std::pair<uint64_t, uint64_t>
1309ASTDeclReader::VisitDeclContext(DeclContext *DC) {
1310  uint64_t LexicalOffset = Record[Idx++];
1311  uint64_t VisibleOffset = Record[Idx++];
1312  return std::make_pair(LexicalOffset, VisibleOffset);
1313}
1314
1315template <typename T>
1316void ASTDeclReader::VisitRedeclarable(Redeclarable<T> *D) {
1317  enum RedeclKind { NoRedeclaration = 0, PointsToPrevious, PointsToLatest };
1318  RedeclKind Kind = (RedeclKind)Record[Idx++];
1319  switch (Kind) {
1320  default:
1321    llvm_unreachable("Out of sync with ASTDeclWriter::VisitRedeclarable or"
1322                     " messed up reading");
1323  case NoRedeclaration:
1324    break;
1325  case PointsToPrevious: {
1326    DeclID PreviousDeclID = ReadDeclID(Record, Idx);
1327    DeclID FirstDeclID = ReadDeclID(Record, Idx);
1328    // We delay loading of the redeclaration chain to avoid deeply nested calls.
1329    // We temporarily set the first (canonical) declaration as the previous one
1330    // which is the one that matters and mark the real previous DeclID to be
1331    // loaded & attached later on.
1332    D->RedeclLink = typename Redeclarable<T>::PreviousDeclLink(
1333                                cast_or_null<T>(Reader.GetDecl(FirstDeclID)));
1334    if (PreviousDeclID != FirstDeclID)
1335      Reader.PendingPreviousDecls.push_back(std::make_pair(static_cast<T*>(D),
1336                                                           PreviousDeclID));
1337    break;
1338  }
1339  case PointsToLatest:
1340    D->RedeclLink = typename Redeclarable<T>::LatestDeclLink(
1341                                                   ReadDeclAs<T>(Record, Idx));
1342    break;
1343  }
1344
1345  assert(!(Kind == PointsToPrevious &&
1346           Reader.FirstLatestDeclIDs.find(ThisDeclID) !=
1347               Reader.FirstLatestDeclIDs.end()) &&
1348         "This decl is not first, it should not be in the map");
1349  if (Kind == PointsToPrevious)
1350    return;
1351
1352  // This decl is a first one and the latest declaration that it points to is in
1353  // the same AST file. However, if this actually needs to point to a
1354  // redeclaration in another AST file, we need to update it by checking the
1355  // FirstLatestDeclIDs map which tracks this kind of decls.
1356  assert(Reader.GetDecl(ThisDeclID) == static_cast<T*>(D) &&
1357         "Invalid ThisDeclID ?");
1358  ASTReader::FirstLatestDeclIDMap::iterator I
1359      = Reader.FirstLatestDeclIDs.find(ThisDeclID);
1360  if (I != Reader.FirstLatestDeclIDs.end()) {
1361    Decl *NewLatest = Reader.GetDecl(I->second);
1362    D->RedeclLink
1363        = typename Redeclarable<T>::LatestDeclLink(cast_or_null<T>(NewLatest));
1364  }
1365}
1366
1367//===----------------------------------------------------------------------===//
1368// Attribute Reading
1369//===----------------------------------------------------------------------===//
1370
1371/// \brief Reads attributes from the current stream position.
1372void ASTReader::ReadAttributes(Module &F, AttrVec &Attrs,
1373                               const RecordData &Record, unsigned &Idx) {
1374  for (unsigned i = 0, e = Record[Idx++]; i != e; ++i) {
1375    Attr *New = 0;
1376    attr::Kind Kind = (attr::Kind)Record[Idx++];
1377    SourceRange Range = ReadSourceRange(F, Record, Idx);
1378
1379#include "clang/Serialization/AttrPCHRead.inc"
1380
1381    assert(New && "Unable to decode attribute?");
1382    Attrs.push_back(New);
1383  }
1384}
1385
1386//===----------------------------------------------------------------------===//
1387// ASTReader Implementation
1388//===----------------------------------------------------------------------===//
1389
1390/// \brief Note that we have loaded the declaration with the given
1391/// Index.
1392///
1393/// This routine notes that this declaration has already been loaded,
1394/// so that future GetDecl calls will return this declaration rather
1395/// than trying to load a new declaration.
1396inline void ASTReader::LoadedDecl(unsigned Index, Decl *D) {
1397  assert(!DeclsLoaded[Index] && "Decl loaded twice?");
1398  DeclsLoaded[Index] = D;
1399}
1400
1401
1402/// \brief Determine whether the consumer will be interested in seeing
1403/// this declaration (via HandleTopLevelDecl).
1404///
1405/// This routine should return true for anything that might affect
1406/// code generation, e.g., inline function definitions, Objective-C
1407/// declarations with metadata, etc.
1408static bool isConsumerInterestedIn(Decl *D) {
1409  // An ObjCMethodDecl is never considered as "interesting" because its
1410  // implementation container always is.
1411
1412  if (isa<FileScopeAsmDecl>(D) ||
1413      isa<ObjCProtocolDecl>(D) ||
1414      isa<ObjCImplDecl>(D))
1415    return true;
1416  if (VarDecl *Var = dyn_cast<VarDecl>(D))
1417    return Var->isFileVarDecl() &&
1418           Var->isThisDeclarationADefinition() == VarDecl::Definition;
1419  if (FunctionDecl *Func = dyn_cast<FunctionDecl>(D))
1420    return Func->doesThisDeclarationHaveABody();
1421
1422  return false;
1423}
1424
1425/// \brief Get the correct cursor and offset for loading a declaration.
1426ASTReader::RecordLocation
1427ASTReader::DeclCursorForID(DeclID ID) {
1428  // See if there's an override.
1429  DeclReplacementMap::iterator It = ReplacedDecls.find(ID);
1430  if (It != ReplacedDecls.end())
1431    return RecordLocation(It->second.first, It->second.second);
1432
1433  GlobalDeclMapType::iterator I = GlobalDeclMap.find(ID);
1434  assert(I != GlobalDeclMap.end() && "Corrupted global declaration map");
1435  Module *M = I->second;
1436  return RecordLocation(M,
1437           M->DeclOffsets[ID - M->BaseDeclID - NUM_PREDEF_DECL_IDS]);
1438}
1439
1440ASTReader::RecordLocation ASTReader::getLocalBitOffset(uint64_t GlobalOffset) {
1441  ContinuousRangeMap<uint64_t, Module*, 4>::iterator I
1442    = GlobalBitOffsetsMap.find(GlobalOffset);
1443
1444  assert(I != GlobalBitOffsetsMap.end() && "Corrupted global bit offsets map");
1445  return RecordLocation(I->second, GlobalOffset - I->second->GlobalBitOffset);
1446}
1447
1448uint64_t ASTReader::getGlobalBitOffset(Module &M, uint32_t LocalOffset) {
1449  return LocalOffset + M.GlobalBitOffset;
1450}
1451
1452void ASTDeclReader::attachPreviousDecl(Decl *D, Decl *previous) {
1453  assert(D && previous);
1454  if (TagDecl *TD = dyn_cast<TagDecl>(D)) {
1455    TD->RedeclLink.setPointer(cast<TagDecl>(previous));
1456  } else if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
1457    FD->RedeclLink.setPointer(cast<FunctionDecl>(previous));
1458  } else if (VarDecl *VD = dyn_cast<VarDecl>(D)) {
1459    VD->RedeclLink.setPointer(cast<VarDecl>(previous));
1460  } else {
1461    RedeclarableTemplateDecl *TD = cast<RedeclarableTemplateDecl>(D);
1462    TD->CommonOrPrev = cast<RedeclarableTemplateDecl>(previous);
1463  }
1464}
1465
1466void ASTReader::loadAndAttachPreviousDecl(Decl *D, serialization::DeclID ID) {
1467  Decl *previous = GetDecl(ID);
1468  ASTDeclReader::attachPreviousDecl(D, previous);
1469}
1470
1471/// \brief Read the declaration at the given offset from the AST file.
1472Decl *ASTReader::ReadDeclRecord(DeclID ID) {
1473  unsigned Index = ID - NUM_PREDEF_DECL_IDS;
1474  RecordLocation Loc = DeclCursorForID(ID);
1475  llvm::BitstreamCursor &DeclsCursor = Loc.F->DeclsCursor;
1476  // Keep track of where we are in the stream, then jump back there
1477  // after reading this declaration.
1478  SavedStreamPosition SavedPosition(DeclsCursor);
1479
1480  ReadingKindTracker ReadingKind(Read_Decl, *this);
1481
1482  // Note that we are loading a declaration record.
1483  Deserializing ADecl(this);
1484
1485  DeclsCursor.JumpToBit(Loc.Offset);
1486  RecordData Record;
1487  unsigned Code = DeclsCursor.ReadCode();
1488  unsigned Idx = 0;
1489  ASTDeclReader Reader(*this, *Loc.F, DeclsCursor, ID, Record, Idx);
1490
1491  Decl *D = 0;
1492  switch ((DeclCode)DeclsCursor.ReadRecord(Code, Record)) {
1493  case DECL_CONTEXT_LEXICAL:
1494  case DECL_CONTEXT_VISIBLE:
1495    llvm_unreachable("Record cannot be de-serialized with ReadDeclRecord");
1496  case DECL_TYPEDEF:
1497    D = TypedefDecl::Create(Context, 0, SourceLocation(), SourceLocation(),
1498                            0, 0);
1499    break;
1500  case DECL_TYPEALIAS:
1501    D = TypeAliasDecl::Create(Context, 0, SourceLocation(), SourceLocation(),
1502                              0, 0);
1503    break;
1504  case DECL_ENUM:
1505    D = EnumDecl::Create(Context, Decl::EmptyShell());
1506    break;
1507  case DECL_RECORD:
1508    D = RecordDecl::Create(Context, Decl::EmptyShell());
1509    break;
1510  case DECL_ENUM_CONSTANT:
1511    D = EnumConstantDecl::Create(Context, 0, SourceLocation(), 0, QualType(),
1512                                 0, llvm::APSInt());
1513    break;
1514  case DECL_FUNCTION:
1515    D = FunctionDecl::Create(Context, 0, SourceLocation(), SourceLocation(),
1516                             DeclarationName(), QualType(), 0);
1517    break;
1518  case DECL_LINKAGE_SPEC:
1519    D = LinkageSpecDecl::Create(Context, 0, SourceLocation(), SourceLocation(),
1520                                (LinkageSpecDecl::LanguageIDs)0,
1521                                SourceLocation());
1522    break;
1523  case DECL_LABEL:
1524    D = LabelDecl::Create(Context, 0, SourceLocation(), 0);
1525    break;
1526  case DECL_NAMESPACE:
1527    D = NamespaceDecl::Create(Context, 0, SourceLocation(),
1528                              SourceLocation(), 0);
1529    break;
1530  case DECL_NAMESPACE_ALIAS:
1531    D = NamespaceAliasDecl::Create(Context, 0, SourceLocation(),
1532                                   SourceLocation(), 0,
1533                                   NestedNameSpecifierLoc(),
1534                                   SourceLocation(), 0);
1535    break;
1536  case DECL_USING:
1537    D = UsingDecl::Create(Context, 0, SourceLocation(),
1538                          NestedNameSpecifierLoc(), DeclarationNameInfo(),
1539                          false);
1540    break;
1541  case DECL_USING_SHADOW:
1542    D = UsingShadowDecl::Create(Context, 0, SourceLocation(), 0, 0);
1543    break;
1544  case DECL_USING_DIRECTIVE:
1545    D = UsingDirectiveDecl::Create(Context, 0, SourceLocation(),
1546                                   SourceLocation(), NestedNameSpecifierLoc(),
1547                                   SourceLocation(), 0, 0);
1548    break;
1549  case DECL_UNRESOLVED_USING_VALUE:
1550    D = UnresolvedUsingValueDecl::Create(Context, 0, SourceLocation(),
1551                                         NestedNameSpecifierLoc(),
1552                                         DeclarationNameInfo());
1553    break;
1554  case DECL_UNRESOLVED_USING_TYPENAME:
1555    D = UnresolvedUsingTypenameDecl::Create(Context, 0, SourceLocation(),
1556                                            SourceLocation(),
1557                                            NestedNameSpecifierLoc(),
1558                                            SourceLocation(),
1559                                            DeclarationName());
1560    break;
1561  case DECL_CXX_RECORD:
1562    D = CXXRecordDecl::Create(Context, Decl::EmptyShell());
1563    break;
1564  case DECL_CXX_METHOD:
1565    D = CXXMethodDecl::Create(Context, 0, SourceLocation(),
1566                              DeclarationNameInfo(), QualType(), 0,
1567                              false, SC_None, false, false, SourceLocation());
1568    break;
1569  case DECL_CXX_CONSTRUCTOR:
1570    D = CXXConstructorDecl::Create(Context, Decl::EmptyShell());
1571    break;
1572  case DECL_CXX_DESTRUCTOR:
1573    D = CXXDestructorDecl::Create(Context, Decl::EmptyShell());
1574    break;
1575  case DECL_CXX_CONVERSION:
1576    D = CXXConversionDecl::Create(Context, Decl::EmptyShell());
1577    break;
1578  case DECL_ACCESS_SPEC:
1579    D = AccessSpecDecl::Create(Context, Decl::EmptyShell());
1580    break;
1581  case DECL_FRIEND:
1582    D = FriendDecl::Create(Context, Decl::EmptyShell());
1583    break;
1584  case DECL_FRIEND_TEMPLATE:
1585    D = FriendTemplateDecl::Create(Context, Decl::EmptyShell());
1586    break;
1587  case DECL_CLASS_TEMPLATE:
1588    D = ClassTemplateDecl::Create(Context, Decl::EmptyShell());
1589    break;
1590  case DECL_CLASS_TEMPLATE_SPECIALIZATION:
1591    D = ClassTemplateSpecializationDecl::Create(Context, Decl::EmptyShell());
1592    break;
1593  case DECL_CLASS_TEMPLATE_PARTIAL_SPECIALIZATION:
1594    D = ClassTemplatePartialSpecializationDecl::Create(Context,
1595                                                       Decl::EmptyShell());
1596    break;
1597  case DECL_CLASS_SCOPE_FUNCTION_SPECIALIZATION:
1598    D = ClassScopeFunctionSpecializationDecl::Create(Context,
1599                                                     Decl::EmptyShell());
1600    break;
1601  case DECL_FUNCTION_TEMPLATE:
1602      D = FunctionTemplateDecl::Create(Context, Decl::EmptyShell());
1603    break;
1604  case DECL_TEMPLATE_TYPE_PARM:
1605    D = TemplateTypeParmDecl::Create(Context, Decl::EmptyShell());
1606    break;
1607  case DECL_NON_TYPE_TEMPLATE_PARM:
1608    D = NonTypeTemplateParmDecl::Create(Context, 0, SourceLocation(),
1609                                        SourceLocation(), 0, 0, 0, QualType(),
1610                                        false, 0);
1611    break;
1612  case DECL_EXPANDED_NON_TYPE_TEMPLATE_PARM_PACK:
1613    D = NonTypeTemplateParmDecl::Create(Context, 0, SourceLocation(),
1614                                        SourceLocation(), 0, 0, 0, QualType(),
1615                                        0, 0, Record[Idx++], 0);
1616    break;
1617  case DECL_TEMPLATE_TEMPLATE_PARM:
1618    D = TemplateTemplateParmDecl::Create(Context, 0, SourceLocation(), 0, 0,
1619                                         false, 0, 0);
1620    break;
1621  case DECL_TYPE_ALIAS_TEMPLATE:
1622    D = TypeAliasTemplateDecl::Create(Context, Decl::EmptyShell());
1623    break;
1624  case DECL_STATIC_ASSERT:
1625    D = StaticAssertDecl::Create(Context, 0, SourceLocation(), 0, 0,
1626                                 SourceLocation());
1627    break;
1628
1629  case DECL_OBJC_METHOD:
1630    D = ObjCMethodDecl::Create(Context, SourceLocation(), SourceLocation(),
1631                               Selector(), QualType(), 0, 0);
1632    break;
1633  case DECL_OBJC_INTERFACE:
1634    D = ObjCInterfaceDecl::Create(Context, 0, SourceLocation(), 0);
1635    break;
1636  case DECL_OBJC_IVAR:
1637    D = ObjCIvarDecl::Create(Context, 0, SourceLocation(), SourceLocation(),
1638                             0, QualType(), 0, ObjCIvarDecl::None);
1639    break;
1640  case DECL_OBJC_PROTOCOL:
1641    D = ObjCProtocolDecl::Create(Context, 0, 0, SourceLocation(),
1642                                 SourceLocation(), 0);
1643    break;
1644  case DECL_OBJC_AT_DEFS_FIELD:
1645    D = ObjCAtDefsFieldDecl::Create(Context, 0, SourceLocation(),
1646                                    SourceLocation(), 0, QualType(), 0);
1647    break;
1648  case DECL_OBJC_CLASS:
1649    D = ObjCClassDecl::Create(Context, 0, SourceLocation());
1650    break;
1651  case DECL_OBJC_FORWARD_PROTOCOL:
1652    D = ObjCForwardProtocolDecl::Create(Context, 0, SourceLocation());
1653    break;
1654  case DECL_OBJC_CATEGORY:
1655    D = ObjCCategoryDecl::Create(Context, Decl::EmptyShell());
1656    break;
1657  case DECL_OBJC_CATEGORY_IMPL:
1658    D = ObjCCategoryImplDecl::Create(Context, 0, 0, 0, SourceLocation(),
1659                                     SourceLocation());
1660    break;
1661  case DECL_OBJC_IMPLEMENTATION:
1662    D = ObjCImplementationDecl::Create(Context, 0, 0, 0, SourceLocation(),
1663                                       SourceLocation());
1664    break;
1665  case DECL_OBJC_COMPATIBLE_ALIAS:
1666    D = ObjCCompatibleAliasDecl::Create(Context, 0, SourceLocation(), 0, 0);
1667    break;
1668  case DECL_OBJC_PROPERTY:
1669    D = ObjCPropertyDecl::Create(Context, 0, SourceLocation(), 0, SourceLocation(),
1670                                 0);
1671    break;
1672  case DECL_OBJC_PROPERTY_IMPL:
1673    D = ObjCPropertyImplDecl::Create(Context, 0, SourceLocation(),
1674                                     SourceLocation(), 0,
1675                                     ObjCPropertyImplDecl::Dynamic, 0,
1676                                     SourceLocation());
1677    break;
1678  case DECL_FIELD:
1679    D = FieldDecl::Create(Context, 0, SourceLocation(), SourceLocation(), 0,
1680                          QualType(), 0, 0, false, false);
1681    break;
1682  case DECL_INDIRECTFIELD:
1683    D = IndirectFieldDecl::Create(Context, 0, SourceLocation(), 0, QualType(),
1684                                  0, 0);
1685    break;
1686  case DECL_VAR:
1687    D = VarDecl::Create(Context, 0, SourceLocation(), SourceLocation(), 0,
1688                        QualType(), 0, SC_None, SC_None);
1689    break;
1690
1691  case DECL_IMPLICIT_PARAM:
1692    D = ImplicitParamDecl::Create(Context, 0, SourceLocation(), 0, QualType());
1693    break;
1694
1695  case DECL_PARM_VAR:
1696    D = ParmVarDecl::Create(Context, 0, SourceLocation(), SourceLocation(), 0,
1697                            QualType(), 0, SC_None, SC_None, 0);
1698    break;
1699  case DECL_FILE_SCOPE_ASM:
1700    D = FileScopeAsmDecl::Create(Context, 0, 0, SourceLocation(),
1701                                 SourceLocation());
1702    break;
1703  case DECL_BLOCK:
1704    D = BlockDecl::Create(Context, 0, SourceLocation());
1705    break;
1706  case DECL_CXX_BASE_SPECIFIERS:
1707    Error("attempt to read a C++ base-specifier record as a declaration");
1708    return 0;
1709  }
1710
1711  assert(D && "Unknown declaration reading AST file");
1712  LoadedDecl(Index, D);
1713  Reader.Visit(D);
1714
1715  // If this declaration is also a declaration context, get the
1716  // offsets for its tables of lexical and visible declarations.
1717  if (DeclContext *DC = dyn_cast<DeclContext>(D)) {
1718    std::pair<uint64_t, uint64_t> Offsets = Reader.VisitDeclContext(DC);
1719    if (Offsets.first || Offsets.second) {
1720      if (Offsets.first != 0)
1721        DC->setHasExternalLexicalStorage(true);
1722      if (Offsets.second != 0)
1723        DC->setHasExternalVisibleStorage(true);
1724      if (ReadDeclContextStorage(*Loc.F, DeclsCursor, Offsets,
1725                                 Loc.F->DeclContextInfos[DC]))
1726        return 0;
1727    }
1728
1729    // Now add the pending visible updates for this decl context, if it has any.
1730    DeclContextVisibleUpdatesPending::iterator I =
1731        PendingVisibleUpdates.find(ID);
1732    if (I != PendingVisibleUpdates.end()) {
1733      // There are updates. This means the context has external visible
1734      // storage, even if the original stored version didn't.
1735      DC->setHasExternalVisibleStorage(true);
1736      DeclContextVisibleUpdates &U = I->second;
1737      for (DeclContextVisibleUpdates::iterator UI = U.begin(), UE = U.end();
1738           UI != UE; ++UI) {
1739        UI->second->DeclContextInfos[DC].NameLookupTableData = UI->first;
1740      }
1741      PendingVisibleUpdates.erase(I);
1742    }
1743  }
1744  assert(Idx == Record.size());
1745
1746  // Load any relevant update records.
1747  loadDeclUpdateRecords(ID, D);
1748
1749  if (ObjCChainedCategoriesInterfaces.count(ID))
1750    loadObjCChainedCategories(ID, cast<ObjCInterfaceDecl>(D));
1751
1752  // If we have deserialized a declaration that has a definition the
1753  // AST consumer might need to know about, queue it.
1754  // We don't pass it to the consumer immediately because we may be in recursive
1755  // loading, and some declarations may still be initializing.
1756  if (isConsumerInterestedIn(D))
1757      InterestingDecls.push_back(D);
1758
1759  return D;
1760}
1761
1762void ASTReader::loadDeclUpdateRecords(serialization::DeclID ID, Decl *D) {
1763  // The declaration may have been modified by files later in the chain.
1764  // If this is the case, read the record containing the updates from each file
1765  // and pass it to ASTDeclReader to make the modifications.
1766  DeclUpdateOffsetsMap::iterator UpdI = DeclUpdateOffsets.find(ID);
1767  if (UpdI != DeclUpdateOffsets.end()) {
1768    FileOffsetsTy &UpdateOffsets = UpdI->second;
1769    for (FileOffsetsTy::iterator
1770         I = UpdateOffsets.begin(), E = UpdateOffsets.end(); I != E; ++I) {
1771      Module *F = I->first;
1772      uint64_t Offset = I->second;
1773      llvm::BitstreamCursor &Cursor = F->DeclsCursor;
1774      SavedStreamPosition SavedPosition(Cursor);
1775      Cursor.JumpToBit(Offset);
1776      RecordData Record;
1777      unsigned Code = Cursor.ReadCode();
1778      unsigned RecCode = Cursor.ReadRecord(Code, Record);
1779      (void)RecCode;
1780      assert(RecCode == DECL_UPDATES && "Expected DECL_UPDATES record!");
1781
1782      unsigned Idx = 0;
1783      ASTDeclReader Reader(*this, *F, Cursor, ID, Record, Idx);
1784      Reader.UpdateDecl(D, *F, Record);
1785    }
1786  }
1787}
1788
1789namespace {
1790  /// \brief Given an ObjC interface, goes through the modules and links to the
1791  /// interface all the categories for it.
1792  class ObjCChainedCategoriesVisitor {
1793    ASTReader &Reader;
1794    serialization::GlobalDeclID InterfaceID;
1795    ObjCInterfaceDecl *Interface;
1796    ObjCCategoryDecl *GlobHeadCat, *GlobTailCat;
1797    llvm::DenseMap<DeclarationName, ObjCCategoryDecl *> NameCategoryMap;
1798
1799  public:
1800    ObjCChainedCategoriesVisitor(ASTReader &Reader,
1801                                 serialization::GlobalDeclID InterfaceID,
1802                                 ObjCInterfaceDecl *Interface)
1803      : Reader(Reader), InterfaceID(InterfaceID), Interface(Interface),
1804        GlobHeadCat(0), GlobTailCat(0) { }
1805
1806    static bool visit(Module &M, void *UserData) {
1807      return static_cast<ObjCChainedCategoriesVisitor *>(UserData)->visit(M);
1808    }
1809
1810    bool visit(Module &M) {
1811      if (Reader.isDeclIDFromModule(InterfaceID, M))
1812        return true; // We reached the module where the interface originated
1813                    // from. Stop traversing the imported modules.
1814
1815      Module::ChainedObjCCategoriesMap::iterator
1816        I = M.ChainedObjCCategories.find(InterfaceID);
1817      if (I == M.ChainedObjCCategories.end())
1818        return false;
1819
1820      ObjCCategoryDecl *
1821        HeadCat = Reader.GetLocalDeclAs<ObjCCategoryDecl>(M, I->second.first);
1822      ObjCCategoryDecl *
1823        TailCat = Reader.GetLocalDeclAs<ObjCCategoryDecl>(M, I->second.second);
1824
1825      addCategories(HeadCat, TailCat);
1826      return false;
1827    }
1828
1829    void addCategories(ObjCCategoryDecl *HeadCat,
1830                       ObjCCategoryDecl *TailCat = 0) {
1831      if (!HeadCat) {
1832        assert(!TailCat);
1833        return;
1834      }
1835
1836      if (!TailCat) {
1837        TailCat = HeadCat;
1838        while (TailCat->getNextClassCategory())
1839          TailCat = TailCat->getNextClassCategory();
1840      }
1841
1842      if (!GlobHeadCat) {
1843        GlobHeadCat = HeadCat;
1844        GlobTailCat = TailCat;
1845      } else {
1846        ASTDeclReader::setNextObjCCategory(GlobTailCat, HeadCat);
1847        GlobTailCat = TailCat;
1848      }
1849
1850      llvm::DenseSet<DeclarationName> Checked;
1851      for (ObjCCategoryDecl *Cat = HeadCat,
1852                            *CatEnd = TailCat->getNextClassCategory();
1853             Cat != CatEnd; Cat = Cat->getNextClassCategory()) {
1854        if (Checked.count(Cat->getDeclName()))
1855          continue;
1856        Checked.insert(Cat->getDeclName());
1857        checkForDuplicate(Cat);
1858      }
1859    }
1860
1861    /// \brief Warns for duplicate categories that come from different modules.
1862    void checkForDuplicate(ObjCCategoryDecl *Cat) {
1863      DeclarationName Name = Cat->getDeclName();
1864      // Find the top category with the same name. We do not want to warn for
1865      // duplicates along the established chain because there were already
1866      // warnings for them when the module was created. We only want to warn for
1867      // duplicates between non-dependent modules:
1868      //
1869      //   MT     //
1870      //  /  \    //
1871      // ML  MR   //
1872      //
1873      // We want to warn for duplicates between ML and MR,not between ML and MT.
1874      //
1875      // FIXME: We should not warn for duplicates in diamond:
1876      //
1877      //   MT     //
1878      //  /  \    //
1879      // ML  MR   //
1880      //  \  /    //
1881      //   MB     //
1882      //
1883      // If there are duplicates in ML/MR, there will be warning when creating
1884      // MB *and* when importing MB. We should not warn when importing.
1885      for (ObjCCategoryDecl *Next = Cat->getNextClassCategory(); Next;
1886             Next = Next->getNextClassCategory()) {
1887        if (Next->getDeclName() == Name)
1888          Cat = Next;
1889      }
1890
1891      ObjCCategoryDecl *&PrevCat = NameCategoryMap[Name];
1892      if (!PrevCat)
1893        PrevCat = Cat;
1894
1895      if (PrevCat != Cat) {
1896        Reader.Diag(Cat->getLocation(), diag::warn_dup_category_def)
1897          << Interface->getDeclName() << Name;
1898        Reader.Diag(PrevCat->getLocation(), diag::note_previous_definition);
1899      }
1900    }
1901
1902    ObjCCategoryDecl *getHeadCategory() const { return GlobHeadCat; }
1903  };
1904}
1905
1906void ASTReader::loadObjCChainedCategories(serialization::GlobalDeclID ID,
1907                                          ObjCInterfaceDecl *D) {
1908  ObjCChainedCategoriesVisitor Visitor(*this, ID, D);
1909  ModuleMgr.visit(ObjCChainedCategoriesVisitor::visit, &Visitor);
1910  // Also add the categories that the interface already links to.
1911  Visitor.addCategories(D->getCategoryList());
1912  D->setCategoryList(Visitor.getHeadCategory());
1913}
1914
1915void ASTDeclReader::UpdateDecl(Decl *D, Module &Module,
1916                               const RecordData &Record) {
1917  unsigned Idx = 0;
1918  while (Idx < Record.size()) {
1919    switch ((DeclUpdateKind)Record[Idx++]) {
1920    case UPD_CXX_SET_DEFINITIONDATA: {
1921      CXXRecordDecl *RD = cast<CXXRecordDecl>(D);
1922      CXXRecordDecl *DefinitionDecl
1923        = Reader.ReadDeclAs<CXXRecordDecl>(Module, Record, Idx);
1924      assert(!RD->DefinitionData && "DefinitionData is already set!");
1925      InitializeCXXDefinitionData(RD, DefinitionDecl, Record, Idx);
1926      break;
1927    }
1928
1929    case UPD_CXX_ADDED_IMPLICIT_MEMBER:
1930      cast<CXXRecordDecl>(D)->addedMember(Reader.ReadDecl(Module, Record, Idx));
1931      break;
1932
1933    case UPD_CXX_ADDED_TEMPLATE_SPECIALIZATION:
1934      // It will be added to the template's specializations set when loaded.
1935      (void)Reader.ReadDecl(Module, Record, Idx);
1936      break;
1937
1938    case UPD_CXX_ADDED_ANONYMOUS_NAMESPACE: {
1939      NamespaceDecl *Anon
1940        = Reader.ReadDeclAs<NamespaceDecl>(Module, Record, Idx);
1941      // Guard against these being loaded out of original order. Don't use
1942      // getNextNamespace(), since it tries to access the context and can't in
1943      // the middle of deserialization.
1944      if (!Anon->NextNamespace) {
1945        if (TranslationUnitDecl *TU = dyn_cast<TranslationUnitDecl>(D))
1946          TU->setAnonymousNamespace(Anon);
1947        else
1948          cast<NamespaceDecl>(D)->OrigOrAnonNamespace.setPointer(Anon);
1949      }
1950      break;
1951    }
1952
1953    case UPD_CXX_INSTANTIATED_STATIC_DATA_MEMBER:
1954      cast<VarDecl>(D)->getMemberSpecializationInfo()->setPointOfInstantiation(
1955          Reader.ReadSourceLocation(Module, Record, Idx));
1956      break;
1957    }
1958  }
1959}
1960