ASTWriterDecl.cpp revision 223017
1218887Sdim//===--- ASTWriterDecl.cpp - Declaration Serialization --------------------===// 2218887Sdim// 3218887Sdim// The LLVM Compiler Infrastructure 4218887Sdim// 5218887Sdim// This file is distributed under the University of Illinois Open Source 6218887Sdim// License. See LICENSE.TXT for details. 7218887Sdim// 8218887Sdim//===----------------------------------------------------------------------===// 9218887Sdim// 10218887Sdim// This file implements serialization for Declarations. 11218887Sdim// 12218887Sdim//===----------------------------------------------------------------------===// 13218887Sdim 14218887Sdim#include "clang/Serialization/ASTWriter.h" 15218887Sdim#include "ASTCommon.h" 16243830Sdim#include "clang/AST/DeclVisitor.h" 17249423Sdim#include "clang/AST/DeclCXX.h" 18243830Sdim#include "clang/AST/DeclTemplate.h" 19243830Sdim#include "clang/AST/Expr.h" 20218887Sdim#include "clang/AST/DeclContextInternals.h" 21243830Sdim#include "llvm/ADT/Twine.h" 22218887Sdim#include "llvm/Bitcode/BitstreamWriter.h" 23243830Sdim#include "llvm/Support/ErrorHandling.h" 24243830Sdimusing namespace clang; 25243830Sdimusing namespace serialization; 26234353Sdim 27243830Sdim//===----------------------------------------------------------------------===// 28218887Sdim// Declaration serialization 29218887Sdim//===----------------------------------------------------------------------===// 30218887Sdim 31218887Sdimnamespace clang { 32243830Sdim class ASTDeclWriter : public DeclVisitor<ASTDeclWriter, void> { 33243830Sdim 34243830Sdim ASTWriter &Writer; 35243830Sdim ASTContext &Context; 36243830Sdim typedef ASTWriter::RecordData RecordData; 37243830Sdim RecordData &Record; 38243830Sdim 39243830Sdim public: 40243830Sdim serialization::DeclCode Code; 41243830Sdim unsigned AbbrevToUse; 42243830Sdim 43243830Sdim ASTDeclWriter(ASTWriter &Writer, ASTContext &Context, RecordData &Record) 44243830Sdim : Writer(Writer), Context(Context), Record(Record) { 45243830Sdim } 46243830Sdim 47243830Sdim void Visit(Decl *D); 48243830Sdim 49243830Sdim void VisitDecl(Decl *D); 50243830Sdim void VisitTranslationUnitDecl(TranslationUnitDecl *D); 51243830Sdim void VisitNamedDecl(NamedDecl *D); 52243830Sdim void VisitLabelDecl(LabelDecl *LD); 53243830Sdim void VisitNamespaceDecl(NamespaceDecl *D); 54243830Sdim void VisitUsingDirectiveDecl(UsingDirectiveDecl *D); 55243830Sdim void VisitNamespaceAliasDecl(NamespaceAliasDecl *D); 56243830Sdim void VisitTypeDecl(TypeDecl *D); 57243830Sdim void VisitTypedefDecl(TypedefDecl *D); 58243830Sdim void VisitTypeAliasDecl(TypeAliasDecl *D); 59243830Sdim void VisitUnresolvedUsingTypenameDecl(UnresolvedUsingTypenameDecl *D); 60243830Sdim void VisitTagDecl(TagDecl *D); 61243830Sdim void VisitEnumDecl(EnumDecl *D); 62243830Sdim void VisitRecordDecl(RecordDecl *D); 63243830Sdim void VisitCXXRecordDecl(CXXRecordDecl *D); 64243830Sdim void VisitClassTemplateSpecializationDecl( 65218887Sdim ClassTemplateSpecializationDecl *D); 66218887Sdim void VisitClassTemplatePartialSpecializationDecl( 67218887Sdim ClassTemplatePartialSpecializationDecl *D); 68218887Sdim void VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D); 69218887Sdim void VisitValueDecl(ValueDecl *D); 70218887Sdim void VisitEnumConstantDecl(EnumConstantDecl *D); 71218887Sdim void VisitUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *D); 72218887Sdim void VisitDeclaratorDecl(DeclaratorDecl *D); 73218887Sdim void VisitFunctionDecl(FunctionDecl *D); 74218887Sdim void VisitCXXMethodDecl(CXXMethodDecl *D); 75218887Sdim void VisitCXXConstructorDecl(CXXConstructorDecl *D); 76218887Sdim void VisitCXXDestructorDecl(CXXDestructorDecl *D); 77218887Sdim void VisitCXXConversionDecl(CXXConversionDecl *D); 78218887Sdim void VisitFieldDecl(FieldDecl *D); 79218887Sdim void VisitIndirectFieldDecl(IndirectFieldDecl *D); 80218887Sdim void VisitVarDecl(VarDecl *D); 81218887Sdim void VisitImplicitParamDecl(ImplicitParamDecl *D); 82218887Sdim void VisitParmVarDecl(ParmVarDecl *D); 83218887Sdim void VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D); 84218887Sdim void VisitTemplateDecl(TemplateDecl *D); 85218887Sdim void VisitRedeclarableTemplateDecl(RedeclarableTemplateDecl *D); 86218887Sdim void VisitClassTemplateDecl(ClassTemplateDecl *D); 87226633Sdim void VisitFunctionTemplateDecl(FunctionTemplateDecl *D); 88218887Sdim void VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D); 89218887Sdim void VisitTypeAliasTemplateDecl(TypeAliasTemplateDecl *D); 90218887Sdim void VisitUsingDecl(UsingDecl *D); 91218887Sdim void VisitUsingShadowDecl(UsingShadowDecl *D); 92218887Sdim void VisitLinkageSpecDecl(LinkageSpecDecl *D); 93218887Sdim void VisitFileScopeAsmDecl(FileScopeAsmDecl *D); 94218887Sdim void VisitAccessSpecDecl(AccessSpecDecl *D); 95218887Sdim void VisitFriendDecl(FriendDecl *D); 96218887Sdim void VisitFriendTemplateDecl(FriendTemplateDecl *D); 97218887Sdim void VisitStaticAssertDecl(StaticAssertDecl *D); 98218887Sdim void VisitBlockDecl(BlockDecl *D); 99218887Sdim 100218887Sdim void VisitDeclContext(DeclContext *DC, uint64_t LexicalOffset, 101218887Sdim uint64_t VisibleOffset); 102218887Sdim template <typename T> void VisitRedeclarable(Redeclarable<T> *D); 103218887Sdim 104251662Sdim 105251662Sdim // FIXME: Put in the same order is DeclNodes.td? 106234353Sdim void VisitObjCMethodDecl(ObjCMethodDecl *D); 107234353Sdim void VisitObjCContainerDecl(ObjCContainerDecl *D); 108234353Sdim void VisitObjCInterfaceDecl(ObjCInterfaceDecl *D); 109234353Sdim void VisitObjCIvarDecl(ObjCIvarDecl *D); 110234353Sdim void VisitObjCProtocolDecl(ObjCProtocolDecl *D); 111234353Sdim void VisitObjCAtDefsFieldDecl(ObjCAtDefsFieldDecl *D); 112234353Sdim void VisitObjCClassDecl(ObjCClassDecl *D); 113234353Sdim void VisitObjCForwardProtocolDecl(ObjCForwardProtocolDecl *D); 114234353Sdim void VisitObjCCategoryDecl(ObjCCategoryDecl *D); 115251662Sdim void VisitObjCImplDecl(ObjCImplDecl *D); 116251662Sdim void VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D); 117251662Sdim void VisitObjCImplementationDecl(ObjCImplementationDecl *D); 118251662Sdim void VisitObjCCompatibleAliasDecl(ObjCCompatibleAliasDecl *D); 119234353Sdim void VisitObjCPropertyDecl(ObjCPropertyDecl *D); 120234353Sdim void VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D); 121234353Sdim }; 122234353Sdim} 123234353Sdim 124218887Sdimvoid ASTDeclWriter::Visit(Decl *D) { 125226633Sdim DeclVisitor<ASTDeclWriter>::Visit(D); 126218887Sdim 127218887Sdim // Source locations require array (variable-length) abbreviations. The 128218887Sdim // abbreviation infrastructure requires that arrays are encoded last, so 129234353Sdim // we handle it here in the case of those classes derived from DeclaratorDecl 130218887Sdim if (DeclaratorDecl *DD = dyn_cast<DeclaratorDecl>(D)){ 131226633Sdim Writer.AddTypeSourceInfo(DD->getTypeSourceInfo(), Record); 132234353Sdim } 133218887Sdim 134249423Sdim // Handle FunctionDecl's body here and write it after all other Stmts/Exprs 135218887Sdim // have been written. We want it last because we will not read it back when 136218887Sdim // retrieving it from the AST, we'll just lazily set the offset. 137218887Sdim if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) { 138218887Sdim Record.push_back(FD->doesThisDeclarationHaveABody()); 139218887Sdim if (FD->doesThisDeclarationHaveABody()) 140234353Sdim Writer.AddStmt(FD->getBody()); 141226633Sdim } 142226633Sdim} 143218887Sdim 144218887Sdimvoid ASTDeclWriter::VisitDecl(Decl *D) { 145218887Sdim Writer.AddDeclRef(cast_or_null<Decl>(D->getDeclContext()), Record); 146218887Sdim Writer.AddDeclRef(cast_or_null<Decl>(D->getLexicalDeclContext()), Record); 147243830Sdim Writer.AddSourceLocation(D->getLocation(), Record); 148243830Sdim Record.push_back(D->isInvalidDecl()); 149243830Sdim Record.push_back(D->hasAttrs()); 150243830Sdim if (D->hasAttrs()) 151243830Sdim Writer.WriteAttributes(D->getAttrs(), Record); 152243830Sdim Record.push_back(D->isImplicit()); 153243830Sdim Record.push_back(D->isUsed(false)); 154243830Sdim Record.push_back(D->isReferenced()); 155243830Sdim Record.push_back(D->getAccess()); 156243830Sdim Record.push_back(D->getPCHLevel()); 157243830Sdim} 158243830Sdim 159243830Sdimvoid ASTDeclWriter::VisitTranslationUnitDecl(TranslationUnitDecl *D) { 160243830Sdim VisitDecl(D); 161243830Sdim Writer.AddDeclRef(D->getAnonymousNamespace(), Record); 162243830Sdim Code = serialization::DECL_TRANSLATION_UNIT; 163243830Sdim} 164226633Sdim 165226633Sdimvoid ASTDeclWriter::VisitNamedDecl(NamedDecl *D) { 166218887Sdim VisitDecl(D); 167218887Sdim Writer.AddDeclarationName(D->getDeclName(), Record); 168218887Sdim} 169218887Sdim 170218887Sdimvoid ASTDeclWriter::VisitTypeDecl(TypeDecl *D) { 171218887Sdim VisitNamedDecl(D); 172218887Sdim Writer.AddSourceLocation(D->getLocStart(), Record); 173218887Sdim Writer.AddTypeRef(QualType(D->getTypeForDecl(), 0), Record); 174218887Sdim} 175218887Sdim 176218887Sdimvoid ASTDeclWriter::VisitTypedefDecl(TypedefDecl *D) { 177218887Sdim VisitTypeDecl(D); 178218887Sdim Writer.AddTypeSourceInfo(D->getTypeSourceInfo(), Record); 179234353Sdim 180226633Sdim if (!D->hasAttrs() && 181226633Sdim !D->isImplicit() && 182218887Sdim !D->isUsed(false) && 183218887Sdim D->getPCHLevel() == 0 && 184218887Sdim D->RedeclLink.getNext() == D && 185218887Sdim !D->isInvalidDecl() && 186226633Sdim !D->isReferenced() && 187226633Sdim D->getAccess() == AS_none && 188218887Sdim D->getDeclName().getNameKind() == DeclarationName::Identifier) 189218887Sdim AbbrevToUse = Writer.getDeclTypedefAbbrev(); 190218887Sdim 191218887Sdim Code = serialization::DECL_TYPEDEF; 192218887Sdim} 193218887Sdim 194226633Sdimvoid ASTDeclWriter::VisitTypeAliasDecl(TypeAliasDecl *D) { 195218887Sdim VisitTypeDecl(D); 196218887Sdim Writer.AddTypeSourceInfo(D->getTypeSourceInfo(), Record); 197218887Sdim Code = serialization::DECL_TYPEALIAS; 198218887Sdim} 199218887Sdim 200218887Sdimvoid ASTDeclWriter::VisitTagDecl(TagDecl *D) { 201218887Sdim VisitTypeDecl(D); 202218887Sdim VisitRedeclarable(D); 203218887Sdim Record.push_back(D->getIdentifierNamespace()); 204234353Sdim Record.push_back((unsigned)D->getTagKind()); // FIXME: stable encoding 205218887Sdim Record.push_back(D->isDefinition()); 206218887Sdim Record.push_back(D->isEmbeddedInDeclarator()); 207226633Sdim Writer.AddSourceLocation(D->getRBraceLoc(), Record); 208218887Sdim Record.push_back(D->hasExtInfo()); 209226633Sdim if (D->hasExtInfo()) 210218887Sdim Writer.AddQualifierInfo(*D->getExtInfo(), Record); 211218887Sdim else 212218887Sdim Writer.AddDeclRef(D->getTypedefNameForAnonDecl(), Record); 213218887Sdim} 214218887Sdim 215218887Sdimvoid ASTDeclWriter::VisitEnumDecl(EnumDecl *D) { 216218887Sdim VisitTagDecl(D); 217218887Sdim Writer.AddTypeSourceInfo(D->getIntegerTypeSourceInfo(), Record); 218243830Sdim if (!D->getIntegerTypeSourceInfo()) 219226633Sdim Writer.AddTypeRef(D->getIntegerType(), Record); 220226633Sdim Writer.AddTypeRef(D->getPromotionType(), Record); 221226633Sdim Record.push_back(D->getNumPositiveBits()); 222226633Sdim Record.push_back(D->getNumNegativeBits()); 223226633Sdim Record.push_back(D->isScoped()); 224226633Sdim Record.push_back(D->isScopedUsingClassTag()); 225218887Sdim Record.push_back(D->isFixed()); 226218887Sdim Writer.AddDeclRef(D->getInstantiatedFromMemberEnum(), Record); 227226633Sdim 228226633Sdim if (!D->hasAttrs() && 229226633Sdim !D->isImplicit() && 230226633Sdim !D->isUsed(false) && 231218887Sdim D->getPCHLevel() == 0 && 232218887Sdim !D->hasExtInfo() && 233226633Sdim D->RedeclLink.getNext() == D && 234218887Sdim !D->isInvalidDecl() && 235218887Sdim !D->isReferenced() && 236218887Sdim D->getAccess() == AS_none && 237226633Sdim !CXXRecordDecl::classofKind(D->getKind()) && 238226633Sdim !D->getIntegerTypeSourceInfo() && 239218887Sdim D->getDeclName().getNameKind() == DeclarationName::Identifier) 240218887Sdim AbbrevToUse = Writer.getDeclEnumAbbrev(); 241218887Sdim 242218887Sdim Code = serialization::DECL_ENUM; 243226633Sdim} 244218887Sdim 245218887Sdimvoid ASTDeclWriter::VisitRecordDecl(RecordDecl *D) { 246218887Sdim VisitTagDecl(D); 247218887Sdim Record.push_back(D->hasFlexibleArrayMember()); 248218887Sdim Record.push_back(D->isAnonymousStructOrUnion()); 249218887Sdim Record.push_back(D->hasObjectMember()); 250218887Sdim 251218887Sdim if (!D->hasAttrs() && 252218887Sdim !D->isImplicit() && 253218887Sdim !D->isUsed(false) && 254218887Sdim D->getPCHLevel() == 0 && 255218887Sdim !D->hasExtInfo() && 256226633Sdim D->RedeclLink.getNext() == D && 257226633Sdim !D->isInvalidDecl() && 258218887Sdim !D->isReferenced() && 259218887Sdim D->getAccess() == AS_none && 260218887Sdim !CXXRecordDecl::classofKind(D->getKind()) && 261218887Sdim D->getDeclName().getNameKind() == DeclarationName::Identifier) 262218887Sdim AbbrevToUse = Writer.getDeclRecordAbbrev(); 263218887Sdim 264218887Sdim Code = serialization::DECL_RECORD; 265218887Sdim} 266218887Sdim 267226633Sdimvoid ASTDeclWriter::VisitValueDecl(ValueDecl *D) { 268218887Sdim VisitNamedDecl(D); 269218887Sdim Writer.AddTypeRef(D->getType(), Record); 270226633Sdim} 271218887Sdim 272218887Sdimvoid ASTDeclWriter::VisitEnumConstantDecl(EnumConstantDecl *D) { 273218887Sdim VisitValueDecl(D); 274251662Sdim Record.push_back(D->getInitExpr()? 1 : 0); 275251662Sdim if (D->getInitExpr()) 276251662Sdim Writer.AddStmt(D->getInitExpr()); 277234353Sdim Writer.AddAPSInt(D->getInitVal(), Record); 278218887Sdim 279218887Sdim Code = serialization::DECL_ENUM_CONSTANT; 280234353Sdim} 281218887Sdim 282218887Sdimvoid ASTDeclWriter::VisitDeclaratorDecl(DeclaratorDecl *D) { 283218887Sdim VisitValueDecl(D); 284218887Sdim Writer.AddSourceLocation(D->getInnerLocStart(), Record); 285218887Sdim Record.push_back(D->hasExtInfo()); 286234353Sdim if (D->hasExtInfo()) 287218887Sdim Writer.AddQualifierInfo(*D->getExtInfo(), Record); 288218887Sdim} 289218887Sdim 290218887Sdimvoid ASTDeclWriter::VisitFunctionDecl(FunctionDecl *D) { 291218887Sdim VisitDeclaratorDecl(D); 292218887Sdim VisitRedeclarable(D); 293218887Sdim 294218887Sdim Writer.AddDeclarationNameLoc(D->DNLoc, D->getDeclName(), Record); 295226633Sdim Record.push_back(D->getIdentifierNamespace()); 296218887Sdim Record.push_back(D->getTemplatedKind()); 297218887Sdim switch (D->getTemplatedKind()) { 298226633Sdim default: assert(false && "Unhandled TemplatedKind!"); 299218887Sdim break; 300218887Sdim case FunctionDecl::TK_NonTemplate: 301218887Sdim break; 302226633Sdim case FunctionDecl::TK_FunctionTemplate: 303218887Sdim Writer.AddDeclRef(D->getDescribedFunctionTemplate(), Record); 304218887Sdim break; 305218887Sdim case FunctionDecl::TK_MemberSpecialization: { 306226633Sdim MemberSpecializationInfo *MemberInfo = D->getMemberSpecializationInfo(); 307218887Sdim Writer.AddDeclRef(MemberInfo->getInstantiatedFrom(), Record); 308226633Sdim Record.push_back(MemberInfo->getTemplateSpecializationKind()); 309226633Sdim Writer.AddSourceLocation(MemberInfo->getPointOfInstantiation(), Record); 310218887Sdim break; 311226633Sdim } 312218887Sdim case FunctionDecl::TK_FunctionTemplateSpecialization: { 313218887Sdim FunctionTemplateSpecializationInfo * 314226633Sdim FTSInfo = D->getTemplateSpecializationInfo(); 315218887Sdim Writer.AddDeclRef(FTSInfo->getTemplate(), Record); 316218887Sdim Record.push_back(FTSInfo->getTemplateSpecializationKind()); 317226633Sdim 318218887Sdim // Template arguments. 319218887Sdim Writer.AddTemplateArgumentList(FTSInfo->TemplateArguments, Record); 320218887Sdim 321218887Sdim // Template args as written. 322218887Sdim Record.push_back(FTSInfo->TemplateArgumentsAsWritten != 0); 323218887Sdim if (FTSInfo->TemplateArgumentsAsWritten) { 324218887Sdim Record.push_back(FTSInfo->TemplateArgumentsAsWritten->size()); 325218887Sdim for (int i=0, e = FTSInfo->TemplateArgumentsAsWritten->size(); i!=e; ++i) 326218887Sdim Writer.AddTemplateArgumentLoc((*FTSInfo->TemplateArgumentsAsWritten)[i], 327218887Sdim Record); 328234353Sdim Writer.AddSourceLocation(FTSInfo->TemplateArgumentsAsWritten->getLAngleLoc(), 329234353Sdim Record); 330234353Sdim Writer.AddSourceLocation(FTSInfo->TemplateArgumentsAsWritten->getRAngleLoc(), 331224145Sdim Record); 332224145Sdim } 333234353Sdim 334234353Sdim Writer.AddSourceLocation(FTSInfo->getPointOfInstantiation(), Record); 335251662Sdim 336234353Sdim if (D->isCanonicalDecl()) { 337218887Sdim // Write the template that contains the specializations set. We will 338218887Sdim // add a FunctionTemplateSpecializationInfo to it when reading. 339218887Sdim Writer.AddDeclRef(FTSInfo->getTemplate()->getCanonicalDecl(), Record); 340218887Sdim } 341218887Sdim break; 342218887Sdim } 343218887Sdim case FunctionDecl::TK_DependentFunctionTemplateSpecialization: { 344218887Sdim DependentFunctionTemplateSpecializationInfo * 345243830Sdim DFTSInfo = D->getDependentSpecializationInfo(); 346218887Sdim 347218887Sdim // Templates. 348218887Sdim Record.push_back(DFTSInfo->getNumTemplates()); 349218887Sdim for (int i=0, e = DFTSInfo->getNumTemplates(); i != e; ++i) 350218887Sdim Writer.AddDeclRef(DFTSInfo->getTemplate(i), Record); 351218887Sdim 352218887Sdim // Templates args. 353234353Sdim Record.push_back(DFTSInfo->getNumTemplateArgs()); 354218887Sdim for (int i=0, e = DFTSInfo->getNumTemplateArgs(); i != e; ++i) 355218887Sdim Writer.AddTemplateArgumentLoc(DFTSInfo->getTemplateArg(i), Record); 356234353Sdim Writer.AddSourceLocation(DFTSInfo->getLAngleLoc(), Record); 357234353Sdim Writer.AddSourceLocation(DFTSInfo->getRAngleLoc(), Record); 358234353Sdim break; 359218887Sdim } 360218887Sdim } 361218887Sdim 362218887Sdim // FunctionDecl's body is handled last at ASTWriterDecl::Visit, 363218887Sdim // after everything else is written. 364218887Sdim 365218887Sdim Record.push_back(D->getStorageClass()); // FIXME: stable encoding 366218887Sdim Record.push_back(D->getStorageClassAsWritten()); 367218887Sdim Record.push_back(D->IsInline); 368218887Sdim Record.push_back(D->isInlineSpecified()); 369218887Sdim Record.push_back(D->isVirtualAsWritten()); 370218887Sdim Record.push_back(D->isPure()); 371218887Sdim Record.push_back(D->hasInheritedPrototype()); 372218887Sdim Record.push_back(D->hasWrittenPrototype()); 373218887Sdim Record.push_back(D->isDeletedAsWritten()); 374218887Sdim Record.push_back(D->isTrivial()); 375218887Sdim Record.push_back(D->isDefaulted()); 376218887Sdim Record.push_back(D->isExplicitlyDefaulted()); 377226633Sdim Record.push_back(D->hasImplicitReturnZero()); 378226633Sdim Writer.AddSourceLocation(D->getLocEnd(), Record); 379226633Sdim 380218887Sdim Record.push_back(D->param_size()); 381218887Sdim for (FunctionDecl::param_iterator P = D->param_begin(), PEnd = D->param_end(); 382218887Sdim P != PEnd; ++P) 383218887Sdim Writer.AddDeclRef(*P, Record); 384218887Sdim Code = serialization::DECL_FUNCTION; 385218887Sdim} 386218887Sdim 387218887Sdimvoid ASTDeclWriter::VisitObjCMethodDecl(ObjCMethodDecl *D) { 388218887Sdim VisitNamedDecl(D); 389218887Sdim // FIXME: convert to LazyStmtPtr? 390218887Sdim // Unlike C/C++, method bodies will never be in header files. 391218887Sdim bool HasBodyStuff = D->getBody() != 0 || 392218887Sdim D->getSelfDecl() != 0 || D->getCmdDecl() != 0; 393218887Sdim Record.push_back(HasBodyStuff); 394218887Sdim if (HasBodyStuff) { 395218887Sdim Writer.AddStmt(D->getBody()); 396218887Sdim Writer.AddDeclRef(D->getSelfDecl(), Record); 397218887Sdim Writer.AddDeclRef(D->getCmdDecl(), Record); 398218887Sdim } 399218887Sdim Record.push_back(D->isInstanceMethod()); 400218887Sdim Record.push_back(D->isVariadic()); 401226633Sdim Record.push_back(D->isSynthesized()); 402218887Sdim Record.push_back(D->isDefined()); 403218887Sdim // FIXME: stable encoding for @required/@optional 404218887Sdim Record.push_back(D->getImplementationControl()); 405218887Sdim // FIXME: stable encoding for in/out/inout/bycopy/byref/oneway 406226633Sdim Record.push_back(D->getObjCDeclQualifier()); 407218887Sdim Record.push_back(D->hasRelatedResultType()); 408226633Sdim Record.push_back(D->getNumSelectorArgs()); 409226633Sdim Writer.AddTypeRef(D->getResultType(), Record); 410218887Sdim Writer.AddTypeSourceInfo(D->getResultTypeSourceInfo(), Record); 411218887Sdim Writer.AddSourceLocation(D->getLocEnd(), Record); 412218887Sdim Record.push_back(D->param_size()); 413218887Sdim for (ObjCMethodDecl::param_iterator P = D->param_begin(), 414218887Sdim PEnd = D->param_end(); P != PEnd; ++P) 415218887Sdim Writer.AddDeclRef(*P, Record); 416218887Sdim Code = serialization::DECL_OBJC_METHOD; 417218887Sdim} 418218887Sdim 419218887Sdimvoid ASTDeclWriter::VisitObjCContainerDecl(ObjCContainerDecl *D) { 420218887Sdim VisitNamedDecl(D); 421218887Sdim Writer.AddSourceRange(D->getAtEndRange(), Record); 422218887Sdim // Abstract class (no need to define a stable serialization::DECL code). 423218887Sdim} 424221345Sdim 425218887Sdimvoid ASTDeclWriter::VisitObjCInterfaceDecl(ObjCInterfaceDecl *D) { 426218887Sdim VisitObjCContainerDecl(D); 427218887Sdim Writer.AddTypeRef(QualType(D->getTypeForDecl(), 0), Record); 428249423Sdim Writer.AddDeclRef(D->getSuperClass(), Record); 429249423Sdim 430249423Sdim // Write out the protocols that are directly referenced by the @interface. 431249423Sdim Record.push_back(D->ReferencedProtocols.size()); 432249423Sdim for (ObjCInterfaceDecl::protocol_iterator P = D->protocol_begin(), 433249423Sdim PEnd = D->protocol_end(); 434249423Sdim P != PEnd; ++P) 435249423Sdim Writer.AddDeclRef(*P, Record); 436249423Sdim for (ObjCInterfaceDecl::protocol_loc_iterator PL = D->protocol_loc_begin(), 437226633Sdim PLEnd = D->protocol_loc_end(); 438218887Sdim PL != PLEnd; ++PL) 439234353Sdim Writer.AddSourceLocation(*PL, Record); 440218887Sdim 441218887Sdim // Write out the protocols that are transitively referenced. 442218887Sdim Record.push_back(D->AllReferencedProtocols.size()); 443226633Sdim for (ObjCList<ObjCProtocolDecl>::iterator 444226633Sdim P = D->AllReferencedProtocols.begin(), 445218887Sdim PEnd = D->AllReferencedProtocols.end(); 446218887Sdim P != PEnd; ++P) 447218887Sdim Writer.AddDeclRef(*P, Record); 448218887Sdim 449218887Sdim // Write out the ivars. 450218887Sdim Record.push_back(D->ivar_size()); 451218887Sdim for (ObjCInterfaceDecl::ivar_iterator I = D->ivar_begin(), 452218887Sdim IEnd = D->ivar_end(); I != IEnd; ++I) 453 Writer.AddDeclRef(*I, Record); 454 Writer.AddDeclRef(D->getCategoryList(), Record); 455 Record.push_back(D->isForwardDecl()); 456 Record.push_back(D->isImplicitInterfaceDecl()); 457 Writer.AddSourceLocation(D->getClassLoc(), Record); 458 Writer.AddSourceLocation(D->getSuperClassLoc(), Record); 459 Writer.AddSourceLocation(D->getLocEnd(), Record); 460 Code = serialization::DECL_OBJC_INTERFACE; 461} 462 463void ASTDeclWriter::VisitObjCIvarDecl(ObjCIvarDecl *D) { 464 VisitFieldDecl(D); 465 // FIXME: stable encoding for @public/@private/@protected/@package 466 Record.push_back(D->getAccessControl()); 467 Record.push_back(D->getSynthesize()); 468 469 if (!D->hasAttrs() && 470 !D->isImplicit() && 471 !D->isUsed(false) && 472 !D->isInvalidDecl() && 473 !D->isReferenced() && 474 D->getPCHLevel() == 0 && 475 !D->getBitWidth() && 476 !D->hasExtInfo() && 477 D->getDeclName()) 478 AbbrevToUse = Writer.getDeclObjCIvarAbbrev(); 479 480 Code = serialization::DECL_OBJC_IVAR; 481} 482 483void ASTDeclWriter::VisitObjCProtocolDecl(ObjCProtocolDecl *D) { 484 VisitObjCContainerDecl(D); 485 Record.push_back(D->isForwardDecl()); 486 Writer.AddSourceLocation(D->getLocEnd(), Record); 487 Record.push_back(D->protocol_size()); 488 for (ObjCProtocolDecl::protocol_iterator 489 I = D->protocol_begin(), IEnd = D->protocol_end(); I != IEnd; ++I) 490 Writer.AddDeclRef(*I, Record); 491 for (ObjCProtocolDecl::protocol_loc_iterator PL = D->protocol_loc_begin(), 492 PLEnd = D->protocol_loc_end(); 493 PL != PLEnd; ++PL) 494 Writer.AddSourceLocation(*PL, Record); 495 Code = serialization::DECL_OBJC_PROTOCOL; 496} 497 498void ASTDeclWriter::VisitObjCAtDefsFieldDecl(ObjCAtDefsFieldDecl *D) { 499 VisitFieldDecl(D); 500 Code = serialization::DECL_OBJC_AT_DEFS_FIELD; 501} 502 503void ASTDeclWriter::VisitObjCClassDecl(ObjCClassDecl *D) { 504 VisitDecl(D); 505 Record.push_back(D->size()); 506 for (ObjCClassDecl::iterator I = D->begin(), IEnd = D->end(); I != IEnd; ++I) 507 Writer.AddDeclRef(I->getInterface(), Record); 508 for (ObjCClassDecl::iterator I = D->begin(), IEnd = D->end(); I != IEnd; ++I) 509 Writer.AddSourceLocation(I->getLocation(), Record); 510 Code = serialization::DECL_OBJC_CLASS; 511} 512 513void ASTDeclWriter::VisitObjCForwardProtocolDecl(ObjCForwardProtocolDecl *D) { 514 VisitDecl(D); 515 Record.push_back(D->protocol_size()); 516 for (ObjCForwardProtocolDecl::protocol_iterator 517 I = D->protocol_begin(), IEnd = D->protocol_end(); I != IEnd; ++I) 518 Writer.AddDeclRef(*I, Record); 519 for (ObjCForwardProtocolDecl::protocol_loc_iterator 520 PL = D->protocol_loc_begin(), PLEnd = D->protocol_loc_end(); 521 PL != PLEnd; ++PL) 522 Writer.AddSourceLocation(*PL, Record); 523 Code = serialization::DECL_OBJC_FORWARD_PROTOCOL; 524} 525 526void ASTDeclWriter::VisitObjCCategoryDecl(ObjCCategoryDecl *D) { 527 VisitObjCContainerDecl(D); 528 Writer.AddDeclRef(D->getClassInterface(), Record); 529 Record.push_back(D->protocol_size()); 530 for (ObjCCategoryDecl::protocol_iterator 531 I = D->protocol_begin(), IEnd = D->protocol_end(); I != IEnd; ++I) 532 Writer.AddDeclRef(*I, Record); 533 for (ObjCCategoryDecl::protocol_loc_iterator 534 PL = D->protocol_loc_begin(), PLEnd = D->protocol_loc_end(); 535 PL != PLEnd; ++PL) 536 Writer.AddSourceLocation(*PL, Record); 537 Writer.AddDeclRef(D->getNextClassCategory(), Record); 538 Record.push_back(D->hasSynthBitfield()); 539 Writer.AddSourceLocation(D->getAtLoc(), Record); 540 Writer.AddSourceLocation(D->getCategoryNameLoc(), Record); 541 Code = serialization::DECL_OBJC_CATEGORY; 542} 543 544void ASTDeclWriter::VisitObjCCompatibleAliasDecl(ObjCCompatibleAliasDecl *D) { 545 VisitNamedDecl(D); 546 Writer.AddDeclRef(D->getClassInterface(), Record); 547 Code = serialization::DECL_OBJC_COMPATIBLE_ALIAS; 548} 549 550void ASTDeclWriter::VisitObjCPropertyDecl(ObjCPropertyDecl *D) { 551 VisitNamedDecl(D); 552 Writer.AddSourceLocation(D->getAtLoc(), Record); 553 Writer.AddTypeSourceInfo(D->getTypeSourceInfo(), Record); 554 // FIXME: stable encoding 555 Record.push_back((unsigned)D->getPropertyAttributes()); 556 Record.push_back((unsigned)D->getPropertyAttributesAsWritten()); 557 // FIXME: stable encoding 558 Record.push_back((unsigned)D->getPropertyImplementation()); 559 Writer.AddDeclarationName(D->getGetterName(), Record); 560 Writer.AddDeclarationName(D->getSetterName(), Record); 561 Writer.AddDeclRef(D->getGetterMethodDecl(), Record); 562 Writer.AddDeclRef(D->getSetterMethodDecl(), Record); 563 Writer.AddDeclRef(D->getPropertyIvarDecl(), Record); 564 Code = serialization::DECL_OBJC_PROPERTY; 565} 566 567void ASTDeclWriter::VisitObjCImplDecl(ObjCImplDecl *D) { 568 VisitObjCContainerDecl(D); 569 Writer.AddDeclRef(D->getClassInterface(), Record); 570 // Abstract class (no need to define a stable serialization::DECL code). 571} 572 573void ASTDeclWriter::VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D) { 574 VisitObjCImplDecl(D); 575 Writer.AddIdentifierRef(D->getIdentifier(), Record); 576 Code = serialization::DECL_OBJC_CATEGORY_IMPL; 577} 578 579void ASTDeclWriter::VisitObjCImplementationDecl(ObjCImplementationDecl *D) { 580 VisitObjCImplDecl(D); 581 Writer.AddDeclRef(D->getSuperClass(), Record); 582 Writer.AddCXXCtorInitializers(D->IvarInitializers, D->NumIvarInitializers, 583 Record); 584 Record.push_back(D->hasSynthBitfield()); 585 Code = serialization::DECL_OBJC_IMPLEMENTATION; 586} 587 588void ASTDeclWriter::VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D) { 589 VisitDecl(D); 590 Writer.AddSourceLocation(D->getLocStart(), Record); 591 Writer.AddDeclRef(D->getPropertyDecl(), Record); 592 Writer.AddDeclRef(D->getPropertyIvarDecl(), Record); 593 Writer.AddSourceLocation(D->getPropertyIvarDeclLoc(), Record); 594 Writer.AddStmt(D->getGetterCXXConstructor()); 595 Writer.AddStmt(D->getSetterCXXAssignment()); 596 Code = serialization::DECL_OBJC_PROPERTY_IMPL; 597} 598 599void ASTDeclWriter::VisitFieldDecl(FieldDecl *D) { 600 VisitDeclaratorDecl(D); 601 Record.push_back(D->isMutable()); 602 Record.push_back(D->getBitWidth()? 1 : D->hasInClassInitializer() ? 2 : 0); 603 if (D->getBitWidth()) 604 Writer.AddStmt(D->getBitWidth()); 605 else if (D->hasInClassInitializer()) 606 Writer.AddStmt(D->getInClassInitializer()); 607 if (!D->getDeclName()) 608 Writer.AddDeclRef(Context.getInstantiatedFromUnnamedFieldDecl(D), Record); 609 610 if (!D->hasAttrs() && 611 !D->isImplicit() && 612 !D->isUsed(false) && 613 !D->isInvalidDecl() && 614 !D->isReferenced() && 615 D->getPCHLevel() == 0 && 616 !D->getBitWidth() && 617 !D->hasInClassInitializer() && 618 !D->hasExtInfo() && 619 !ObjCIvarDecl::classofKind(D->getKind()) && 620 !ObjCAtDefsFieldDecl::classofKind(D->getKind()) && 621 D->getDeclName()) 622 AbbrevToUse = Writer.getDeclFieldAbbrev(); 623 624 Code = serialization::DECL_FIELD; 625} 626 627void ASTDeclWriter::VisitIndirectFieldDecl(IndirectFieldDecl *D) { 628 VisitValueDecl(D); 629 Record.push_back(D->getChainingSize()); 630 631 for (IndirectFieldDecl::chain_iterator 632 P = D->chain_begin(), 633 PEnd = D->chain_end(); P != PEnd; ++P) 634 Writer.AddDeclRef(*P, Record); 635 Code = serialization::DECL_INDIRECTFIELD; 636} 637 638void ASTDeclWriter::VisitVarDecl(VarDecl *D) { 639 VisitDeclaratorDecl(D); 640 VisitRedeclarable(D); 641 Record.push_back(D->getStorageClass()); // FIXME: stable encoding 642 Record.push_back(D->getStorageClassAsWritten()); 643 Record.push_back(D->isThreadSpecified()); 644 Record.push_back(D->hasCXXDirectInitializer()); 645 Record.push_back(D->isExceptionVariable()); 646 Record.push_back(D->isNRVOVariable()); 647 Record.push_back(D->isCXXForRangeDecl()); 648 Record.push_back(D->getInit() ? 1 : 0); 649 if (D->getInit()) 650 Writer.AddStmt(D->getInit()); 651 652 MemberSpecializationInfo *SpecInfo 653 = D->isStaticDataMember() ? D->getMemberSpecializationInfo() : 0; 654 Record.push_back(SpecInfo != 0); 655 if (SpecInfo) { 656 Writer.AddDeclRef(SpecInfo->getInstantiatedFrom(), Record); 657 Record.push_back(SpecInfo->getTemplateSpecializationKind()); 658 Writer.AddSourceLocation(SpecInfo->getPointOfInstantiation(), Record); 659 } 660 661 if (!D->hasAttrs() && 662 !D->isImplicit() && 663 !D->isUsed(false) && 664 !D->isInvalidDecl() && 665 !D->isReferenced() && 666 D->getAccess() == AS_none && 667 D->getPCHLevel() == 0 && 668 D->getDeclName().getNameKind() == DeclarationName::Identifier && 669 !D->hasExtInfo() && 670 D->RedeclLink.getNext() == D && 671 !D->hasCXXDirectInitializer() && 672 D->getInit() == 0 && 673 !ParmVarDecl::classofKind(D->getKind()) && 674 !SpecInfo) 675 AbbrevToUse = Writer.getDeclVarAbbrev(); 676 677 Code = serialization::DECL_VAR; 678} 679 680void ASTDeclWriter::VisitImplicitParamDecl(ImplicitParamDecl *D) { 681 VisitVarDecl(D); 682 Code = serialization::DECL_IMPLICIT_PARAM; 683} 684 685void ASTDeclWriter::VisitParmVarDecl(ParmVarDecl *D) { 686 VisitVarDecl(D); 687 Record.push_back(D->isObjCMethodParameter()); 688 Record.push_back(D->getFunctionScopeDepth()); 689 Record.push_back(D->getFunctionScopeIndex()); 690 Record.push_back(D->getObjCDeclQualifier()); // FIXME: stable encoding 691 Record.push_back(D->isKNRPromoted()); 692 Record.push_back(D->hasInheritedDefaultArg()); 693 Record.push_back(D->hasUninstantiatedDefaultArg()); 694 if (D->hasUninstantiatedDefaultArg()) 695 Writer.AddStmt(D->getUninstantiatedDefaultArg()); 696 Code = serialization::DECL_PARM_VAR; 697 698 // If the assumptions about the DECL_PARM_VAR abbrev are true, use it. Here 699 // we dynamically check for the properties that we optimize for, but don't 700 // know are true of all PARM_VAR_DECLs. 701 if (!D->hasAttrs() && 702 !D->hasExtInfo() && 703 !D->isImplicit() && 704 !D->isUsed(false) && 705 D->getAccess() == AS_none && 706 D->getPCHLevel() == 0 && 707 D->getStorageClass() == 0 && 708 !D->hasCXXDirectInitializer() && // Can params have this ever? 709 D->getFunctionScopeDepth() == 0 && 710 D->getObjCDeclQualifier() == 0 && 711 !D->isKNRPromoted() && 712 !D->hasInheritedDefaultArg() && 713 D->getInit() == 0 && 714 !D->hasUninstantiatedDefaultArg()) // No default expr. 715 AbbrevToUse = Writer.getDeclParmVarAbbrev(); 716 717 // Check things we know are true of *every* PARM_VAR_DECL, which is more than 718 // just us assuming it. 719 assert(!D->isInvalidDecl() && "Shouldn't emit invalid decls"); 720 assert(!D->isThreadSpecified() && "PARM_VAR_DECL can't be __thread"); 721 assert(D->getAccess() == AS_none && "PARM_VAR_DECL can't be public/private"); 722 assert(!D->isExceptionVariable() && "PARM_VAR_DECL can't be exception var"); 723 assert(D->getPreviousDeclaration() == 0 && "PARM_VAR_DECL can't be redecl"); 724 assert(!D->isStaticDataMember() && 725 "PARM_VAR_DECL can't be static data member"); 726} 727 728void ASTDeclWriter::VisitFileScopeAsmDecl(FileScopeAsmDecl *D) { 729 VisitDecl(D); 730 Writer.AddStmt(D->getAsmString()); 731 Writer.AddSourceLocation(D->getRParenLoc(), Record); 732 Code = serialization::DECL_FILE_SCOPE_ASM; 733} 734 735void ASTDeclWriter::VisitBlockDecl(BlockDecl *D) { 736 VisitDecl(D); 737 Writer.AddStmt(D->getBody()); 738 Writer.AddTypeSourceInfo(D->getSignatureAsWritten(), Record); 739 Record.push_back(D->param_size()); 740 for (FunctionDecl::param_iterator P = D->param_begin(), PEnd = D->param_end(); 741 P != PEnd; ++P) 742 Writer.AddDeclRef(*P, Record); 743 Record.push_back(D->capturesCXXThis()); 744 Record.push_back(D->getNumCaptures()); 745 for (BlockDecl::capture_iterator 746 i = D->capture_begin(), e = D->capture_end(); i != e; ++i) { 747 const BlockDecl::Capture &capture = *i; 748 Writer.AddDeclRef(capture.getVariable(), Record); 749 750 unsigned flags = 0; 751 if (capture.isByRef()) flags |= 1; 752 if (capture.isNested()) flags |= 2; 753 if (capture.hasCopyExpr()) flags |= 4; 754 Record.push_back(flags); 755 756 if (capture.hasCopyExpr()) Writer.AddStmt(capture.getCopyExpr()); 757 } 758 759 Code = serialization::DECL_BLOCK; 760} 761 762void ASTDeclWriter::VisitLinkageSpecDecl(LinkageSpecDecl *D) { 763 VisitDecl(D); 764 Record.push_back(D->getLanguage()); 765 Writer.AddSourceLocation(D->getExternLoc(), Record); 766 Writer.AddSourceLocation(D->getRBraceLoc(), Record); 767 Code = serialization::DECL_LINKAGE_SPEC; 768} 769 770void ASTDeclWriter::VisitLabelDecl(LabelDecl *D) { 771 VisitNamedDecl(D); 772 Writer.AddSourceLocation(D->getLocStart(), Record); 773 Code = serialization::DECL_LABEL; 774} 775 776 777void ASTDeclWriter::VisitNamespaceDecl(NamespaceDecl *D) { 778 VisitNamedDecl(D); 779 Record.push_back(D->isInline()); 780 Writer.AddSourceLocation(D->getLocStart(), Record); 781 Writer.AddSourceLocation(D->getRBraceLoc(), Record); 782 Writer.AddDeclRef(D->getNextNamespace(), Record); 783 784 // Only write one reference--original or anonymous 785 Record.push_back(D->isOriginalNamespace()); 786 if (D->isOriginalNamespace()) 787 Writer.AddDeclRef(D->getAnonymousNamespace(), Record); 788 else 789 Writer.AddDeclRef(D->getOriginalNamespace(), Record); 790 Code = serialization::DECL_NAMESPACE; 791 792 if (Writer.hasChain() && !D->isOriginalNamespace() && 793 D->getOriginalNamespace()->getPCHLevel() > 0) { 794 NamespaceDecl *NS = D->getOriginalNamespace(); 795 Writer.AddUpdatedDeclContext(NS); 796 797 // Make sure all visible decls are written. They will be recorded later. 798 NS->lookup(DeclarationName()); 799 StoredDeclsMap *Map = static_cast<StoredDeclsMap*>(NS->getLookupPtr()); 800 if (Map) { 801 for (StoredDeclsMap::iterator D = Map->begin(), DEnd = Map->end(); 802 D != DEnd; ++D) { 803 DeclContext::lookup_result Result = D->second.getLookupResult(); 804 while (Result.first != Result.second) { 805 Writer.GetDeclRef(*Result.first); 806 ++Result.first; 807 } 808 } 809 } 810 } 811 812 if (Writer.hasChain() && D->isAnonymousNamespace() && !D->getNextNamespace()){ 813 // This is a most recent reopening of the anonymous namespace. If its parent 814 // is in a previous PCH (or is the TU), mark that parent for update, because 815 // the original namespace always points to the latest re-opening of its 816 // anonymous namespace. 817 Decl *Parent = cast<Decl>( 818 D->getParent()->getRedeclContext()->getPrimaryContext()); 819 if (Parent->getPCHLevel() > 0) { 820 ASTWriter::UpdateRecord &Record = Writer.DeclUpdates[Parent]; 821 Record.push_back(UPD_CXX_ADDED_ANONYMOUS_NAMESPACE); 822 Writer.AddDeclRef(D, Record); 823 } 824 } 825} 826 827void ASTDeclWriter::VisitNamespaceAliasDecl(NamespaceAliasDecl *D) { 828 VisitNamedDecl(D); 829 Writer.AddSourceLocation(D->getNamespaceLoc(), Record); 830 Writer.AddSourceLocation(D->getTargetNameLoc(), Record); 831 Writer.AddNestedNameSpecifierLoc(D->getQualifierLoc(), Record); 832 Writer.AddDeclRef(D->getNamespace(), Record); 833 Code = serialization::DECL_NAMESPACE_ALIAS; 834} 835 836void ASTDeclWriter::VisitUsingDecl(UsingDecl *D) { 837 VisitNamedDecl(D); 838 Writer.AddSourceLocation(D->getUsingLocation(), Record); 839 Writer.AddNestedNameSpecifierLoc(D->getQualifierLoc(), Record); 840 Writer.AddDeclarationNameLoc(D->DNLoc, D->getDeclName(), Record); 841 Writer.AddDeclRef(D->FirstUsingShadow, Record); 842 Record.push_back(D->isTypeName()); 843 Writer.AddDeclRef(Context.getInstantiatedFromUsingDecl(D), Record); 844 Code = serialization::DECL_USING; 845} 846 847void ASTDeclWriter::VisitUsingShadowDecl(UsingShadowDecl *D) { 848 VisitNamedDecl(D); 849 Writer.AddDeclRef(D->getTargetDecl(), Record); 850 Writer.AddDeclRef(D->UsingOrNextShadow, Record); 851 Writer.AddDeclRef(Context.getInstantiatedFromUsingShadowDecl(D), Record); 852 Code = serialization::DECL_USING_SHADOW; 853} 854 855void ASTDeclWriter::VisitUsingDirectiveDecl(UsingDirectiveDecl *D) { 856 VisitNamedDecl(D); 857 Writer.AddSourceLocation(D->getUsingLoc(), Record); 858 Writer.AddSourceLocation(D->getNamespaceKeyLocation(), Record); 859 Writer.AddNestedNameSpecifierLoc(D->getQualifierLoc(), Record); 860 Writer.AddDeclRef(D->getNominatedNamespace(), Record); 861 Writer.AddDeclRef(dyn_cast<Decl>(D->getCommonAncestor()), Record); 862 Code = serialization::DECL_USING_DIRECTIVE; 863} 864 865void ASTDeclWriter::VisitUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *D) { 866 VisitValueDecl(D); 867 Writer.AddSourceLocation(D->getUsingLoc(), Record); 868 Writer.AddNestedNameSpecifierLoc(D->getQualifierLoc(), Record); 869 Writer.AddDeclarationNameLoc(D->DNLoc, D->getDeclName(), Record); 870 Code = serialization::DECL_UNRESOLVED_USING_VALUE; 871} 872 873void ASTDeclWriter::VisitUnresolvedUsingTypenameDecl( 874 UnresolvedUsingTypenameDecl *D) { 875 VisitTypeDecl(D); 876 Writer.AddSourceLocation(D->getTypenameLoc(), Record); 877 Writer.AddNestedNameSpecifierLoc(D->getQualifierLoc(), Record); 878 Code = serialization::DECL_UNRESOLVED_USING_TYPENAME; 879} 880 881void ASTDeclWriter::VisitCXXRecordDecl(CXXRecordDecl *D) { 882 VisitRecordDecl(D); 883 884 CXXRecordDecl *DefinitionDecl = 0; 885 if (D->DefinitionData) 886 DefinitionDecl = D->DefinitionData->Definition; 887 Writer.AddDeclRef(DefinitionDecl, Record); 888 if (D == DefinitionDecl) 889 Writer.AddCXXDefinitionData(D, Record); 890 891 enum { 892 CXXRecNotTemplate = 0, CXXRecTemplate, CXXRecMemberSpecialization 893 }; 894 if (ClassTemplateDecl *TemplD = D->getDescribedClassTemplate()) { 895 Record.push_back(CXXRecTemplate); 896 Writer.AddDeclRef(TemplD, Record); 897 } else if (MemberSpecializationInfo *MSInfo 898 = D->getMemberSpecializationInfo()) { 899 Record.push_back(CXXRecMemberSpecialization); 900 Writer.AddDeclRef(MSInfo->getInstantiatedFrom(), Record); 901 Record.push_back(MSInfo->getTemplateSpecializationKind()); 902 Writer.AddSourceLocation(MSInfo->getPointOfInstantiation(), Record); 903 } else { 904 Record.push_back(CXXRecNotTemplate); 905 } 906 907 // Store the key function to avoid deserializing every method so we can 908 // compute it. 909 if (D->IsDefinition) 910 Writer.AddDeclRef(Context.getKeyFunction(D), Record); 911 912 Code = serialization::DECL_CXX_RECORD; 913} 914 915void ASTDeclWriter::VisitCXXMethodDecl(CXXMethodDecl *D) { 916 VisitFunctionDecl(D); 917 Record.push_back(D->size_overridden_methods()); 918 for (CXXMethodDecl::method_iterator 919 I = D->begin_overridden_methods(), E = D->end_overridden_methods(); 920 I != E; ++I) 921 Writer.AddDeclRef(*I, Record); 922 Code = serialization::DECL_CXX_METHOD; 923} 924 925void ASTDeclWriter::VisitCXXConstructorDecl(CXXConstructorDecl *D) { 926 VisitCXXMethodDecl(D); 927 928 Record.push_back(D->IsExplicitSpecified); 929 Record.push_back(D->ImplicitlyDefined); 930 Writer.AddCXXCtorInitializers(D->CtorInitializers, D->NumCtorInitializers, 931 Record); 932 933 Code = serialization::DECL_CXX_CONSTRUCTOR; 934} 935 936void ASTDeclWriter::VisitCXXDestructorDecl(CXXDestructorDecl *D) { 937 VisitCXXMethodDecl(D); 938 939 Record.push_back(D->ImplicitlyDefined); 940 Writer.AddDeclRef(D->OperatorDelete, Record); 941 942 Code = serialization::DECL_CXX_DESTRUCTOR; 943} 944 945void ASTDeclWriter::VisitCXXConversionDecl(CXXConversionDecl *D) { 946 VisitCXXMethodDecl(D); 947 Record.push_back(D->IsExplicitSpecified); 948 Code = serialization::DECL_CXX_CONVERSION; 949} 950 951void ASTDeclWriter::VisitAccessSpecDecl(AccessSpecDecl *D) { 952 VisitDecl(D); 953 Writer.AddSourceLocation(D->getColonLoc(), Record); 954 Code = serialization::DECL_ACCESS_SPEC; 955} 956 957void ASTDeclWriter::VisitFriendDecl(FriendDecl *D) { 958 VisitDecl(D); 959 Record.push_back(D->Friend.is<TypeSourceInfo*>()); 960 if (D->Friend.is<TypeSourceInfo*>()) 961 Writer.AddTypeSourceInfo(D->Friend.get<TypeSourceInfo*>(), Record); 962 else 963 Writer.AddDeclRef(D->Friend.get<NamedDecl*>(), Record); 964 Writer.AddDeclRef(D->getNextFriend(), Record); 965 Record.push_back(D->UnsupportedFriend); 966 Writer.AddSourceLocation(D->FriendLoc, Record); 967 Code = serialization::DECL_FRIEND; 968} 969 970void ASTDeclWriter::VisitFriendTemplateDecl(FriendTemplateDecl *D) { 971 VisitDecl(D); 972 Record.push_back(D->getNumTemplateParameters()); 973 for (unsigned i = 0, e = D->getNumTemplateParameters(); i != e; ++i) 974 Writer.AddTemplateParameterList(D->getTemplateParameterList(i), Record); 975 Record.push_back(D->getFriendDecl() != 0); 976 if (D->getFriendDecl()) 977 Writer.AddDeclRef(D->getFriendDecl(), Record); 978 else 979 Writer.AddTypeSourceInfo(D->getFriendType(), Record); 980 Writer.AddSourceLocation(D->getFriendLoc(), Record); 981 Code = serialization::DECL_FRIEND_TEMPLATE; 982} 983 984void ASTDeclWriter::VisitTemplateDecl(TemplateDecl *D) { 985 VisitNamedDecl(D); 986 987 Writer.AddDeclRef(D->getTemplatedDecl(), Record); 988 Writer.AddTemplateParameterList(D->getTemplateParameters(), Record); 989} 990 991void ASTDeclWriter::VisitRedeclarableTemplateDecl(RedeclarableTemplateDecl *D) { 992 // Emit data to initialize CommonOrPrev before VisitTemplateDecl so that 993 // getCommonPtr() can be used while this is still initializing. 994 995 Writer.AddDeclRef(D->getPreviousDeclaration(), Record); 996 if (D->getPreviousDeclaration()) 997 Writer.AddDeclRef(D->getFirstDeclaration(), Record); 998 999 if (D->getPreviousDeclaration() == 0) { 1000 // This TemplateDecl owns the CommonPtr; write it. 1001 assert(D->isCanonicalDecl()); 1002 1003 Writer.AddDeclRef(D->getInstantiatedFromMemberTemplate(), Record); 1004 if (D->getInstantiatedFromMemberTemplate()) 1005 Record.push_back(D->isMemberSpecialization()); 1006 1007 Writer.AddDeclRef(D->getCommonPtr()->Latest, Record); 1008 } else { 1009 RedeclarableTemplateDecl *First = D->getFirstDeclaration(); 1010 assert(First != D); 1011 // If this is a most recent redeclaration that is pointed to by a first decl 1012 // in a chained PCH, keep track of the association with the map so we can 1013 // update the first decl during AST reading. 1014 if (First->getMostRecentDeclaration() == D && 1015 First->getPCHLevel() > D->getPCHLevel()) { 1016 assert(Writer.FirstLatestDecls.find(First)==Writer.FirstLatestDecls.end() 1017 && "The latest is already set"); 1018 Writer.FirstLatestDecls[First] = D; 1019 } 1020 } 1021 1022 VisitTemplateDecl(D); 1023 Record.push_back(D->getIdentifierNamespace()); 1024} 1025 1026void ASTDeclWriter::VisitClassTemplateDecl(ClassTemplateDecl *D) { 1027 VisitRedeclarableTemplateDecl(D); 1028 1029 if (D->getPreviousDeclaration() == 0) { 1030 typedef llvm::FoldingSet<ClassTemplateSpecializationDecl> CTSDSetTy; 1031 CTSDSetTy &CTSDSet = D->getSpecializations(); 1032 Record.push_back(CTSDSet.size()); 1033 for (CTSDSetTy::iterator I=CTSDSet.begin(), E = CTSDSet.end(); I!=E; ++I) { 1034 assert(I->isCanonicalDecl() && "Expected only canonical decls in set"); 1035 Writer.AddDeclRef(&*I, Record); 1036 } 1037 1038 typedef llvm::FoldingSet<ClassTemplatePartialSpecializationDecl> CTPSDSetTy; 1039 CTPSDSetTy &CTPSDSet = D->getPartialSpecializations(); 1040 Record.push_back(CTPSDSet.size()); 1041 for (CTPSDSetTy::iterator I=CTPSDSet.begin(), E=CTPSDSet.end(); I!=E; ++I) { 1042 assert(I->isCanonicalDecl() && "Expected only canonical decls in set"); 1043 Writer.AddDeclRef(&*I, Record); 1044 } 1045 1046 // InjectedClassNameType is computed, no need to write it. 1047 } 1048 Code = serialization::DECL_CLASS_TEMPLATE; 1049} 1050 1051void ASTDeclWriter::VisitClassTemplateSpecializationDecl( 1052 ClassTemplateSpecializationDecl *D) { 1053 VisitCXXRecordDecl(D); 1054 1055 llvm::PointerUnion<ClassTemplateDecl *, 1056 ClassTemplatePartialSpecializationDecl *> InstFrom 1057 = D->getSpecializedTemplateOrPartial(); 1058 Decl *InstFromD; 1059 if (InstFrom.is<ClassTemplateDecl *>()) { 1060 InstFromD = InstFrom.get<ClassTemplateDecl *>(); 1061 Writer.AddDeclRef(InstFromD, Record); 1062 } else { 1063 InstFromD = InstFrom.get<ClassTemplatePartialSpecializationDecl *>(); 1064 Writer.AddDeclRef(InstFromD, Record); 1065 Writer.AddTemplateArgumentList(&D->getTemplateInstantiationArgs(), Record); 1066 InstFromD = cast<ClassTemplatePartialSpecializationDecl>(InstFromD)-> 1067 getSpecializedTemplate(); 1068 } 1069 1070 // Explicit info. 1071 Writer.AddTypeSourceInfo(D->getTypeAsWritten(), Record); 1072 if (D->getTypeAsWritten()) { 1073 Writer.AddSourceLocation(D->getExternLoc(), Record); 1074 Writer.AddSourceLocation(D->getTemplateKeywordLoc(), Record); 1075 } 1076 1077 Writer.AddTemplateArgumentList(&D->getTemplateArgs(), Record); 1078 Writer.AddSourceLocation(D->getPointOfInstantiation(), Record); 1079 Record.push_back(D->getSpecializationKind()); 1080 1081 if (D->isCanonicalDecl()) { 1082 // When reading, we'll add it to the folding set of the following template. 1083 Writer.AddDeclRef(D->getSpecializedTemplate()->getCanonicalDecl(), Record); 1084 } 1085 1086 Code = serialization::DECL_CLASS_TEMPLATE_SPECIALIZATION; 1087} 1088 1089void ASTDeclWriter::VisitClassTemplatePartialSpecializationDecl( 1090 ClassTemplatePartialSpecializationDecl *D) { 1091 VisitClassTemplateSpecializationDecl(D); 1092 1093 Writer.AddTemplateParameterList(D->getTemplateParameters(), Record); 1094 1095 Record.push_back(D->getNumTemplateArgsAsWritten()); 1096 for (int i = 0, e = D->getNumTemplateArgsAsWritten(); i != e; ++i) 1097 Writer.AddTemplateArgumentLoc(D->getTemplateArgsAsWritten()[i], Record); 1098 1099 Record.push_back(D->getSequenceNumber()); 1100 1101 // These are read/set from/to the first declaration. 1102 if (D->getPreviousDeclaration() == 0) { 1103 Writer.AddDeclRef(D->getInstantiatedFromMember(), Record); 1104 Record.push_back(D->isMemberSpecialization()); 1105 } 1106 1107 Code = serialization::DECL_CLASS_TEMPLATE_PARTIAL_SPECIALIZATION; 1108} 1109 1110void ASTDeclWriter::VisitFunctionTemplateDecl(FunctionTemplateDecl *D) { 1111 VisitRedeclarableTemplateDecl(D); 1112 1113 if (D->getPreviousDeclaration() == 0) { 1114 // This FunctionTemplateDecl owns the CommonPtr; write it. 1115 1116 // Write the function specialization declarations. 1117 Record.push_back(D->getSpecializations().size()); 1118 for (llvm::FoldingSet<FunctionTemplateSpecializationInfo>::iterator 1119 I = D->getSpecializations().begin(), 1120 E = D->getSpecializations().end() ; I != E; ++I) { 1121 assert(I->Function->isCanonicalDecl() && 1122 "Expected only canonical decls in set"); 1123 Writer.AddDeclRef(I->Function, Record); 1124 } 1125 } 1126 Code = serialization::DECL_FUNCTION_TEMPLATE; 1127} 1128 1129void ASTDeclWriter::VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D) { 1130 VisitTypeDecl(D); 1131 1132 Record.push_back(D->wasDeclaredWithTypename()); 1133 Record.push_back(D->defaultArgumentWasInherited()); 1134 Writer.AddTypeSourceInfo(D->getDefaultArgumentInfo(), Record); 1135 1136 Code = serialization::DECL_TEMPLATE_TYPE_PARM; 1137} 1138 1139void ASTDeclWriter::VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D) { 1140 // For an expanded parameter pack, record the number of expansion types here 1141 // so that it's easier for 1142 if (D->isExpandedParameterPack()) 1143 Record.push_back(D->getNumExpansionTypes()); 1144 1145 VisitDeclaratorDecl(D); 1146 // TemplateParmPosition. 1147 Record.push_back(D->getDepth()); 1148 Record.push_back(D->getPosition()); 1149 1150 if (D->isExpandedParameterPack()) { 1151 for (unsigned I = 0, N = D->getNumExpansionTypes(); I != N; ++I) { 1152 Writer.AddTypeRef(D->getExpansionType(I), Record); 1153 Writer.AddTypeSourceInfo(D->getExpansionTypeSourceInfo(I), Record); 1154 } 1155 1156 Code = serialization::DECL_EXPANDED_NON_TYPE_TEMPLATE_PARM_PACK; 1157 } else { 1158 // Rest of NonTypeTemplateParmDecl. 1159 Record.push_back(D->isParameterPack()); 1160 Record.push_back(D->getDefaultArgument() != 0); 1161 if (D->getDefaultArgument()) { 1162 Writer.AddStmt(D->getDefaultArgument()); 1163 Record.push_back(D->defaultArgumentWasInherited()); 1164 } 1165 Code = serialization::DECL_NON_TYPE_TEMPLATE_PARM; 1166 } 1167} 1168 1169void ASTDeclWriter::VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D) { 1170 VisitTemplateDecl(D); 1171 // TemplateParmPosition. 1172 Record.push_back(D->getDepth()); 1173 Record.push_back(D->getPosition()); 1174 // Rest of TemplateTemplateParmDecl. 1175 Writer.AddTemplateArgumentLoc(D->getDefaultArgument(), Record); 1176 Record.push_back(D->defaultArgumentWasInherited()); 1177 Record.push_back(D->isParameterPack()); 1178 Code = serialization::DECL_TEMPLATE_TEMPLATE_PARM; 1179} 1180 1181void ASTDeclWriter::VisitTypeAliasTemplateDecl(TypeAliasTemplateDecl *D) { 1182 VisitRedeclarableTemplateDecl(D); 1183 Code = serialization::DECL_TYPE_ALIAS_TEMPLATE; 1184} 1185 1186void ASTDeclWriter::VisitStaticAssertDecl(StaticAssertDecl *D) { 1187 VisitDecl(D); 1188 Writer.AddStmt(D->getAssertExpr()); 1189 Writer.AddStmt(D->getMessage()); 1190 Writer.AddSourceLocation(D->getRParenLoc(), Record); 1191 Code = serialization::DECL_STATIC_ASSERT; 1192} 1193 1194/// \brief Emit the DeclContext part of a declaration context decl. 1195/// 1196/// \param LexicalOffset the offset at which the DECL_CONTEXT_LEXICAL 1197/// block for this declaration context is stored. May be 0 to indicate 1198/// that there are no declarations stored within this context. 1199/// 1200/// \param VisibleOffset the offset at which the DECL_CONTEXT_VISIBLE 1201/// block for this declaration context is stored. May be 0 to indicate 1202/// that there are no declarations visible from this context. Note 1203/// that this value will not be emitted for non-primary declaration 1204/// contexts. 1205void ASTDeclWriter::VisitDeclContext(DeclContext *DC, uint64_t LexicalOffset, 1206 uint64_t VisibleOffset) { 1207 Record.push_back(LexicalOffset); 1208 Record.push_back(VisibleOffset); 1209} 1210 1211template <typename T> 1212void ASTDeclWriter::VisitRedeclarable(Redeclarable<T> *D) { 1213 enum { NoRedeclaration = 0, PointsToPrevious, PointsToLatest }; 1214 if (D->RedeclLink.getNext() == D) { 1215 Record.push_back(NoRedeclaration); 1216 } else { 1217 if (D->RedeclLink.NextIsPrevious()) { 1218 Record.push_back(PointsToPrevious); 1219 Writer.AddDeclRef(D->getPreviousDeclaration(), Record); 1220 Writer.AddDeclRef(D->getFirstDeclaration(), Record); 1221 } else { 1222 Record.push_back(PointsToLatest); 1223 Writer.AddDeclRef(D->RedeclLink.getPointer(), Record); 1224 } 1225 } 1226 1227 T *First = D->getFirstDeclaration(); 1228 T *ThisDecl = static_cast<T*>(D); 1229 // If this is a most recent redeclaration that is pointed to by a first decl 1230 // in a chained PCH, keep track of the association with the map so we can 1231 // update the first decl during AST reading. 1232 if (ThisDecl != First && First->getMostRecentDeclaration() == ThisDecl && 1233 First->getPCHLevel() > ThisDecl->getPCHLevel()) { 1234 assert(Writer.FirstLatestDecls.find(First) == Writer.FirstLatestDecls.end() 1235 && "The latest is already set"); 1236 Writer.FirstLatestDecls[First] = ThisDecl; 1237 } 1238} 1239 1240//===----------------------------------------------------------------------===// 1241// ASTWriter Implementation 1242//===----------------------------------------------------------------------===// 1243 1244void ASTWriter::WriteDeclsBlockAbbrevs() { 1245 using namespace llvm; 1246 1247 BitCodeAbbrev *Abv; 1248 1249 // Abbreviation for DECL_FIELD 1250 Abv = new BitCodeAbbrev(); 1251 Abv->Add(BitCodeAbbrevOp(serialization::DECL_FIELD)); 1252 // Decl 1253 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclContext 1254 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // LexicalDeclContext 1255 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Location 1256 Abv->Add(BitCodeAbbrevOp(0)); // isInvalidDecl (!?) 1257 Abv->Add(BitCodeAbbrevOp(0)); // HasAttrs 1258 Abv->Add(BitCodeAbbrevOp(0)); // isImplicit 1259 Abv->Add(BitCodeAbbrevOp(0)); // isUsed 1260 Abv->Add(BitCodeAbbrevOp(0)); // isReferenced 1261 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2)); // AccessSpecifier 1262 Abv->Add(BitCodeAbbrevOp(0)); // PCH level 1263 // NamedDecl 1264 Abv->Add(BitCodeAbbrevOp(0)); // NameKind = Identifier 1265 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Name 1266 // ValueDecl 1267 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type 1268 // DeclaratorDecl 1269 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // InnerStartLoc 1270 Abv->Add(BitCodeAbbrevOp(0)); // hasExtInfo 1271 // FieldDecl 1272 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isMutable 1273 Abv->Add(BitCodeAbbrevOp(0)); //getBitWidth 1274 // Type Source Info 1275 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); 1276 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array)); 1277 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // TypeLoc 1278 DeclFieldAbbrev = Stream.EmitAbbrev(Abv); 1279 1280 // Abbreviation for DECL_OBJC_IVAR 1281 Abv = new BitCodeAbbrev(); 1282 Abv->Add(BitCodeAbbrevOp(serialization::DECL_OBJC_IVAR)); 1283 // Decl 1284 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclContext 1285 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // LexicalDeclContext 1286 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Location 1287 Abv->Add(BitCodeAbbrevOp(0)); // isInvalidDecl (!?) 1288 Abv->Add(BitCodeAbbrevOp(0)); // HasAttrs 1289 Abv->Add(BitCodeAbbrevOp(0)); // isImplicit 1290 Abv->Add(BitCodeAbbrevOp(0)); // isUsed 1291 Abv->Add(BitCodeAbbrevOp(0)); // isReferenced 1292 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2)); // AccessSpecifier 1293 Abv->Add(BitCodeAbbrevOp(0)); // PCH level 1294 // NamedDecl 1295 Abv->Add(BitCodeAbbrevOp(0)); // NameKind = Identifier 1296 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Name 1297 // ValueDecl 1298 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type 1299 // DeclaratorDecl 1300 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // InnerStartLoc 1301 Abv->Add(BitCodeAbbrevOp(0)); // hasExtInfo 1302 // FieldDecl 1303 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isMutable 1304 Abv->Add(BitCodeAbbrevOp(0)); //getBitWidth 1305 // ObjC Ivar 1306 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // getAccessControl 1307 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // getSynthesize 1308 // Type Source Info 1309 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); 1310 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array)); 1311 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // TypeLoc 1312 DeclObjCIvarAbbrev = Stream.EmitAbbrev(Abv); 1313 1314 // Abbreviation for DECL_ENUM 1315 Abv = new BitCodeAbbrev(); 1316 Abv->Add(BitCodeAbbrevOp(serialization::DECL_ENUM)); 1317 // Decl 1318 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclContext 1319 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // LexicalDeclContext 1320 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Location 1321 Abv->Add(BitCodeAbbrevOp(0)); // isInvalidDecl (!?) 1322 Abv->Add(BitCodeAbbrevOp(0)); // HasAttrs 1323 Abv->Add(BitCodeAbbrevOp(0)); // isImplicit 1324 Abv->Add(BitCodeAbbrevOp(0)); // isUsed 1325 Abv->Add(BitCodeAbbrevOp(0)); // isReferenced 1326 Abv->Add(BitCodeAbbrevOp(AS_none)); // C++ AccessSpecifier 1327 Abv->Add(BitCodeAbbrevOp(0)); // PCH level 1328 // NamedDecl 1329 Abv->Add(BitCodeAbbrevOp(0)); // NameKind = Identifier 1330 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Name 1331 // TypeDecl 1332 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Source Location 1333 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type Ref 1334 // Redeclarable 1335 Abv->Add(BitCodeAbbrevOp(0)); // No redeclaration 1336 // TagDecl 1337 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // IdentifierNamespace 1338 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // getTagKind 1339 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isDefinition 1340 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // EmbeddedInDeclarator 1341 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SourceLocation 1342 Abv->Add(BitCodeAbbrevOp(0)); // hasExtInfo 1343 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // TypedefNameAnonDecl 1344 // EnumDecl 1345 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // AddTypeRef 1346 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // IntegerType 1347 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // getPromotionType 1348 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // getNumPositiveBits 1349 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // getNumNegativeBits 1350 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isScoped 1351 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isScopedUsingClassTag 1352 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isFixed 1353 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // InstantiatedMembEnum 1354 // DC 1355 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // LexicalOffset 1356 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // VisibleOffset 1357 DeclEnumAbbrev = Stream.EmitAbbrev(Abv); 1358 1359 // Abbreviation for DECL_RECORD 1360 Abv = new BitCodeAbbrev(); 1361 Abv->Add(BitCodeAbbrevOp(serialization::DECL_RECORD)); 1362 // Decl 1363 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclContext 1364 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // LexicalDeclContext 1365 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Location 1366 Abv->Add(BitCodeAbbrevOp(0)); // isInvalidDecl (!?) 1367 Abv->Add(BitCodeAbbrevOp(0)); // HasAttrs 1368 Abv->Add(BitCodeAbbrevOp(0)); // isImplicit 1369 Abv->Add(BitCodeAbbrevOp(0)); // isUsed 1370 Abv->Add(BitCodeAbbrevOp(0)); // isReferenced 1371 Abv->Add(BitCodeAbbrevOp(AS_none)); // C++ AccessSpecifier 1372 Abv->Add(BitCodeAbbrevOp(0)); // PCH level 1373 // NamedDecl 1374 Abv->Add(BitCodeAbbrevOp(0)); // NameKind = Identifier 1375 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Name 1376 // TypeDecl 1377 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Source Location 1378 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type Ref 1379 // Redeclarable 1380 Abv->Add(BitCodeAbbrevOp(0)); // No redeclaration 1381 // TagDecl 1382 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // IdentifierNamespace 1383 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // getTagKind 1384 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isDefinition 1385 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // EmbeddedInDeclarator 1386 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SourceLocation 1387 Abv->Add(BitCodeAbbrevOp(0)); // hasExtInfo 1388 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // TypedefNameAnonDecl 1389 // RecordDecl 1390 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // FlexibleArrayMember 1391 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // AnonymousStructUnion 1392 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // hasObjectMember 1393 // DC 1394 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // LexicalOffset 1395 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // VisibleOffset 1396 DeclRecordAbbrev = Stream.EmitAbbrev(Abv); 1397 1398 // Abbreviation for DECL_PARM_VAR 1399 Abv = new BitCodeAbbrev(); 1400 Abv->Add(BitCodeAbbrevOp(serialization::DECL_PARM_VAR)); 1401 // Decl 1402 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclContext 1403 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // LexicalDeclContext 1404 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Location 1405 Abv->Add(BitCodeAbbrevOp(0)); // isInvalidDecl (!?) 1406 Abv->Add(BitCodeAbbrevOp(0)); // HasAttrs 1407 Abv->Add(BitCodeAbbrevOp(0)); // isImplicit 1408 Abv->Add(BitCodeAbbrevOp(0)); // isUsed 1409 Abv->Add(BitCodeAbbrevOp(0)); // isReferenced 1410 Abv->Add(BitCodeAbbrevOp(AS_none)); // C++ AccessSpecifier 1411 Abv->Add(BitCodeAbbrevOp(0)); // PCH level 1412 // NamedDecl 1413 Abv->Add(BitCodeAbbrevOp(0)); // NameKind = Identifier 1414 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Name 1415 // ValueDecl 1416 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type 1417 // DeclaratorDecl 1418 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // InnerStartLoc 1419 Abv->Add(BitCodeAbbrevOp(0)); // hasExtInfo 1420 // VarDecl 1421 Abv->Add(BitCodeAbbrevOp(0)); // No redeclaration 1422 Abv->Add(BitCodeAbbrevOp(0)); // StorageClass 1423 Abv->Add(BitCodeAbbrevOp(0)); // StorageClassAsWritten 1424 Abv->Add(BitCodeAbbrevOp(0)); // isThreadSpecified 1425 Abv->Add(BitCodeAbbrevOp(0)); // hasCXXDirectInitializer 1426 Abv->Add(BitCodeAbbrevOp(0)); // isExceptionVariable 1427 Abv->Add(BitCodeAbbrevOp(0)); // isNRVOVariable 1428 Abv->Add(BitCodeAbbrevOp(0)); // isCXXForRangeDecl 1429 Abv->Add(BitCodeAbbrevOp(0)); // HasInit 1430 Abv->Add(BitCodeAbbrevOp(0)); // HasMemberSpecializationInfo 1431 // ParmVarDecl 1432 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsObjCMethodParameter 1433 Abv->Add(BitCodeAbbrevOp(0)); // ScopeDepth 1434 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // ScopeIndex 1435 Abv->Add(BitCodeAbbrevOp(0)); // ObjCDeclQualifier 1436 Abv->Add(BitCodeAbbrevOp(0)); // KNRPromoted 1437 Abv->Add(BitCodeAbbrevOp(0)); // HasInheritedDefaultArg 1438 Abv->Add(BitCodeAbbrevOp(0)); // HasUninstantiatedDefaultArg 1439 // Type Source Info 1440 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); 1441 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array)); 1442 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // TypeLoc 1443 DeclParmVarAbbrev = Stream.EmitAbbrev(Abv); 1444 1445 // Abbreviation for DECL_TYPEDEF 1446 Abv = new BitCodeAbbrev(); 1447 Abv->Add(BitCodeAbbrevOp(serialization::DECL_TYPEDEF)); 1448 // Decl 1449 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclContext 1450 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // LexicalDeclContext 1451 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Location 1452 Abv->Add(BitCodeAbbrevOp(0)); // isInvalidDecl (!?) 1453 Abv->Add(BitCodeAbbrevOp(0)); // HasAttrs 1454 Abv->Add(BitCodeAbbrevOp(0)); // isImplicit 1455 Abv->Add(BitCodeAbbrevOp(0)); // isUsed 1456 Abv->Add(BitCodeAbbrevOp(0)); // isReferenced 1457 Abv->Add(BitCodeAbbrevOp(AS_none)); // C++ AccessSpecifier 1458 Abv->Add(BitCodeAbbrevOp(0)); // PCH level 1459 // NamedDecl 1460 Abv->Add(BitCodeAbbrevOp(0)); // NameKind = Identifier 1461 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Name 1462 // TypeDecl 1463 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Source Location 1464 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type Ref 1465 // TypedefDecl 1466 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array)); 1467 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // TypeLoc 1468 DeclTypedefAbbrev = Stream.EmitAbbrev(Abv); 1469 1470 // Abbreviation for DECL_VAR 1471 Abv = new BitCodeAbbrev(); 1472 Abv->Add(BitCodeAbbrevOp(serialization::DECL_VAR)); 1473 // Decl 1474 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclContext 1475 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // LexicalDeclContext 1476 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Location 1477 Abv->Add(BitCodeAbbrevOp(0)); // isInvalidDecl (!?) 1478 Abv->Add(BitCodeAbbrevOp(0)); // HasAttrs 1479 Abv->Add(BitCodeAbbrevOp(0)); // isImplicit 1480 Abv->Add(BitCodeAbbrevOp(0)); // isUsed 1481 Abv->Add(BitCodeAbbrevOp(0)); // isReferenced 1482 Abv->Add(BitCodeAbbrevOp(AS_none)); // C++ AccessSpecifier 1483 Abv->Add(BitCodeAbbrevOp(0)); // PCH level 1484 // NamedDecl 1485 Abv->Add(BitCodeAbbrevOp(0)); // NameKind = Identifier 1486 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Name 1487 // ValueDecl 1488 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type 1489 // DeclaratorDecl 1490 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // InnerStartLoc 1491 Abv->Add(BitCodeAbbrevOp(0)); // hasExtInfo 1492 // VarDecl 1493 Abv->Add(BitCodeAbbrevOp(0)); // No redeclaration 1494 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // StorageClass 1495 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // StorageClassAsWritten 1496 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isThreadSpecified 1497 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // CXXDirectInitializer 1498 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isExceptionVariable 1499 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isNRVOVariable 1500 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isCXXForRangeDecl 1501 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // HasInit 1502 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // HasMemberSpecInfo 1503 // Type Source Info 1504 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); 1505 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array)); 1506 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // TypeLoc 1507 DeclVarAbbrev = Stream.EmitAbbrev(Abv); 1508 1509 // Abbreviation for EXPR_DECL_REF 1510 Abv = new BitCodeAbbrev(); 1511 Abv->Add(BitCodeAbbrevOp(serialization::EXPR_DECL_REF)); 1512 //Stmt 1513 //Expr 1514 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type 1515 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //IsTypeDependent 1516 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //IsValueDependent 1517 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //UnexpandedParamPack 1518 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); //GetValueKind 1519 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); //GetObjectKind 1520 //DeclRefExpr 1521 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //HasQualifier 1522 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //GetDeclFound 1523 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //ExplicitTemplateArgs 1524 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclRef 1525 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Location 1526 DeclRefExprAbbrev = Stream.EmitAbbrev(Abv); 1527 1528 // Abbreviation for EXPR_INTEGER_LITERAL 1529 Abv = new BitCodeAbbrev(); 1530 Abv->Add(BitCodeAbbrevOp(serialization::EXPR_INTEGER_LITERAL)); 1531 //Stmt 1532 //Expr 1533 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type 1534 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //IsTypeDependent 1535 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //IsValueDependent 1536 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //UnexpandedParamPack 1537 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); //GetValueKind 1538 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); //GetObjectKind 1539 //Integer Literal 1540 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Location 1541 Abv->Add(BitCodeAbbrevOp(32)); // Bit Width 1542 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Value 1543 IntegerLiteralAbbrev = Stream.EmitAbbrev(Abv); 1544 1545 // Abbreviation for EXPR_CHARACTER_LITERAL 1546 Abv = new BitCodeAbbrev(); 1547 Abv->Add(BitCodeAbbrevOp(serialization::EXPR_CHARACTER_LITERAL)); 1548 //Stmt 1549 //Expr 1550 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type 1551 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //IsTypeDependent 1552 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //IsValueDependent 1553 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //UnexpandedParamPack 1554 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); //GetValueKind 1555 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); //GetObjectKind 1556 //Character Literal 1557 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // getValue 1558 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Location 1559 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //IsWide 1560 CharacterLiteralAbbrev = Stream.EmitAbbrev(Abv); 1561 1562 Abv = new BitCodeAbbrev(); 1563 Abv->Add(BitCodeAbbrevOp(serialization::DECL_CONTEXT_LEXICAL)); 1564 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); 1565 DeclContextLexicalAbbrev = Stream.EmitAbbrev(Abv); 1566 1567 Abv = new BitCodeAbbrev(); 1568 Abv->Add(BitCodeAbbrevOp(serialization::DECL_CONTEXT_VISIBLE)); 1569 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); 1570 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); 1571 DeclContextVisibleLookupAbbrev = Stream.EmitAbbrev(Abv); 1572} 1573 1574/// isRequiredDecl - Check if this is a "required" Decl, which must be seen by 1575/// consumers of the AST. 1576/// 1577/// Such decls will always be deserialized from the AST file, so we would like 1578/// this to be as restrictive as possible. Currently the predicate is driven by 1579/// code generation requirements, if other clients have a different notion of 1580/// what is "required" then we may have to consider an alternate scheme where 1581/// clients can iterate over the top-level decls and get information on them, 1582/// without necessary deserializing them. We could explicitly require such 1583/// clients to use a separate API call to "realize" the decl. This should be 1584/// relatively painless since they would presumably only do it for top-level 1585/// decls. 1586static bool isRequiredDecl(const Decl *D, ASTContext &Context) { 1587 // File scoped assembly or obj-c implementation must be seen. 1588 if (isa<FileScopeAsmDecl>(D) || isa<ObjCImplementationDecl>(D)) 1589 return true; 1590 1591 return Context.DeclMustBeEmitted(D); 1592} 1593 1594void ASTWriter::WriteDecl(ASTContext &Context, Decl *D) { 1595 // Switch case IDs are per Decl. 1596 ClearSwitchCaseIDs(); 1597 1598 RecordData Record; 1599 ASTDeclWriter W(*this, Context, Record); 1600 1601 // If this declaration is also a DeclContext, write blocks for the 1602 // declarations that lexically stored inside its context and those 1603 // declarations that are visible from its context. These blocks 1604 // are written before the declaration itself so that we can put 1605 // their offsets into the record for the declaration. 1606 uint64_t LexicalOffset = 0; 1607 uint64_t VisibleOffset = 0; 1608 DeclContext *DC = dyn_cast<DeclContext>(D); 1609 if (DC) { 1610 LexicalOffset = WriteDeclContextLexicalBlock(Context, DC); 1611 VisibleOffset = WriteDeclContextVisibleBlock(Context, DC); 1612 } 1613 1614 // Determine the ID for this declaration 1615 serialization::DeclID &IDR = DeclIDs[D]; 1616 if (IDR == 0) 1617 IDR = NextDeclID++; 1618 serialization::DeclID ID = IDR; 1619 1620 if (ID < FirstDeclID) { 1621 // We're replacing a decl in a previous file. 1622 ReplacedDecls.push_back(std::make_pair(ID, Stream.GetCurrentBitNo())); 1623 } else { 1624 unsigned Index = ID - FirstDeclID; 1625 1626 // Record the offset for this declaration 1627 if (DeclOffsets.size() == Index) 1628 DeclOffsets.push_back(Stream.GetCurrentBitNo()); 1629 else if (DeclOffsets.size() < Index) { 1630 DeclOffsets.resize(Index+1); 1631 DeclOffsets[Index] = Stream.GetCurrentBitNo(); 1632 } 1633 } 1634 1635 // Build and emit a record for this declaration 1636 Record.clear(); 1637 W.Code = (serialization::DeclCode)0; 1638 W.AbbrevToUse = 0; 1639 W.Visit(D); 1640 if (DC) W.VisitDeclContext(DC, LexicalOffset, VisibleOffset); 1641 1642 if (!W.Code) 1643 llvm::report_fatal_error(llvm::StringRef("unexpected declaration kind '") + 1644 D->getDeclKindName() + "'"); 1645 Stream.EmitRecord(W.Code, Record, W.AbbrevToUse); 1646 1647 // Flush any expressions that were written as part of this declaration. 1648 FlushStmts(); 1649 1650 // Flush C++ base specifiers, if there are any. 1651 FlushCXXBaseSpecifiers(); 1652 1653 // Note "external" declarations so that we can add them to a record in the 1654 // AST file later. 1655 // 1656 // FIXME: This should be renamed, the predicate is much more complicated. 1657 if (isRequiredDecl(D, Context)) 1658 ExternalDefinitions.push_back(ID); 1659} 1660