1212795Sdim//===--- ASTWriterDecl.cpp - Declaration Serialization --------------------===// 2212795Sdim// 3212795Sdim// The LLVM Compiler Infrastructure 4212795Sdim// 5212795Sdim// This file is distributed under the University of Illinois Open Source 6212795Sdim// License. See LICENSE.TXT for details. 7212795Sdim// 8212795Sdim//===----------------------------------------------------------------------===// 9212795Sdim// 10212795Sdim// This file implements serialization for Declarations. 11212795Sdim// 12212795Sdim//===----------------------------------------------------------------------===// 13212795Sdim 14212795Sdim#include "clang/Serialization/ASTWriter.h" 15221345Sdim#include "ASTCommon.h" 16212795Sdim#include "clang/AST/DeclCXX.h" 17252723Sdim#include "clang/AST/DeclContextInternals.h" 18212795Sdim#include "clang/AST/DeclTemplate.h" 19252723Sdim#include "clang/AST/DeclVisitor.h" 20212795Sdim#include "clang/AST/Expr.h" 21235633Sdim#include "clang/Basic/SourceManager.h" 22252723Sdim#include "clang/Serialization/ASTReader.h" 23212795Sdim#include "llvm/ADT/Twine.h" 24212795Sdim#include "llvm/Bitcode/BitstreamWriter.h" 25212795Sdim#include "llvm/Support/ErrorHandling.h" 26212795Sdimusing namespace clang; 27221345Sdimusing namespace serialization; 28212795Sdim 29212795Sdim//===----------------------------------------------------------------------===// 30212795Sdim// Declaration serialization 31212795Sdim//===----------------------------------------------------------------------===// 32212795Sdim 33212795Sdimnamespace clang { 34212795Sdim class ASTDeclWriter : public DeclVisitor<ASTDeclWriter, void> { 35212795Sdim 36212795Sdim ASTWriter &Writer; 37212795Sdim ASTContext &Context; 38218893Sdim typedef ASTWriter::RecordData RecordData; 39218893Sdim RecordData &Record; 40212795Sdim 41212795Sdim public: 42212795Sdim serialization::DeclCode Code; 43212795Sdim unsigned AbbrevToUse; 44212795Sdim 45218893Sdim ASTDeclWriter(ASTWriter &Writer, ASTContext &Context, RecordData &Record) 46212795Sdim : Writer(Writer), Context(Context), Record(Record) { 47212795Sdim } 48218893Sdim 49212795Sdim void Visit(Decl *D); 50212795Sdim 51212795Sdim void VisitDecl(Decl *D); 52212795Sdim void VisitTranslationUnitDecl(TranslationUnitDecl *D); 53212795Sdim void VisitNamedDecl(NamedDecl *D); 54218893Sdim void VisitLabelDecl(LabelDecl *LD); 55212795Sdim void VisitNamespaceDecl(NamespaceDecl *D); 56212795Sdim void VisitUsingDirectiveDecl(UsingDirectiveDecl *D); 57212795Sdim void VisitNamespaceAliasDecl(NamespaceAliasDecl *D); 58212795Sdim void VisitTypeDecl(TypeDecl *D); 59235633Sdim void VisitTypedefNameDecl(TypedefNameDecl *D); 60212795Sdim void VisitTypedefDecl(TypedefDecl *D); 61221345Sdim void VisitTypeAliasDecl(TypeAliasDecl *D); 62212795Sdim void VisitUnresolvedUsingTypenameDecl(UnresolvedUsingTypenameDecl *D); 63212795Sdim void VisitTagDecl(TagDecl *D); 64212795Sdim void VisitEnumDecl(EnumDecl *D); 65212795Sdim void VisitRecordDecl(RecordDecl *D); 66212795Sdim void VisitCXXRecordDecl(CXXRecordDecl *D); 67212795Sdim void VisitClassTemplateSpecializationDecl( 68212795Sdim ClassTemplateSpecializationDecl *D); 69212795Sdim void VisitClassTemplatePartialSpecializationDecl( 70212795Sdim ClassTemplatePartialSpecializationDecl *D); 71263509Sdim void VisitVarTemplateSpecializationDecl(VarTemplateSpecializationDecl *D); 72263509Sdim void VisitVarTemplatePartialSpecializationDecl( 73263509Sdim VarTemplatePartialSpecializationDecl *D); 74226890Sdim void VisitClassScopeFunctionSpecializationDecl( 75226890Sdim ClassScopeFunctionSpecializationDecl *D); 76212795Sdim void VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D); 77212795Sdim void VisitValueDecl(ValueDecl *D); 78212795Sdim void VisitEnumConstantDecl(EnumConstantDecl *D); 79212795Sdim void VisitUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *D); 80212795Sdim void VisitDeclaratorDecl(DeclaratorDecl *D); 81212795Sdim void VisitFunctionDecl(FunctionDecl *D); 82212795Sdim void VisitCXXMethodDecl(CXXMethodDecl *D); 83212795Sdim void VisitCXXConstructorDecl(CXXConstructorDecl *D); 84212795Sdim void VisitCXXDestructorDecl(CXXDestructorDecl *D); 85212795Sdim void VisitCXXConversionDecl(CXXConversionDecl *D); 86212795Sdim void VisitFieldDecl(FieldDecl *D); 87252723Sdim void VisitMSPropertyDecl(MSPropertyDecl *D); 88218893Sdim void VisitIndirectFieldDecl(IndirectFieldDecl *D); 89212795Sdim void VisitVarDecl(VarDecl *D); 90212795Sdim void VisitImplicitParamDecl(ImplicitParamDecl *D); 91212795Sdim void VisitParmVarDecl(ParmVarDecl *D); 92212795Sdim void VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D); 93212795Sdim void VisitTemplateDecl(TemplateDecl *D); 94212795Sdim void VisitRedeclarableTemplateDecl(RedeclarableTemplateDecl *D); 95212795Sdim void VisitClassTemplateDecl(ClassTemplateDecl *D); 96263509Sdim void VisitVarTemplateDecl(VarTemplateDecl *D); 97212795Sdim void VisitFunctionTemplateDecl(FunctionTemplateDecl *D); 98212795Sdim void VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D); 99223017Sdim void VisitTypeAliasTemplateDecl(TypeAliasTemplateDecl *D); 100212795Sdim void VisitUsingDecl(UsingDecl *D); 101212795Sdim void VisitUsingShadowDecl(UsingShadowDecl *D); 102212795Sdim void VisitLinkageSpecDecl(LinkageSpecDecl *D); 103212795Sdim void VisitFileScopeAsmDecl(FileScopeAsmDecl *D); 104235633Sdim void VisitImportDecl(ImportDecl *D); 105212795Sdim void VisitAccessSpecDecl(AccessSpecDecl *D); 106212795Sdim void VisitFriendDecl(FriendDecl *D); 107212795Sdim void VisitFriendTemplateDecl(FriendTemplateDecl *D); 108212795Sdim void VisitStaticAssertDecl(StaticAssertDecl *D); 109212795Sdim void VisitBlockDecl(BlockDecl *D); 110252723Sdim void VisitCapturedDecl(CapturedDecl *D); 111252723Sdim void VisitEmptyDecl(EmptyDecl *D); 112212795Sdim 113212795Sdim void VisitDeclContext(DeclContext *DC, uint64_t LexicalOffset, 114212795Sdim uint64_t VisibleOffset); 115212795Sdim template <typename T> void VisitRedeclarable(Redeclarable<T> *D); 116212795Sdim 117212795Sdim 118212795Sdim // FIXME: Put in the same order is DeclNodes.td? 119212795Sdim void VisitObjCMethodDecl(ObjCMethodDecl *D); 120212795Sdim void VisitObjCContainerDecl(ObjCContainerDecl *D); 121212795Sdim void VisitObjCInterfaceDecl(ObjCInterfaceDecl *D); 122212795Sdim void VisitObjCIvarDecl(ObjCIvarDecl *D); 123212795Sdim void VisitObjCProtocolDecl(ObjCProtocolDecl *D); 124212795Sdim void VisitObjCAtDefsFieldDecl(ObjCAtDefsFieldDecl *D); 125212795Sdim void VisitObjCCategoryDecl(ObjCCategoryDecl *D); 126212795Sdim void VisitObjCImplDecl(ObjCImplDecl *D); 127212795Sdim void VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D); 128212795Sdim void VisitObjCImplementationDecl(ObjCImplementationDecl *D); 129212795Sdim void VisitObjCCompatibleAliasDecl(ObjCCompatibleAliasDecl *D); 130212795Sdim void VisitObjCPropertyDecl(ObjCPropertyDecl *D); 131212795Sdim void VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D); 132252723Sdim void VisitOMPThreadPrivateDecl(OMPThreadPrivateDecl *D); 133212795Sdim }; 134212795Sdim} 135212795Sdim 136212795Sdimvoid ASTDeclWriter::Visit(Decl *D) { 137212795Sdim DeclVisitor<ASTDeclWriter>::Visit(D); 138212795Sdim 139223017Sdim // Source locations require array (variable-length) abbreviations. The 140223017Sdim // abbreviation infrastructure requires that arrays are encoded last, so 141223017Sdim // we handle it here in the case of those classes derived from DeclaratorDecl 142223017Sdim if (DeclaratorDecl *DD = dyn_cast<DeclaratorDecl>(D)){ 143223017Sdim Writer.AddTypeSourceInfo(DD->getTypeSourceInfo(), Record); 144223017Sdim } 145223017Sdim 146212795Sdim // Handle FunctionDecl's body here and write it after all other Stmts/Exprs 147212795Sdim // have been written. We want it last because we will not read it back when 148212795Sdim // retrieving it from the AST, we'll just lazily set the offset. 149212795Sdim if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) { 150223017Sdim Record.push_back(FD->doesThisDeclarationHaveABody()); 151223017Sdim if (FD->doesThisDeclarationHaveABody()) 152212795Sdim Writer.AddStmt(FD->getBody()); 153212795Sdim } 154212795Sdim} 155212795Sdim 156212795Sdimvoid ASTDeclWriter::VisitDecl(Decl *D) { 157212795Sdim Writer.AddDeclRef(cast_or_null<Decl>(D->getDeclContext()), Record); 158212795Sdim Writer.AddDeclRef(cast_or_null<Decl>(D->getLexicalDeclContext()), Record); 159212795Sdim Record.push_back(D->isInvalidDecl()); 160212795Sdim Record.push_back(D->hasAttrs()); 161218893Sdim if (D->hasAttrs()) 162245431Sdim Writer.WriteAttributes(ArrayRef<const Attr*>(D->getAttrs().begin(), 163245431Sdim D->getAttrs().size()), Record); 164212795Sdim Record.push_back(D->isImplicit()); 165212795Sdim Record.push_back(D->isUsed(false)); 166221345Sdim Record.push_back(D->isReferenced()); 167235633Sdim Record.push_back(D->isTopLevelDeclInObjCContainer()); 168212795Sdim Record.push_back(D->getAccess()); 169235633Sdim Record.push_back(D->isModulePrivate()); 170235633Sdim Record.push_back(Writer.inferSubmoduleIDFromLocation(D->getLocation())); 171212795Sdim} 172212795Sdim 173212795Sdimvoid ASTDeclWriter::VisitTranslationUnitDecl(TranslationUnitDecl *D) { 174226890Sdim llvm_unreachable("Translation units aren't directly serialized"); 175212795Sdim} 176212795Sdim 177212795Sdimvoid ASTDeclWriter::VisitNamedDecl(NamedDecl *D) { 178212795Sdim VisitDecl(D); 179212795Sdim Writer.AddDeclarationName(D->getDeclName(), Record); 180212795Sdim} 181212795Sdim 182212795Sdimvoid ASTDeclWriter::VisitTypeDecl(TypeDecl *D) { 183212795Sdim VisitNamedDecl(D); 184221345Sdim Writer.AddSourceLocation(D->getLocStart(), Record); 185212795Sdim Writer.AddTypeRef(QualType(D->getTypeForDecl(), 0), Record); 186212795Sdim} 187212795Sdim 188235633Sdimvoid ASTDeclWriter::VisitTypedefNameDecl(TypedefNameDecl *D) { 189235633Sdim VisitRedeclarable(D); 190212795Sdim VisitTypeDecl(D); 191263509Sdim Writer.AddTypeSourceInfo(D->getTypeSourceInfo(), Record); 192263509Sdim Record.push_back(D->isModed()); 193263509Sdim if (D->isModed()) 194263509Sdim Writer.AddTypeRef(D->getUnderlyingType(), Record); 195235633Sdim} 196223017Sdim 197235633Sdimvoid ASTDeclWriter::VisitTypedefDecl(TypedefDecl *D) { 198235633Sdim VisitTypedefNameDecl(D); 199223017Sdim if (!D->hasAttrs() && 200223017Sdim !D->isImplicit() && 201223017Sdim !D->isUsed(false) && 202263509Sdim D->getFirstDecl() == D->getMostRecentDecl() && 203223017Sdim !D->isInvalidDecl() && 204223017Sdim !D->isReferenced() && 205235633Sdim !D->isTopLevelDeclInObjCContainer() && 206223017Sdim D->getAccess() == AS_none && 207226890Sdim !D->isModulePrivate() && 208223017Sdim D->getDeclName().getNameKind() == DeclarationName::Identifier) 209223017Sdim AbbrevToUse = Writer.getDeclTypedefAbbrev(); 210223017Sdim 211212795Sdim Code = serialization::DECL_TYPEDEF; 212212795Sdim} 213212795Sdim 214221345Sdimvoid ASTDeclWriter::VisitTypeAliasDecl(TypeAliasDecl *D) { 215235633Sdim VisitTypedefNameDecl(D); 216221345Sdim Code = serialization::DECL_TYPEALIAS; 217221345Sdim} 218221345Sdim 219212795Sdimvoid ASTDeclWriter::VisitTagDecl(TagDecl *D) { 220235633Sdim VisitRedeclarable(D); 221212795Sdim VisitTypeDecl(D); 222212795Sdim Record.push_back(D->getIdentifierNamespace()); 223212795Sdim Record.push_back((unsigned)D->getTagKind()); // FIXME: stable encoding 224226890Sdim Record.push_back(D->isCompleteDefinition()); 225212795Sdim Record.push_back(D->isEmbeddedInDeclarator()); 226226890Sdim Record.push_back(D->isFreeStanding()); 227263509Sdim Record.push_back(D->isCompleteDefinitionRequired()); 228212795Sdim Writer.AddSourceLocation(D->getRBraceLoc(), Record); 229218893Sdim Record.push_back(D->hasExtInfo()); 230218893Sdim if (D->hasExtInfo()) 231218893Sdim Writer.AddQualifierInfo(*D->getExtInfo(), Record); 232263509Sdim else if (D->hasDeclaratorForAnonDecl()) 233263509Sdim Writer.AddDeclRef(D->getDeclaratorForAnonDecl(), Record); 234218893Sdim else 235221345Sdim Writer.AddDeclRef(D->getTypedefNameForAnonDecl(), Record); 236212795Sdim} 237212795Sdim 238212795Sdimvoid ASTDeclWriter::VisitEnumDecl(EnumDecl *D) { 239212795Sdim VisitTagDecl(D); 240218893Sdim Writer.AddTypeSourceInfo(D->getIntegerTypeSourceInfo(), Record); 241218893Sdim if (!D->getIntegerTypeSourceInfo()) 242218893Sdim Writer.AddTypeRef(D->getIntegerType(), Record); 243212795Sdim Writer.AddTypeRef(D->getPromotionType(), Record); 244212795Sdim Record.push_back(D->getNumPositiveBits()); 245212795Sdim Record.push_back(D->getNumNegativeBits()); 246218893Sdim Record.push_back(D->isScoped()); 247218893Sdim Record.push_back(D->isScopedUsingClassTag()); 248218893Sdim Record.push_back(D->isFixed()); 249235633Sdim if (MemberSpecializationInfo *MemberInfo = D->getMemberSpecializationInfo()) { 250235633Sdim Writer.AddDeclRef(MemberInfo->getInstantiatedFrom(), Record); 251235633Sdim Record.push_back(MemberInfo->getTemplateSpecializationKind()); 252235633Sdim Writer.AddSourceLocation(MemberInfo->getPointOfInstantiation(), Record); 253235633Sdim } else { 254235633Sdim Writer.AddDeclRef(0, Record); 255235633Sdim } 256223017Sdim 257223017Sdim if (!D->hasAttrs() && 258223017Sdim !D->isImplicit() && 259223017Sdim !D->isUsed(false) && 260223017Sdim !D->hasExtInfo() && 261263509Sdim D->getFirstDecl() == D->getMostRecentDecl() && 262223017Sdim !D->isInvalidDecl() && 263223017Sdim !D->isReferenced() && 264235633Sdim !D->isTopLevelDeclInObjCContainer() && 265223017Sdim D->getAccess() == AS_none && 266226890Sdim !D->isModulePrivate() && 267223017Sdim !CXXRecordDecl::classofKind(D->getKind()) && 268223017Sdim !D->getIntegerTypeSourceInfo() && 269252723Sdim !D->getMemberSpecializationInfo() && 270223017Sdim D->getDeclName().getNameKind() == DeclarationName::Identifier) 271223017Sdim AbbrevToUse = Writer.getDeclEnumAbbrev(); 272223017Sdim 273212795Sdim Code = serialization::DECL_ENUM; 274212795Sdim} 275212795Sdim 276212795Sdimvoid ASTDeclWriter::VisitRecordDecl(RecordDecl *D) { 277212795Sdim VisitTagDecl(D); 278212795Sdim Record.push_back(D->hasFlexibleArrayMember()); 279212795Sdim Record.push_back(D->isAnonymousStructOrUnion()); 280212795Sdim Record.push_back(D->hasObjectMember()); 281252723Sdim Record.push_back(D->hasVolatileMember()); 282223017Sdim 283223017Sdim if (!D->hasAttrs() && 284223017Sdim !D->isImplicit() && 285223017Sdim !D->isUsed(false) && 286223017Sdim !D->hasExtInfo() && 287263509Sdim D->getFirstDecl() == D->getMostRecentDecl() && 288223017Sdim !D->isInvalidDecl() && 289223017Sdim !D->isReferenced() && 290235633Sdim !D->isTopLevelDeclInObjCContainer() && 291223017Sdim D->getAccess() == AS_none && 292226890Sdim !D->isModulePrivate() && 293223017Sdim !CXXRecordDecl::classofKind(D->getKind()) && 294223017Sdim D->getDeclName().getNameKind() == DeclarationName::Identifier) 295223017Sdim AbbrevToUse = Writer.getDeclRecordAbbrev(); 296223017Sdim 297212795Sdim Code = serialization::DECL_RECORD; 298212795Sdim} 299212795Sdim 300212795Sdimvoid ASTDeclWriter::VisitValueDecl(ValueDecl *D) { 301212795Sdim VisitNamedDecl(D); 302212795Sdim Writer.AddTypeRef(D->getType(), Record); 303212795Sdim} 304212795Sdim 305212795Sdimvoid ASTDeclWriter::VisitEnumConstantDecl(EnumConstantDecl *D) { 306212795Sdim VisitValueDecl(D); 307212795Sdim Record.push_back(D->getInitExpr()? 1 : 0); 308212795Sdim if (D->getInitExpr()) 309212795Sdim Writer.AddStmt(D->getInitExpr()); 310212795Sdim Writer.AddAPSInt(D->getInitVal(), Record); 311223017Sdim 312212795Sdim Code = serialization::DECL_ENUM_CONSTANT; 313212795Sdim} 314212795Sdim 315212795Sdimvoid ASTDeclWriter::VisitDeclaratorDecl(DeclaratorDecl *D) { 316212795Sdim VisitValueDecl(D); 317221345Sdim Writer.AddSourceLocation(D->getInnerLocStart(), Record); 318218893Sdim Record.push_back(D->hasExtInfo()); 319218893Sdim if (D->hasExtInfo()) 320218893Sdim Writer.AddQualifierInfo(*D->getExtInfo(), Record); 321212795Sdim} 322212795Sdim 323212795Sdimvoid ASTDeclWriter::VisitFunctionDecl(FunctionDecl *D) { 324235633Sdim VisitRedeclarable(D); 325212795Sdim VisitDeclaratorDecl(D); 326212795Sdim 327218893Sdim Writer.AddDeclarationNameLoc(D->DNLoc, D->getDeclName(), Record); 328212795Sdim Record.push_back(D->getIdentifierNamespace()); 329235633Sdim 330235633Sdim // FunctionDecl's body is handled last at ASTWriterDecl::Visit, 331235633Sdim // after everything else is written. 332235633Sdim 333235633Sdim Record.push_back(D->getStorageClass()); // FIXME: stable encoding 334235633Sdim Record.push_back(D->IsInline); 335235633Sdim Record.push_back(D->isInlineSpecified()); 336235633Sdim Record.push_back(D->isVirtualAsWritten()); 337235633Sdim Record.push_back(D->isPure()); 338235633Sdim Record.push_back(D->hasInheritedPrototype()); 339235633Sdim Record.push_back(D->hasWrittenPrototype()); 340235633Sdim Record.push_back(D->isDeletedAsWritten()); 341235633Sdim Record.push_back(D->isTrivial()); 342235633Sdim Record.push_back(D->isDefaulted()); 343235633Sdim Record.push_back(D->isExplicitlyDefaulted()); 344235633Sdim Record.push_back(D->hasImplicitReturnZero()); 345235633Sdim Record.push_back(D->isConstexpr()); 346252723Sdim Record.push_back(D->HasSkippedBody); 347263509Sdim Record.push_back(D->isLateTemplateParsed()); 348263509Sdim Record.push_back(D->getLinkageInternal()); 349235633Sdim Writer.AddSourceLocation(D->getLocEnd(), Record); 350235633Sdim 351212795Sdim Record.push_back(D->getTemplatedKind()); 352212795Sdim switch (D->getTemplatedKind()) { 353212795Sdim case FunctionDecl::TK_NonTemplate: 354212795Sdim break; 355212795Sdim case FunctionDecl::TK_FunctionTemplate: 356212795Sdim Writer.AddDeclRef(D->getDescribedFunctionTemplate(), Record); 357212795Sdim break; 358212795Sdim case FunctionDecl::TK_MemberSpecialization: { 359212795Sdim MemberSpecializationInfo *MemberInfo = D->getMemberSpecializationInfo(); 360212795Sdim Writer.AddDeclRef(MemberInfo->getInstantiatedFrom(), Record); 361212795Sdim Record.push_back(MemberInfo->getTemplateSpecializationKind()); 362212795Sdim Writer.AddSourceLocation(MemberInfo->getPointOfInstantiation(), Record); 363212795Sdim break; 364212795Sdim } 365212795Sdim case FunctionDecl::TK_FunctionTemplateSpecialization: { 366212795Sdim FunctionTemplateSpecializationInfo * 367212795Sdim FTSInfo = D->getTemplateSpecializationInfo(); 368218893Sdim Writer.AddDeclRef(FTSInfo->getTemplate(), Record); 369212795Sdim Record.push_back(FTSInfo->getTemplateSpecializationKind()); 370212795Sdim 371212795Sdim // Template arguments. 372212795Sdim Writer.AddTemplateArgumentList(FTSInfo->TemplateArguments, Record); 373212795Sdim 374212795Sdim // Template args as written. 375212795Sdim Record.push_back(FTSInfo->TemplateArgumentsAsWritten != 0); 376212795Sdim if (FTSInfo->TemplateArgumentsAsWritten) { 377226890Sdim Record.push_back(FTSInfo->TemplateArgumentsAsWritten->NumTemplateArgs); 378226890Sdim for (int i=0, e = FTSInfo->TemplateArgumentsAsWritten->NumTemplateArgs; 379226890Sdim i!=e; ++i) 380212795Sdim Writer.AddTemplateArgumentLoc((*FTSInfo->TemplateArgumentsAsWritten)[i], 381212795Sdim Record); 382226890Sdim Writer.AddSourceLocation(FTSInfo->TemplateArgumentsAsWritten->LAngleLoc, 383212795Sdim Record); 384226890Sdim Writer.AddSourceLocation(FTSInfo->TemplateArgumentsAsWritten->RAngleLoc, 385212795Sdim Record); 386212795Sdim } 387212795Sdim 388212795Sdim Writer.AddSourceLocation(FTSInfo->getPointOfInstantiation(), Record); 389218893Sdim 390218893Sdim if (D->isCanonicalDecl()) { 391218893Sdim // Write the template that contains the specializations set. We will 392218893Sdim // add a FunctionTemplateSpecializationInfo to it when reading. 393218893Sdim Writer.AddDeclRef(FTSInfo->getTemplate()->getCanonicalDecl(), Record); 394218893Sdim } 395212795Sdim break; 396212795Sdim } 397212795Sdim case FunctionDecl::TK_DependentFunctionTemplateSpecialization: { 398212795Sdim DependentFunctionTemplateSpecializationInfo * 399212795Sdim DFTSInfo = D->getDependentSpecializationInfo(); 400212795Sdim 401212795Sdim // Templates. 402212795Sdim Record.push_back(DFTSInfo->getNumTemplates()); 403212795Sdim for (int i=0, e = DFTSInfo->getNumTemplates(); i != e; ++i) 404212795Sdim Writer.AddDeclRef(DFTSInfo->getTemplate(i), Record); 405212795Sdim 406212795Sdim // Templates args. 407212795Sdim Record.push_back(DFTSInfo->getNumTemplateArgs()); 408212795Sdim for (int i=0, e = DFTSInfo->getNumTemplateArgs(); i != e; ++i) 409212795Sdim Writer.AddTemplateArgumentLoc(DFTSInfo->getTemplateArg(i), Record); 410212795Sdim Writer.AddSourceLocation(DFTSInfo->getLAngleLoc(), Record); 411212795Sdim Writer.AddSourceLocation(DFTSInfo->getRAngleLoc(), Record); 412212795Sdim break; 413212795Sdim } 414212795Sdim } 415212795Sdim 416212795Sdim Record.push_back(D->param_size()); 417212795Sdim for (FunctionDecl::param_iterator P = D->param_begin(), PEnd = D->param_end(); 418212795Sdim P != PEnd; ++P) 419212795Sdim Writer.AddDeclRef(*P, Record); 420212795Sdim Code = serialization::DECL_FUNCTION; 421212795Sdim} 422212795Sdim 423212795Sdimvoid ASTDeclWriter::VisitObjCMethodDecl(ObjCMethodDecl *D) { 424212795Sdim VisitNamedDecl(D); 425212795Sdim // FIXME: convert to LazyStmtPtr? 426212795Sdim // Unlike C/C++, method bodies will never be in header files. 427212795Sdim bool HasBodyStuff = D->getBody() != 0 || 428212795Sdim D->getSelfDecl() != 0 || D->getCmdDecl() != 0; 429212795Sdim Record.push_back(HasBodyStuff); 430212795Sdim if (HasBodyStuff) { 431212795Sdim Writer.AddStmt(D->getBody()); 432212795Sdim Writer.AddDeclRef(D->getSelfDecl(), Record); 433212795Sdim Writer.AddDeclRef(D->getCmdDecl(), Record); 434212795Sdim } 435212795Sdim Record.push_back(D->isInstanceMethod()); 436212795Sdim Record.push_back(D->isVariadic()); 437245431Sdim Record.push_back(D->isPropertyAccessor()); 438212795Sdim Record.push_back(D->isDefined()); 439245431Sdim Record.push_back(D->IsOverriding); 440252723Sdim Record.push_back(D->HasSkippedBody); 441226890Sdim 442226890Sdim Record.push_back(D->IsRedeclaration); 443226890Sdim Record.push_back(D->HasRedeclaration); 444226890Sdim if (D->HasRedeclaration) { 445226890Sdim assert(Context.getObjCMethodRedeclaration(D)); 446226890Sdim Writer.AddDeclRef(Context.getObjCMethodRedeclaration(D), Record); 447226890Sdim } 448226890Sdim 449212795Sdim // FIXME: stable encoding for @required/@optional 450212795Sdim Record.push_back(D->getImplementationControl()); 451212795Sdim // FIXME: stable encoding for in/out/inout/bycopy/byref/oneway 452212795Sdim Record.push_back(D->getObjCDeclQualifier()); 453223017Sdim Record.push_back(D->hasRelatedResultType()); 454212795Sdim Writer.AddTypeRef(D->getResultType(), Record); 455212795Sdim Writer.AddTypeSourceInfo(D->getResultTypeSourceInfo(), Record); 456212795Sdim Writer.AddSourceLocation(D->getLocEnd(), Record); 457212795Sdim Record.push_back(D->param_size()); 458212795Sdim for (ObjCMethodDecl::param_iterator P = D->param_begin(), 459212795Sdim PEnd = D->param_end(); P != PEnd; ++P) 460212795Sdim Writer.AddDeclRef(*P, Record); 461226890Sdim 462226890Sdim Record.push_back(D->SelLocsKind); 463226890Sdim unsigned NumStoredSelLocs = D->getNumStoredSelLocs(); 464226890Sdim SourceLocation *SelLocs = D->getStoredSelLocs(); 465226890Sdim Record.push_back(NumStoredSelLocs); 466226890Sdim for (unsigned i = 0; i != NumStoredSelLocs; ++i) 467226890Sdim Writer.AddSourceLocation(SelLocs[i], Record); 468226890Sdim 469212795Sdim Code = serialization::DECL_OBJC_METHOD; 470212795Sdim} 471212795Sdim 472212795Sdimvoid ASTDeclWriter::VisitObjCContainerDecl(ObjCContainerDecl *D) { 473212795Sdim VisitNamedDecl(D); 474226890Sdim Writer.AddSourceLocation(D->getAtStartLoc(), Record); 475212795Sdim Writer.AddSourceRange(D->getAtEndRange(), Record); 476212795Sdim // Abstract class (no need to define a stable serialization::DECL code). 477212795Sdim} 478212795Sdim 479212795Sdimvoid ASTDeclWriter::VisitObjCInterfaceDecl(ObjCInterfaceDecl *D) { 480235633Sdim VisitRedeclarable(D); 481212795Sdim VisitObjCContainerDecl(D); 482212795Sdim Writer.AddTypeRef(QualType(D->getTypeForDecl(), 0), Record); 483212795Sdim 484235633Sdim Record.push_back(D->isThisDeclarationADefinition()); 485235633Sdim if (D->isThisDeclarationADefinition()) { 486235633Sdim // Write the DefinitionData 487235633Sdim ObjCInterfaceDecl::DefinitionData &Data = D->data(); 488235633Sdim 489235633Sdim Writer.AddDeclRef(D->getSuperClass(), Record); 490235633Sdim Writer.AddSourceLocation(D->getSuperClassLoc(), Record); 491235633Sdim Writer.AddSourceLocation(D->getEndOfDefinitionLoc(), Record); 492235633Sdim 493235633Sdim // Write out the protocols that are directly referenced by the @interface. 494235633Sdim Record.push_back(Data.ReferencedProtocols.size()); 495235633Sdim for (ObjCInterfaceDecl::protocol_iterator P = D->protocol_begin(), 496235633Sdim PEnd = D->protocol_end(); 497235633Sdim P != PEnd; ++P) 498235633Sdim Writer.AddDeclRef(*P, Record); 499235633Sdim for (ObjCInterfaceDecl::protocol_loc_iterator PL = D->protocol_loc_begin(), 500212795Sdim PLEnd = D->protocol_loc_end(); 501235633Sdim PL != PLEnd; ++PL) 502235633Sdim Writer.AddSourceLocation(*PL, Record); 503235633Sdim 504235633Sdim // Write out the protocols that are transitively referenced. 505235633Sdim Record.push_back(Data.AllReferencedProtocols.size()); 506235633Sdim for (ObjCList<ObjCProtocolDecl>::iterator 507235633Sdim P = Data.AllReferencedProtocols.begin(), 508235633Sdim PEnd = Data.AllReferencedProtocols.end(); 509235633Sdim P != PEnd; ++P) 510235633Sdim Writer.AddDeclRef(*P, Record); 511252723Sdim 512235633Sdim 513252723Sdim if (ObjCCategoryDecl *Cat = D->getCategoryListRaw()) { 514235633Sdim // Ensure that we write out the set of categories for this class. 515235633Sdim Writer.ObjCClassesWithCategories.insert(D); 516235633Sdim 517235633Sdim // Make sure that the categories get serialized. 518252723Sdim for (; Cat; Cat = Cat->getNextClassCategoryRaw()) 519235633Sdim (void)Writer.GetDeclRef(Cat); 520235633Sdim } 521235633Sdim } 522212795Sdim 523212795Sdim Code = serialization::DECL_OBJC_INTERFACE; 524212795Sdim} 525212795Sdim 526212795Sdimvoid ASTDeclWriter::VisitObjCIvarDecl(ObjCIvarDecl *D) { 527212795Sdim VisitFieldDecl(D); 528212795Sdim // FIXME: stable encoding for @public/@private/@protected/@package 529212795Sdim Record.push_back(D->getAccessControl()); 530212795Sdim Record.push_back(D->getSynthesize()); 531263509Sdim Record.push_back(D->getBackingIvarReferencedInAccessor()); 532223017Sdim 533223017Sdim if (!D->hasAttrs() && 534223017Sdim !D->isImplicit() && 535223017Sdim !D->isUsed(false) && 536223017Sdim !D->isInvalidDecl() && 537223017Sdim !D->isReferenced() && 538226890Sdim !D->isModulePrivate() && 539223017Sdim !D->getBitWidth() && 540223017Sdim !D->hasExtInfo() && 541223017Sdim D->getDeclName()) 542223017Sdim AbbrevToUse = Writer.getDeclObjCIvarAbbrev(); 543223017Sdim 544212795Sdim Code = serialization::DECL_OBJC_IVAR; 545212795Sdim} 546212795Sdim 547212795Sdimvoid ASTDeclWriter::VisitObjCProtocolDecl(ObjCProtocolDecl *D) { 548235633Sdim VisitRedeclarable(D); 549212795Sdim VisitObjCContainerDecl(D); 550235633Sdim 551235633Sdim Record.push_back(D->isThisDeclarationADefinition()); 552235633Sdim if (D->isThisDeclarationADefinition()) { 553235633Sdim Record.push_back(D->protocol_size()); 554235633Sdim for (ObjCProtocolDecl::protocol_iterator 555235633Sdim I = D->protocol_begin(), IEnd = D->protocol_end(); I != IEnd; ++I) 556235633Sdim Writer.AddDeclRef(*I, Record); 557235633Sdim for (ObjCProtocolDecl::protocol_loc_iterator PL = D->protocol_loc_begin(), 558235633Sdim PLEnd = D->protocol_loc_end(); 559235633Sdim PL != PLEnd; ++PL) 560235633Sdim Writer.AddSourceLocation(*PL, Record); 561235633Sdim } 562235633Sdim 563212795Sdim Code = serialization::DECL_OBJC_PROTOCOL; 564212795Sdim} 565212795Sdim 566212795Sdimvoid ASTDeclWriter::VisitObjCAtDefsFieldDecl(ObjCAtDefsFieldDecl *D) { 567212795Sdim VisitFieldDecl(D); 568212795Sdim Code = serialization::DECL_OBJC_AT_DEFS_FIELD; 569212795Sdim} 570212795Sdim 571212795Sdimvoid ASTDeclWriter::VisitObjCCategoryDecl(ObjCCategoryDecl *D) { 572212795Sdim VisitObjCContainerDecl(D); 573235633Sdim Writer.AddSourceLocation(D->getCategoryNameLoc(), Record); 574235633Sdim Writer.AddSourceLocation(D->getIvarLBraceLoc(), Record); 575235633Sdim Writer.AddSourceLocation(D->getIvarRBraceLoc(), Record); 576212795Sdim Writer.AddDeclRef(D->getClassInterface(), Record); 577212795Sdim Record.push_back(D->protocol_size()); 578212795Sdim for (ObjCCategoryDecl::protocol_iterator 579212795Sdim I = D->protocol_begin(), IEnd = D->protocol_end(); I != IEnd; ++I) 580212795Sdim Writer.AddDeclRef(*I, Record); 581212795Sdim for (ObjCCategoryDecl::protocol_loc_iterator 582212795Sdim PL = D->protocol_loc_begin(), PLEnd = D->protocol_loc_end(); 583212795Sdim PL != PLEnd; ++PL) 584212795Sdim Writer.AddSourceLocation(*PL, Record); 585212795Sdim Code = serialization::DECL_OBJC_CATEGORY; 586212795Sdim} 587212795Sdim 588212795Sdimvoid ASTDeclWriter::VisitObjCCompatibleAliasDecl(ObjCCompatibleAliasDecl *D) { 589212795Sdim VisitNamedDecl(D); 590212795Sdim Writer.AddDeclRef(D->getClassInterface(), Record); 591212795Sdim Code = serialization::DECL_OBJC_COMPATIBLE_ALIAS; 592212795Sdim} 593212795Sdim 594212795Sdimvoid ASTDeclWriter::VisitObjCPropertyDecl(ObjCPropertyDecl *D) { 595212795Sdim VisitNamedDecl(D); 596212795Sdim Writer.AddSourceLocation(D->getAtLoc(), Record); 597235633Sdim Writer.AddSourceLocation(D->getLParenLoc(), Record); 598212795Sdim Writer.AddTypeSourceInfo(D->getTypeSourceInfo(), Record); 599212795Sdim // FIXME: stable encoding 600212795Sdim Record.push_back((unsigned)D->getPropertyAttributes()); 601212795Sdim Record.push_back((unsigned)D->getPropertyAttributesAsWritten()); 602212795Sdim // FIXME: stable encoding 603212795Sdim Record.push_back((unsigned)D->getPropertyImplementation()); 604212795Sdim Writer.AddDeclarationName(D->getGetterName(), Record); 605212795Sdim Writer.AddDeclarationName(D->getSetterName(), Record); 606212795Sdim Writer.AddDeclRef(D->getGetterMethodDecl(), Record); 607212795Sdim Writer.AddDeclRef(D->getSetterMethodDecl(), Record); 608212795Sdim Writer.AddDeclRef(D->getPropertyIvarDecl(), Record); 609212795Sdim Code = serialization::DECL_OBJC_PROPERTY; 610212795Sdim} 611212795Sdim 612212795Sdimvoid ASTDeclWriter::VisitObjCImplDecl(ObjCImplDecl *D) { 613212795Sdim VisitObjCContainerDecl(D); 614212795Sdim Writer.AddDeclRef(D->getClassInterface(), Record); 615212795Sdim // Abstract class (no need to define a stable serialization::DECL code). 616212795Sdim} 617212795Sdim 618212795Sdimvoid ASTDeclWriter::VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D) { 619212795Sdim VisitObjCImplDecl(D); 620212795Sdim Writer.AddIdentifierRef(D->getIdentifier(), Record); 621235633Sdim Writer.AddSourceLocation(D->getCategoryNameLoc(), Record); 622212795Sdim Code = serialization::DECL_OBJC_CATEGORY_IMPL; 623212795Sdim} 624212795Sdim 625212795Sdimvoid ASTDeclWriter::VisitObjCImplementationDecl(ObjCImplementationDecl *D) { 626212795Sdim VisitObjCImplDecl(D); 627212795Sdim Writer.AddDeclRef(D->getSuperClass(), Record); 628252723Sdim Writer.AddSourceLocation(D->getSuperClassLoc(), Record); 629235633Sdim Writer.AddSourceLocation(D->getIvarLBraceLoc(), Record); 630235633Sdim Writer.AddSourceLocation(D->getIvarRBraceLoc(), Record); 631245431Sdim Record.push_back(D->hasNonZeroConstructors()); 632245431Sdim Record.push_back(D->hasDestructors()); 633218893Sdim Writer.AddCXXCtorInitializers(D->IvarInitializers, D->NumIvarInitializers, 634218893Sdim Record); 635212795Sdim Code = serialization::DECL_OBJC_IMPLEMENTATION; 636212795Sdim} 637212795Sdim 638212795Sdimvoid ASTDeclWriter::VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D) { 639212795Sdim VisitDecl(D); 640212795Sdim Writer.AddSourceLocation(D->getLocStart(), Record); 641212795Sdim Writer.AddDeclRef(D->getPropertyDecl(), Record); 642212795Sdim Writer.AddDeclRef(D->getPropertyIvarDecl(), Record); 643218893Sdim Writer.AddSourceLocation(D->getPropertyIvarDeclLoc(), Record); 644212795Sdim Writer.AddStmt(D->getGetterCXXConstructor()); 645212795Sdim Writer.AddStmt(D->getSetterCXXAssignment()); 646212795Sdim Code = serialization::DECL_OBJC_PROPERTY_IMPL; 647212795Sdim} 648212795Sdim 649212795Sdimvoid ASTDeclWriter::VisitFieldDecl(FieldDecl *D) { 650212795Sdim VisitDeclaratorDecl(D); 651212795Sdim Record.push_back(D->isMutable()); 652245431Sdim if (D->InitializerOrBitWidth.getInt() != ICIS_NoInit || 653245431Sdim D->InitializerOrBitWidth.getPointer()) { 654245431Sdim Record.push_back(D->InitializerOrBitWidth.getInt() + 1); 655245431Sdim Writer.AddStmt(D->InitializerOrBitWidth.getPointer()); 656245431Sdim } else { 657245431Sdim Record.push_back(0); 658245431Sdim } 659212795Sdim if (!D->getDeclName()) 660212795Sdim Writer.AddDeclRef(Context.getInstantiatedFromUnnamedFieldDecl(D), Record); 661223017Sdim 662223017Sdim if (!D->hasAttrs() && 663223017Sdim !D->isImplicit() && 664223017Sdim !D->isUsed(false) && 665223017Sdim !D->isInvalidDecl() && 666223017Sdim !D->isReferenced() && 667235633Sdim !D->isTopLevelDeclInObjCContainer() && 668226890Sdim !D->isModulePrivate() && 669223017Sdim !D->getBitWidth() && 670223017Sdim !D->hasInClassInitializer() && 671223017Sdim !D->hasExtInfo() && 672223017Sdim !ObjCIvarDecl::classofKind(D->getKind()) && 673223017Sdim !ObjCAtDefsFieldDecl::classofKind(D->getKind()) && 674223017Sdim D->getDeclName()) 675223017Sdim AbbrevToUse = Writer.getDeclFieldAbbrev(); 676223017Sdim 677212795Sdim Code = serialization::DECL_FIELD; 678212795Sdim} 679212795Sdim 680252723Sdimvoid ASTDeclWriter::VisitMSPropertyDecl(MSPropertyDecl *D) { 681252723Sdim VisitDeclaratorDecl(D); 682252723Sdim Writer.AddIdentifierRef(D->getGetterId(), Record); 683252723Sdim Writer.AddIdentifierRef(D->getSetterId(), Record); 684252723Sdim Code = serialization::DECL_MS_PROPERTY; 685252723Sdim} 686252723Sdim 687218893Sdimvoid ASTDeclWriter::VisitIndirectFieldDecl(IndirectFieldDecl *D) { 688218893Sdim VisitValueDecl(D); 689218893Sdim Record.push_back(D->getChainingSize()); 690218893Sdim 691218893Sdim for (IndirectFieldDecl::chain_iterator 692218893Sdim P = D->chain_begin(), 693218893Sdim PEnd = D->chain_end(); P != PEnd; ++P) 694218893Sdim Writer.AddDeclRef(*P, Record); 695218893Sdim Code = serialization::DECL_INDIRECTFIELD; 696218893Sdim} 697218893Sdim 698212795Sdimvoid ASTDeclWriter::VisitVarDecl(VarDecl *D) { 699235633Sdim VisitRedeclarable(D); 700212795Sdim VisitDeclaratorDecl(D); 701252723Sdim Record.push_back(D->getStorageClass()); 702252723Sdim Record.push_back(D->getTSCSpec()); 703235633Sdim Record.push_back(D->getInitStyle()); 704212795Sdim Record.push_back(D->isExceptionVariable()); 705212795Sdim Record.push_back(D->isNRVOVariable()); 706221345Sdim Record.push_back(D->isCXXForRangeDecl()); 707224145Sdim Record.push_back(D->isARCPseudoStrong()); 708245431Sdim Record.push_back(D->isConstexpr()); 709263509Sdim Record.push_back(D->isInitCapture()); 710263509Sdim Record.push_back(D->isPreviousDeclInSameBlockScope()); 711263509Sdim Record.push_back(D->getLinkageInternal()); 712245431Sdim 713235633Sdim if (D->getInit()) { 714235633Sdim Record.push_back(!D->isInitKnownICE() ? 1 : (D->isInitICE() ? 3 : 2)); 715212795Sdim Writer.AddStmt(D->getInit()); 716235633Sdim } else { 717235633Sdim Record.push_back(0); 718235633Sdim } 719263509Sdim 720263509Sdim enum { 721263509Sdim VarNotTemplate = 0, VarTemplate, StaticDataMemberSpecialization 722263509Sdim }; 723263509Sdim if (VarTemplateDecl *TemplD = D->getDescribedVarTemplate()) { 724263509Sdim Record.push_back(VarTemplate); 725263509Sdim Writer.AddDeclRef(TemplD, Record); 726263509Sdim } else if (MemberSpecializationInfo *SpecInfo 727263509Sdim = D->getMemberSpecializationInfo()) { 728263509Sdim Record.push_back(StaticDataMemberSpecialization); 729212795Sdim Writer.AddDeclRef(SpecInfo->getInstantiatedFrom(), Record); 730212795Sdim Record.push_back(SpecInfo->getTemplateSpecializationKind()); 731212795Sdim Writer.AddSourceLocation(SpecInfo->getPointOfInstantiation(), Record); 732263509Sdim } else { 733263509Sdim Record.push_back(VarNotTemplate); 734212795Sdim } 735212795Sdim 736223017Sdim if (!D->hasAttrs() && 737223017Sdim !D->isImplicit() && 738223017Sdim !D->isUsed(false) && 739223017Sdim !D->isInvalidDecl() && 740223017Sdim !D->isReferenced() && 741235633Sdim !D->isTopLevelDeclInObjCContainer() && 742223017Sdim D->getAccess() == AS_none && 743226890Sdim !D->isModulePrivate() && 744223017Sdim D->getDeclName().getNameKind() == DeclarationName::Identifier && 745223017Sdim !D->hasExtInfo() && 746263509Sdim D->getFirstDecl() == D->getMostRecentDecl() && 747235633Sdim D->getInitStyle() == VarDecl::CInit && 748223017Sdim D->getInit() == 0 && 749224145Sdim !isa<ParmVarDecl>(D) && 750263509Sdim !isa<VarTemplateSpecializationDecl>(D) && 751245431Sdim !D->isConstexpr() && 752263509Sdim !D->isInitCapture() && 753263509Sdim !D->isPreviousDeclInSameBlockScope() && 754263509Sdim !D->getMemberSpecializationInfo()) 755223017Sdim AbbrevToUse = Writer.getDeclVarAbbrev(); 756223017Sdim 757212795Sdim Code = serialization::DECL_VAR; 758212795Sdim} 759212795Sdim 760212795Sdimvoid ASTDeclWriter::VisitImplicitParamDecl(ImplicitParamDecl *D) { 761212795Sdim VisitVarDecl(D); 762212795Sdim Code = serialization::DECL_IMPLICIT_PARAM; 763212795Sdim} 764212795Sdim 765212795Sdimvoid ASTDeclWriter::VisitParmVarDecl(ParmVarDecl *D) { 766212795Sdim VisitVarDecl(D); 767221345Sdim Record.push_back(D->isObjCMethodParameter()); 768221345Sdim Record.push_back(D->getFunctionScopeDepth()); 769221345Sdim Record.push_back(D->getFunctionScopeIndex()); 770212795Sdim Record.push_back(D->getObjCDeclQualifier()); // FIXME: stable encoding 771221345Sdim Record.push_back(D->isKNRPromoted()); 772212795Sdim Record.push_back(D->hasInheritedDefaultArg()); 773212795Sdim Record.push_back(D->hasUninstantiatedDefaultArg()); 774212795Sdim if (D->hasUninstantiatedDefaultArg()) 775212795Sdim Writer.AddStmt(D->getUninstantiatedDefaultArg()); 776212795Sdim Code = serialization::DECL_PARM_VAR; 777212795Sdim 778224145Sdim assert(!D->isARCPseudoStrong()); // can be true of ImplicitParamDecl 779224145Sdim 780212795Sdim // If the assumptions about the DECL_PARM_VAR abbrev are true, use it. Here 781212795Sdim // we dynamically check for the properties that we optimize for, but don't 782212795Sdim // know are true of all PARM_VAR_DECLs. 783223017Sdim if (!D->hasAttrs() && 784223017Sdim !D->hasExtInfo() && 785212795Sdim !D->isImplicit() && 786212795Sdim !D->isUsed(false) && 787235633Sdim !D->isInvalidDecl() && 788235633Sdim !D->isReferenced() && 789212795Sdim D->getAccess() == AS_none && 790226890Sdim !D->isModulePrivate() && 791212795Sdim D->getStorageClass() == 0 && 792235633Sdim D->getInitStyle() == VarDecl::CInit && // Can params have anything else? 793221345Sdim D->getFunctionScopeDepth() == 0 && 794212795Sdim D->getObjCDeclQualifier() == 0 && 795221345Sdim !D->isKNRPromoted() && 796212795Sdim !D->hasInheritedDefaultArg() && 797212795Sdim D->getInit() == 0 && 798212795Sdim !D->hasUninstantiatedDefaultArg()) // No default expr. 799223017Sdim AbbrevToUse = Writer.getDeclParmVarAbbrev(); 800212795Sdim 801212795Sdim // Check things we know are true of *every* PARM_VAR_DECL, which is more than 802212795Sdim // just us assuming it. 803252723Sdim assert(!D->getTSCSpec() && "PARM_VAR_DECL can't use TLS"); 804212795Sdim assert(D->getAccess() == AS_none && "PARM_VAR_DECL can't be public/private"); 805212795Sdim assert(!D->isExceptionVariable() && "PARM_VAR_DECL can't be exception var"); 806235633Sdim assert(D->getPreviousDecl() == 0 && "PARM_VAR_DECL can't be redecl"); 807212795Sdim assert(!D->isStaticDataMember() && 808212795Sdim "PARM_VAR_DECL can't be static data member"); 809212795Sdim} 810212795Sdim 811212795Sdimvoid ASTDeclWriter::VisitFileScopeAsmDecl(FileScopeAsmDecl *D) { 812212795Sdim VisitDecl(D); 813212795Sdim Writer.AddStmt(D->getAsmString()); 814221345Sdim Writer.AddSourceLocation(D->getRParenLoc(), Record); 815212795Sdim Code = serialization::DECL_FILE_SCOPE_ASM; 816212795Sdim} 817212795Sdim 818252723Sdimvoid ASTDeclWriter::VisitEmptyDecl(EmptyDecl *D) { 819252723Sdim VisitDecl(D); 820252723Sdim Code = serialization::DECL_EMPTY; 821252723Sdim} 822252723Sdim 823212795Sdimvoid ASTDeclWriter::VisitBlockDecl(BlockDecl *D) { 824212795Sdim VisitDecl(D); 825212795Sdim Writer.AddStmt(D->getBody()); 826212795Sdim Writer.AddTypeSourceInfo(D->getSignatureAsWritten(), Record); 827212795Sdim Record.push_back(D->param_size()); 828212795Sdim for (FunctionDecl::param_iterator P = D->param_begin(), PEnd = D->param_end(); 829212795Sdim P != PEnd; ++P) 830212795Sdim Writer.AddDeclRef(*P, Record); 831235633Sdim Record.push_back(D->isVariadic()); 832235633Sdim Record.push_back(D->blockMissingReturnType()); 833235633Sdim Record.push_back(D->isConversionFromLambda()); 834218893Sdim Record.push_back(D->capturesCXXThis()); 835218893Sdim Record.push_back(D->getNumCaptures()); 836218893Sdim for (BlockDecl::capture_iterator 837218893Sdim i = D->capture_begin(), e = D->capture_end(); i != e; ++i) { 838218893Sdim const BlockDecl::Capture &capture = *i; 839218893Sdim Writer.AddDeclRef(capture.getVariable(), Record); 840218893Sdim 841218893Sdim unsigned flags = 0; 842218893Sdim if (capture.isByRef()) flags |= 1; 843218893Sdim if (capture.isNested()) flags |= 2; 844218893Sdim if (capture.hasCopyExpr()) flags |= 4; 845218893Sdim Record.push_back(flags); 846218893Sdim 847218893Sdim if (capture.hasCopyExpr()) Writer.AddStmt(capture.getCopyExpr()); 848218893Sdim } 849218893Sdim 850212795Sdim Code = serialization::DECL_BLOCK; 851212795Sdim} 852212795Sdim 853252723Sdimvoid ASTDeclWriter::VisitCapturedDecl(CapturedDecl *CD) { 854252723Sdim Record.push_back(CD->getNumParams()); 855252723Sdim VisitDecl(CD); 856252723Sdim // Body is stored by VisitCapturedStmt. 857252723Sdim for (unsigned i = 0; i < CD->getNumParams(); ++i) 858252723Sdim Writer.AddDeclRef(CD->getParam(i), Record); 859252723Sdim Code = serialization::DECL_CAPTURED; 860252723Sdim} 861252723Sdim 862212795Sdimvoid ASTDeclWriter::VisitLinkageSpecDecl(LinkageSpecDecl *D) { 863212795Sdim VisitDecl(D); 864212795Sdim Record.push_back(D->getLanguage()); 865221345Sdim Writer.AddSourceLocation(D->getExternLoc(), Record); 866221345Sdim Writer.AddSourceLocation(D->getRBraceLoc(), Record); 867212795Sdim Code = serialization::DECL_LINKAGE_SPEC; 868212795Sdim} 869212795Sdim 870218893Sdimvoid ASTDeclWriter::VisitLabelDecl(LabelDecl *D) { 871218893Sdim VisitNamedDecl(D); 872221345Sdim Writer.AddSourceLocation(D->getLocStart(), Record); 873218893Sdim Code = serialization::DECL_LABEL; 874218893Sdim} 875218893Sdim 876218893Sdim 877212795Sdimvoid ASTDeclWriter::VisitNamespaceDecl(NamespaceDecl *D) { 878235633Sdim VisitRedeclarable(D); 879212795Sdim VisitNamedDecl(D); 880218893Sdim Record.push_back(D->isInline()); 881221345Sdim Writer.AddSourceLocation(D->getLocStart(), Record); 882221345Sdim Writer.AddSourceLocation(D->getRBraceLoc(), Record); 883212795Sdim 884212795Sdim if (D->isOriginalNamespace()) 885212795Sdim Writer.AddDeclRef(D->getAnonymousNamespace(), Record); 886212795Sdim Code = serialization::DECL_NAMESPACE; 887212795Sdim 888212795Sdim if (Writer.hasChain() && !D->isOriginalNamespace() && 889226890Sdim D->getOriginalNamespace()->isFromASTFile()) { 890218893Sdim NamespaceDecl *NS = D->getOriginalNamespace(); 891218893Sdim Writer.AddUpdatedDeclContext(NS); 892218893Sdim 893218893Sdim // Make sure all visible decls are written. They will be recorded later. 894235633Sdim if (StoredDeclsMap *Map = NS->buildLookup()) { 895218893Sdim for (StoredDeclsMap::iterator D = Map->begin(), DEnd = Map->end(); 896218893Sdim D != DEnd; ++D) { 897252723Sdim DeclContext::lookup_result R = D->second.getLookupResult(); 898252723Sdim for (DeclContext::lookup_iterator I = R.begin(), E = R.end(); I != E; 899252723Sdim ++I) 900252723Sdim Writer.GetDeclRef(*I); 901218893Sdim } 902218893Sdim } 903212795Sdim } 904221345Sdim 905235633Sdim if (Writer.hasChain() && D->isAnonymousNamespace() && 906235633Sdim D == D->getMostRecentDecl()) { 907221345Sdim // This is a most recent reopening of the anonymous namespace. If its parent 908221345Sdim // is in a previous PCH (or is the TU), mark that parent for update, because 909221345Sdim // the original namespace always points to the latest re-opening of its 910221345Sdim // anonymous namespace. 911221345Sdim Decl *Parent = cast<Decl>( 912221345Sdim D->getParent()->getRedeclContext()->getPrimaryContext()); 913226890Sdim if (Parent->isFromASTFile() || isa<TranslationUnitDecl>(Parent)) { 914221345Sdim ASTWriter::UpdateRecord &Record = Writer.DeclUpdates[Parent]; 915221345Sdim Record.push_back(UPD_CXX_ADDED_ANONYMOUS_NAMESPACE); 916221345Sdim Writer.AddDeclRef(D, Record); 917221345Sdim } 918221345Sdim } 919212795Sdim} 920212795Sdim 921212795Sdimvoid ASTDeclWriter::VisitNamespaceAliasDecl(NamespaceAliasDecl *D) { 922212795Sdim VisitNamedDecl(D); 923212795Sdim Writer.AddSourceLocation(D->getNamespaceLoc(), Record); 924212795Sdim Writer.AddSourceLocation(D->getTargetNameLoc(), Record); 925219077Sdim Writer.AddNestedNameSpecifierLoc(D->getQualifierLoc(), Record); 926212795Sdim Writer.AddDeclRef(D->getNamespace(), Record); 927212795Sdim Code = serialization::DECL_NAMESPACE_ALIAS; 928212795Sdim} 929212795Sdim 930212795Sdimvoid ASTDeclWriter::VisitUsingDecl(UsingDecl *D) { 931212795Sdim VisitNamedDecl(D); 932263509Sdim Writer.AddSourceLocation(D->getUsingLoc(), Record); 933219077Sdim Writer.AddNestedNameSpecifierLoc(D->getQualifierLoc(), Record); 934218893Sdim Writer.AddDeclarationNameLoc(D->DNLoc, D->getDeclName(), Record); 935235633Sdim Writer.AddDeclRef(D->FirstUsingShadow.getPointer(), Record); 936263509Sdim Record.push_back(D->hasTypename()); 937212795Sdim Writer.AddDeclRef(Context.getInstantiatedFromUsingDecl(D), Record); 938212795Sdim Code = serialization::DECL_USING; 939212795Sdim} 940212795Sdim 941212795Sdimvoid ASTDeclWriter::VisitUsingShadowDecl(UsingShadowDecl *D) { 942263509Sdim VisitRedeclarable(D); 943212795Sdim VisitNamedDecl(D); 944212795Sdim Writer.AddDeclRef(D->getTargetDecl(), Record); 945218893Sdim Writer.AddDeclRef(D->UsingOrNextShadow, Record); 946212795Sdim Writer.AddDeclRef(Context.getInstantiatedFromUsingShadowDecl(D), Record); 947212795Sdim Code = serialization::DECL_USING_SHADOW; 948212795Sdim} 949212795Sdim 950212795Sdimvoid ASTDeclWriter::VisitUsingDirectiveDecl(UsingDirectiveDecl *D) { 951212795Sdim VisitNamedDecl(D); 952212795Sdim Writer.AddSourceLocation(D->getUsingLoc(), Record); 953212795Sdim Writer.AddSourceLocation(D->getNamespaceKeyLocation(), Record); 954219077Sdim Writer.AddNestedNameSpecifierLoc(D->getQualifierLoc(), Record); 955212795Sdim Writer.AddDeclRef(D->getNominatedNamespace(), Record); 956212795Sdim Writer.AddDeclRef(dyn_cast<Decl>(D->getCommonAncestor()), Record); 957212795Sdim Code = serialization::DECL_USING_DIRECTIVE; 958212795Sdim} 959212795Sdim 960212795Sdimvoid ASTDeclWriter::VisitUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *D) { 961212795Sdim VisitValueDecl(D); 962212795Sdim Writer.AddSourceLocation(D->getUsingLoc(), Record); 963219077Sdim Writer.AddNestedNameSpecifierLoc(D->getQualifierLoc(), Record); 964218893Sdim Writer.AddDeclarationNameLoc(D->DNLoc, D->getDeclName(), Record); 965212795Sdim Code = serialization::DECL_UNRESOLVED_USING_VALUE; 966212795Sdim} 967212795Sdim 968212795Sdimvoid ASTDeclWriter::VisitUnresolvedUsingTypenameDecl( 969212795Sdim UnresolvedUsingTypenameDecl *D) { 970212795Sdim VisitTypeDecl(D); 971212795Sdim Writer.AddSourceLocation(D->getTypenameLoc(), Record); 972219077Sdim Writer.AddNestedNameSpecifierLoc(D->getQualifierLoc(), Record); 973212795Sdim Code = serialization::DECL_UNRESOLVED_USING_TYPENAME; 974212795Sdim} 975212795Sdim 976212795Sdimvoid ASTDeclWriter::VisitCXXRecordDecl(CXXRecordDecl *D) { 977212795Sdim VisitRecordDecl(D); 978235633Sdim Record.push_back(D->isThisDeclarationADefinition()); 979235633Sdim if (D->isThisDeclarationADefinition()) 980218893Sdim Writer.AddCXXDefinitionData(D, Record); 981212795Sdim 982212795Sdim enum { 983212795Sdim CXXRecNotTemplate = 0, CXXRecTemplate, CXXRecMemberSpecialization 984212795Sdim }; 985212795Sdim if (ClassTemplateDecl *TemplD = D->getDescribedClassTemplate()) { 986212795Sdim Record.push_back(CXXRecTemplate); 987212795Sdim Writer.AddDeclRef(TemplD, Record); 988212795Sdim } else if (MemberSpecializationInfo *MSInfo 989212795Sdim = D->getMemberSpecializationInfo()) { 990212795Sdim Record.push_back(CXXRecMemberSpecialization); 991212795Sdim Writer.AddDeclRef(MSInfo->getInstantiatedFrom(), Record); 992212795Sdim Record.push_back(MSInfo->getTemplateSpecializationKind()); 993212795Sdim Writer.AddSourceLocation(MSInfo->getPointOfInstantiation(), Record); 994212795Sdim } else { 995212795Sdim Record.push_back(CXXRecNotTemplate); 996212795Sdim } 997212795Sdim 998252723Sdim // Store (what we currently believe to be) the key function to avoid 999252723Sdim // deserializing every method so we can compute it. 1000226890Sdim if (D->IsCompleteDefinition) 1001252723Sdim Writer.AddDeclRef(Context.getCurrentKeyFunction(D), Record); 1002218893Sdim 1003212795Sdim Code = serialization::DECL_CXX_RECORD; 1004212795Sdim} 1005212795Sdim 1006212795Sdimvoid ASTDeclWriter::VisitCXXMethodDecl(CXXMethodDecl *D) { 1007212795Sdim VisitFunctionDecl(D); 1008245431Sdim if (D->isCanonicalDecl()) { 1009245431Sdim Record.push_back(D->size_overridden_methods()); 1010245431Sdim for (CXXMethodDecl::method_iterator 1011245431Sdim I = D->begin_overridden_methods(), E = D->end_overridden_methods(); 1012245431Sdim I != E; ++I) 1013245431Sdim Writer.AddDeclRef(*I, Record); 1014245431Sdim } else { 1015245431Sdim // We only need to record overridden methods once for the canonical decl. 1016245431Sdim Record.push_back(0); 1017245431Sdim } 1018212795Sdim Code = serialization::DECL_CXX_METHOD; 1019212795Sdim} 1020212795Sdim 1021212795Sdimvoid ASTDeclWriter::VisitCXXConstructorDecl(CXXConstructorDecl *D) { 1022212795Sdim VisitCXXMethodDecl(D); 1023212795Sdim 1024212795Sdim Record.push_back(D->IsExplicitSpecified); 1025218893Sdim Writer.AddCXXCtorInitializers(D->CtorInitializers, D->NumCtorInitializers, 1026218893Sdim Record); 1027212795Sdim 1028212795Sdim Code = serialization::DECL_CXX_CONSTRUCTOR; 1029212795Sdim} 1030212795Sdim 1031212795Sdimvoid ASTDeclWriter::VisitCXXDestructorDecl(CXXDestructorDecl *D) { 1032212795Sdim VisitCXXMethodDecl(D); 1033212795Sdim 1034212795Sdim Writer.AddDeclRef(D->OperatorDelete, Record); 1035212795Sdim 1036212795Sdim Code = serialization::DECL_CXX_DESTRUCTOR; 1037212795Sdim} 1038212795Sdim 1039212795Sdimvoid ASTDeclWriter::VisitCXXConversionDecl(CXXConversionDecl *D) { 1040212795Sdim VisitCXXMethodDecl(D); 1041212795Sdim Record.push_back(D->IsExplicitSpecified); 1042212795Sdim Code = serialization::DECL_CXX_CONVERSION; 1043212795Sdim} 1044212795Sdim 1045235633Sdimvoid ASTDeclWriter::VisitImportDecl(ImportDecl *D) { 1046235633Sdim VisitDecl(D); 1047245431Sdim Record.push_back(Writer.getSubmoduleID(D->getImportedModule())); 1048235633Sdim ArrayRef<SourceLocation> IdentifierLocs = D->getIdentifierLocs(); 1049235633Sdim Record.push_back(!IdentifierLocs.empty()); 1050235633Sdim if (IdentifierLocs.empty()) { 1051235633Sdim Writer.AddSourceLocation(D->getLocEnd(), Record); 1052235633Sdim Record.push_back(1); 1053235633Sdim } else { 1054235633Sdim for (unsigned I = 0, N = IdentifierLocs.size(); I != N; ++I) 1055235633Sdim Writer.AddSourceLocation(IdentifierLocs[I], Record); 1056235633Sdim Record.push_back(IdentifierLocs.size()); 1057235633Sdim } 1058235633Sdim // Note: the number of source locations must always be the last element in 1059235633Sdim // the record. 1060235633Sdim Code = serialization::DECL_IMPORT; 1061235633Sdim} 1062235633Sdim 1063212795Sdimvoid ASTDeclWriter::VisitAccessSpecDecl(AccessSpecDecl *D) { 1064212795Sdim VisitDecl(D); 1065212795Sdim Writer.AddSourceLocation(D->getColonLoc(), Record); 1066212795Sdim Code = serialization::DECL_ACCESS_SPEC; 1067212795Sdim} 1068212795Sdim 1069212795Sdimvoid ASTDeclWriter::VisitFriendDecl(FriendDecl *D) { 1070252723Sdim // Record the number of friend type template parameter lists here 1071252723Sdim // so as to simplify memory allocation during deserialization. 1072252723Sdim Record.push_back(D->NumTPLists); 1073212795Sdim VisitDecl(D); 1074252723Sdim bool hasFriendDecl = D->Friend.is<NamedDecl*>(); 1075252723Sdim Record.push_back(hasFriendDecl); 1076252723Sdim if (hasFriendDecl) 1077252723Sdim Writer.AddDeclRef(D->getFriendDecl(), Record); 1078212795Sdim else 1079252723Sdim Writer.AddTypeSourceInfo(D->getFriendType(), Record); 1080252723Sdim for (unsigned i = 0; i < D->NumTPLists; ++i) 1081252723Sdim Writer.AddTemplateParameterList(D->getFriendTypeTemplateParameterList(i), 1082252723Sdim Record); 1083218893Sdim Writer.AddDeclRef(D->getNextFriend(), Record); 1084218893Sdim Record.push_back(D->UnsupportedFriend); 1085212795Sdim Writer.AddSourceLocation(D->FriendLoc, Record); 1086212795Sdim Code = serialization::DECL_FRIEND; 1087212795Sdim} 1088212795Sdim 1089212795Sdimvoid ASTDeclWriter::VisitFriendTemplateDecl(FriendTemplateDecl *D) { 1090212795Sdim VisitDecl(D); 1091212795Sdim Record.push_back(D->getNumTemplateParameters()); 1092212795Sdim for (unsigned i = 0, e = D->getNumTemplateParameters(); i != e; ++i) 1093212795Sdim Writer.AddTemplateParameterList(D->getTemplateParameterList(i), Record); 1094212795Sdim Record.push_back(D->getFriendDecl() != 0); 1095212795Sdim if (D->getFriendDecl()) 1096212795Sdim Writer.AddDeclRef(D->getFriendDecl(), Record); 1097212795Sdim else 1098212795Sdim Writer.AddTypeSourceInfo(D->getFriendType(), Record); 1099212795Sdim Writer.AddSourceLocation(D->getFriendLoc(), Record); 1100212795Sdim Code = serialization::DECL_FRIEND_TEMPLATE; 1101212795Sdim} 1102212795Sdim 1103212795Sdimvoid ASTDeclWriter::VisitTemplateDecl(TemplateDecl *D) { 1104212795Sdim VisitNamedDecl(D); 1105212795Sdim 1106212795Sdim Writer.AddDeclRef(D->getTemplatedDecl(), Record); 1107212795Sdim Writer.AddTemplateParameterList(D->getTemplateParameters(), Record); 1108212795Sdim} 1109212795Sdim 1110212795Sdimvoid ASTDeclWriter::VisitRedeclarableTemplateDecl(RedeclarableTemplateDecl *D) { 1111235633Sdim VisitRedeclarable(D); 1112235633Sdim 1113218893Sdim // Emit data to initialize CommonOrPrev before VisitTemplateDecl so that 1114218893Sdim // getCommonPtr() can be used while this is still initializing. 1115263509Sdim if (D->isFirstDecl()) { 1116235633Sdim // This declaration owns the 'common' pointer, so serialize that data now. 1117212795Sdim Writer.AddDeclRef(D->getInstantiatedFromMemberTemplate(), Record); 1118212795Sdim if (D->getInstantiatedFromMemberTemplate()) 1119212795Sdim Record.push_back(D->isMemberSpecialization()); 1120212795Sdim } 1121235633Sdim 1122218893Sdim VisitTemplateDecl(D); 1123218893Sdim Record.push_back(D->getIdentifierNamespace()); 1124212795Sdim} 1125212795Sdim 1126212795Sdimvoid ASTDeclWriter::VisitClassTemplateDecl(ClassTemplateDecl *D) { 1127212795Sdim VisitRedeclarableTemplateDecl(D); 1128212795Sdim 1129263509Sdim if (D->isFirstDecl()) { 1130245431Sdim typedef llvm::FoldingSetVector<ClassTemplateSpecializationDecl> CTSDSetTy; 1131212795Sdim CTSDSetTy &CTSDSet = D->getSpecializations(); 1132212795Sdim Record.push_back(CTSDSet.size()); 1133212795Sdim for (CTSDSetTy::iterator I=CTSDSet.begin(), E = CTSDSet.end(); I!=E; ++I) { 1134212795Sdim assert(I->isCanonicalDecl() && "Expected only canonical decls in set"); 1135212795Sdim Writer.AddDeclRef(&*I, Record); 1136212795Sdim } 1137212795Sdim 1138245431Sdim typedef llvm::FoldingSetVector<ClassTemplatePartialSpecializationDecl> 1139245431Sdim CTPSDSetTy; 1140212795Sdim CTPSDSetTy &CTPSDSet = D->getPartialSpecializations(); 1141212795Sdim Record.push_back(CTPSDSet.size()); 1142212795Sdim for (CTPSDSetTy::iterator I=CTPSDSet.begin(), E=CTPSDSet.end(); I!=E; ++I) { 1143212795Sdim assert(I->isCanonicalDecl() && "Expected only canonical decls in set"); 1144212795Sdim Writer.AddDeclRef(&*I, Record); 1145212795Sdim } 1146212795Sdim 1147245431Sdim Writer.AddTypeRef(D->getCommonPtr()->InjectedClassNameType, Record); 1148212795Sdim } 1149212795Sdim Code = serialization::DECL_CLASS_TEMPLATE; 1150212795Sdim} 1151212795Sdim 1152212795Sdimvoid ASTDeclWriter::VisitClassTemplateSpecializationDecl( 1153212795Sdim ClassTemplateSpecializationDecl *D) { 1154212795Sdim VisitCXXRecordDecl(D); 1155212795Sdim 1156212795Sdim llvm::PointerUnion<ClassTemplateDecl *, 1157212795Sdim ClassTemplatePartialSpecializationDecl *> InstFrom 1158212795Sdim = D->getSpecializedTemplateOrPartial(); 1159226890Sdim if (Decl *InstFromD = InstFrom.dyn_cast<ClassTemplateDecl *>()) { 1160212795Sdim Writer.AddDeclRef(InstFromD, Record); 1161212795Sdim } else { 1162226890Sdim Writer.AddDeclRef(InstFrom.get<ClassTemplatePartialSpecializationDecl *>(), 1163226890Sdim Record); 1164212795Sdim Writer.AddTemplateArgumentList(&D->getTemplateInstantiationArgs(), Record); 1165212795Sdim } 1166212795Sdim 1167263509Sdim Writer.AddTemplateArgumentList(&D->getTemplateArgs(), Record); 1168263509Sdim Writer.AddSourceLocation(D->getPointOfInstantiation(), Record); 1169263509Sdim Record.push_back(D->getSpecializationKind()); 1170263509Sdim Record.push_back(D->isCanonicalDecl()); 1171263509Sdim 1172263509Sdim if (D->isCanonicalDecl()) { 1173263509Sdim // When reading, we'll add it to the folding set of the following template. 1174263509Sdim Writer.AddDeclRef(D->getSpecializedTemplate()->getCanonicalDecl(), Record); 1175263509Sdim } 1176263509Sdim 1177212795Sdim // Explicit info. 1178212795Sdim Writer.AddTypeSourceInfo(D->getTypeAsWritten(), Record); 1179212795Sdim if (D->getTypeAsWritten()) { 1180212795Sdim Writer.AddSourceLocation(D->getExternLoc(), Record); 1181212795Sdim Writer.AddSourceLocation(D->getTemplateKeywordLoc(), Record); 1182212795Sdim } 1183212795Sdim 1184263509Sdim Code = serialization::DECL_CLASS_TEMPLATE_SPECIALIZATION; 1185263509Sdim} 1186263509Sdim 1187263509Sdimvoid ASTDeclWriter::VisitClassTemplatePartialSpecializationDecl( 1188263509Sdim ClassTemplatePartialSpecializationDecl *D) { 1189263509Sdim VisitClassTemplateSpecializationDecl(D); 1190263509Sdim 1191263509Sdim Writer.AddTemplateParameterList(D->getTemplateParameters(), Record); 1192263509Sdim Writer.AddASTTemplateArgumentListInfo(D->getTemplateArgsAsWritten(), Record); 1193263509Sdim 1194263509Sdim // These are read/set from/to the first declaration. 1195263509Sdim if (D->getPreviousDecl() == 0) { 1196263509Sdim Writer.AddDeclRef(D->getInstantiatedFromMember(), Record); 1197263509Sdim Record.push_back(D->isMemberSpecialization()); 1198263509Sdim } 1199263509Sdim 1200263509Sdim Code = serialization::DECL_CLASS_TEMPLATE_PARTIAL_SPECIALIZATION; 1201263509Sdim} 1202263509Sdim 1203263509Sdimvoid ASTDeclWriter::VisitVarTemplateDecl(VarTemplateDecl *D) { 1204263509Sdim VisitRedeclarableTemplateDecl(D); 1205263509Sdim 1206263509Sdim if (D->isFirstDecl()) { 1207263509Sdim typedef llvm::FoldingSetVector<VarTemplateSpecializationDecl> VTSDSetTy; 1208263509Sdim VTSDSetTy &VTSDSet = D->getSpecializations(); 1209263509Sdim Record.push_back(VTSDSet.size()); 1210263509Sdim for (VTSDSetTy::iterator I = VTSDSet.begin(), E = VTSDSet.end(); I != E; 1211263509Sdim ++I) { 1212263509Sdim assert(I->isCanonicalDecl() && "Expected only canonical decls in set"); 1213263509Sdim Writer.AddDeclRef(&*I, Record); 1214263509Sdim } 1215263509Sdim 1216263509Sdim typedef llvm::FoldingSetVector<VarTemplatePartialSpecializationDecl> 1217263509Sdim VTPSDSetTy; 1218263509Sdim VTPSDSetTy &VTPSDSet = D->getPartialSpecializations(); 1219263509Sdim Record.push_back(VTPSDSet.size()); 1220263509Sdim for (VTPSDSetTy::iterator I = VTPSDSet.begin(), E = VTPSDSet.end(); I != E; 1221263509Sdim ++I) { 1222263509Sdim assert(I->isCanonicalDecl() && "Expected only canonical decls in set"); 1223263509Sdim Writer.AddDeclRef(&*I, Record); 1224263509Sdim } 1225263509Sdim } 1226263509Sdim Code = serialization::DECL_VAR_TEMPLATE; 1227263509Sdim} 1228263509Sdim 1229263509Sdimvoid ASTDeclWriter::VisitVarTemplateSpecializationDecl( 1230263509Sdim VarTemplateSpecializationDecl *D) { 1231263509Sdim VisitVarDecl(D); 1232263509Sdim 1233263509Sdim llvm::PointerUnion<VarTemplateDecl *, VarTemplatePartialSpecializationDecl *> 1234263509Sdim InstFrom = D->getSpecializedTemplateOrPartial(); 1235263509Sdim if (Decl *InstFromD = InstFrom.dyn_cast<VarTemplateDecl *>()) { 1236263509Sdim Writer.AddDeclRef(InstFromD, Record); 1237263509Sdim } else { 1238263509Sdim Writer.AddDeclRef(InstFrom.get<VarTemplatePartialSpecializationDecl *>(), 1239263509Sdim Record); 1240263509Sdim Writer.AddTemplateArgumentList(&D->getTemplateInstantiationArgs(), Record); 1241263509Sdim } 1242263509Sdim 1243263509Sdim // Explicit info. 1244263509Sdim Writer.AddTypeSourceInfo(D->getTypeAsWritten(), Record); 1245263509Sdim if (D->getTypeAsWritten()) { 1246263509Sdim Writer.AddSourceLocation(D->getExternLoc(), Record); 1247263509Sdim Writer.AddSourceLocation(D->getTemplateKeywordLoc(), Record); 1248263509Sdim } 1249263509Sdim 1250212795Sdim Writer.AddTemplateArgumentList(&D->getTemplateArgs(), Record); 1251212795Sdim Writer.AddSourceLocation(D->getPointOfInstantiation(), Record); 1252212795Sdim Record.push_back(D->getSpecializationKind()); 1253245431Sdim Record.push_back(D->isCanonicalDecl()); 1254212795Sdim 1255212795Sdim if (D->isCanonicalDecl()) { 1256263509Sdim // When reading, we'll add it to the folding set of the following template. 1257212795Sdim Writer.AddDeclRef(D->getSpecializedTemplate()->getCanonicalDecl(), Record); 1258212795Sdim } 1259212795Sdim 1260263509Sdim Code = serialization::DECL_VAR_TEMPLATE_SPECIALIZATION; 1261212795Sdim} 1262212795Sdim 1263263509Sdimvoid ASTDeclWriter::VisitVarTemplatePartialSpecializationDecl( 1264263509Sdim VarTemplatePartialSpecializationDecl *D) { 1265263509Sdim VisitVarTemplateSpecializationDecl(D); 1266212795Sdim 1267212795Sdim Writer.AddTemplateParameterList(D->getTemplateParameters(), Record); 1268263509Sdim Writer.AddASTTemplateArgumentListInfo(D->getTemplateArgsAsWritten(), Record); 1269212795Sdim 1270212795Sdim // These are read/set from/to the first declaration. 1271235633Sdim if (D->getPreviousDecl() == 0) { 1272212795Sdim Writer.AddDeclRef(D->getInstantiatedFromMember(), Record); 1273212795Sdim Record.push_back(D->isMemberSpecialization()); 1274212795Sdim } 1275212795Sdim 1276263509Sdim Code = serialization::DECL_VAR_TEMPLATE_PARTIAL_SPECIALIZATION; 1277212795Sdim} 1278212795Sdim 1279226890Sdimvoid ASTDeclWriter::VisitClassScopeFunctionSpecializationDecl( 1280226890Sdim ClassScopeFunctionSpecializationDecl *D) { 1281226890Sdim VisitDecl(D); 1282226890Sdim Writer.AddDeclRef(D->getSpecialization(), Record); 1283226890Sdim Code = serialization::DECL_CLASS_SCOPE_FUNCTION_SPECIALIZATION; 1284226890Sdim} 1285226890Sdim 1286226890Sdim 1287212795Sdimvoid ASTDeclWriter::VisitFunctionTemplateDecl(FunctionTemplateDecl *D) { 1288212795Sdim VisitRedeclarableTemplateDecl(D); 1289212795Sdim 1290263509Sdim if (D->isFirstDecl()) { 1291212795Sdim // This FunctionTemplateDecl owns the CommonPtr; write it. 1292212795Sdim 1293212795Sdim // Write the function specialization declarations. 1294212795Sdim Record.push_back(D->getSpecializations().size()); 1295245431Sdim for (llvm::FoldingSetVector<FunctionTemplateSpecializationInfo>::iterator 1296212795Sdim I = D->getSpecializations().begin(), 1297212795Sdim E = D->getSpecializations().end() ; I != E; ++I) { 1298212795Sdim assert(I->Function->isCanonicalDecl() && 1299212795Sdim "Expected only canonical decls in set"); 1300212795Sdim Writer.AddDeclRef(I->Function, Record); 1301212795Sdim } 1302212795Sdim } 1303212795Sdim Code = serialization::DECL_FUNCTION_TEMPLATE; 1304212795Sdim} 1305212795Sdim 1306212795Sdimvoid ASTDeclWriter::VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D) { 1307212795Sdim VisitTypeDecl(D); 1308212795Sdim 1309212795Sdim Record.push_back(D->wasDeclaredWithTypename()); 1310212795Sdim Record.push_back(D->defaultArgumentWasInherited()); 1311212795Sdim Writer.AddTypeSourceInfo(D->getDefaultArgumentInfo(), Record); 1312212795Sdim 1313212795Sdim Code = serialization::DECL_TEMPLATE_TYPE_PARM; 1314212795Sdim} 1315212795Sdim 1316212795Sdimvoid ASTDeclWriter::VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D) { 1317218893Sdim // For an expanded parameter pack, record the number of expansion types here 1318245431Sdim // so that it's easier for deserialization to allocate the right amount of 1319245431Sdim // memory. 1320218893Sdim if (D->isExpandedParameterPack()) 1321218893Sdim Record.push_back(D->getNumExpansionTypes()); 1322218893Sdim 1323218893Sdim VisitDeclaratorDecl(D); 1324212795Sdim // TemplateParmPosition. 1325212795Sdim Record.push_back(D->getDepth()); 1326212795Sdim Record.push_back(D->getPosition()); 1327218893Sdim 1328218893Sdim if (D->isExpandedParameterPack()) { 1329218893Sdim for (unsigned I = 0, N = D->getNumExpansionTypes(); I != N; ++I) { 1330218893Sdim Writer.AddTypeRef(D->getExpansionType(I), Record); 1331218893Sdim Writer.AddTypeSourceInfo(D->getExpansionTypeSourceInfo(I), Record); 1332218893Sdim } 1333218893Sdim 1334218893Sdim Code = serialization::DECL_EXPANDED_NON_TYPE_TEMPLATE_PARM_PACK; 1335218893Sdim } else { 1336218893Sdim // Rest of NonTypeTemplateParmDecl. 1337218893Sdim Record.push_back(D->isParameterPack()); 1338218893Sdim Record.push_back(D->getDefaultArgument() != 0); 1339218893Sdim if (D->getDefaultArgument()) { 1340218893Sdim Writer.AddStmt(D->getDefaultArgument()); 1341218893Sdim Record.push_back(D->defaultArgumentWasInherited()); 1342218893Sdim } 1343218893Sdim Code = serialization::DECL_NON_TYPE_TEMPLATE_PARM; 1344212795Sdim } 1345212795Sdim} 1346212795Sdim 1347212795Sdimvoid ASTDeclWriter::VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D) { 1348245431Sdim // For an expanded parameter pack, record the number of expansion types here 1349245431Sdim // so that it's easier for deserialization to allocate the right amount of 1350245431Sdim // memory. 1351245431Sdim if (D->isExpandedParameterPack()) 1352245431Sdim Record.push_back(D->getNumExpansionTemplateParameters()); 1353245431Sdim 1354212795Sdim VisitTemplateDecl(D); 1355212795Sdim // TemplateParmPosition. 1356212795Sdim Record.push_back(D->getDepth()); 1357212795Sdim Record.push_back(D->getPosition()); 1358245431Sdim 1359245431Sdim if (D->isExpandedParameterPack()) { 1360245431Sdim for (unsigned I = 0, N = D->getNumExpansionTemplateParameters(); 1361245431Sdim I != N; ++I) 1362245431Sdim Writer.AddTemplateParameterList(D->getExpansionTemplateParameters(I), 1363245431Sdim Record); 1364245431Sdim Code = serialization::DECL_EXPANDED_TEMPLATE_TEMPLATE_PARM_PACK; 1365245431Sdim } else { 1366245431Sdim // Rest of TemplateTemplateParmDecl. 1367245431Sdim Writer.AddTemplateArgumentLoc(D->getDefaultArgument(), Record); 1368245431Sdim Record.push_back(D->defaultArgumentWasInherited()); 1369245431Sdim Record.push_back(D->isParameterPack()); 1370245431Sdim Code = serialization::DECL_TEMPLATE_TEMPLATE_PARM; 1371245431Sdim } 1372212795Sdim} 1373212795Sdim 1374223017Sdimvoid ASTDeclWriter::VisitTypeAliasTemplateDecl(TypeAliasTemplateDecl *D) { 1375223017Sdim VisitRedeclarableTemplateDecl(D); 1376223017Sdim Code = serialization::DECL_TYPE_ALIAS_TEMPLATE; 1377223017Sdim} 1378223017Sdim 1379212795Sdimvoid ASTDeclWriter::VisitStaticAssertDecl(StaticAssertDecl *D) { 1380212795Sdim VisitDecl(D); 1381212795Sdim Writer.AddStmt(D->getAssertExpr()); 1382245431Sdim Record.push_back(D->isFailed()); 1383212795Sdim Writer.AddStmt(D->getMessage()); 1384221345Sdim Writer.AddSourceLocation(D->getRParenLoc(), Record); 1385212795Sdim Code = serialization::DECL_STATIC_ASSERT; 1386212795Sdim} 1387212795Sdim 1388212795Sdim/// \brief Emit the DeclContext part of a declaration context decl. 1389212795Sdim/// 1390212795Sdim/// \param LexicalOffset the offset at which the DECL_CONTEXT_LEXICAL 1391212795Sdim/// block for this declaration context is stored. May be 0 to indicate 1392212795Sdim/// that there are no declarations stored within this context. 1393212795Sdim/// 1394212795Sdim/// \param VisibleOffset the offset at which the DECL_CONTEXT_VISIBLE 1395212795Sdim/// block for this declaration context is stored. May be 0 to indicate 1396212795Sdim/// that there are no declarations visible from this context. Note 1397212795Sdim/// that this value will not be emitted for non-primary declaration 1398212795Sdim/// contexts. 1399212795Sdimvoid ASTDeclWriter::VisitDeclContext(DeclContext *DC, uint64_t LexicalOffset, 1400212795Sdim uint64_t VisibleOffset) { 1401212795Sdim Record.push_back(LexicalOffset); 1402212795Sdim Record.push_back(VisibleOffset); 1403212795Sdim} 1404212795Sdim 1405212795Sdimtemplate <typename T> 1406212795Sdimvoid ASTDeclWriter::VisitRedeclarable(Redeclarable<T> *D) { 1407263509Sdim T *First = D->getFirstDecl(); 1408235633Sdim if (First->getMostRecentDecl() != First) { 1409252723Sdim assert(isRedeclarableDeclKind(static_cast<T *>(D)->getKind()) && 1410252723Sdim "Not considered redeclarable?"); 1411252723Sdim 1412252723Sdim // There is more than one declaration of this entity, so we will need to 1413235633Sdim // write a redeclaration chain. 1414235633Sdim Writer.AddDeclRef(First, Record); 1415235633Sdim Writer.Redeclarations.insert(First); 1416235633Sdim 1417235633Sdim // Make sure that we serialize both the previous and the most-recent 1418235633Sdim // declarations, which (transitively) ensures that all declarations in the 1419235633Sdim // chain get serialized. 1420235633Sdim (void)Writer.GetDeclRef(D->getPreviousDecl()); 1421235633Sdim (void)Writer.GetDeclRef(First->getMostRecentDecl()); 1422212795Sdim } else { 1423235633Sdim // We use the sentinel value 0 to indicate an only declaration. 1424235633Sdim Record.push_back(0); 1425212795Sdim } 1426235633Sdim 1427212795Sdim} 1428212795Sdim 1429252723Sdimvoid ASTDeclWriter::VisitOMPThreadPrivateDecl(OMPThreadPrivateDecl *D) { 1430252723Sdim Record.push_back(D->varlist_size()); 1431252723Sdim VisitDecl(D); 1432252723Sdim for (OMPThreadPrivateDecl::varlist_iterator I = D->varlist_begin(), 1433252723Sdim E = D->varlist_end(); 1434252723Sdim I != E; ++I) 1435252723Sdim Writer.AddStmt(*I); 1436252723Sdim Code = serialization::DECL_OMP_THREADPRIVATE; 1437252723Sdim} 1438252723Sdim 1439212795Sdim//===----------------------------------------------------------------------===// 1440212795Sdim// ASTWriter Implementation 1441212795Sdim//===----------------------------------------------------------------------===// 1442212795Sdim 1443212795Sdimvoid ASTWriter::WriteDeclsBlockAbbrevs() { 1444212795Sdim using namespace llvm; 1445212795Sdim 1446223017Sdim BitCodeAbbrev *Abv; 1447223017Sdim 1448223017Sdim // Abbreviation for DECL_FIELD 1449223017Sdim Abv = new BitCodeAbbrev(); 1450223017Sdim Abv->Add(BitCodeAbbrevOp(serialization::DECL_FIELD)); 1451212795Sdim // Decl 1452212795Sdim Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclContext 1453212795Sdim Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // LexicalDeclContext 1454235633Sdim Abv->Add(BitCodeAbbrevOp(0)); // isInvalidDecl 1455212795Sdim Abv->Add(BitCodeAbbrevOp(0)); // HasAttrs 1456212795Sdim Abv->Add(BitCodeAbbrevOp(0)); // isImplicit 1457212795Sdim Abv->Add(BitCodeAbbrevOp(0)); // isUsed 1458221345Sdim Abv->Add(BitCodeAbbrevOp(0)); // isReferenced 1459235633Sdim Abv->Add(BitCodeAbbrevOp(0)); // TopLevelDeclInObjCContainer 1460223017Sdim Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2)); // AccessSpecifier 1461226890Sdim Abv->Add(BitCodeAbbrevOp(0)); // ModulePrivate 1462235633Sdim Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SubmoduleID 1463223017Sdim // NamedDecl 1464223017Sdim Abv->Add(BitCodeAbbrevOp(0)); // NameKind = Identifier 1465223017Sdim Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Name 1466223017Sdim // ValueDecl 1467223017Sdim Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type 1468223017Sdim // DeclaratorDecl 1469223017Sdim Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // InnerStartLoc 1470223017Sdim Abv->Add(BitCodeAbbrevOp(0)); // hasExtInfo 1471223017Sdim // FieldDecl 1472223017Sdim Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isMutable 1473223017Sdim Abv->Add(BitCodeAbbrevOp(0)); //getBitWidth 1474223017Sdim // Type Source Info 1475223017Sdim Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); 1476223017Sdim Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array)); 1477223017Sdim Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // TypeLoc 1478223017Sdim DeclFieldAbbrev = Stream.EmitAbbrev(Abv); 1479223017Sdim 1480223017Sdim // Abbreviation for DECL_OBJC_IVAR 1481223017Sdim Abv = new BitCodeAbbrev(); 1482223017Sdim Abv->Add(BitCodeAbbrevOp(serialization::DECL_OBJC_IVAR)); 1483223017Sdim // Decl 1484223017Sdim Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclContext 1485223017Sdim Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // LexicalDeclContext 1486235633Sdim Abv->Add(BitCodeAbbrevOp(0)); // isInvalidDecl 1487223017Sdim Abv->Add(BitCodeAbbrevOp(0)); // HasAttrs 1488223017Sdim Abv->Add(BitCodeAbbrevOp(0)); // isImplicit 1489223017Sdim Abv->Add(BitCodeAbbrevOp(0)); // isUsed 1490223017Sdim Abv->Add(BitCodeAbbrevOp(0)); // isReferenced 1491235633Sdim Abv->Add(BitCodeAbbrevOp(0)); // TopLevelDeclInObjCContainer 1492223017Sdim Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2)); // AccessSpecifier 1493226890Sdim Abv->Add(BitCodeAbbrevOp(0)); // ModulePrivate 1494235633Sdim Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SubmoduleID 1495223017Sdim // NamedDecl 1496223017Sdim Abv->Add(BitCodeAbbrevOp(0)); // NameKind = Identifier 1497223017Sdim Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Name 1498223017Sdim // ValueDecl 1499223017Sdim Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type 1500223017Sdim // DeclaratorDecl 1501223017Sdim Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // InnerStartLoc 1502223017Sdim Abv->Add(BitCodeAbbrevOp(0)); // hasExtInfo 1503223017Sdim // FieldDecl 1504223017Sdim Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isMutable 1505223017Sdim Abv->Add(BitCodeAbbrevOp(0)); //getBitWidth 1506223017Sdim // ObjC Ivar 1507223017Sdim Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // getAccessControl 1508223017Sdim Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // getSynthesize 1509263509Sdim // getBackingIvarReferencedInAccessor 1510263509Sdim Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); 1511223017Sdim // Type Source Info 1512223017Sdim Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); 1513223017Sdim Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array)); 1514223017Sdim Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // TypeLoc 1515223017Sdim DeclObjCIvarAbbrev = Stream.EmitAbbrev(Abv); 1516223017Sdim 1517223017Sdim // Abbreviation for DECL_ENUM 1518223017Sdim Abv = new BitCodeAbbrev(); 1519223017Sdim Abv->Add(BitCodeAbbrevOp(serialization::DECL_ENUM)); 1520235633Sdim // Redeclarable 1521235633Sdim Abv->Add(BitCodeAbbrevOp(0)); // No redeclaration 1522223017Sdim // Decl 1523223017Sdim Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclContext 1524223017Sdim Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // LexicalDeclContext 1525235633Sdim Abv->Add(BitCodeAbbrevOp(0)); // isInvalidDecl 1526223017Sdim Abv->Add(BitCodeAbbrevOp(0)); // HasAttrs 1527223017Sdim Abv->Add(BitCodeAbbrevOp(0)); // isImplicit 1528223017Sdim Abv->Add(BitCodeAbbrevOp(0)); // isUsed 1529223017Sdim Abv->Add(BitCodeAbbrevOp(0)); // isReferenced 1530235633Sdim Abv->Add(BitCodeAbbrevOp(0)); // TopLevelDeclInObjCContainer 1531212795Sdim Abv->Add(BitCodeAbbrevOp(AS_none)); // C++ AccessSpecifier 1532226890Sdim Abv->Add(BitCodeAbbrevOp(0)); // ModulePrivate 1533235633Sdim Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SubmoduleID 1534223017Sdim // NamedDecl 1535223017Sdim Abv->Add(BitCodeAbbrevOp(0)); // NameKind = Identifier 1536223017Sdim Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Name 1537223017Sdim // TypeDecl 1538223017Sdim Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Source Location 1539223017Sdim Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type Ref 1540223017Sdim // TagDecl 1541223017Sdim Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // IdentifierNamespace 1542223017Sdim Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // getTagKind 1543226890Sdim Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isCompleteDefinition 1544223017Sdim Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // EmbeddedInDeclarator 1545226890Sdim Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsFreeStanding 1546263509Sdim Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsCompleteDefinitionRequired 1547223017Sdim Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SourceLocation 1548223017Sdim Abv->Add(BitCodeAbbrevOp(0)); // hasExtInfo 1549223017Sdim Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // TypedefNameAnonDecl 1550223017Sdim // EnumDecl 1551223017Sdim Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // AddTypeRef 1552223017Sdim Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // IntegerType 1553223017Sdim Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // getPromotionType 1554223017Sdim Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // getNumPositiveBits 1555223017Sdim Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // getNumNegativeBits 1556223017Sdim Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isScoped 1557223017Sdim Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isScopedUsingClassTag 1558223017Sdim Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isFixed 1559223017Sdim Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // InstantiatedMembEnum 1560223017Sdim // DC 1561223017Sdim Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // LexicalOffset 1562223017Sdim Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // VisibleOffset 1563223017Sdim DeclEnumAbbrev = Stream.EmitAbbrev(Abv); 1564212795Sdim 1565223017Sdim // Abbreviation for DECL_RECORD 1566223017Sdim Abv = new BitCodeAbbrev(); 1567223017Sdim Abv->Add(BitCodeAbbrevOp(serialization::DECL_RECORD)); 1568235633Sdim // Redeclarable 1569235633Sdim Abv->Add(BitCodeAbbrevOp(0)); // No redeclaration 1570223017Sdim // Decl 1571223017Sdim Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclContext 1572223017Sdim Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // LexicalDeclContext 1573235633Sdim Abv->Add(BitCodeAbbrevOp(0)); // isInvalidDecl 1574223017Sdim Abv->Add(BitCodeAbbrevOp(0)); // HasAttrs 1575223017Sdim Abv->Add(BitCodeAbbrevOp(0)); // isImplicit 1576223017Sdim Abv->Add(BitCodeAbbrevOp(0)); // isUsed 1577223017Sdim Abv->Add(BitCodeAbbrevOp(0)); // isReferenced 1578235633Sdim Abv->Add(BitCodeAbbrevOp(0)); // TopLevelDeclInObjCContainer 1579223017Sdim Abv->Add(BitCodeAbbrevOp(AS_none)); // C++ AccessSpecifier 1580226890Sdim Abv->Add(BitCodeAbbrevOp(0)); // ModulePrivate 1581235633Sdim Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SubmoduleID 1582212795Sdim // NamedDecl 1583212795Sdim Abv->Add(BitCodeAbbrevOp(0)); // NameKind = Identifier 1584212795Sdim Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Name 1585223017Sdim // TypeDecl 1586223017Sdim Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Source Location 1587223017Sdim Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type Ref 1588223017Sdim // TagDecl 1589223017Sdim Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // IdentifierNamespace 1590223017Sdim Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // getTagKind 1591226890Sdim Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isCompleteDefinition 1592223017Sdim Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // EmbeddedInDeclarator 1593226890Sdim Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsFreeStanding 1594263509Sdim Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsCompleteDefinitionRequired 1595223017Sdim Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SourceLocation 1596223017Sdim Abv->Add(BitCodeAbbrevOp(0)); // hasExtInfo 1597223017Sdim Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // TypedefNameAnonDecl 1598223017Sdim // RecordDecl 1599223017Sdim Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // FlexibleArrayMember 1600223017Sdim Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // AnonymousStructUnion 1601223017Sdim Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // hasObjectMember 1602252723Sdim Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // hasVolatileMember 1603223017Sdim // DC 1604223017Sdim Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // LexicalOffset 1605223017Sdim Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // VisibleOffset 1606223017Sdim DeclRecordAbbrev = Stream.EmitAbbrev(Abv); 1607223017Sdim 1608223017Sdim // Abbreviation for DECL_PARM_VAR 1609223017Sdim Abv = new BitCodeAbbrev(); 1610223017Sdim Abv->Add(BitCodeAbbrevOp(serialization::DECL_PARM_VAR)); 1611235633Sdim // Redeclarable 1612235633Sdim Abv->Add(BitCodeAbbrevOp(0)); // No redeclaration 1613223017Sdim // Decl 1614223017Sdim Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclContext 1615223017Sdim Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // LexicalDeclContext 1616235633Sdim Abv->Add(BitCodeAbbrevOp(0)); // isInvalidDecl 1617223017Sdim Abv->Add(BitCodeAbbrevOp(0)); // HasAttrs 1618223017Sdim Abv->Add(BitCodeAbbrevOp(0)); // isImplicit 1619223017Sdim Abv->Add(BitCodeAbbrevOp(0)); // isUsed 1620223017Sdim Abv->Add(BitCodeAbbrevOp(0)); // isReferenced 1621235633Sdim Abv->Add(BitCodeAbbrevOp(0)); // TopLevelDeclInObjCContainer 1622223017Sdim Abv->Add(BitCodeAbbrevOp(AS_none)); // C++ AccessSpecifier 1623226890Sdim Abv->Add(BitCodeAbbrevOp(0)); // ModulePrivate 1624235633Sdim Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SubmoduleID 1625223017Sdim // NamedDecl 1626223017Sdim Abv->Add(BitCodeAbbrevOp(0)); // NameKind = Identifier 1627223017Sdim Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Name 1628212795Sdim // ValueDecl 1629212795Sdim Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type 1630212795Sdim // DeclaratorDecl 1631221345Sdim Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // InnerStartLoc 1632218893Sdim Abv->Add(BitCodeAbbrevOp(0)); // hasExtInfo 1633212795Sdim // VarDecl 1634212795Sdim Abv->Add(BitCodeAbbrevOp(0)); // StorageClass 1635252723Sdim Abv->Add(BitCodeAbbrevOp(0)); // getTSCSpec 1636212795Sdim Abv->Add(BitCodeAbbrevOp(0)); // hasCXXDirectInitializer 1637212795Sdim Abv->Add(BitCodeAbbrevOp(0)); // isExceptionVariable 1638212795Sdim Abv->Add(BitCodeAbbrevOp(0)); // isNRVOVariable 1639221345Sdim Abv->Add(BitCodeAbbrevOp(0)); // isCXXForRangeDecl 1640224145Sdim Abv->Add(BitCodeAbbrevOp(0)); // isARCPseudoStrong 1641245431Sdim Abv->Add(BitCodeAbbrevOp(0)); // isConstexpr 1642263509Sdim Abv->Add(BitCodeAbbrevOp(0)); // isInitCapture 1643263509Sdim Abv->Add(BitCodeAbbrevOp(0)); // isPrevDeclInSameScope 1644252723Sdim Abv->Add(BitCodeAbbrevOp(0)); // Linkage 1645212795Sdim Abv->Add(BitCodeAbbrevOp(0)); // HasInit 1646212795Sdim Abv->Add(BitCodeAbbrevOp(0)); // HasMemberSpecializationInfo 1647212795Sdim // ParmVarDecl 1648221345Sdim Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsObjCMethodParameter 1649221345Sdim Abv->Add(BitCodeAbbrevOp(0)); // ScopeDepth 1650221345Sdim Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // ScopeIndex 1651212795Sdim Abv->Add(BitCodeAbbrevOp(0)); // ObjCDeclQualifier 1652221345Sdim Abv->Add(BitCodeAbbrevOp(0)); // KNRPromoted 1653212795Sdim Abv->Add(BitCodeAbbrevOp(0)); // HasInheritedDefaultArg 1654212795Sdim Abv->Add(BitCodeAbbrevOp(0)); // HasUninstantiatedDefaultArg 1655223017Sdim // Type Source Info 1656223017Sdim Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); 1657223017Sdim Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array)); 1658223017Sdim Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // TypeLoc 1659223017Sdim DeclParmVarAbbrev = Stream.EmitAbbrev(Abv); 1660212795Sdim 1661223017Sdim // Abbreviation for DECL_TYPEDEF 1662223017Sdim Abv = new BitCodeAbbrev(); 1663223017Sdim Abv->Add(BitCodeAbbrevOp(serialization::DECL_TYPEDEF)); 1664235633Sdim // Redeclarable 1665235633Sdim Abv->Add(BitCodeAbbrevOp(0)); // No redeclaration 1666223017Sdim // Decl 1667223017Sdim Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclContext 1668223017Sdim Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // LexicalDeclContext 1669235633Sdim Abv->Add(BitCodeAbbrevOp(0)); // isInvalidDecl 1670223017Sdim Abv->Add(BitCodeAbbrevOp(0)); // HasAttrs 1671223017Sdim Abv->Add(BitCodeAbbrevOp(0)); // isImplicit 1672223017Sdim Abv->Add(BitCodeAbbrevOp(0)); // isUsed 1673223017Sdim Abv->Add(BitCodeAbbrevOp(0)); // isReferenced 1674235633Sdim Abv->Add(BitCodeAbbrevOp(0)); // TopLevelDeclInObjCContainer 1675223017Sdim Abv->Add(BitCodeAbbrevOp(AS_none)); // C++ AccessSpecifier 1676226890Sdim Abv->Add(BitCodeAbbrevOp(0)); // ModulePrivate 1677235633Sdim Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SubmoduleID 1678223017Sdim // NamedDecl 1679223017Sdim Abv->Add(BitCodeAbbrevOp(0)); // NameKind = Identifier 1680223017Sdim Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Name 1681223017Sdim // TypeDecl 1682223017Sdim Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Source Location 1683223017Sdim Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type Ref 1684223017Sdim // TypedefDecl 1685223017Sdim Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array)); 1686223017Sdim Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // TypeLoc 1687223017Sdim DeclTypedefAbbrev = Stream.EmitAbbrev(Abv); 1688212795Sdim 1689223017Sdim // Abbreviation for DECL_VAR 1690212795Sdim Abv = new BitCodeAbbrev(); 1691223017Sdim Abv->Add(BitCodeAbbrevOp(serialization::DECL_VAR)); 1692235633Sdim // Redeclarable 1693235633Sdim Abv->Add(BitCodeAbbrevOp(0)); // No redeclaration 1694223017Sdim // Decl 1695223017Sdim Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclContext 1696223017Sdim Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // LexicalDeclContext 1697235633Sdim Abv->Add(BitCodeAbbrevOp(0)); // isInvalidDecl 1698223017Sdim Abv->Add(BitCodeAbbrevOp(0)); // HasAttrs 1699223017Sdim Abv->Add(BitCodeAbbrevOp(0)); // isImplicit 1700223017Sdim Abv->Add(BitCodeAbbrevOp(0)); // isUsed 1701223017Sdim Abv->Add(BitCodeAbbrevOp(0)); // isReferenced 1702235633Sdim Abv->Add(BitCodeAbbrevOp(0)); // TopLevelDeclInObjCContainer 1703223017Sdim Abv->Add(BitCodeAbbrevOp(AS_none)); // C++ AccessSpecifier 1704226890Sdim Abv->Add(BitCodeAbbrevOp(0)); // ModulePrivate 1705235633Sdim Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SubmoduleID 1706223017Sdim // NamedDecl 1707223017Sdim Abv->Add(BitCodeAbbrevOp(0)); // NameKind = Identifier 1708223017Sdim Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Name 1709223017Sdim // ValueDecl 1710223017Sdim Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type 1711223017Sdim // DeclaratorDecl 1712223017Sdim Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // InnerStartLoc 1713223017Sdim Abv->Add(BitCodeAbbrevOp(0)); // hasExtInfo 1714223017Sdim // VarDecl 1715223017Sdim Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // StorageClass 1716252723Sdim Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2)); // getTSCSpec 1717223017Sdim Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // CXXDirectInitializer 1718223017Sdim Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isExceptionVariable 1719223017Sdim Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isNRVOVariable 1720223017Sdim Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isCXXForRangeDecl 1721224145Sdim Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isARCPseudoStrong 1722245431Sdim Abv->Add(BitCodeAbbrevOp(0)); // isConstexpr 1723263509Sdim Abv->Add(BitCodeAbbrevOp(0)); // isInitCapture 1724263509Sdim Abv->Add(BitCodeAbbrevOp(0)); // isPrevDeclInSameScope 1725263509Sdim Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); // Linkage 1726223017Sdim Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // HasInit 1727223017Sdim Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // HasMemberSpecInfo 1728223017Sdim // Type Source Info 1729223017Sdim Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); 1730223017Sdim Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array)); 1731223017Sdim Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // TypeLoc 1732223017Sdim DeclVarAbbrev = Stream.EmitAbbrev(Abv); 1733223017Sdim 1734223017Sdim // Abbreviation for EXPR_DECL_REF 1735223017Sdim Abv = new BitCodeAbbrev(); 1736223017Sdim Abv->Add(BitCodeAbbrevOp(serialization::EXPR_DECL_REF)); 1737223017Sdim //Stmt 1738223017Sdim //Expr 1739223017Sdim Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type 1740224145Sdim Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //TypeDependent 1741224145Sdim Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //ValueDependent 1742224145Sdim Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //InstantiationDependent 1743223017Sdim Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //UnexpandedParamPack 1744223017Sdim Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); //GetValueKind 1745223017Sdim Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); //GetObjectKind 1746223017Sdim //DeclRefExpr 1747223017Sdim Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //HasQualifier 1748223017Sdim Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //GetDeclFound 1749223017Sdim Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //ExplicitTemplateArgs 1750226890Sdim Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //HadMultipleCandidates 1751235633Sdim Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //RefersToEnclosingLocal 1752223017Sdim Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclRef 1753223017Sdim Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Location 1754223017Sdim DeclRefExprAbbrev = Stream.EmitAbbrev(Abv); 1755223017Sdim 1756223017Sdim // Abbreviation for EXPR_INTEGER_LITERAL 1757223017Sdim Abv = new BitCodeAbbrev(); 1758223017Sdim Abv->Add(BitCodeAbbrevOp(serialization::EXPR_INTEGER_LITERAL)); 1759223017Sdim //Stmt 1760223017Sdim //Expr 1761223017Sdim Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type 1762224145Sdim Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //TypeDependent 1763224145Sdim Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //ValueDependent 1764224145Sdim Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //InstantiationDependent 1765223017Sdim Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //UnexpandedParamPack 1766223017Sdim Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); //GetValueKind 1767223017Sdim Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); //GetObjectKind 1768223017Sdim //Integer Literal 1769223017Sdim Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Location 1770223017Sdim Abv->Add(BitCodeAbbrevOp(32)); // Bit Width 1771223017Sdim Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Value 1772223017Sdim IntegerLiteralAbbrev = Stream.EmitAbbrev(Abv); 1773223017Sdim 1774223017Sdim // Abbreviation for EXPR_CHARACTER_LITERAL 1775223017Sdim Abv = new BitCodeAbbrev(); 1776223017Sdim Abv->Add(BitCodeAbbrevOp(serialization::EXPR_CHARACTER_LITERAL)); 1777223017Sdim //Stmt 1778223017Sdim //Expr 1779223017Sdim Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type 1780224145Sdim Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //TypeDependent 1781224145Sdim Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //ValueDependent 1782224145Sdim Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //InstantiationDependent 1783223017Sdim Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //UnexpandedParamPack 1784223017Sdim Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); //GetValueKind 1785223017Sdim Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); //GetObjectKind 1786223017Sdim //Character Literal 1787223017Sdim Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // getValue 1788223017Sdim Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Location 1789245431Sdim Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2)); // getKind 1790223017Sdim CharacterLiteralAbbrev = Stream.EmitAbbrev(Abv); 1791223017Sdim 1792223017Sdim Abv = new BitCodeAbbrev(); 1793212795Sdim Abv->Add(BitCodeAbbrevOp(serialization::DECL_CONTEXT_LEXICAL)); 1794212795Sdim Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); 1795212795Sdim DeclContextLexicalAbbrev = Stream.EmitAbbrev(Abv); 1796212795Sdim 1797212795Sdim Abv = new BitCodeAbbrev(); 1798212795Sdim Abv->Add(BitCodeAbbrevOp(serialization::DECL_CONTEXT_VISIBLE)); 1799212795Sdim Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); 1800212795Sdim Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); 1801212795Sdim DeclContextVisibleLookupAbbrev = Stream.EmitAbbrev(Abv); 1802212795Sdim} 1803212795Sdim 1804212795Sdim/// isRequiredDecl - Check if this is a "required" Decl, which must be seen by 1805212795Sdim/// consumers of the AST. 1806212795Sdim/// 1807212795Sdim/// Such decls will always be deserialized from the AST file, so we would like 1808212795Sdim/// this to be as restrictive as possible. Currently the predicate is driven by 1809212795Sdim/// code generation requirements, if other clients have a different notion of 1810212795Sdim/// what is "required" then we may have to consider an alternate scheme where 1811212795Sdim/// clients can iterate over the top-level decls and get information on them, 1812212795Sdim/// without necessary deserializing them. We could explicitly require such 1813212795Sdim/// clients to use a separate API call to "realize" the decl. This should be 1814212795Sdim/// relatively painless since they would presumably only do it for top-level 1815212795Sdim/// decls. 1816212795Sdimstatic bool isRequiredDecl(const Decl *D, ASTContext &Context) { 1817226890Sdim // An ObjCMethodDecl is never considered as "required" because its 1818226890Sdim // implementation container always is. 1819226890Sdim 1820212795Sdim // File scoped assembly or obj-c implementation must be seen. 1821226890Sdim if (isa<FileScopeAsmDecl>(D) || isa<ObjCImplDecl>(D)) 1822212795Sdim return true; 1823212795Sdim 1824212795Sdim return Context.DeclMustBeEmitted(D); 1825212795Sdim} 1826212795Sdim 1827212795Sdimvoid ASTWriter::WriteDecl(ASTContext &Context, Decl *D) { 1828218893Sdim // Switch case IDs are per Decl. 1829218893Sdim ClearSwitchCaseIDs(); 1830218893Sdim 1831212795Sdim RecordData Record; 1832212795Sdim ASTDeclWriter W(*this, Context, Record); 1833212795Sdim 1834235633Sdim // Determine the ID for this declaration. 1835235633Sdim serialization::DeclID ID; 1836235633Sdim if (D->isFromASTFile()) 1837235633Sdim ID = getDeclID(D); 1838235633Sdim else { 1839235633Sdim serialization::DeclID &IDR = DeclIDs[D]; 1840235633Sdim if (IDR == 0) 1841235633Sdim IDR = NextDeclID++; 1842235633Sdim 1843235633Sdim ID= IDR; 1844235633Sdim } 1845235633Sdim 1846235633Sdim bool isReplacingADecl = ID < FirstDeclID; 1847235633Sdim 1848212795Sdim // If this declaration is also a DeclContext, write blocks for the 1849212795Sdim // declarations that lexically stored inside its context and those 1850212795Sdim // declarations that are visible from its context. These blocks 1851212795Sdim // are written before the declaration itself so that we can put 1852212795Sdim // their offsets into the record for the declaration. 1853212795Sdim uint64_t LexicalOffset = 0; 1854212795Sdim uint64_t VisibleOffset = 0; 1855212795Sdim DeclContext *DC = dyn_cast<DeclContext>(D); 1856212795Sdim if (DC) { 1857235633Sdim if (isReplacingADecl) { 1858235633Sdim // It is replacing a decl from a chained PCH; make sure that the 1859235633Sdim // DeclContext is fully loaded. 1860235633Sdim if (DC->hasExternalLexicalStorage()) 1861235633Sdim DC->LoadLexicalDeclsFromExternalStorage(); 1862235633Sdim if (DC->hasExternalVisibleStorage()) 1863235633Sdim Chain->completeVisibleDeclsMap(DC); 1864235633Sdim } 1865212795Sdim LexicalOffset = WriteDeclContextLexicalBlock(Context, DC); 1866212795Sdim VisibleOffset = WriteDeclContextVisibleBlock(Context, DC); 1867212795Sdim } 1868235633Sdim 1869235633Sdim if (isReplacingADecl) { 1870212795Sdim // We're replacing a decl in a previous file. 1871235633Sdim ReplacedDecls.push_back(ReplacedDeclInfo(ID, Stream.GetCurrentBitNo(), 1872235633Sdim D->getLocation())); 1873212795Sdim } else { 1874212795Sdim unsigned Index = ID - FirstDeclID; 1875212795Sdim 1876212795Sdim // Record the offset for this declaration 1877235633Sdim SourceLocation Loc = D->getLocation(); 1878212795Sdim if (DeclOffsets.size() == Index) 1879235633Sdim DeclOffsets.push_back(DeclOffset(Loc, Stream.GetCurrentBitNo())); 1880212795Sdim else if (DeclOffsets.size() < Index) { 1881212795Sdim DeclOffsets.resize(Index+1); 1882235633Sdim DeclOffsets[Index].setLocation(Loc); 1883235633Sdim DeclOffsets[Index].BitOffset = Stream.GetCurrentBitNo(); 1884212795Sdim } 1885235633Sdim 1886235633Sdim SourceManager &SM = Context.getSourceManager(); 1887235633Sdim if (Loc.isValid() && SM.isLocalSourceLocation(Loc)) 1888235633Sdim associateDeclWithFile(D, ID); 1889212795Sdim } 1890212795Sdim 1891212795Sdim // Build and emit a record for this declaration 1892212795Sdim Record.clear(); 1893212795Sdim W.Code = (serialization::DeclCode)0; 1894212795Sdim W.AbbrevToUse = 0; 1895212795Sdim W.Visit(D); 1896212795Sdim if (DC) W.VisitDeclContext(DC, LexicalOffset, VisibleOffset); 1897212795Sdim 1898212795Sdim if (!W.Code) 1899226890Sdim llvm::report_fatal_error(StringRef("unexpected declaration kind '") + 1900212795Sdim D->getDeclKindName() + "'"); 1901212795Sdim Stream.EmitRecord(W.Code, Record, W.AbbrevToUse); 1902212795Sdim 1903212795Sdim // Flush any expressions that were written as part of this declaration. 1904212795Sdim FlushStmts(); 1905218893Sdim 1906218893Sdim // Flush C++ base specifiers, if there are any. 1907218893Sdim FlushCXXBaseSpecifiers(); 1908218893Sdim 1909212795Sdim // Note "external" declarations so that we can add them to a record in the 1910212795Sdim // AST file later. 1911212795Sdim // 1912212795Sdim // FIXME: This should be renamed, the predicate is much more complicated. 1913212795Sdim if (isRequiredDecl(D, Context)) 1914212795Sdim ExternalDefinitions.push_back(ID); 1915212795Sdim} 1916