ASTReaderDecl.cpp revision 8538e8d43a3a9bd439c987c0de37bcbf035dd391 
1//===--- ASTReaderDecl.cpp - Decl Deserialization ---------------*- C++ -*-===//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10// This file implements the ASTReader::ReadDeclRecord method, which is the
11// entrypoint for loading a decl.
12//
13//===----------------------------------------------------------------------===//
14
15#include "clang/Serialization/ASTReader.h"
16#include "clang/AST/ASTConsumer.h"
17#include "clang/AST/ASTContext.h"
18#include "clang/AST/DeclVisitor.h"
19#include "clang/AST/DeclGroup.h"
20#include "clang/AST/DeclCXX.h"
21#include "clang/AST/DeclTemplate.h"
22#include "clang/AST/Expr.h"
23using namespace clang;
24using namespace clang::serialization;
25
26//===----------------------------------------------------------------------===//
27// Declaration deserialization
28//===----------------------------------------------------------------------===//
29
30namespace clang {
31  class ASTDeclReader : public DeclVisitor<ASTDeclReader, void> {
32    ASTReader &Reader;
33    llvm::BitstreamCursor &Cursor;
34    const DeclID ThisDeclID;
35    const ASTReader::RecordData &Record;
36    unsigned &Idx;
37    TypeID TypeIDForTypeDecl;
38
39    uint64_t GetCurrentCursorOffset();
40
41  public:
42    ASTDeclReader(ASTReader &Reader, llvm::BitstreamCursor &Cursor,
43                  DeclID thisDeclID, const ASTReader::RecordData &Record,
44                  unsigned &Idx)
45      : Reader(Reader), Cursor(Cursor), ThisDeclID(thisDeclID), Record(Record),
46        Idx(Idx), TypeIDForTypeDecl(0) { }
47
48    void Visit(Decl *D);
49
50    void VisitDecl(Decl *D);
51    void VisitTranslationUnitDecl(TranslationUnitDecl *TU);
52    void VisitNamedDecl(NamedDecl *ND);
53    void VisitNamespaceDecl(NamespaceDecl *D);
54    void VisitUsingDirectiveDecl(UsingDirectiveDecl *D);
55    void VisitNamespaceAliasDecl(NamespaceAliasDecl *D);
56    void VisitTypeDecl(TypeDecl *TD);
57    void VisitTypedefDecl(TypedefDecl *TD);
58    void VisitUnresolvedUsingTypenameDecl(UnresolvedUsingTypenameDecl *D);
59    void VisitTagDecl(TagDecl *TD);
60    void VisitEnumDecl(EnumDecl *ED);
61    void VisitRecordDecl(RecordDecl *RD);
62    void VisitCXXRecordDecl(CXXRecordDecl *D);
63    void VisitClassTemplateSpecializationDecl(
64                                            ClassTemplateSpecializationDecl *D);
65    void VisitClassTemplatePartialSpecializationDecl(
66                                     ClassTemplatePartialSpecializationDecl *D);
67    void VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D);
68    void VisitValueDecl(ValueDecl *VD);
69    void VisitEnumConstantDecl(EnumConstantDecl *ECD);
70    void VisitUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *D);
71    void VisitDeclaratorDecl(DeclaratorDecl *DD);
72    void VisitFunctionDecl(FunctionDecl *FD);
73    void VisitCXXMethodDecl(CXXMethodDecl *D);
74    void VisitCXXConstructorDecl(CXXConstructorDecl *D);
75    void VisitCXXDestructorDecl(CXXDestructorDecl *D);
76    void VisitCXXConversionDecl(CXXConversionDecl *D);
77    void VisitFieldDecl(FieldDecl *FD);
78    void VisitVarDecl(VarDecl *VD);
79    void VisitImplicitParamDecl(ImplicitParamDecl *PD);
80    void VisitParmVarDecl(ParmVarDecl *PD);
81    void VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D);
82    void VisitTemplateDecl(TemplateDecl *D);
83    void VisitRedeclarableTemplateDecl(RedeclarableTemplateDecl *D);
84    void VisitClassTemplateDecl(ClassTemplateDecl *D);
85    void VisitFunctionTemplateDecl(FunctionTemplateDecl *D);
86    void VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D);
87    void VisitUsingDecl(UsingDecl *D);
88    void VisitUsingShadowDecl(UsingShadowDecl *D);
89    void VisitLinkageSpecDecl(LinkageSpecDecl *D);
90    void VisitFileScopeAsmDecl(FileScopeAsmDecl *AD);
91    void VisitAccessSpecDecl(AccessSpecDecl *D);
92    void VisitFriendDecl(FriendDecl *D);
93    void VisitFriendTemplateDecl(FriendTemplateDecl *D);
94    void VisitStaticAssertDecl(StaticAssertDecl *D);
95    void VisitBlockDecl(BlockDecl *BD);
96
97    std::pair<uint64_t, uint64_t> VisitDeclContext(DeclContext *DC);
98    template <typename T> void VisitRedeclarable(Redeclarable<T> *D);
99
100    // FIXME: Reorder according to DeclNodes.td?
101    void VisitObjCMethodDecl(ObjCMethodDecl *D);
102    void VisitObjCContainerDecl(ObjCContainerDecl *D);
103    void VisitObjCInterfaceDecl(ObjCInterfaceDecl *D);
104    void VisitObjCIvarDecl(ObjCIvarDecl *D);
105    void VisitObjCProtocolDecl(ObjCProtocolDecl *D);
106    void VisitObjCAtDefsFieldDecl(ObjCAtDefsFieldDecl *D);
107    void VisitObjCClassDecl(ObjCClassDecl *D);
108    void VisitObjCForwardProtocolDecl(ObjCForwardProtocolDecl *D);
109    void VisitObjCCategoryDecl(ObjCCategoryDecl *D);
110    void VisitObjCImplDecl(ObjCImplDecl *D);
111    void VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D);
112    void VisitObjCImplementationDecl(ObjCImplementationDecl *D);
113    void VisitObjCCompatibleAliasDecl(ObjCCompatibleAliasDecl *D);
114    void VisitObjCPropertyDecl(ObjCPropertyDecl *D);
115    void VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D);
116  };
117}
118
119uint64_t ASTDeclReader::GetCurrentCursorOffset() {
120  uint64_t Off = 0;
121  for (unsigned I = 0, N = Reader.Chain.size(); I != N; ++I) {
122    ASTReader::PerFileData &F = *Reader.Chain[N - I - 1];
123    if (&Cursor == &F.DeclsCursor) {
124      Off += F.DeclsCursor.GetCurrentBitNo();
125      break;
126    }
127    Off += F.SizeInBits;
128  }
129  return Off;
130}
131
132void ASTDeclReader::Visit(Decl *D) {
133  DeclVisitor<ASTDeclReader, void>::Visit(D);
134
135  if (TypeDecl *TD = dyn_cast<TypeDecl>(D)) {
136    // if we have a fully initialized TypeDecl, we can safely read its type now.
137    TD->setTypeForDecl(Reader.GetType(TypeIDForTypeDecl).getTypePtr());
138  } else if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
139    // FunctionDecl's body was written last after all other Stmts/Exprs.
140    if (Record[Idx++])
141      FD->setLazyBody(GetCurrentCursorOffset());
142  }
143}
144
145void ASTDeclReader::VisitDecl(Decl *D) {
146  D->setDeclContext(cast_or_null<DeclContext>(Reader.GetDecl(Record[Idx++])));
147  D->setLexicalDeclContext(
148                     cast_or_null<DeclContext>(Reader.GetDecl(Record[Idx++])));
149  D->setLocation(SourceLocation::getFromRawEncoding(Record[Idx++]));
150  D->setInvalidDecl(Record[Idx++]);
151  if (Record[Idx++]) {
152    AttrVec Attrs;
153    Reader.ReadAttributes(Cursor, Attrs);
154    D->setAttrs(Attrs);
155  }
156  D->setImplicit(Record[Idx++]);
157  D->setUsed(Record[Idx++]);
158  D->setAccess((AccessSpecifier)Record[Idx++]);
159  D->setPCHLevel(Record[Idx++] + 1);
160}
161
162void ASTDeclReader::VisitTranslationUnitDecl(TranslationUnitDecl *TU) {
163  VisitDecl(TU);
164  TU->setAnonymousNamespace(
165                    cast_or_null<NamespaceDecl>(Reader.GetDecl(Record[Idx++])));
166}
167
168void ASTDeclReader::VisitNamedDecl(NamedDecl *ND) {
169  VisitDecl(ND);
170  ND->setDeclName(Reader.ReadDeclarationName(Record, Idx));
171}
172
173void ASTDeclReader::VisitTypeDecl(TypeDecl *TD) {
174  VisitNamedDecl(TD);
175  // Delay type reading until after we have fully initialized the decl.
176  TypeIDForTypeDecl = Record[Idx++];
177}
178
179void ASTDeclReader::VisitTypedefDecl(TypedefDecl *TD) {
180  VisitTypeDecl(TD);
181  TD->setTypeSourceInfo(Reader.GetTypeSourceInfo(Cursor, Record, Idx));
182}
183
184void ASTDeclReader::VisitTagDecl(TagDecl *TD) {
185  VisitTypeDecl(TD);
186  TD->IdentifierNamespace = Record[Idx++];
187  VisitRedeclarable(TD);
188  TD->setTagKind((TagDecl::TagKind)Record[Idx++]);
189  TD->setDefinition(Record[Idx++]);
190  TD->setEmbeddedInDeclarator(Record[Idx++]);
191  TD->setRBraceLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
192  TD->setTagKeywordLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
193  // FIXME: maybe read optional qualifier and its range.
194  TD->setTypedefForAnonDecl(
195                    cast_or_null<TypedefDecl>(Reader.GetDecl(Record[Idx++])));
196}
197
198void ASTDeclReader::VisitEnumDecl(EnumDecl *ED) {
199  VisitTagDecl(ED);
200  ED->setIntegerType(Reader.GetType(Record[Idx++]));
201  ED->setPromotionType(Reader.GetType(Record[Idx++]));
202  ED->setNumPositiveBits(Record[Idx++]);
203  ED->setNumNegativeBits(Record[Idx++]);
204  ED->setInstantiationOfMemberEnum(
205                         cast_or_null<EnumDecl>(Reader.GetDecl(Record[Idx++])));
206}
207
208void ASTDeclReader::VisitRecordDecl(RecordDecl *RD) {
209  VisitTagDecl(RD);
210  RD->setHasFlexibleArrayMember(Record[Idx++]);
211  RD->setAnonymousStructOrUnion(Record[Idx++]);
212  RD->setHasObjectMember(Record[Idx++]);
213}
214
215void ASTDeclReader::VisitValueDecl(ValueDecl *VD) {
216  VisitNamedDecl(VD);
217  VD->setType(Reader.GetType(Record[Idx++]));
218}
219
220void ASTDeclReader::VisitEnumConstantDecl(EnumConstantDecl *ECD) {
221  VisitValueDecl(ECD);
222  if (Record[Idx++])
223    ECD->setInitExpr(Reader.ReadExpr(Cursor));
224  ECD->setInitVal(Reader.ReadAPSInt(Record, Idx));
225}
226
227void ASTDeclReader::VisitDeclaratorDecl(DeclaratorDecl *DD) {
228  VisitValueDecl(DD);
229  TypeSourceInfo *TInfo = Reader.GetTypeSourceInfo(Cursor, Record, Idx);
230  if (TInfo)
231    DD->setTypeSourceInfo(TInfo);
232  // FIXME: read optional qualifier and its range.
233}
234
235void ASTDeclReader::VisitFunctionDecl(FunctionDecl *FD) {
236  VisitDeclaratorDecl(FD);
237  // FIXME: read DeclarationNameLoc.
238
239  FD->IdentifierNamespace = Record[Idx++];
240  switch ((FunctionDecl::TemplatedKind)Record[Idx++]) {
241  default: assert(false && "Unhandled TemplatedKind!");
242    break;
243  case FunctionDecl::TK_NonTemplate:
244    break;
245  case FunctionDecl::TK_FunctionTemplate:
246    FD->setDescribedFunctionTemplate(
247                     cast<FunctionTemplateDecl>(Reader.GetDecl(Record[Idx++])));
248    break;
249  case FunctionDecl::TK_MemberSpecialization: {
250    FunctionDecl *InstFD = cast<FunctionDecl>(Reader.GetDecl(Record[Idx++]));
251    TemplateSpecializationKind TSK = (TemplateSpecializationKind)Record[Idx++];
252    SourceLocation POI = Reader.ReadSourceLocation(Record, Idx);
253    FD->setInstantiationOfMemberFunction(InstFD, TSK);
254    FD->getMemberSpecializationInfo()->setPointOfInstantiation(POI);
255    break;
256  }
257  case FunctionDecl::TK_FunctionTemplateSpecialization: {
258    FunctionTemplateDecl *Template
259      = cast<FunctionTemplateDecl>(Reader.GetDecl(Record[Idx++]));
260    TemplateSpecializationKind TSK = (TemplateSpecializationKind)Record[Idx++];
261
262    // Template arguments.
263    llvm::SmallVector<TemplateArgument, 8> TemplArgs;
264    Reader.ReadTemplateArgumentList(TemplArgs, Cursor, Record, Idx);
265
266    // Template args as written.
267    llvm::SmallVector<TemplateArgumentLoc, 8> TemplArgLocs;
268    SourceLocation LAngleLoc, RAngleLoc;
269    if (Record[Idx++]) {  // TemplateArgumentsAsWritten != 0
270      unsigned NumTemplateArgLocs = Record[Idx++];
271      TemplArgLocs.reserve(NumTemplateArgLocs);
272      for (unsigned i=0; i != NumTemplateArgLocs; ++i)
273        TemplArgLocs.push_back(
274            Reader.ReadTemplateArgumentLoc(Cursor, Record, Idx));
275
276      LAngleLoc = Reader.ReadSourceLocation(Record, Idx);
277      RAngleLoc = Reader.ReadSourceLocation(Record, Idx);
278    }
279
280    SourceLocation POI = Reader.ReadSourceLocation(Record, Idx);
281
282    if (FD->isCanonicalDecl()) // if canonical add to template's set.
283      FD->setFunctionTemplateSpecialization(Template, TemplArgs.size(),
284                                            TemplArgs.data(), TSK,
285                                            TemplArgLocs.size(),
286                                            TemplArgLocs.data(),
287                                            LAngleLoc, RAngleLoc, POI);
288    break;
289  }
290  case FunctionDecl::TK_DependentFunctionTemplateSpecialization: {
291    // Templates.
292    UnresolvedSet<8> TemplDecls;
293    unsigned NumTemplates = Record[Idx++];
294    while (NumTemplates--)
295      TemplDecls.addDecl(cast<NamedDecl>(Reader.GetDecl(Record[Idx++])));
296
297    // Templates args.
298    TemplateArgumentListInfo TemplArgs;
299    unsigned NumArgs = Record[Idx++];
300    while (NumArgs--)
301      TemplArgs.addArgument(Reader.ReadTemplateArgumentLoc(Cursor,Record, Idx));
302    TemplArgs.setLAngleLoc(Reader.ReadSourceLocation(Record, Idx));
303    TemplArgs.setRAngleLoc(Reader.ReadSourceLocation(Record, Idx));
304
305    FD->setDependentTemplateSpecialization(*Reader.getContext(),
306                                           TemplDecls, TemplArgs);
307    break;
308  }
309  }
310
311  // FunctionDecl's body is handled last at ASTDeclReader::Visit,
312  // after everything else is read.
313
314  VisitRedeclarable(FD);
315  FD->setStorageClass((FunctionDecl::StorageClass)Record[Idx++]);
316  FD->setStorageClassAsWritten((FunctionDecl::StorageClass)Record[Idx++]);
317  FD->setInlineSpecified(Record[Idx++]);
318  FD->setVirtualAsWritten(Record[Idx++]);
319  FD->setPure(Record[Idx++]);
320  FD->setHasInheritedPrototype(Record[Idx++]);
321  FD->setHasWrittenPrototype(Record[Idx++]);
322  FD->setDeleted(Record[Idx++]);
323  FD->setTrivial(Record[Idx++]);
324  FD->setCopyAssignment(Record[Idx++]);
325  FD->setHasImplicitReturnZero(Record[Idx++]);
326  FD->setLocEnd(SourceLocation::getFromRawEncoding(Record[Idx++]));
327
328  // Read in the parameters.
329  unsigned NumParams = Record[Idx++];
330  llvm::SmallVector<ParmVarDecl *, 16> Params;
331  Params.reserve(NumParams);
332  for (unsigned I = 0; I != NumParams; ++I)
333    Params.push_back(cast<ParmVarDecl>(Reader.GetDecl(Record[Idx++])));
334  FD->setParams(Params.data(), NumParams);
335}
336
337void ASTDeclReader::VisitObjCMethodDecl(ObjCMethodDecl *MD) {
338  VisitNamedDecl(MD);
339  if (Record[Idx++]) {
340    // In practice, this won't be executed (since method definitions
341    // don't occur in header files).
342    MD->setBody(Reader.ReadStmt(Cursor));
343    MD->setSelfDecl(cast<ImplicitParamDecl>(Reader.GetDecl(Record[Idx++])));
344    MD->setCmdDecl(cast<ImplicitParamDecl>(Reader.GetDecl(Record[Idx++])));
345  }
346  MD->setInstanceMethod(Record[Idx++]);
347  MD->setVariadic(Record[Idx++]);
348  MD->setSynthesized(Record[Idx++]);
349  MD->setDefined(Record[Idx++]);
350  MD->setDeclImplementation((ObjCMethodDecl::ImplementationControl)Record[Idx++]);
351  MD->setObjCDeclQualifier((Decl::ObjCDeclQualifier)Record[Idx++]);
352  MD->setNumSelectorArgs(unsigned(Record[Idx++]));
353  MD->setResultType(Reader.GetType(Record[Idx++]));
354  MD->setResultTypeSourceInfo(Reader.GetTypeSourceInfo(Cursor, Record, Idx));
355  MD->setEndLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
356  unsigned NumParams = Record[Idx++];
357  llvm::SmallVector<ParmVarDecl *, 16> Params;
358  Params.reserve(NumParams);
359  for (unsigned I = 0; I != NumParams; ++I)
360    Params.push_back(cast<ParmVarDecl>(Reader.GetDecl(Record[Idx++])));
361  MD->setMethodParams(*Reader.getContext(), Params.data(), NumParams,
362                      NumParams);
363}
364
365void ASTDeclReader::VisitObjCContainerDecl(ObjCContainerDecl *CD) {
366  VisitNamedDecl(CD);
367  SourceLocation A = SourceLocation::getFromRawEncoding(Record[Idx++]);
368  SourceLocation B = SourceLocation::getFromRawEncoding(Record[Idx++]);
369  CD->setAtEndRange(SourceRange(A, B));
370}
371
372void ASTDeclReader::VisitObjCInterfaceDecl(ObjCInterfaceDecl *ID) {
373  VisitObjCContainerDecl(ID);
374  ID->setTypeForDecl(Reader.GetType(Record[Idx++]).getTypePtr());
375  ID->setSuperClass(cast_or_null<ObjCInterfaceDecl>
376                       (Reader.GetDecl(Record[Idx++])));
377  unsigned NumProtocols = Record[Idx++];
378  llvm::SmallVector<ObjCProtocolDecl *, 16> Protocols;
379  Protocols.reserve(NumProtocols);
380  for (unsigned I = 0; I != NumProtocols; ++I)
381    Protocols.push_back(cast<ObjCProtocolDecl>(Reader.GetDecl(Record[Idx++])));
382  llvm::SmallVector<SourceLocation, 16> ProtoLocs;
383  ProtoLocs.reserve(NumProtocols);
384  for (unsigned I = 0; I != NumProtocols; ++I)
385    ProtoLocs.push_back(SourceLocation::getFromRawEncoding(Record[Idx++]));
386  ID->setProtocolList(Protocols.data(), NumProtocols, ProtoLocs.data(),
387                      *Reader.getContext());
388  unsigned NumIvars = Record[Idx++];
389  llvm::SmallVector<ObjCIvarDecl *, 16> IVars;
390  IVars.reserve(NumIvars);
391  for (unsigned I = 0; I != NumIvars; ++I)
392    IVars.push_back(cast<ObjCIvarDecl>(Reader.GetDecl(Record[Idx++])));
393  ID->setCategoryList(
394               cast_or_null<ObjCCategoryDecl>(Reader.GetDecl(Record[Idx++])));
395  ID->setForwardDecl(Record[Idx++]);
396  ID->setImplicitInterfaceDecl(Record[Idx++]);
397  ID->setClassLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
398  ID->setSuperClassLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
399  ID->setLocEnd(SourceLocation::getFromRawEncoding(Record[Idx++]));
400}
401
402void ASTDeclReader::VisitObjCIvarDecl(ObjCIvarDecl *IVD) {
403  VisitFieldDecl(IVD);
404  IVD->setAccessControl((ObjCIvarDecl::AccessControl)Record[Idx++]);
405  bool synth = Record[Idx++];
406  IVD->setSynthesize(synth);
407}
408
409void ASTDeclReader::VisitObjCProtocolDecl(ObjCProtocolDecl *PD) {
410  VisitObjCContainerDecl(PD);
411  PD->setForwardDecl(Record[Idx++]);
412  PD->setLocEnd(SourceLocation::getFromRawEncoding(Record[Idx++]));
413  unsigned NumProtoRefs = Record[Idx++];
414  llvm::SmallVector<ObjCProtocolDecl *, 16> ProtoRefs;
415  ProtoRefs.reserve(NumProtoRefs);
416  for (unsigned I = 0; I != NumProtoRefs; ++I)
417    ProtoRefs.push_back(cast<ObjCProtocolDecl>(Reader.GetDecl(Record[Idx++])));
418  llvm::SmallVector<SourceLocation, 16> ProtoLocs;
419  ProtoLocs.reserve(NumProtoRefs);
420  for (unsigned I = 0; I != NumProtoRefs; ++I)
421    ProtoLocs.push_back(SourceLocation::getFromRawEncoding(Record[Idx++]));
422  PD->setProtocolList(ProtoRefs.data(), NumProtoRefs, ProtoLocs.data(),
423                      *Reader.getContext());
424}
425
426void ASTDeclReader::VisitObjCAtDefsFieldDecl(ObjCAtDefsFieldDecl *FD) {
427  VisitFieldDecl(FD);
428}
429
430void ASTDeclReader::VisitObjCClassDecl(ObjCClassDecl *CD) {
431  VisitDecl(CD);
432  unsigned NumClassRefs = Record[Idx++];
433  llvm::SmallVector<ObjCInterfaceDecl *, 16> ClassRefs;
434  ClassRefs.reserve(NumClassRefs);
435  for (unsigned I = 0; I != NumClassRefs; ++I)
436    ClassRefs.push_back(cast<ObjCInterfaceDecl>(Reader.GetDecl(Record[Idx++])));
437  llvm::SmallVector<SourceLocation, 16> SLocs;
438  SLocs.reserve(NumClassRefs);
439  for (unsigned I = 0; I != NumClassRefs; ++I)
440    SLocs.push_back(SourceLocation::getFromRawEncoding(Record[Idx++]));
441  CD->setClassList(*Reader.getContext(), ClassRefs.data(), SLocs.data(),
442                   NumClassRefs);
443}
444
445void ASTDeclReader::VisitObjCForwardProtocolDecl(ObjCForwardProtocolDecl *FPD) {
446  VisitDecl(FPD);
447  unsigned NumProtoRefs = Record[Idx++];
448  llvm::SmallVector<ObjCProtocolDecl *, 16> ProtoRefs;
449  ProtoRefs.reserve(NumProtoRefs);
450  for (unsigned I = 0; I != NumProtoRefs; ++I)
451    ProtoRefs.push_back(cast<ObjCProtocolDecl>(Reader.GetDecl(Record[Idx++])));
452  llvm::SmallVector<SourceLocation, 16> ProtoLocs;
453  ProtoLocs.reserve(NumProtoRefs);
454  for (unsigned I = 0; I != NumProtoRefs; ++I)
455    ProtoLocs.push_back(SourceLocation::getFromRawEncoding(Record[Idx++]));
456  FPD->setProtocolList(ProtoRefs.data(), NumProtoRefs, ProtoLocs.data(),
457                       *Reader.getContext());
458}
459
460void ASTDeclReader::VisitObjCCategoryDecl(ObjCCategoryDecl *CD) {
461  VisitObjCContainerDecl(CD);
462  CD->setClassInterface(cast<ObjCInterfaceDecl>(Reader.GetDecl(Record[Idx++])));
463  unsigned NumProtoRefs = Record[Idx++];
464  llvm::SmallVector<ObjCProtocolDecl *, 16> ProtoRefs;
465  ProtoRefs.reserve(NumProtoRefs);
466  for (unsigned I = 0; I != NumProtoRefs; ++I)
467    ProtoRefs.push_back(cast<ObjCProtocolDecl>(Reader.GetDecl(Record[Idx++])));
468  llvm::SmallVector<SourceLocation, 16> ProtoLocs;
469  ProtoLocs.reserve(NumProtoRefs);
470  for (unsigned I = 0; I != NumProtoRefs; ++I)
471    ProtoLocs.push_back(SourceLocation::getFromRawEncoding(Record[Idx++]));
472  CD->setProtocolList(ProtoRefs.data(), NumProtoRefs, ProtoLocs.data(),
473                      *Reader.getContext());
474  CD->setNextClassCategory(cast_or_null<ObjCCategoryDecl>(Reader.GetDecl(Record[Idx++])));
475  CD->setAtLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
476  CD->setCategoryNameLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
477}
478
479void ASTDeclReader::VisitObjCCompatibleAliasDecl(ObjCCompatibleAliasDecl *CAD) {
480  VisitNamedDecl(CAD);
481  CAD->setClassInterface(cast<ObjCInterfaceDecl>(Reader.GetDecl(Record[Idx++])));
482}
483
484void ASTDeclReader::VisitObjCPropertyDecl(ObjCPropertyDecl *D) {
485  VisitNamedDecl(D);
486  D->setAtLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
487  D->setType(Reader.GetTypeSourceInfo(Cursor, Record, Idx));
488  // FIXME: stable encoding
489  D->setPropertyAttributes(
490                      (ObjCPropertyDecl::PropertyAttributeKind)Record[Idx++]);
491  D->setPropertyAttributesAsWritten(
492                      (ObjCPropertyDecl::PropertyAttributeKind)Record[Idx++]);
493  // FIXME: stable encoding
494  D->setPropertyImplementation(
495                            (ObjCPropertyDecl::PropertyControl)Record[Idx++]);
496  D->setGetterName(Reader.ReadDeclarationName(Record, Idx).getObjCSelector());
497  D->setSetterName(Reader.ReadDeclarationName(Record, Idx).getObjCSelector());
498  D->setGetterMethodDecl(
499                 cast_or_null<ObjCMethodDecl>(Reader.GetDecl(Record[Idx++])));
500  D->setSetterMethodDecl(
501                 cast_or_null<ObjCMethodDecl>(Reader.GetDecl(Record[Idx++])));
502  D->setPropertyIvarDecl(
503                   cast_or_null<ObjCIvarDecl>(Reader.GetDecl(Record[Idx++])));
504}
505
506void ASTDeclReader::VisitObjCImplDecl(ObjCImplDecl *D) {
507  VisitObjCContainerDecl(D);
508  D->setClassInterface(
509              cast_or_null<ObjCInterfaceDecl>(Reader.GetDecl(Record[Idx++])));
510}
511
512void ASTDeclReader::VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D) {
513  VisitObjCImplDecl(D);
514  D->setIdentifier(Reader.GetIdentifierInfo(Record, Idx));
515}
516
517void ASTDeclReader::VisitObjCImplementationDecl(ObjCImplementationDecl *D) {
518  VisitObjCImplDecl(D);
519  D->setSuperClass(
520              cast_or_null<ObjCInterfaceDecl>(Reader.GetDecl(Record[Idx++])));
521  llvm::tie(D->IvarInitializers, D->NumIvarInitializers)
522      = Reader.ReadCXXBaseOrMemberInitializers(Cursor, Record, Idx);
523}
524
525
526void ASTDeclReader::VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D) {
527  VisitDecl(D);
528  D->setAtLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
529  D->setPropertyDecl(
530               cast_or_null<ObjCPropertyDecl>(Reader.GetDecl(Record[Idx++])));
531  D->setPropertyIvarDecl(
532                   cast_or_null<ObjCIvarDecl>(Reader.GetDecl(Record[Idx++])));
533  D->setGetterCXXConstructor(Reader.ReadExpr(Cursor));
534  D->setSetterCXXAssignment(Reader.ReadExpr(Cursor));
535}
536
537void ASTDeclReader::VisitFieldDecl(FieldDecl *FD) {
538  VisitDeclaratorDecl(FD);
539  FD->setMutable(Record[Idx++]);
540  if (Record[Idx++])
541    FD->setBitWidth(Reader.ReadExpr(Cursor));
542  if (!FD->getDeclName()) {
543    FieldDecl *Tmpl = cast_or_null<FieldDecl>(Reader.GetDecl(Record[Idx++]));
544    if (Tmpl)
545      Reader.getContext()->setInstantiatedFromUnnamedFieldDecl(FD, Tmpl);
546  }
547}
548
549void ASTDeclReader::VisitVarDecl(VarDecl *VD) {
550  VisitDeclaratorDecl(VD);
551  VD->setStorageClass((VarDecl::StorageClass)Record[Idx++]);
552  VD->setStorageClassAsWritten((VarDecl::StorageClass)Record[Idx++]);
553  VD->setThreadSpecified(Record[Idx++]);
554  VD->setCXXDirectInitializer(Record[Idx++]);
555  VD->setExceptionVariable(Record[Idx++]);
556  VD->setNRVOVariable(Record[Idx++]);
557  VisitRedeclarable(VD);
558  if (Record[Idx++])
559    VD->setInit(Reader.ReadExpr(Cursor));
560
561  if (Record[Idx++]) { // HasMemberSpecializationInfo.
562    VarDecl *Tmpl = cast<VarDecl>(Reader.GetDecl(Record[Idx++]));
563    TemplateSpecializationKind TSK = (TemplateSpecializationKind)Record[Idx++];
564    SourceLocation POI = Reader.ReadSourceLocation(Record, Idx);
565    Reader.getContext()->setInstantiatedFromStaticDataMember(VD, Tmpl, TSK,POI);
566  }
567}
568
569void ASTDeclReader::VisitImplicitParamDecl(ImplicitParamDecl *PD) {
570  VisitVarDecl(PD);
571}
572
573void ASTDeclReader::VisitParmVarDecl(ParmVarDecl *PD) {
574  VisitVarDecl(PD);
575  PD->setObjCDeclQualifier((Decl::ObjCDeclQualifier)Record[Idx++]);
576  PD->setHasInheritedDefaultArg(Record[Idx++]);
577  if (Record[Idx++]) // hasUninstantiatedDefaultArg.
578    PD->setUninstantiatedDefaultArg(Reader.ReadExpr(Cursor));
579}
580
581void ASTDeclReader::VisitFileScopeAsmDecl(FileScopeAsmDecl *AD) {
582  VisitDecl(AD);
583  AD->setAsmString(cast<StringLiteral>(Reader.ReadExpr(Cursor)));
584}
585
586void ASTDeclReader::VisitBlockDecl(BlockDecl *BD) {
587  VisitDecl(BD);
588  BD->setBody(cast_or_null<CompoundStmt>(Reader.ReadStmt(Cursor)));
589  BD->setSignatureAsWritten(Reader.GetTypeSourceInfo(Cursor, Record, Idx));
590  unsigned NumParams = Record[Idx++];
591  llvm::SmallVector<ParmVarDecl *, 16> Params;
592  Params.reserve(NumParams);
593  for (unsigned I = 0; I != NumParams; ++I)
594    Params.push_back(cast<ParmVarDecl>(Reader.GetDecl(Record[Idx++])));
595  BD->setParams(Params.data(), NumParams);
596}
597
598void ASTDeclReader::VisitLinkageSpecDecl(LinkageSpecDecl *D) {
599  VisitDecl(D);
600  D->setLanguage((LinkageSpecDecl::LanguageIDs)Record[Idx++]);
601  D->setHasBraces(Record[Idx++]);
602}
603
604void ASTDeclReader::VisitNamespaceDecl(NamespaceDecl *D) {
605  VisitNamedDecl(D);
606  D->setLBracLoc(Reader.ReadSourceLocation(Record, Idx));
607  D->setRBracLoc(Reader.ReadSourceLocation(Record, Idx));
608  D->setNextNamespace(
609                    cast_or_null<NamespaceDecl>(Reader.GetDecl(Record[Idx++])));
610
611  bool IsOriginal = Record[Idx++];
612  D->OrigOrAnonNamespace.setInt(IsOriginal);
613  D->OrigOrAnonNamespace.setPointer(
614                    cast_or_null<NamespaceDecl>(Reader.GetDecl(Record[Idx++])));
615}
616
617void ASTDeclReader::VisitNamespaceAliasDecl(NamespaceAliasDecl *D) {
618  VisitNamedDecl(D);
619
620  D->setAliasLoc(Reader.ReadSourceLocation(Record, Idx));
621  D->setQualifierRange(Reader.ReadSourceRange(Record, Idx));
622  D->setQualifier(Reader.ReadNestedNameSpecifier(Record, Idx));
623  D->setTargetNameLoc(Reader.ReadSourceLocation(Record, Idx));
624  D->setAliasedNamespace(cast<NamedDecl>(Reader.GetDecl(Record[Idx++])));
625}
626
627void ASTDeclReader::VisitUsingDecl(UsingDecl *D) {
628  VisitNamedDecl(D);
629  D->setUsingLocation(Reader.ReadSourceLocation(Record, Idx));
630  D->setNestedNameRange(Reader.ReadSourceRange(Record, Idx));
631  D->setTargetNestedNameDecl(Reader.ReadNestedNameSpecifier(Record, Idx));
632  // FIXME: read the DNLoc component.
633
634  // FIXME: It would probably be more efficient to read these into a vector
635  // and then re-cosntruct the shadow decl set over that vector since it
636  // would avoid existence checks.
637  unsigned NumShadows = Record[Idx++];
638  for(unsigned I = 0; I != NumShadows; ++I) {
639    // Avoid invariant checking of UsingDecl::addShadowDecl, the decl may still
640    // be initializing.
641    D->Shadows.insert(cast<UsingShadowDecl>(Reader.GetDecl(Record[Idx++])));
642  }
643  D->setTypeName(Record[Idx++]);
644  NamedDecl *Pattern = cast_or_null<NamedDecl>(Reader.GetDecl(Record[Idx++]));
645  if (Pattern)
646    Reader.getContext()->setInstantiatedFromUsingDecl(D, Pattern);
647}
648
649void ASTDeclReader::VisitUsingShadowDecl(UsingShadowDecl *D) {
650  VisitNamedDecl(D);
651  D->setTargetDecl(cast<NamedDecl>(Reader.GetDecl(Record[Idx++])));
652  D->setUsingDecl(cast<UsingDecl>(Reader.GetDecl(Record[Idx++])));
653  UsingShadowDecl *Pattern
654      = cast_or_null<UsingShadowDecl>(Reader.GetDecl(Record[Idx++]));
655  if (Pattern)
656    Reader.getContext()->setInstantiatedFromUsingShadowDecl(D, Pattern);
657}
658
659void ASTDeclReader::VisitUsingDirectiveDecl(UsingDirectiveDecl *D) {
660  VisitNamedDecl(D);
661  D->setNamespaceKeyLocation(Reader.ReadSourceLocation(Record, Idx));
662  D->setQualifierRange(Reader.ReadSourceRange(Record, Idx));
663  D->setQualifier(Reader.ReadNestedNameSpecifier(Record, Idx));
664  D->setIdentLocation(Reader.ReadSourceLocation(Record, Idx));
665  D->setNominatedNamespace(cast<NamedDecl>(Reader.GetDecl(Record[Idx++])));
666  D->setCommonAncestor(cast_or_null<DeclContext>(
667                                                Reader.GetDecl(Record[Idx++])));
668}
669
670void ASTDeclReader::VisitUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *D) {
671  VisitValueDecl(D);
672  D->setTargetNestedNameRange(Reader.ReadSourceRange(Record, Idx));
673  D->setUsingLoc(Reader.ReadSourceLocation(Record, Idx));
674  D->setTargetNestedNameSpecifier(Reader.ReadNestedNameSpecifier(Record, Idx));
675  // FIXME: read the DNLoc component.
676}
677
678void ASTDeclReader::VisitUnresolvedUsingTypenameDecl(
679                                               UnresolvedUsingTypenameDecl *D) {
680  VisitTypeDecl(D);
681  D->setTargetNestedNameRange(Reader.ReadSourceRange(Record, Idx));
682  D->setUsingLoc(Reader.ReadSourceLocation(Record, Idx));
683  D->setTypenameLoc(Reader.ReadSourceLocation(Record, Idx));
684  D->setTargetNestedNameSpecifier(Reader.ReadNestedNameSpecifier(Record, Idx));
685}
686
687void ASTDeclReader::VisitCXXRecordDecl(CXXRecordDecl *D) {
688  ASTContext &C = *Reader.getContext();
689
690  // We need to allocate the DefinitionData struct ahead of VisitRecordDecl
691  // so that the other CXXRecordDecls can get a pointer even when the owner
692  // is still initializing.
693  bool OwnsDefinitionData = false;
694  enum DataOwnership { Data_NoDefData, Data_Owner, Data_NotOwner };
695  switch ((DataOwnership)Record[Idx++]) {
696  default:
697    assert(0 && "Out of sync with ASTDeclWriter or messed up reading");
698  case Data_NoDefData:
699    break;
700  case Data_Owner:
701    OwnsDefinitionData = true;
702    D->DefinitionData = new (C) struct CXXRecordDecl::DefinitionData(D);
703    break;
704  case Data_NotOwner:
705    D->DefinitionData
706        = cast<CXXRecordDecl>(Reader.GetDecl(Record[Idx++]))->DefinitionData;
707    break;
708  }
709
710  VisitRecordDecl(D);
711
712  if (OwnsDefinitionData) {
713    assert(D->DefinitionData);
714    struct CXXRecordDecl::DefinitionData &Data = *D->DefinitionData;
715
716    Data.UserDeclaredConstructor = Record[Idx++];
717    Data.UserDeclaredCopyConstructor = Record[Idx++];
718    Data.UserDeclaredCopyAssignment = Record[Idx++];
719    Data.UserDeclaredDestructor = Record[Idx++];
720    Data.Aggregate = Record[Idx++];
721    Data.PlainOldData = Record[Idx++];
722    Data.Empty = Record[Idx++];
723    Data.Polymorphic = Record[Idx++];
724    Data.Abstract = Record[Idx++];
725    Data.HasTrivialConstructor = Record[Idx++];
726    Data.HasTrivialCopyConstructor = Record[Idx++];
727    Data.HasTrivialCopyAssignment = Record[Idx++];
728    Data.HasTrivialDestructor = Record[Idx++];
729    Data.ComputedVisibleConversions = Record[Idx++];
730    Data.DeclaredDefaultConstructor = Record[Idx++];
731    Data.DeclaredCopyConstructor = Record[Idx++];
732    Data.DeclaredCopyAssignment = Record[Idx++];
733    Data.DeclaredDestructor = Record[Idx++];
734
735    // setBases() is unsuitable since it may try to iterate the bases of an
736    // uninitialized base.
737    Data.NumBases = Record[Idx++];
738    Data.Bases = new(C) CXXBaseSpecifier [Data.NumBases];
739    for (unsigned i = 0; i != Data.NumBases; ++i)
740      Data.Bases[i] = Reader.ReadCXXBaseSpecifier(Cursor, Record, Idx);
741
742    // FIXME: Make VBases lazily computed when needed to avoid storing them.
743    Data.NumVBases = Record[Idx++];
744    Data.VBases = new(C) CXXBaseSpecifier [Data.NumVBases];
745    for (unsigned i = 0; i != Data.NumVBases; ++i)
746      Data.VBases[i] = Reader.ReadCXXBaseSpecifier(Cursor, Record, Idx);
747
748    Reader.ReadUnresolvedSet(Data.Conversions, Record, Idx);
749    Reader.ReadUnresolvedSet(Data.VisibleConversions, Record, Idx);
750    assert(Data.Definition && "Data.Definition should be already set!");
751    Data.FirstFriend
752        = cast_or_null<FriendDecl>(Reader.GetDecl(Record[Idx++]));
753  }
754
755  enum CXXRecKind {
756    CXXRecNotTemplate = 0, CXXRecTemplate, CXXRecMemberSpecialization
757  };
758  switch ((CXXRecKind)Record[Idx++]) {
759  default:
760    assert(false && "Out of sync with ASTDeclWriter::VisitCXXRecordDecl?");
761  case CXXRecNotTemplate:
762    break;
763  case CXXRecTemplate:
764    D->setDescribedClassTemplate(
765                        cast<ClassTemplateDecl>(Reader.GetDecl(Record[Idx++])));
766    break;
767  case CXXRecMemberSpecialization: {
768    CXXRecordDecl *RD = cast<CXXRecordDecl>(Reader.GetDecl(Record[Idx++]));
769    TemplateSpecializationKind TSK = (TemplateSpecializationKind)Record[Idx++];
770    SourceLocation POI = Reader.ReadSourceLocation(Record, Idx);
771    D->setInstantiationOfMemberClass(RD, TSK);
772    D->getMemberSpecializationInfo()->setPointOfInstantiation(POI);
773    break;
774  }
775  }
776}
777
778void ASTDeclReader::VisitCXXMethodDecl(CXXMethodDecl *D) {
779  VisitFunctionDecl(D);
780  unsigned NumOverridenMethods = Record[Idx++];
781  while (NumOverridenMethods--) {
782    CXXMethodDecl *MD = cast<CXXMethodDecl>(Reader.GetDecl(Record[Idx++]));
783    // Avoid invariant checking of CXXMethodDecl::addOverriddenMethod,
784    // MD may be initializing.
785    Reader.getContext()->addOverriddenMethod(D, MD);
786  }
787}
788
789void ASTDeclReader::VisitCXXConstructorDecl(CXXConstructorDecl *D) {
790  VisitCXXMethodDecl(D);
791
792  D->IsExplicitSpecified = Record[Idx++];
793  D->ImplicitlyDefined = Record[Idx++];
794  llvm::tie(D->BaseOrMemberInitializers, D->NumBaseOrMemberInitializers)
795      = Reader.ReadCXXBaseOrMemberInitializers(Cursor, Record, Idx);
796}
797
798void ASTDeclReader::VisitCXXDestructorDecl(CXXDestructorDecl *D) {
799  VisitCXXMethodDecl(D);
800
801  D->ImplicitlyDefined = Record[Idx++];
802  D->OperatorDelete = cast_or_null<FunctionDecl>(Reader.GetDecl(Record[Idx++]));
803}
804
805void ASTDeclReader::VisitCXXConversionDecl(CXXConversionDecl *D) {
806  VisitCXXMethodDecl(D);
807  D->IsExplicitSpecified = Record[Idx++];
808}
809
810void ASTDeclReader::VisitAccessSpecDecl(AccessSpecDecl *D) {
811  VisitDecl(D);
812  D->setColonLoc(Reader.ReadSourceLocation(Record, Idx));
813}
814
815void ASTDeclReader::VisitFriendDecl(FriendDecl *D) {
816  VisitDecl(D);
817  if (Record[Idx++])
818    D->Friend = Reader.GetTypeSourceInfo(Cursor, Record, Idx);
819  else
820    D->Friend = cast<NamedDecl>(Reader.GetDecl(Record[Idx++]));
821  D->NextFriend = cast_or_null<FriendDecl>(Reader.GetDecl(Record[Idx++]));
822  D->FriendLoc = Reader.ReadSourceLocation(Record, Idx);
823}
824
825void ASTDeclReader::VisitFriendTemplateDecl(FriendTemplateDecl *D) {
826  VisitDecl(D);
827  unsigned NumParams = Record[Idx++];
828  D->NumParams = NumParams;
829  D->Params = new TemplateParameterList*[NumParams];
830  for (unsigned i = 0; i != NumParams; ++i)
831    D->Params[i] = Reader.ReadTemplateParameterList(Record, Idx);
832  if (Record[Idx++]) // HasFriendDecl
833    D->Friend = cast<NamedDecl>(Reader.GetDecl(Record[Idx++]));
834  else
835    D->Friend = Reader.GetTypeSourceInfo(Cursor, Record, Idx);
836  D->FriendLoc = Reader.ReadSourceLocation(Record, Idx);
837}
838
839void ASTDeclReader::VisitTemplateDecl(TemplateDecl *D) {
840  VisitNamedDecl(D);
841
842  NamedDecl *TemplatedDecl
843    = cast_or_null<NamedDecl>(Reader.GetDecl(Record[Idx++]));
844  TemplateParameterList* TemplateParams
845      = Reader.ReadTemplateParameterList(Record, Idx);
846  D->init(TemplatedDecl, TemplateParams);
847}
848
849void ASTDeclReader::VisitRedeclarableTemplateDecl(RedeclarableTemplateDecl *D) {
850  VisitTemplateDecl(D);
851
852  D->IdentifierNamespace = Record[Idx++];
853  RedeclarableTemplateDecl *PrevDecl =
854      cast_or_null<RedeclarableTemplateDecl>(Reader.GetDecl(Record[Idx++]));
855  assert((PrevDecl == 0 || PrevDecl->getKind() == D->getKind()) &&
856         "PrevDecl kind mismatch");
857  if (PrevDecl)
858    D->CommonOrPrev = PrevDecl;
859  if (PrevDecl == 0) {
860    if (RedeclarableTemplateDecl *RTD
861          = cast_or_null<RedeclarableTemplateDecl>(Reader.GetDecl(Record[Idx++]))) {
862      assert(RTD->getKind() == D->getKind() &&
863             "InstantiatedFromMemberTemplate kind mismatch");
864      D->setInstantiatedFromMemberTemplateImpl(RTD);
865      if (Record[Idx++])
866        D->setMemberSpecialization();
867    }
868
869    RedeclarableTemplateDecl *LatestDecl =
870        cast_or_null<RedeclarableTemplateDecl>(Reader.GetDecl(Record[Idx++]));
871
872    // This decl is a first one and the latest declaration that it points to is
873    // in the same AST file. However, if this actually needs to point to a
874    // redeclaration in another AST file, we need to update it by checking
875    // the FirstLatestDeclIDs map which tracks this kind of decls.
876    assert(Reader.GetDecl(ThisDeclID) == D && "Invalid ThisDeclID ?");
877    ASTReader::FirstLatestDeclIDMap::iterator I
878        = Reader.FirstLatestDeclIDs.find(ThisDeclID);
879    if (I != Reader.FirstLatestDeclIDs.end()) {
880      Decl *NewLatest = Reader.GetDecl(I->second);
881      assert((LatestDecl->getLocation().isInvalid() ||
882              NewLatest->getLocation().isInvalid()  ||
883              Reader.SourceMgr.isBeforeInTranslationUnit(
884                                                   LatestDecl->getLocation(),
885                                                   NewLatest->getLocation())) &&
886             "The new latest is supposed to come after the previous latest");
887      LatestDecl = cast<RedeclarableTemplateDecl>(NewLatest);
888    }
889
890    assert(LatestDecl->getKind() == D->getKind() && "Latest kind mismatch");
891    D->getCommonPtr()->Latest = LatestDecl;
892  }
893}
894
895void ASTDeclReader::VisitClassTemplateDecl(ClassTemplateDecl *D) {
896  VisitRedeclarableTemplateDecl(D);
897
898  if (D->getPreviousDeclaration() == 0) {
899    // This ClassTemplateDecl owns a CommonPtr; read it.
900
901    // FoldingSets are filled in VisitClassTemplateSpecializationDecl.
902    unsigned size = Record[Idx++];
903    while (size--)
904      cast<ClassTemplateSpecializationDecl>(Reader.GetDecl(Record[Idx++]));
905
906    size = Record[Idx++];
907    while (size--)
908      cast<ClassTemplatePartialSpecializationDecl>(
909                                                 Reader.GetDecl(Record[Idx++]));
910
911    // InjectedClassNameType is computed.
912  }
913}
914
915void ASTDeclReader::VisitClassTemplateSpecializationDecl(
916                                           ClassTemplateSpecializationDecl *D) {
917  VisitCXXRecordDecl(D);
918
919  if (Decl *InstD = Reader.GetDecl(Record[Idx++])) {
920    if (ClassTemplateDecl *CTD = dyn_cast<ClassTemplateDecl>(InstD)) {
921      D->setInstantiationOf(CTD);
922    } else {
923      llvm::SmallVector<TemplateArgument, 8> TemplArgs;
924      Reader.ReadTemplateArgumentList(TemplArgs, Cursor, Record, Idx);
925      D->setInstantiationOf(cast<ClassTemplatePartialSpecializationDecl>(InstD),
926                            TemplArgs.data(), TemplArgs.size());
927    }
928  }
929
930  // Explicit info.
931  if (TypeSourceInfo *TyInfo = Reader.GetTypeSourceInfo(Cursor, Record, Idx)) {
932    D->setTypeAsWritten(TyInfo);
933    D->setExternLoc(Reader.ReadSourceLocation(Record, Idx));
934    D->setTemplateKeywordLoc(Reader.ReadSourceLocation(Record, Idx));
935  }
936
937  llvm::SmallVector<TemplateArgument, 8> TemplArgs;
938  Reader.ReadTemplateArgumentList(TemplArgs, Cursor, Record, Idx);
939  D->initTemplateArgs(TemplArgs.data(), TemplArgs.size());
940  SourceLocation POI = Reader.ReadSourceLocation(Record, Idx);
941  if (POI.isValid())
942    D->setPointOfInstantiation(POI);
943  D->setSpecializationKind((TemplateSpecializationKind)Record[Idx++]);
944
945  if (D->isCanonicalDecl()) { // It's kept in the folding set.
946    ClassTemplateDecl *CanonPattern
947                       = cast<ClassTemplateDecl>(Reader.GetDecl(Record[Idx++]));
948    if (ClassTemplatePartialSpecializationDecl *Partial
949            = dyn_cast<ClassTemplatePartialSpecializationDecl>(D)) {
950      CanonPattern->getPartialSpecializations().InsertNode(Partial);
951    } else {
952      CanonPattern->getSpecializations().InsertNode(D);
953    }
954  }
955}
956
957void ASTDeclReader::VisitClassTemplatePartialSpecializationDecl(
958                                    ClassTemplatePartialSpecializationDecl *D) {
959  VisitClassTemplateSpecializationDecl(D);
960
961  D->initTemplateParameters(Reader.ReadTemplateParameterList(Record, Idx));
962
963  TemplateArgumentListInfo ArgInfos;
964  unsigned NumArgs = Record[Idx++];
965  while (NumArgs--)
966    ArgInfos.addArgument(Reader.ReadTemplateArgumentLoc(Cursor, Record, Idx));
967  D->initTemplateArgsAsWritten(ArgInfos);
968
969  D->setSequenceNumber(Record[Idx++]);
970
971  // These are read/set from/to the first declaration.
972  if (D->getPreviousDeclaration() == 0) {
973    D->setInstantiatedFromMember(
974        cast_or_null<ClassTemplatePartialSpecializationDecl>(
975                                                Reader.GetDecl(Record[Idx++])));
976    if (Record[Idx++])
977      D->setMemberSpecialization();
978  }
979}
980
981void ASTDeclReader::VisitFunctionTemplateDecl(FunctionTemplateDecl *D) {
982  VisitRedeclarableTemplateDecl(D);
983
984  if (D->getPreviousDeclaration() == 0) {
985    // This FunctionTemplateDecl owns a CommonPtr; read it.
986
987    // Read the function specialization declarations.
988    // FunctionTemplateDecl's FunctionTemplateSpecializationInfos are filled
989    // through the specialized FunctionDecl's setFunctionTemplateSpecialization.
990    unsigned NumSpecs = Record[Idx++];
991    while (NumSpecs--)
992      Reader.GetDecl(Record[Idx++]);
993  }
994}
995
996void ASTDeclReader::VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D) {
997  VisitTypeDecl(D);
998
999  D->setDeclaredWithTypename(Record[Idx++]);
1000  D->setParameterPack(Record[Idx++]);
1001
1002  bool Inherited = Record[Idx++];
1003  TypeSourceInfo *DefArg = Reader.GetTypeSourceInfo(Cursor, Record, Idx);
1004  D->setDefaultArgument(DefArg, Inherited);
1005}
1006
1007void ASTDeclReader::VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D) {
1008  VisitVarDecl(D);
1009  // TemplateParmPosition.
1010  D->setDepth(Record[Idx++]);
1011  D->setPosition(Record[Idx++]);
1012  // Rest of NonTypeTemplateParmDecl.
1013  if (Record[Idx++]) {
1014    Expr *DefArg = Reader.ReadExpr(Cursor);
1015    bool Inherited = Record[Idx++];
1016    D->setDefaultArgument(DefArg, Inherited);
1017 }
1018}
1019
1020void ASTDeclReader::VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D) {
1021  VisitTemplateDecl(D);
1022  // TemplateParmPosition.
1023  D->setDepth(Record[Idx++]);
1024  D->setPosition(Record[Idx++]);
1025  // Rest of TemplateTemplateParmDecl.
1026  TemplateArgumentLoc Arg = Reader.ReadTemplateArgumentLoc(Cursor, Record, Idx);
1027  bool IsInherited = Record[Idx++];
1028  D->setDefaultArgument(Arg, IsInherited);
1029}
1030
1031void ASTDeclReader::VisitStaticAssertDecl(StaticAssertDecl *D) {
1032  VisitDecl(D);
1033  D->AssertExpr = Reader.ReadExpr(Cursor);
1034  D->Message = cast<StringLiteral>(Reader.ReadExpr(Cursor));
1035}
1036
1037std::pair<uint64_t, uint64_t>
1038ASTDeclReader::VisitDeclContext(DeclContext *DC) {
1039  uint64_t LexicalOffset = Record[Idx++];
1040  uint64_t VisibleOffset = Record[Idx++];
1041  return std::make_pair(LexicalOffset, VisibleOffset);
1042}
1043
1044template <typename T>
1045void ASTDeclReader::VisitRedeclarable(Redeclarable<T> *D) {
1046  enum RedeclKind { NoRedeclaration = 0, PointsToPrevious, PointsToLatest };
1047  RedeclKind Kind = (RedeclKind)Record[Idx++];
1048  switch (Kind) {
1049  default:
1050    assert(0 && "Out of sync with ASTDeclWriter::VisitRedeclarable or messed up"
1051                " reading");
1052  case NoRedeclaration:
1053    break;
1054  case PointsToPrevious:
1055    D->RedeclLink = typename Redeclarable<T>::PreviousDeclLink(
1056                                cast_or_null<T>(Reader.GetDecl(Record[Idx++])));
1057    break;
1058  case PointsToLatest:
1059    D->RedeclLink = typename Redeclarable<T>::LatestDeclLink(
1060                                cast_or_null<T>(Reader.GetDecl(Record[Idx++])));
1061    break;
1062  }
1063
1064  assert(!(Kind == PointsToPrevious &&
1065           Reader.FirstLatestDeclIDs.find(ThisDeclID) !=
1066               Reader.FirstLatestDeclIDs.end()) &&
1067         "This decl is not first, it should not be in the map");
1068  if (Kind == PointsToPrevious)
1069    return;
1070
1071  // This decl is a first one and the latest declaration that it points to is in
1072  // the same AST file. However, if this actually needs to point to a
1073  // redeclaration in another AST file, we need to update it by checking the
1074  // FirstLatestDeclIDs map which tracks this kind of decls.
1075  assert(Reader.GetDecl(ThisDeclID) == static_cast<T*>(D) &&
1076         "Invalid ThisDeclID ?");
1077  ASTReader::FirstLatestDeclIDMap::iterator I
1078      = Reader.FirstLatestDeclIDs.find(ThisDeclID);
1079  if (I != Reader.FirstLatestDeclIDs.end()) {
1080    Decl *NewLatest = Reader.GetDecl(I->second);
1081    assert((D->getMostRecentDeclaration()->getLocation().isInvalid() ||
1082            NewLatest->getLocation().isInvalid() ||
1083            Reader.SourceMgr.isBeforeInTranslationUnit(
1084                                   D->getMostRecentDeclaration()->getLocation(),
1085                                   NewLatest->getLocation())) &&
1086           "The new latest is supposed to come after the previous latest");
1087    D->RedeclLink
1088        = typename Redeclarable<T>::LatestDeclLink(cast_or_null<T>(NewLatest));
1089  }
1090}
1091
1092//===----------------------------------------------------------------------===//
1093// Attribute Reading
1094//===----------------------------------------------------------------------===//
1095
1096/// \brief Reads attributes from the current stream position.
1097void ASTReader::ReadAttributes(llvm::BitstreamCursor &DeclsCursor,
1098                               AttrVec &Attrs) {
1099  unsigned Code = DeclsCursor.ReadCode();
1100  assert(Code == llvm::bitc::UNABBREV_RECORD &&
1101         "Expected unabbreviated record"); (void)Code;
1102
1103  RecordData Record;
1104  unsigned Idx = 0;
1105  unsigned RecCode = DeclsCursor.ReadRecord(Code, Record);
1106  assert(RecCode == DECL_ATTR && "Expected attribute record");
1107  (void)RecCode;
1108
1109  while (Idx < Record.size()) {
1110    Attr *New = 0;
1111    attr::Kind Kind = (attr::Kind)Record[Idx++];
1112    SourceLocation Loc = SourceLocation::getFromRawEncoding(Record[Idx++]);
1113    bool isInherited = Record[Idx++];
1114
1115#include "clang/Serialization/AttrPCHRead.inc"
1116
1117    assert(New && "Unable to decode attribute?");
1118    New->setInherited(isInherited);
1119    Attrs.push_back(New);
1120  }
1121}
1122
1123//===----------------------------------------------------------------------===//
1124// ASTReader Implementation
1125//===----------------------------------------------------------------------===//
1126
1127/// \brief Note that we have loaded the declaration with the given
1128/// Index.
1129///
1130/// This routine notes that this declaration has already been loaded,
1131/// so that future GetDecl calls will return this declaration rather
1132/// than trying to load a new declaration.
1133inline void ASTReader::LoadedDecl(unsigned Index, Decl *D) {
1134  assert(!DeclsLoaded[Index] && "Decl loaded twice?");
1135  DeclsLoaded[Index] = D;
1136}
1137
1138
1139/// \brief Determine whether the consumer will be interested in seeing
1140/// this declaration (via HandleTopLevelDecl).
1141///
1142/// This routine should return true for anything that might affect
1143/// code generation, e.g., inline function definitions, Objective-C
1144/// declarations with metadata, etc.
1145static bool isConsumerInterestedIn(Decl *D) {
1146  if (isa<FileScopeAsmDecl>(D))
1147    return true;
1148  if (VarDecl *Var = dyn_cast<VarDecl>(D))
1149    return Var->isFileVarDecl() &&
1150           Var->isThisDeclarationADefinition() == VarDecl::Definition;
1151  if (FunctionDecl *Func = dyn_cast<FunctionDecl>(D))
1152    return Func->isThisDeclarationADefinition();
1153  return isa<ObjCProtocolDecl>(D) || isa<ObjCImplementationDecl>(D);
1154}
1155
1156/// \brief Get the correct cursor and offset for loading a type.
1157ASTReader::RecordLocation
1158ASTReader::DeclCursorForIndex(unsigned Index, DeclID ID) {
1159  // See if there's an override.
1160  DeclReplacementMap::iterator It = ReplacedDecls.find(ID);
1161  if (It != ReplacedDecls.end())
1162    return RecordLocation(&It->second.first->DeclsCursor, It->second.second);
1163
1164  PerFileData *F = 0;
1165  for (unsigned I = 0, N = Chain.size(); I != N; ++I) {
1166    F = Chain[N - I - 1];
1167    if (Index < F->LocalNumDecls)
1168      break;
1169    Index -= F->LocalNumDecls;
1170  }
1171  assert(F && F->LocalNumDecls > Index && "Broken chain");
1172  return RecordLocation(&F->DeclsCursor, F->DeclOffsets[Index]);
1173}
1174
1175/// \brief Read the declaration at the given offset from the AST file.
1176Decl *ASTReader::ReadDeclRecord(unsigned Index, DeclID ID) {
1177  RecordLocation Loc = DeclCursorForIndex(Index, ID);
1178  llvm::BitstreamCursor &DeclsCursor = *Loc.first;
1179  // Keep track of where we are in the stream, then jump back there
1180  // after reading this declaration.
1181  SavedStreamPosition SavedPosition(DeclsCursor);
1182
1183  ReadingKindTracker ReadingKind(Read_Decl, *this);
1184
1185  // Note that we are loading a declaration record.
1186  Deserializing ADecl(this);
1187
1188  DeclsCursor.JumpToBit(Loc.second);
1189  RecordData Record;
1190  unsigned Code = DeclsCursor.ReadCode();
1191  unsigned Idx = 0;
1192  ASTDeclReader Reader(*this, DeclsCursor, ID, Record, Idx);
1193
1194  Decl *D = 0;
1195  switch ((DeclCode)DeclsCursor.ReadRecord(Code, Record)) {
1196  case DECL_ATTR:
1197  case DECL_CONTEXT_LEXICAL:
1198  case DECL_CONTEXT_VISIBLE:
1199    assert(false && "Record cannot be de-serialized with ReadDeclRecord");
1200    break;
1201  case DECL_TRANSLATION_UNIT:
1202    assert(Index == 0 && "Translation unit must be at index 0");
1203    D = Context->getTranslationUnitDecl();
1204    break;
1205  case DECL_TYPEDEF:
1206    D = TypedefDecl::Create(*Context, 0, SourceLocation(), 0, 0);
1207    break;
1208  case DECL_ENUM:
1209    D = EnumDecl::Create(*Context, Decl::EmptyShell());
1210    break;
1211  case DECL_RECORD:
1212    D = RecordDecl::Create(*Context, Decl::EmptyShell());
1213    break;
1214  case DECL_ENUM_CONSTANT:
1215    D = EnumConstantDecl::Create(*Context, 0, SourceLocation(), 0, QualType(),
1216                                 0, llvm::APSInt());
1217    break;
1218  case DECL_FUNCTION:
1219    D = FunctionDecl::Create(*Context, 0, SourceLocation(), DeclarationName(),
1220                             QualType(), 0);
1221    break;
1222  case DECL_LINKAGE_SPEC:
1223    D = LinkageSpecDecl::Create(*Context, 0, SourceLocation(),
1224                                (LinkageSpecDecl::LanguageIDs)0,
1225                                false);
1226    break;
1227  case DECL_NAMESPACE:
1228    D = NamespaceDecl::Create(*Context, 0, SourceLocation(), 0);
1229    break;
1230  case DECL_NAMESPACE_ALIAS:
1231    D = NamespaceAliasDecl::Create(*Context, 0, SourceLocation(),
1232                                   SourceLocation(), 0, SourceRange(), 0,
1233                                   SourceLocation(), 0);
1234    break;
1235  case DECL_USING:
1236    D = UsingDecl::Create(*Context, 0, SourceRange(), SourceLocation(),
1237                          0, DeclarationNameInfo(), false);
1238    break;
1239  case DECL_USING_SHADOW:
1240    D = UsingShadowDecl::Create(*Context, 0, SourceLocation(), 0, 0);
1241    break;
1242  case DECL_USING_DIRECTIVE:
1243    D = UsingDirectiveDecl::Create(*Context, 0, SourceLocation(),
1244                                   SourceLocation(), SourceRange(), 0,
1245                                   SourceLocation(), 0, 0);
1246    break;
1247  case DECL_UNRESOLVED_USING_VALUE:
1248    D = UnresolvedUsingValueDecl::Create(*Context, 0, SourceLocation(),
1249                                         SourceRange(), 0,
1250                                         DeclarationNameInfo());
1251    break;
1252  case DECL_UNRESOLVED_USING_TYPENAME:
1253    D = UnresolvedUsingTypenameDecl::Create(*Context, 0, SourceLocation(),
1254                                            SourceLocation(), SourceRange(),
1255                                            0, SourceLocation(),
1256                                            DeclarationName());
1257    break;
1258  case DECL_CXX_RECORD:
1259    D = CXXRecordDecl::Create(*Context, Decl::EmptyShell());
1260    break;
1261  case DECL_CXX_METHOD:
1262    D = CXXMethodDecl::Create(*Context, 0, DeclarationNameInfo(),
1263                              QualType(), 0);
1264    break;
1265  case DECL_CXX_CONSTRUCTOR:
1266    D = CXXConstructorDecl::Create(*Context, Decl::EmptyShell());
1267    break;
1268  case DECL_CXX_DESTRUCTOR:
1269    D = CXXDestructorDecl::Create(*Context, Decl::EmptyShell());
1270    break;
1271  case DECL_CXX_CONVERSION:
1272    D = CXXConversionDecl::Create(*Context, Decl::EmptyShell());
1273    break;
1274  case DECL_ACCESS_SPEC:
1275    D = AccessSpecDecl::Create(*Context, AS_none, 0, SourceLocation(),
1276                               SourceLocation());
1277    break;
1278  case DECL_FRIEND:
1279    D = FriendDecl::Create(*Context, Decl::EmptyShell());
1280    break;
1281  case DECL_FRIEND_TEMPLATE:
1282    D = FriendTemplateDecl::Create(*Context, Decl::EmptyShell());
1283    break;
1284  case DECL_CLASS_TEMPLATE:
1285    D = ClassTemplateDecl::Create(*Context, 0, SourceLocation(),
1286                                  DeclarationName(), 0, 0, 0);
1287    break;
1288  case DECL_CLASS_TEMPLATE_SPECIALIZATION:
1289    D = ClassTemplateSpecializationDecl::Create(*Context, Decl::EmptyShell());
1290    break;
1291  case DECL_CLASS_TEMPLATE_PARTIAL_SPECIALIZATION:
1292    D = ClassTemplatePartialSpecializationDecl::Create(*Context,
1293                                                            Decl::EmptyShell());
1294    break;
1295  case DECL_FUNCTION_TEMPLATE:
1296    D = FunctionTemplateDecl::Create(*Context, 0, SourceLocation(),
1297                                     DeclarationName(), 0, 0);
1298    break;
1299  case DECL_TEMPLATE_TYPE_PARM:
1300    D = TemplateTypeParmDecl::Create(*Context, Decl::EmptyShell());
1301    break;
1302  case DECL_NON_TYPE_TEMPLATE_PARM:
1303    D = NonTypeTemplateParmDecl::Create(*Context, 0, SourceLocation(), 0,0,0,
1304                                        QualType(),0);
1305    break;
1306  case DECL_TEMPLATE_TEMPLATE_PARM:
1307    D = TemplateTemplateParmDecl::Create(*Context, 0, SourceLocation(),0,0,0,0);
1308    break;
1309  case DECL_STATIC_ASSERT:
1310    D = StaticAssertDecl::Create(*Context, 0, SourceLocation(), 0, 0);
1311    break;
1312
1313  case DECL_OBJC_METHOD:
1314    D = ObjCMethodDecl::Create(*Context, SourceLocation(), SourceLocation(),
1315                               Selector(), QualType(), 0, 0);
1316    break;
1317  case DECL_OBJC_INTERFACE:
1318    D = ObjCInterfaceDecl::Create(*Context, 0, SourceLocation(), 0);
1319    break;
1320  case DECL_OBJC_IVAR:
1321    D = ObjCIvarDecl::Create(*Context, 0, SourceLocation(), 0, QualType(), 0,
1322                             ObjCIvarDecl::None);
1323    break;
1324  case DECL_OBJC_PROTOCOL:
1325    D = ObjCProtocolDecl::Create(*Context, 0, SourceLocation(), 0);
1326    break;
1327  case DECL_OBJC_AT_DEFS_FIELD:
1328    D = ObjCAtDefsFieldDecl::Create(*Context, 0, SourceLocation(), 0,
1329                                    QualType(), 0);
1330    break;
1331  case DECL_OBJC_CLASS:
1332    D = ObjCClassDecl::Create(*Context, 0, SourceLocation());
1333    break;
1334  case DECL_OBJC_FORWARD_PROTOCOL:
1335    D = ObjCForwardProtocolDecl::Create(*Context, 0, SourceLocation());
1336    break;
1337  case DECL_OBJC_CATEGORY:
1338    D = ObjCCategoryDecl::Create(*Context, 0, SourceLocation(),
1339                                 SourceLocation(), SourceLocation(), 0);
1340    break;
1341  case DECL_OBJC_CATEGORY_IMPL:
1342    D = ObjCCategoryImplDecl::Create(*Context, 0, SourceLocation(), 0, 0);
1343    break;
1344  case DECL_OBJC_IMPLEMENTATION:
1345    D = ObjCImplementationDecl::Create(*Context, 0, SourceLocation(), 0, 0);
1346    break;
1347  case DECL_OBJC_COMPATIBLE_ALIAS:
1348    D = ObjCCompatibleAliasDecl::Create(*Context, 0, SourceLocation(), 0, 0);
1349    break;
1350  case DECL_OBJC_PROPERTY:
1351    D = ObjCPropertyDecl::Create(*Context, 0, SourceLocation(), 0, SourceLocation(),
1352                                 0);
1353    break;
1354  case DECL_OBJC_PROPERTY_IMPL:
1355    D = ObjCPropertyImplDecl::Create(*Context, 0, SourceLocation(),
1356                                     SourceLocation(), 0,
1357                                     ObjCPropertyImplDecl::Dynamic, 0);
1358    break;
1359  case DECL_FIELD:
1360    D = FieldDecl::Create(*Context, 0, SourceLocation(), 0, QualType(), 0, 0,
1361                          false);
1362    break;
1363  case DECL_VAR:
1364    D = VarDecl::Create(*Context, 0, SourceLocation(), 0, QualType(), 0,
1365                        VarDecl::None, VarDecl::None);
1366    break;
1367
1368  case DECL_IMPLICIT_PARAM:
1369    D = ImplicitParamDecl::Create(*Context, 0, SourceLocation(), 0, QualType());
1370    break;
1371
1372  case DECL_PARM_VAR:
1373    D = ParmVarDecl::Create(*Context, 0, SourceLocation(), 0, QualType(), 0,
1374                            VarDecl::None, VarDecl::None, 0);
1375    break;
1376  case DECL_FILE_SCOPE_ASM:
1377    D = FileScopeAsmDecl::Create(*Context, 0, SourceLocation(), 0);
1378    break;
1379  case DECL_BLOCK:
1380    D = BlockDecl::Create(*Context, 0, SourceLocation());
1381    break;
1382  }
1383
1384  assert(D && "Unknown declaration reading AST file");
1385  LoadedDecl(Index, D);
1386  Reader.Visit(D);
1387
1388  // If this declaration is also a declaration context, get the
1389  // offsets for its tables of lexical and visible declarations.
1390  if (DeclContext *DC = dyn_cast<DeclContext>(D)) {
1391    std::pair<uint64_t, uint64_t> Offsets = Reader.VisitDeclContext(DC);
1392    if (Offsets.first || Offsets.second) {
1393      DC->setHasExternalLexicalStorage(Offsets.first != 0);
1394      DC->setHasExternalVisibleStorage(Offsets.second != 0);
1395      DeclContextInfo Info;
1396      if (ReadDeclContextStorage(DeclsCursor, Offsets, Info))
1397        return 0;
1398      DeclContextInfos &Infos = DeclContextOffsets[DC];
1399      // Reading the TU will happen after reading its update blocks, so we need
1400      // to make sure we insert in front. For all other contexts, the vector
1401      // is empty here anyway, so there's no loss in efficiency.
1402      Infos.insert(Infos.begin(), Info);
1403    }
1404  }
1405  assert(Idx == Record.size());
1406
1407  // If we have deserialized a declaration that has a definition the
1408  // AST consumer might need to know about, queue it.
1409  // We don't pass it to the consumer immediately because we may be in recursive
1410  // loading, and some declarations may still be initializing.
1411  if (isConsumerInterestedIn(D))
1412    InterestingDecls.push_back(D);
1413
1414  return D;
1415}
1416
1417bool ASTReader::ReadDeclContextStorage(llvm::BitstreamCursor &Cursor,
1418                                   const std::pair<uint64_t, uint64_t> &Offsets,
1419                                       DeclContextInfo &Info) {
1420  SavedStreamPosition SavedPosition(Cursor);
1421  // First the lexical decls.
1422  if (Offsets.first != 0) {
1423    Cursor.JumpToBit(Offsets.first);
1424
1425    RecordData Record;
1426    const char *Blob;
1427    unsigned BlobLen;
1428    unsigned Code = Cursor.ReadCode();
1429    unsigned RecCode = Cursor.ReadRecord(Code, Record, &Blob, &BlobLen);
1430    if (RecCode != DECL_CONTEXT_LEXICAL) {
1431      Error("Expected lexical block");
1432      return true;
1433    }
1434
1435    Info.LexicalDecls = reinterpret_cast<const DeclID*>(Blob);
1436    Info.NumLexicalDecls = BlobLen / sizeof(DeclID);
1437  } else {
1438    Info.LexicalDecls = 0;
1439    Info.NumLexicalDecls = 0;
1440  }
1441
1442  // Now the visible decls.
1443  Info.Stream = &Cursor;
1444  Info.OffsetToVisibleDecls = Offsets.second;
1445
1446  return false;
1447}
1448