ASTWriterDecl.cpp revision 243830
1//===--- ASTWriterDecl.cpp - Declaration Serialization --------------------===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file is distributed under the University of Illinois Open Source 6// License. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9// 10// This file implements serialization for Declarations. 11// 12//===----------------------------------------------------------------------===// 13 14#include "clang/Serialization/ASTWriter.h" 15#include "clang/Serialization/ASTReader.h" 16#include "ASTCommon.h" 17#include "clang/AST/DeclVisitor.h" 18#include "clang/AST/DeclCXX.h" 19#include "clang/AST/DeclTemplate.h" 20#include "clang/AST/Expr.h" 21#include "clang/AST/DeclContextInternals.h" 22#include "clang/Basic/SourceManager.h" 23#include "llvm/ADT/Twine.h" 24#include "llvm/Bitcode/BitstreamWriter.h" 25#include "llvm/Support/ErrorHandling.h" 26using namespace clang; 27using namespace serialization; 28 29//===----------------------------------------------------------------------===// 30// Declaration serialization 31//===----------------------------------------------------------------------===// 32 33namespace clang { 34 class ASTDeclWriter : public DeclVisitor<ASTDeclWriter, void> { 35 36 ASTWriter &Writer; 37 ASTContext &Context; 38 typedef ASTWriter::RecordData RecordData; 39 RecordData &Record; 40 41 public: 42 serialization::DeclCode Code; 43 unsigned AbbrevToUse; 44 45 ASTDeclWriter(ASTWriter &Writer, ASTContext &Context, RecordData &Record) 46 : Writer(Writer), Context(Context), Record(Record) { 47 } 48 49 void Visit(Decl *D); 50 51 void VisitDecl(Decl *D); 52 void VisitTranslationUnitDecl(TranslationUnitDecl *D); 53 void VisitNamedDecl(NamedDecl *D); 54 void VisitLabelDecl(LabelDecl *LD); 55 void VisitNamespaceDecl(NamespaceDecl *D); 56 void VisitUsingDirectiveDecl(UsingDirectiveDecl *D); 57 void VisitNamespaceAliasDecl(NamespaceAliasDecl *D); 58 void VisitTypeDecl(TypeDecl *D); 59 void VisitTypedefNameDecl(TypedefNameDecl *D); 60 void VisitTypedefDecl(TypedefDecl *D); 61 void VisitTypeAliasDecl(TypeAliasDecl *D); 62 void VisitUnresolvedUsingTypenameDecl(UnresolvedUsingTypenameDecl *D); 63 void VisitTagDecl(TagDecl *D); 64 void VisitEnumDecl(EnumDecl *D); 65 void VisitRecordDecl(RecordDecl *D); 66 void VisitCXXRecordDecl(CXXRecordDecl *D); 67 void VisitClassTemplateSpecializationDecl( 68 ClassTemplateSpecializationDecl *D); 69 void VisitClassTemplatePartialSpecializationDecl( 70 ClassTemplatePartialSpecializationDecl *D); 71 void VisitClassScopeFunctionSpecializationDecl( 72 ClassScopeFunctionSpecializationDecl *D); 73 void VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D); 74 void VisitValueDecl(ValueDecl *D); 75 void VisitEnumConstantDecl(EnumConstantDecl *D); 76 void VisitUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *D); 77 void VisitDeclaratorDecl(DeclaratorDecl *D); 78 void VisitFunctionDecl(FunctionDecl *D); 79 void VisitCXXMethodDecl(CXXMethodDecl *D); 80 void VisitCXXConstructorDecl(CXXConstructorDecl *D); 81 void VisitCXXDestructorDecl(CXXDestructorDecl *D); 82 void VisitCXXConversionDecl(CXXConversionDecl *D); 83 void VisitFieldDecl(FieldDecl *D); 84 void VisitIndirectFieldDecl(IndirectFieldDecl *D); 85 void VisitVarDecl(VarDecl *D); 86 void VisitImplicitParamDecl(ImplicitParamDecl *D); 87 void VisitParmVarDecl(ParmVarDecl *D); 88 void VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D); 89 void VisitTemplateDecl(TemplateDecl *D); 90 void VisitRedeclarableTemplateDecl(RedeclarableTemplateDecl *D); 91 void VisitClassTemplateDecl(ClassTemplateDecl *D); 92 void VisitFunctionTemplateDecl(FunctionTemplateDecl *D); 93 void VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D); 94 void VisitTypeAliasTemplateDecl(TypeAliasTemplateDecl *D); 95 void VisitUsingDecl(UsingDecl *D); 96 void VisitUsingShadowDecl(UsingShadowDecl *D); 97 void VisitLinkageSpecDecl(LinkageSpecDecl *D); 98 void VisitFileScopeAsmDecl(FileScopeAsmDecl *D); 99 void VisitImportDecl(ImportDecl *D); 100 void VisitAccessSpecDecl(AccessSpecDecl *D); 101 void VisitFriendDecl(FriendDecl *D); 102 void VisitFriendTemplateDecl(FriendTemplateDecl *D); 103 void VisitStaticAssertDecl(StaticAssertDecl *D); 104 void VisitBlockDecl(BlockDecl *D); 105 106 void VisitDeclContext(DeclContext *DC, uint64_t LexicalOffset, 107 uint64_t VisibleOffset); 108 template <typename T> void VisitRedeclarable(Redeclarable<T> *D); 109 110 111 // FIXME: Put in the same order is DeclNodes.td? 112 void VisitObjCMethodDecl(ObjCMethodDecl *D); 113 void VisitObjCContainerDecl(ObjCContainerDecl *D); 114 void VisitObjCInterfaceDecl(ObjCInterfaceDecl *D); 115 void VisitObjCIvarDecl(ObjCIvarDecl *D); 116 void VisitObjCProtocolDecl(ObjCProtocolDecl *D); 117 void VisitObjCAtDefsFieldDecl(ObjCAtDefsFieldDecl *D); 118 void VisitObjCCategoryDecl(ObjCCategoryDecl *D); 119 void VisitObjCImplDecl(ObjCImplDecl *D); 120 void VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D); 121 void VisitObjCImplementationDecl(ObjCImplementationDecl *D); 122 void VisitObjCCompatibleAliasDecl(ObjCCompatibleAliasDecl *D); 123 void VisitObjCPropertyDecl(ObjCPropertyDecl *D); 124 void VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D); 125 }; 126} 127 128void ASTDeclWriter::Visit(Decl *D) { 129 DeclVisitor<ASTDeclWriter>::Visit(D); 130 131 // Source locations require array (variable-length) abbreviations. The 132 // abbreviation infrastructure requires that arrays are encoded last, so 133 // we handle it here in the case of those classes derived from DeclaratorDecl 134 if (DeclaratorDecl *DD = dyn_cast<DeclaratorDecl>(D)){ 135 Writer.AddTypeSourceInfo(DD->getTypeSourceInfo(), Record); 136 } 137 138 // Handle FunctionDecl's body here and write it after all other Stmts/Exprs 139 // have been written. We want it last because we will not read it back when 140 // retrieving it from the AST, we'll just lazily set the offset. 141 if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) { 142 Record.push_back(FD->doesThisDeclarationHaveABody()); 143 if (FD->doesThisDeclarationHaveABody()) 144 Writer.AddStmt(FD->getBody()); 145 } 146} 147 148void ASTDeclWriter::VisitDecl(Decl *D) { 149 Writer.AddDeclRef(cast_or_null<Decl>(D->getDeclContext()), Record); 150 Writer.AddDeclRef(cast_or_null<Decl>(D->getLexicalDeclContext()), Record); 151 Record.push_back(D->isInvalidDecl()); 152 Record.push_back(D->hasAttrs()); 153 if (D->hasAttrs()) 154 Writer.WriteAttributes(ArrayRef<const Attr*>(D->getAttrs().begin(), 155 D->getAttrs().size()), Record); 156 Record.push_back(D->isImplicit()); 157 Record.push_back(D->isUsed(false)); 158 Record.push_back(D->isReferenced()); 159 Record.push_back(D->isTopLevelDeclInObjCContainer()); 160 Record.push_back(D->getAccess()); 161 Record.push_back(D->isModulePrivate()); 162 Record.push_back(Writer.inferSubmoduleIDFromLocation(D->getLocation())); 163} 164 165void ASTDeclWriter::VisitTranslationUnitDecl(TranslationUnitDecl *D) { 166 llvm_unreachable("Translation units aren't directly serialized"); 167} 168 169void ASTDeclWriter::VisitNamedDecl(NamedDecl *D) { 170 VisitDecl(D); 171 Writer.AddDeclarationName(D->getDeclName(), Record); 172} 173 174void ASTDeclWriter::VisitTypeDecl(TypeDecl *D) { 175 VisitNamedDecl(D); 176 Writer.AddSourceLocation(D->getLocStart(), Record); 177 Writer.AddTypeRef(QualType(D->getTypeForDecl(), 0), Record); 178} 179 180void ASTDeclWriter::VisitTypedefNameDecl(TypedefNameDecl *D) { 181 VisitRedeclarable(D); 182 VisitTypeDecl(D); 183 Writer.AddTypeSourceInfo(D->getTypeSourceInfo(), Record); 184} 185 186void ASTDeclWriter::VisitTypedefDecl(TypedefDecl *D) { 187 VisitTypedefNameDecl(D); 188 if (!D->hasAttrs() && 189 !D->isImplicit() && 190 !D->isUsed(false) && 191 D->getFirstDeclaration() == D->getMostRecentDecl() && 192 !D->isInvalidDecl() && 193 !D->isReferenced() && 194 !D->isTopLevelDeclInObjCContainer() && 195 D->getAccess() == AS_none && 196 !D->isModulePrivate() && 197 D->getDeclName().getNameKind() == DeclarationName::Identifier) 198 AbbrevToUse = Writer.getDeclTypedefAbbrev(); 199 200 Code = serialization::DECL_TYPEDEF; 201} 202 203void ASTDeclWriter::VisitTypeAliasDecl(TypeAliasDecl *D) { 204 VisitTypedefNameDecl(D); 205 Code = serialization::DECL_TYPEALIAS; 206} 207 208void ASTDeclWriter::VisitTagDecl(TagDecl *D) { 209 VisitRedeclarable(D); 210 VisitTypeDecl(D); 211 Record.push_back(D->getIdentifierNamespace()); 212 Record.push_back((unsigned)D->getTagKind()); // FIXME: stable encoding 213 Record.push_back(D->isCompleteDefinition()); 214 Record.push_back(D->isEmbeddedInDeclarator()); 215 Record.push_back(D->isFreeStanding()); 216 Writer.AddSourceLocation(D->getRBraceLoc(), Record); 217 Record.push_back(D->hasExtInfo()); 218 if (D->hasExtInfo()) 219 Writer.AddQualifierInfo(*D->getExtInfo(), Record); 220 else 221 Writer.AddDeclRef(D->getTypedefNameForAnonDecl(), Record); 222} 223 224void ASTDeclWriter::VisitEnumDecl(EnumDecl *D) { 225 VisitTagDecl(D); 226 Writer.AddTypeSourceInfo(D->getIntegerTypeSourceInfo(), Record); 227 if (!D->getIntegerTypeSourceInfo()) 228 Writer.AddTypeRef(D->getIntegerType(), Record); 229 Writer.AddTypeRef(D->getPromotionType(), Record); 230 Record.push_back(D->getNumPositiveBits()); 231 Record.push_back(D->getNumNegativeBits()); 232 Record.push_back(D->isScoped()); 233 Record.push_back(D->isScopedUsingClassTag()); 234 Record.push_back(D->isFixed()); 235 if (MemberSpecializationInfo *MemberInfo = D->getMemberSpecializationInfo()) { 236 Writer.AddDeclRef(MemberInfo->getInstantiatedFrom(), Record); 237 Record.push_back(MemberInfo->getTemplateSpecializationKind()); 238 Writer.AddSourceLocation(MemberInfo->getPointOfInstantiation(), Record); 239 } else { 240 Writer.AddDeclRef(0, Record); 241 } 242 243 if (!D->hasAttrs() && 244 !D->isImplicit() && 245 !D->isUsed(false) && 246 !D->hasExtInfo() && 247 D->getFirstDeclaration() == D->getMostRecentDecl() && 248 !D->isInvalidDecl() && 249 !D->isReferenced() && 250 !D->isTopLevelDeclInObjCContainer() && 251 D->getAccess() == AS_none && 252 !D->isModulePrivate() && 253 !CXXRecordDecl::classofKind(D->getKind()) && 254 !D->getIntegerTypeSourceInfo() && 255 D->getDeclName().getNameKind() == DeclarationName::Identifier) 256 AbbrevToUse = Writer.getDeclEnumAbbrev(); 257 258 Code = serialization::DECL_ENUM; 259} 260 261void ASTDeclWriter::VisitRecordDecl(RecordDecl *D) { 262 VisitTagDecl(D); 263 Record.push_back(D->hasFlexibleArrayMember()); 264 Record.push_back(D->isAnonymousStructOrUnion()); 265 Record.push_back(D->hasObjectMember()); 266 267 if (!D->hasAttrs() && 268 !D->isImplicit() && 269 !D->isUsed(false) && 270 !D->hasExtInfo() && 271 D->getFirstDeclaration() == D->getMostRecentDecl() && 272 !D->isInvalidDecl() && 273 !D->isReferenced() && 274 !D->isTopLevelDeclInObjCContainer() && 275 D->getAccess() == AS_none && 276 !D->isModulePrivate() && 277 !CXXRecordDecl::classofKind(D->getKind()) && 278 D->getDeclName().getNameKind() == DeclarationName::Identifier) 279 AbbrevToUse = Writer.getDeclRecordAbbrev(); 280 281 Code = serialization::DECL_RECORD; 282} 283 284void ASTDeclWriter::VisitValueDecl(ValueDecl *D) { 285 VisitNamedDecl(D); 286 Writer.AddTypeRef(D->getType(), Record); 287} 288 289void ASTDeclWriter::VisitEnumConstantDecl(EnumConstantDecl *D) { 290 VisitValueDecl(D); 291 Record.push_back(D->getInitExpr()? 1 : 0); 292 if (D->getInitExpr()) 293 Writer.AddStmt(D->getInitExpr()); 294 Writer.AddAPSInt(D->getInitVal(), Record); 295 296 Code = serialization::DECL_ENUM_CONSTANT; 297} 298 299void ASTDeclWriter::VisitDeclaratorDecl(DeclaratorDecl *D) { 300 VisitValueDecl(D); 301 Writer.AddSourceLocation(D->getInnerLocStart(), Record); 302 Record.push_back(D->hasExtInfo()); 303 if (D->hasExtInfo()) 304 Writer.AddQualifierInfo(*D->getExtInfo(), Record); 305} 306 307void ASTDeclWriter::VisitFunctionDecl(FunctionDecl *D) { 308 VisitRedeclarable(D); 309 VisitDeclaratorDecl(D); 310 311 Writer.AddDeclarationNameLoc(D->DNLoc, D->getDeclName(), Record); 312 Record.push_back(D->getIdentifierNamespace()); 313 314 // FunctionDecl's body is handled last at ASTWriterDecl::Visit, 315 // after everything else is written. 316 317 Record.push_back(D->getStorageClass()); // FIXME: stable encoding 318 Record.push_back(D->getStorageClassAsWritten()); 319 Record.push_back(D->IsInline); 320 Record.push_back(D->isInlineSpecified()); 321 Record.push_back(D->isVirtualAsWritten()); 322 Record.push_back(D->isPure()); 323 Record.push_back(D->hasInheritedPrototype()); 324 Record.push_back(D->hasWrittenPrototype()); 325 Record.push_back(D->isDeletedAsWritten()); 326 Record.push_back(D->isTrivial()); 327 Record.push_back(D->isDefaulted()); 328 Record.push_back(D->isExplicitlyDefaulted()); 329 Record.push_back(D->hasImplicitReturnZero()); 330 Record.push_back(D->isConstexpr()); 331 Writer.AddSourceLocation(D->getLocEnd(), Record); 332 333 Record.push_back(D->getTemplatedKind()); 334 switch (D->getTemplatedKind()) { 335 case FunctionDecl::TK_NonTemplate: 336 break; 337 case FunctionDecl::TK_FunctionTemplate: 338 Writer.AddDeclRef(D->getDescribedFunctionTemplate(), Record); 339 break; 340 case FunctionDecl::TK_MemberSpecialization: { 341 MemberSpecializationInfo *MemberInfo = D->getMemberSpecializationInfo(); 342 Writer.AddDeclRef(MemberInfo->getInstantiatedFrom(), Record); 343 Record.push_back(MemberInfo->getTemplateSpecializationKind()); 344 Writer.AddSourceLocation(MemberInfo->getPointOfInstantiation(), Record); 345 break; 346 } 347 case FunctionDecl::TK_FunctionTemplateSpecialization: { 348 FunctionTemplateSpecializationInfo * 349 FTSInfo = D->getTemplateSpecializationInfo(); 350 Writer.AddDeclRef(FTSInfo->getTemplate(), Record); 351 Record.push_back(FTSInfo->getTemplateSpecializationKind()); 352 353 // Template arguments. 354 Writer.AddTemplateArgumentList(FTSInfo->TemplateArguments, Record); 355 356 // Template args as written. 357 Record.push_back(FTSInfo->TemplateArgumentsAsWritten != 0); 358 if (FTSInfo->TemplateArgumentsAsWritten) { 359 Record.push_back(FTSInfo->TemplateArgumentsAsWritten->NumTemplateArgs); 360 for (int i=0, e = FTSInfo->TemplateArgumentsAsWritten->NumTemplateArgs; 361 i!=e; ++i) 362 Writer.AddTemplateArgumentLoc((*FTSInfo->TemplateArgumentsAsWritten)[i], 363 Record); 364 Writer.AddSourceLocation(FTSInfo->TemplateArgumentsAsWritten->LAngleLoc, 365 Record); 366 Writer.AddSourceLocation(FTSInfo->TemplateArgumentsAsWritten->RAngleLoc, 367 Record); 368 } 369 370 Writer.AddSourceLocation(FTSInfo->getPointOfInstantiation(), Record); 371 372 if (D->isCanonicalDecl()) { 373 // Write the template that contains the specializations set. We will 374 // add a FunctionTemplateSpecializationInfo to it when reading. 375 Writer.AddDeclRef(FTSInfo->getTemplate()->getCanonicalDecl(), Record); 376 } 377 break; 378 } 379 case FunctionDecl::TK_DependentFunctionTemplateSpecialization: { 380 DependentFunctionTemplateSpecializationInfo * 381 DFTSInfo = D->getDependentSpecializationInfo(); 382 383 // Templates. 384 Record.push_back(DFTSInfo->getNumTemplates()); 385 for (int i=0, e = DFTSInfo->getNumTemplates(); i != e; ++i) 386 Writer.AddDeclRef(DFTSInfo->getTemplate(i), Record); 387 388 // Templates args. 389 Record.push_back(DFTSInfo->getNumTemplateArgs()); 390 for (int i=0, e = DFTSInfo->getNumTemplateArgs(); i != e; ++i) 391 Writer.AddTemplateArgumentLoc(DFTSInfo->getTemplateArg(i), Record); 392 Writer.AddSourceLocation(DFTSInfo->getLAngleLoc(), Record); 393 Writer.AddSourceLocation(DFTSInfo->getRAngleLoc(), Record); 394 break; 395 } 396 } 397 398 Record.push_back(D->param_size()); 399 for (FunctionDecl::param_iterator P = D->param_begin(), PEnd = D->param_end(); 400 P != PEnd; ++P) 401 Writer.AddDeclRef(*P, Record); 402 Code = serialization::DECL_FUNCTION; 403} 404 405void ASTDeclWriter::VisitObjCMethodDecl(ObjCMethodDecl *D) { 406 VisitNamedDecl(D); 407 // FIXME: convert to LazyStmtPtr? 408 // Unlike C/C++, method bodies will never be in header files. 409 bool HasBodyStuff = D->getBody() != 0 || 410 D->getSelfDecl() != 0 || D->getCmdDecl() != 0; 411 Record.push_back(HasBodyStuff); 412 if (HasBodyStuff) { 413 Writer.AddStmt(D->getBody()); 414 Writer.AddDeclRef(D->getSelfDecl(), Record); 415 Writer.AddDeclRef(D->getCmdDecl(), Record); 416 } 417 Record.push_back(D->isInstanceMethod()); 418 Record.push_back(D->isVariadic()); 419 Record.push_back(D->isPropertyAccessor()); 420 Record.push_back(D->isDefined()); 421 Record.push_back(D->IsOverriding); 422 423 Record.push_back(D->IsRedeclaration); 424 Record.push_back(D->HasRedeclaration); 425 if (D->HasRedeclaration) { 426 assert(Context.getObjCMethodRedeclaration(D)); 427 Writer.AddDeclRef(Context.getObjCMethodRedeclaration(D), Record); 428 } 429 430 // FIXME: stable encoding for @required/@optional 431 Record.push_back(D->getImplementationControl()); 432 // FIXME: stable encoding for in/out/inout/bycopy/byref/oneway 433 Record.push_back(D->getObjCDeclQualifier()); 434 Record.push_back(D->hasRelatedResultType()); 435 Writer.AddTypeRef(D->getResultType(), Record); 436 Writer.AddTypeSourceInfo(D->getResultTypeSourceInfo(), Record); 437 Writer.AddSourceLocation(D->getLocEnd(), Record); 438 Record.push_back(D->param_size()); 439 for (ObjCMethodDecl::param_iterator P = D->param_begin(), 440 PEnd = D->param_end(); P != PEnd; ++P) 441 Writer.AddDeclRef(*P, Record); 442 443 Record.push_back(D->SelLocsKind); 444 unsigned NumStoredSelLocs = D->getNumStoredSelLocs(); 445 SourceLocation *SelLocs = D->getStoredSelLocs(); 446 Record.push_back(NumStoredSelLocs); 447 for (unsigned i = 0; i != NumStoredSelLocs; ++i) 448 Writer.AddSourceLocation(SelLocs[i], Record); 449 450 Code = serialization::DECL_OBJC_METHOD; 451} 452 453void ASTDeclWriter::VisitObjCContainerDecl(ObjCContainerDecl *D) { 454 VisitNamedDecl(D); 455 Writer.AddSourceLocation(D->getAtStartLoc(), Record); 456 Writer.AddSourceRange(D->getAtEndRange(), Record); 457 // Abstract class (no need to define a stable serialization::DECL code). 458} 459 460void ASTDeclWriter::VisitObjCInterfaceDecl(ObjCInterfaceDecl *D) { 461 VisitRedeclarable(D); 462 VisitObjCContainerDecl(D); 463 Writer.AddTypeRef(QualType(D->getTypeForDecl(), 0), Record); 464 465 Record.push_back(D->isThisDeclarationADefinition()); 466 if (D->isThisDeclarationADefinition()) { 467 // Write the DefinitionData 468 ObjCInterfaceDecl::DefinitionData &Data = D->data(); 469 470 Writer.AddDeclRef(D->getSuperClass(), Record); 471 Writer.AddSourceLocation(D->getSuperClassLoc(), Record); 472 Writer.AddSourceLocation(D->getEndOfDefinitionLoc(), Record); 473 474 // Write out the protocols that are directly referenced by the @interface. 475 Record.push_back(Data.ReferencedProtocols.size()); 476 for (ObjCInterfaceDecl::protocol_iterator P = D->protocol_begin(), 477 PEnd = D->protocol_end(); 478 P != PEnd; ++P) 479 Writer.AddDeclRef(*P, Record); 480 for (ObjCInterfaceDecl::protocol_loc_iterator PL = D->protocol_loc_begin(), 481 PLEnd = D->protocol_loc_end(); 482 PL != PLEnd; ++PL) 483 Writer.AddSourceLocation(*PL, Record); 484 485 // Write out the protocols that are transitively referenced. 486 Record.push_back(Data.AllReferencedProtocols.size()); 487 for (ObjCList<ObjCProtocolDecl>::iterator 488 P = Data.AllReferencedProtocols.begin(), 489 PEnd = Data.AllReferencedProtocols.end(); 490 P != PEnd; ++P) 491 Writer.AddDeclRef(*P, Record); 492 493 if (ObjCCategoryDecl *Cat = D->getCategoryList()) { 494 // Ensure that we write out the set of categories for this class. 495 Writer.ObjCClassesWithCategories.insert(D); 496 497 // Make sure that the categories get serialized. 498 for (; Cat; Cat = Cat->getNextClassCategory()) 499 (void)Writer.GetDeclRef(Cat); 500 } 501 } 502 503 Code = serialization::DECL_OBJC_INTERFACE; 504} 505 506void ASTDeclWriter::VisitObjCIvarDecl(ObjCIvarDecl *D) { 507 VisitFieldDecl(D); 508 // FIXME: stable encoding for @public/@private/@protected/@package 509 Record.push_back(D->getAccessControl()); 510 Record.push_back(D->getSynthesize()); 511 512 if (!D->hasAttrs() && 513 !D->isImplicit() && 514 !D->isUsed(false) && 515 !D->isInvalidDecl() && 516 !D->isReferenced() && 517 !D->isModulePrivate() && 518 !D->getBitWidth() && 519 !D->hasExtInfo() && 520 D->getDeclName()) 521 AbbrevToUse = Writer.getDeclObjCIvarAbbrev(); 522 523 Code = serialization::DECL_OBJC_IVAR; 524} 525 526void ASTDeclWriter::VisitObjCProtocolDecl(ObjCProtocolDecl *D) { 527 VisitRedeclarable(D); 528 VisitObjCContainerDecl(D); 529 530 Record.push_back(D->isThisDeclarationADefinition()); 531 if (D->isThisDeclarationADefinition()) { 532 Record.push_back(D->protocol_size()); 533 for (ObjCProtocolDecl::protocol_iterator 534 I = D->protocol_begin(), IEnd = D->protocol_end(); I != IEnd; ++I) 535 Writer.AddDeclRef(*I, Record); 536 for (ObjCProtocolDecl::protocol_loc_iterator PL = D->protocol_loc_begin(), 537 PLEnd = D->protocol_loc_end(); 538 PL != PLEnd; ++PL) 539 Writer.AddSourceLocation(*PL, Record); 540 } 541 542 Code = serialization::DECL_OBJC_PROTOCOL; 543} 544 545void ASTDeclWriter::VisitObjCAtDefsFieldDecl(ObjCAtDefsFieldDecl *D) { 546 VisitFieldDecl(D); 547 Code = serialization::DECL_OBJC_AT_DEFS_FIELD; 548} 549 550void ASTDeclWriter::VisitObjCCategoryDecl(ObjCCategoryDecl *D) { 551 VisitObjCContainerDecl(D); 552 Writer.AddSourceLocation(D->getCategoryNameLoc(), Record); 553 Writer.AddSourceLocation(D->getIvarLBraceLoc(), Record); 554 Writer.AddSourceLocation(D->getIvarRBraceLoc(), Record); 555 Writer.AddDeclRef(D->getClassInterface(), Record); 556 Record.push_back(D->protocol_size()); 557 for (ObjCCategoryDecl::protocol_iterator 558 I = D->protocol_begin(), IEnd = D->protocol_end(); I != IEnd; ++I) 559 Writer.AddDeclRef(*I, Record); 560 for (ObjCCategoryDecl::protocol_loc_iterator 561 PL = D->protocol_loc_begin(), PLEnd = D->protocol_loc_end(); 562 PL != PLEnd; ++PL) 563 Writer.AddSourceLocation(*PL, Record); 564 Code = serialization::DECL_OBJC_CATEGORY; 565} 566 567void ASTDeclWriter::VisitObjCCompatibleAliasDecl(ObjCCompatibleAliasDecl *D) { 568 VisitNamedDecl(D); 569 Writer.AddDeclRef(D->getClassInterface(), Record); 570 Code = serialization::DECL_OBJC_COMPATIBLE_ALIAS; 571} 572 573void ASTDeclWriter::VisitObjCPropertyDecl(ObjCPropertyDecl *D) { 574 VisitNamedDecl(D); 575 Writer.AddSourceLocation(D->getAtLoc(), Record); 576 Writer.AddSourceLocation(D->getLParenLoc(), Record); 577 Writer.AddTypeSourceInfo(D->getTypeSourceInfo(), Record); 578 // FIXME: stable encoding 579 Record.push_back((unsigned)D->getPropertyAttributes()); 580 Record.push_back((unsigned)D->getPropertyAttributesAsWritten()); 581 // FIXME: stable encoding 582 Record.push_back((unsigned)D->getPropertyImplementation()); 583 Writer.AddDeclarationName(D->getGetterName(), Record); 584 Writer.AddDeclarationName(D->getSetterName(), Record); 585 Writer.AddDeclRef(D->getGetterMethodDecl(), Record); 586 Writer.AddDeclRef(D->getSetterMethodDecl(), Record); 587 Writer.AddDeclRef(D->getPropertyIvarDecl(), Record); 588 Code = serialization::DECL_OBJC_PROPERTY; 589} 590 591void ASTDeclWriter::VisitObjCImplDecl(ObjCImplDecl *D) { 592 VisitObjCContainerDecl(D); 593 Writer.AddDeclRef(D->getClassInterface(), Record); 594 // Abstract class (no need to define a stable serialization::DECL code). 595} 596 597void ASTDeclWriter::VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D) { 598 VisitObjCImplDecl(D); 599 Writer.AddIdentifierRef(D->getIdentifier(), Record); 600 Writer.AddSourceLocation(D->getCategoryNameLoc(), Record); 601 Code = serialization::DECL_OBJC_CATEGORY_IMPL; 602} 603 604void ASTDeclWriter::VisitObjCImplementationDecl(ObjCImplementationDecl *D) { 605 VisitObjCImplDecl(D); 606 Writer.AddDeclRef(D->getSuperClass(), Record); 607 Writer.AddSourceLocation(D->getIvarLBraceLoc(), Record); 608 Writer.AddSourceLocation(D->getIvarRBraceLoc(), Record); 609 Record.push_back(D->hasNonZeroConstructors()); 610 Record.push_back(D->hasDestructors()); 611 Writer.AddCXXCtorInitializers(D->IvarInitializers, D->NumIvarInitializers, 612 Record); 613 Code = serialization::DECL_OBJC_IMPLEMENTATION; 614} 615 616void ASTDeclWriter::VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D) { 617 VisitDecl(D); 618 Writer.AddSourceLocation(D->getLocStart(), Record); 619 Writer.AddDeclRef(D->getPropertyDecl(), Record); 620 Writer.AddDeclRef(D->getPropertyIvarDecl(), Record); 621 Writer.AddSourceLocation(D->getPropertyIvarDeclLoc(), Record); 622 Writer.AddStmt(D->getGetterCXXConstructor()); 623 Writer.AddStmt(D->getSetterCXXAssignment()); 624 Code = serialization::DECL_OBJC_PROPERTY_IMPL; 625} 626 627void ASTDeclWriter::VisitFieldDecl(FieldDecl *D) { 628 VisitDeclaratorDecl(D); 629 Record.push_back(D->isMutable()); 630 if (D->InitializerOrBitWidth.getInt() != ICIS_NoInit || 631 D->InitializerOrBitWidth.getPointer()) { 632 Record.push_back(D->InitializerOrBitWidth.getInt() + 1); 633 Writer.AddStmt(D->InitializerOrBitWidth.getPointer()); 634 } else { 635 Record.push_back(0); 636 } 637 if (!D->getDeclName()) 638 Writer.AddDeclRef(Context.getInstantiatedFromUnnamedFieldDecl(D), Record); 639 640 if (!D->hasAttrs() && 641 !D->isImplicit() && 642 !D->isUsed(false) && 643 !D->isInvalidDecl() && 644 !D->isReferenced() && 645 !D->isTopLevelDeclInObjCContainer() && 646 !D->isModulePrivate() && 647 !D->getBitWidth() && 648 !D->hasInClassInitializer() && 649 !D->hasExtInfo() && 650 !ObjCIvarDecl::classofKind(D->getKind()) && 651 !ObjCAtDefsFieldDecl::classofKind(D->getKind()) && 652 D->getDeclName()) 653 AbbrevToUse = Writer.getDeclFieldAbbrev(); 654 655 Code = serialization::DECL_FIELD; 656} 657 658void ASTDeclWriter::VisitIndirectFieldDecl(IndirectFieldDecl *D) { 659 VisitValueDecl(D); 660 Record.push_back(D->getChainingSize()); 661 662 for (IndirectFieldDecl::chain_iterator 663 P = D->chain_begin(), 664 PEnd = D->chain_end(); P != PEnd; ++P) 665 Writer.AddDeclRef(*P, Record); 666 Code = serialization::DECL_INDIRECTFIELD; 667} 668 669void ASTDeclWriter::VisitVarDecl(VarDecl *D) { 670 VisitRedeclarable(D); 671 VisitDeclaratorDecl(D); 672 Record.push_back(D->getStorageClass()); // FIXME: stable encoding 673 Record.push_back(D->getStorageClassAsWritten()); 674 Record.push_back(D->isThreadSpecified()); 675 Record.push_back(D->getInitStyle()); 676 Record.push_back(D->isExceptionVariable()); 677 Record.push_back(D->isNRVOVariable()); 678 Record.push_back(D->isCXXForRangeDecl()); 679 Record.push_back(D->isARCPseudoStrong()); 680 Record.push_back(D->isConstexpr()); 681 682 if (D->getInit()) { 683 Record.push_back(!D->isInitKnownICE() ? 1 : (D->isInitICE() ? 3 : 2)); 684 Writer.AddStmt(D->getInit()); 685 } else { 686 Record.push_back(0); 687 } 688 689 MemberSpecializationInfo *SpecInfo 690 = D->isStaticDataMember() ? D->getMemberSpecializationInfo() : 0; 691 Record.push_back(SpecInfo != 0); 692 if (SpecInfo) { 693 Writer.AddDeclRef(SpecInfo->getInstantiatedFrom(), Record); 694 Record.push_back(SpecInfo->getTemplateSpecializationKind()); 695 Writer.AddSourceLocation(SpecInfo->getPointOfInstantiation(), Record); 696 } 697 698 if (!D->hasAttrs() && 699 !D->isImplicit() && 700 !D->isUsed(false) && 701 !D->isInvalidDecl() && 702 !D->isReferenced() && 703 !D->isTopLevelDeclInObjCContainer() && 704 D->getAccess() == AS_none && 705 !D->isModulePrivate() && 706 D->getDeclName().getNameKind() == DeclarationName::Identifier && 707 !D->hasExtInfo() && 708 D->getFirstDeclaration() == D->getMostRecentDecl() && 709 D->getInitStyle() == VarDecl::CInit && 710 D->getInit() == 0 && 711 !isa<ParmVarDecl>(D) && 712 !D->isConstexpr() && 713 !SpecInfo) 714 AbbrevToUse = Writer.getDeclVarAbbrev(); 715 716 Code = serialization::DECL_VAR; 717} 718 719void ASTDeclWriter::VisitImplicitParamDecl(ImplicitParamDecl *D) { 720 VisitVarDecl(D); 721 Code = serialization::DECL_IMPLICIT_PARAM; 722} 723 724void ASTDeclWriter::VisitParmVarDecl(ParmVarDecl *D) { 725 VisitVarDecl(D); 726 Record.push_back(D->isObjCMethodParameter()); 727 Record.push_back(D->getFunctionScopeDepth()); 728 Record.push_back(D->getFunctionScopeIndex()); 729 Record.push_back(D->getObjCDeclQualifier()); // FIXME: stable encoding 730 Record.push_back(D->isKNRPromoted()); 731 Record.push_back(D->hasInheritedDefaultArg()); 732 Record.push_back(D->hasUninstantiatedDefaultArg()); 733 if (D->hasUninstantiatedDefaultArg()) 734 Writer.AddStmt(D->getUninstantiatedDefaultArg()); 735 Code = serialization::DECL_PARM_VAR; 736 737 assert(!D->isARCPseudoStrong()); // can be true of ImplicitParamDecl 738 739 // If the assumptions about the DECL_PARM_VAR abbrev are true, use it. Here 740 // we dynamically check for the properties that we optimize for, but don't 741 // know are true of all PARM_VAR_DECLs. 742 if (!D->hasAttrs() && 743 !D->hasExtInfo() && 744 !D->isImplicit() && 745 !D->isUsed(false) && 746 !D->isInvalidDecl() && 747 !D->isReferenced() && 748 D->getAccess() == AS_none && 749 !D->isModulePrivate() && 750 D->getStorageClass() == 0 && 751 D->getInitStyle() == VarDecl::CInit && // Can params have anything else? 752 D->getFunctionScopeDepth() == 0 && 753 D->getObjCDeclQualifier() == 0 && 754 !D->isKNRPromoted() && 755 !D->hasInheritedDefaultArg() && 756 D->getInit() == 0 && 757 !D->hasUninstantiatedDefaultArg()) // No default expr. 758 AbbrevToUse = Writer.getDeclParmVarAbbrev(); 759 760 // Check things we know are true of *every* PARM_VAR_DECL, which is more than 761 // just us assuming it. 762 assert(!D->isThreadSpecified() && "PARM_VAR_DECL can't be __thread"); 763 assert(D->getAccess() == AS_none && "PARM_VAR_DECL can't be public/private"); 764 assert(!D->isExceptionVariable() && "PARM_VAR_DECL can't be exception var"); 765 assert(D->getPreviousDecl() == 0 && "PARM_VAR_DECL can't be redecl"); 766 assert(!D->isStaticDataMember() && 767 "PARM_VAR_DECL can't be static data member"); 768} 769 770void ASTDeclWriter::VisitFileScopeAsmDecl(FileScopeAsmDecl *D) { 771 VisitDecl(D); 772 Writer.AddStmt(D->getAsmString()); 773 Writer.AddSourceLocation(D->getRParenLoc(), Record); 774 Code = serialization::DECL_FILE_SCOPE_ASM; 775} 776 777void ASTDeclWriter::VisitBlockDecl(BlockDecl *D) { 778 VisitDecl(D); 779 Writer.AddStmt(D->getBody()); 780 Writer.AddTypeSourceInfo(D->getSignatureAsWritten(), Record); 781 Record.push_back(D->param_size()); 782 for (FunctionDecl::param_iterator P = D->param_begin(), PEnd = D->param_end(); 783 P != PEnd; ++P) 784 Writer.AddDeclRef(*P, Record); 785 Record.push_back(D->isVariadic()); 786 Record.push_back(D->blockMissingReturnType()); 787 Record.push_back(D->isConversionFromLambda()); 788 Record.push_back(D->capturesCXXThis()); 789 Record.push_back(D->getNumCaptures()); 790 for (BlockDecl::capture_iterator 791 i = D->capture_begin(), e = D->capture_end(); i != e; ++i) { 792 const BlockDecl::Capture &capture = *i; 793 Writer.AddDeclRef(capture.getVariable(), Record); 794 795 unsigned flags = 0; 796 if (capture.isByRef()) flags |= 1; 797 if (capture.isNested()) flags |= 2; 798 if (capture.hasCopyExpr()) flags |= 4; 799 Record.push_back(flags); 800 801 if (capture.hasCopyExpr()) Writer.AddStmt(capture.getCopyExpr()); 802 } 803 804 Code = serialization::DECL_BLOCK; 805} 806 807void ASTDeclWriter::VisitLinkageSpecDecl(LinkageSpecDecl *D) { 808 VisitDecl(D); 809 Record.push_back(D->getLanguage()); 810 Writer.AddSourceLocation(D->getExternLoc(), Record); 811 Writer.AddSourceLocation(D->getRBraceLoc(), Record); 812 Code = serialization::DECL_LINKAGE_SPEC; 813} 814 815void ASTDeclWriter::VisitLabelDecl(LabelDecl *D) { 816 VisitNamedDecl(D); 817 Writer.AddSourceLocation(D->getLocStart(), Record); 818 Code = serialization::DECL_LABEL; 819} 820 821 822void ASTDeclWriter::VisitNamespaceDecl(NamespaceDecl *D) { 823 VisitRedeclarable(D); 824 VisitNamedDecl(D); 825 Record.push_back(D->isInline()); 826 Writer.AddSourceLocation(D->getLocStart(), Record); 827 Writer.AddSourceLocation(D->getRBraceLoc(), Record); 828 829 if (D->isOriginalNamespace()) 830 Writer.AddDeclRef(D->getAnonymousNamespace(), Record); 831 Code = serialization::DECL_NAMESPACE; 832 833 if (Writer.hasChain() && !D->isOriginalNamespace() && 834 D->getOriginalNamespace()->isFromASTFile()) { 835 NamespaceDecl *NS = D->getOriginalNamespace(); 836 Writer.AddUpdatedDeclContext(NS); 837 838 // Make sure all visible decls are written. They will be recorded later. 839 if (StoredDeclsMap *Map = NS->buildLookup()) { 840 for (StoredDeclsMap::iterator D = Map->begin(), DEnd = Map->end(); 841 D != DEnd; ++D) { 842 DeclContext::lookup_result Result = D->second.getLookupResult(); 843 while (Result.first != Result.second) { 844 Writer.GetDeclRef(*Result.first); 845 ++Result.first; 846 } 847 } 848 } 849 } 850 851 if (Writer.hasChain() && D->isAnonymousNamespace() && 852 D == D->getMostRecentDecl()) { 853 // This is a most recent reopening of the anonymous namespace. If its parent 854 // is in a previous PCH (or is the TU), mark that parent for update, because 855 // the original namespace always points to the latest re-opening of its 856 // anonymous namespace. 857 Decl *Parent = cast<Decl>( 858 D->getParent()->getRedeclContext()->getPrimaryContext()); 859 if (Parent->isFromASTFile() || isa<TranslationUnitDecl>(Parent)) { 860 ASTWriter::UpdateRecord &Record = Writer.DeclUpdates[Parent]; 861 Record.push_back(UPD_CXX_ADDED_ANONYMOUS_NAMESPACE); 862 Writer.AddDeclRef(D, Record); 863 } 864 } 865} 866 867void ASTDeclWriter::VisitNamespaceAliasDecl(NamespaceAliasDecl *D) { 868 VisitNamedDecl(D); 869 Writer.AddSourceLocation(D->getNamespaceLoc(), Record); 870 Writer.AddSourceLocation(D->getTargetNameLoc(), Record); 871 Writer.AddNestedNameSpecifierLoc(D->getQualifierLoc(), Record); 872 Writer.AddDeclRef(D->getNamespace(), Record); 873 Code = serialization::DECL_NAMESPACE_ALIAS; 874} 875 876void ASTDeclWriter::VisitUsingDecl(UsingDecl *D) { 877 VisitNamedDecl(D); 878 Writer.AddSourceLocation(D->getUsingLocation(), Record); 879 Writer.AddNestedNameSpecifierLoc(D->getQualifierLoc(), Record); 880 Writer.AddDeclarationNameLoc(D->DNLoc, D->getDeclName(), Record); 881 Writer.AddDeclRef(D->FirstUsingShadow.getPointer(), Record); 882 Record.push_back(D->isTypeName()); 883 Writer.AddDeclRef(Context.getInstantiatedFromUsingDecl(D), Record); 884 Code = serialization::DECL_USING; 885} 886 887void ASTDeclWriter::VisitUsingShadowDecl(UsingShadowDecl *D) { 888 VisitNamedDecl(D); 889 Writer.AddDeclRef(D->getTargetDecl(), Record); 890 Writer.AddDeclRef(D->UsingOrNextShadow, Record); 891 Writer.AddDeclRef(Context.getInstantiatedFromUsingShadowDecl(D), Record); 892 Code = serialization::DECL_USING_SHADOW; 893} 894 895void ASTDeclWriter::VisitUsingDirectiveDecl(UsingDirectiveDecl *D) { 896 VisitNamedDecl(D); 897 Writer.AddSourceLocation(D->getUsingLoc(), Record); 898 Writer.AddSourceLocation(D->getNamespaceKeyLocation(), Record); 899 Writer.AddNestedNameSpecifierLoc(D->getQualifierLoc(), Record); 900 Writer.AddDeclRef(D->getNominatedNamespace(), Record); 901 Writer.AddDeclRef(dyn_cast<Decl>(D->getCommonAncestor()), Record); 902 Code = serialization::DECL_USING_DIRECTIVE; 903} 904 905void ASTDeclWriter::VisitUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *D) { 906 VisitValueDecl(D); 907 Writer.AddSourceLocation(D->getUsingLoc(), Record); 908 Writer.AddNestedNameSpecifierLoc(D->getQualifierLoc(), Record); 909 Writer.AddDeclarationNameLoc(D->DNLoc, D->getDeclName(), Record); 910 Code = serialization::DECL_UNRESOLVED_USING_VALUE; 911} 912 913void ASTDeclWriter::VisitUnresolvedUsingTypenameDecl( 914 UnresolvedUsingTypenameDecl *D) { 915 VisitTypeDecl(D); 916 Writer.AddSourceLocation(D->getTypenameLoc(), Record); 917 Writer.AddNestedNameSpecifierLoc(D->getQualifierLoc(), Record); 918 Code = serialization::DECL_UNRESOLVED_USING_TYPENAME; 919} 920 921void ASTDeclWriter::VisitCXXRecordDecl(CXXRecordDecl *D) { 922 VisitRecordDecl(D); 923 Record.push_back(D->isThisDeclarationADefinition()); 924 if (D->isThisDeclarationADefinition()) 925 Writer.AddCXXDefinitionData(D, Record); 926 927 enum { 928 CXXRecNotTemplate = 0, CXXRecTemplate, CXXRecMemberSpecialization 929 }; 930 if (ClassTemplateDecl *TemplD = D->getDescribedClassTemplate()) { 931 Record.push_back(CXXRecTemplate); 932 Writer.AddDeclRef(TemplD, Record); 933 } else if (MemberSpecializationInfo *MSInfo 934 = D->getMemberSpecializationInfo()) { 935 Record.push_back(CXXRecMemberSpecialization); 936 Writer.AddDeclRef(MSInfo->getInstantiatedFrom(), Record); 937 Record.push_back(MSInfo->getTemplateSpecializationKind()); 938 Writer.AddSourceLocation(MSInfo->getPointOfInstantiation(), Record); 939 } else { 940 Record.push_back(CXXRecNotTemplate); 941 } 942 943 // Store the key function to avoid deserializing every method so we can 944 // compute it. 945 if (D->IsCompleteDefinition) 946 Writer.AddDeclRef(Context.getKeyFunction(D), Record); 947 948 Code = serialization::DECL_CXX_RECORD; 949} 950 951void ASTDeclWriter::VisitCXXMethodDecl(CXXMethodDecl *D) { 952 VisitFunctionDecl(D); 953 if (D->isCanonicalDecl()) { 954 Record.push_back(D->size_overridden_methods()); 955 for (CXXMethodDecl::method_iterator 956 I = D->begin_overridden_methods(), E = D->end_overridden_methods(); 957 I != E; ++I) 958 Writer.AddDeclRef(*I, Record); 959 } else { 960 // We only need to record overridden methods once for the canonical decl. 961 Record.push_back(0); 962 } 963 Code = serialization::DECL_CXX_METHOD; 964} 965 966void ASTDeclWriter::VisitCXXConstructorDecl(CXXConstructorDecl *D) { 967 VisitCXXMethodDecl(D); 968 969 Record.push_back(D->IsExplicitSpecified); 970 Record.push_back(D->ImplicitlyDefined); 971 Writer.AddCXXCtorInitializers(D->CtorInitializers, D->NumCtorInitializers, 972 Record); 973 974 Code = serialization::DECL_CXX_CONSTRUCTOR; 975} 976 977void ASTDeclWriter::VisitCXXDestructorDecl(CXXDestructorDecl *D) { 978 VisitCXXMethodDecl(D); 979 980 Record.push_back(D->ImplicitlyDefined); 981 Writer.AddDeclRef(D->OperatorDelete, Record); 982 983 Code = serialization::DECL_CXX_DESTRUCTOR; 984} 985 986void ASTDeclWriter::VisitCXXConversionDecl(CXXConversionDecl *D) { 987 VisitCXXMethodDecl(D); 988 Record.push_back(D->IsExplicitSpecified); 989 Code = serialization::DECL_CXX_CONVERSION; 990} 991 992void ASTDeclWriter::VisitImportDecl(ImportDecl *D) { 993 VisitDecl(D); 994 Record.push_back(Writer.getSubmoduleID(D->getImportedModule())); 995 ArrayRef<SourceLocation> IdentifierLocs = D->getIdentifierLocs(); 996 Record.push_back(!IdentifierLocs.empty()); 997 if (IdentifierLocs.empty()) { 998 Writer.AddSourceLocation(D->getLocEnd(), Record); 999 Record.push_back(1); 1000 } else { 1001 for (unsigned I = 0, N = IdentifierLocs.size(); I != N; ++I) 1002 Writer.AddSourceLocation(IdentifierLocs[I], Record); 1003 Record.push_back(IdentifierLocs.size()); 1004 } 1005 // Note: the number of source locations must always be the last element in 1006 // the record. 1007 Code = serialization::DECL_IMPORT; 1008} 1009 1010void ASTDeclWriter::VisitAccessSpecDecl(AccessSpecDecl *D) { 1011 VisitDecl(D); 1012 Writer.AddSourceLocation(D->getColonLoc(), Record); 1013 Code = serialization::DECL_ACCESS_SPEC; 1014} 1015 1016void ASTDeclWriter::VisitFriendDecl(FriendDecl *D) { 1017 VisitDecl(D); 1018 Record.push_back(D->Friend.is<TypeSourceInfo*>()); 1019 if (D->Friend.is<TypeSourceInfo*>()) 1020 Writer.AddTypeSourceInfo(D->Friend.get<TypeSourceInfo*>(), Record); 1021 else 1022 Writer.AddDeclRef(D->Friend.get<NamedDecl*>(), Record); 1023 Writer.AddDeclRef(D->getNextFriend(), Record); 1024 Record.push_back(D->UnsupportedFriend); 1025 Writer.AddSourceLocation(D->FriendLoc, Record); 1026 Code = serialization::DECL_FRIEND; 1027} 1028 1029void ASTDeclWriter::VisitFriendTemplateDecl(FriendTemplateDecl *D) { 1030 VisitDecl(D); 1031 Record.push_back(D->getNumTemplateParameters()); 1032 for (unsigned i = 0, e = D->getNumTemplateParameters(); i != e; ++i) 1033 Writer.AddTemplateParameterList(D->getTemplateParameterList(i), Record); 1034 Record.push_back(D->getFriendDecl() != 0); 1035 if (D->getFriendDecl()) 1036 Writer.AddDeclRef(D->getFriendDecl(), Record); 1037 else 1038 Writer.AddTypeSourceInfo(D->getFriendType(), Record); 1039 Writer.AddSourceLocation(D->getFriendLoc(), Record); 1040 Code = serialization::DECL_FRIEND_TEMPLATE; 1041} 1042 1043void ASTDeclWriter::VisitTemplateDecl(TemplateDecl *D) { 1044 VisitNamedDecl(D); 1045 1046 Writer.AddDeclRef(D->getTemplatedDecl(), Record); 1047 Writer.AddTemplateParameterList(D->getTemplateParameters(), Record); 1048} 1049 1050void ASTDeclWriter::VisitRedeclarableTemplateDecl(RedeclarableTemplateDecl *D) { 1051 VisitRedeclarable(D); 1052 1053 // Emit data to initialize CommonOrPrev before VisitTemplateDecl so that 1054 // getCommonPtr() can be used while this is still initializing. 1055 if (D->isFirstDeclaration()) { 1056 // This declaration owns the 'common' pointer, so serialize that data now. 1057 Writer.AddDeclRef(D->getInstantiatedFromMemberTemplate(), Record); 1058 if (D->getInstantiatedFromMemberTemplate()) 1059 Record.push_back(D->isMemberSpecialization()); 1060 } 1061 1062 VisitTemplateDecl(D); 1063 Record.push_back(D->getIdentifierNamespace()); 1064} 1065 1066void ASTDeclWriter::VisitClassTemplateDecl(ClassTemplateDecl *D) { 1067 VisitRedeclarableTemplateDecl(D); 1068 1069 if (D->isFirstDeclaration()) { 1070 typedef llvm::FoldingSetVector<ClassTemplateSpecializationDecl> CTSDSetTy; 1071 CTSDSetTy &CTSDSet = D->getSpecializations(); 1072 Record.push_back(CTSDSet.size()); 1073 for (CTSDSetTy::iterator I=CTSDSet.begin(), E = CTSDSet.end(); I!=E; ++I) { 1074 assert(I->isCanonicalDecl() && "Expected only canonical decls in set"); 1075 Writer.AddDeclRef(&*I, Record); 1076 } 1077 1078 typedef llvm::FoldingSetVector<ClassTemplatePartialSpecializationDecl> 1079 CTPSDSetTy; 1080 CTPSDSetTy &CTPSDSet = D->getPartialSpecializations(); 1081 Record.push_back(CTPSDSet.size()); 1082 for (CTPSDSetTy::iterator I=CTPSDSet.begin(), E=CTPSDSet.end(); I!=E; ++I) { 1083 assert(I->isCanonicalDecl() && "Expected only canonical decls in set"); 1084 Writer.AddDeclRef(&*I, Record); 1085 } 1086 1087 Writer.AddTypeRef(D->getCommonPtr()->InjectedClassNameType, Record); 1088 } 1089 Code = serialization::DECL_CLASS_TEMPLATE; 1090} 1091 1092void ASTDeclWriter::VisitClassTemplateSpecializationDecl( 1093 ClassTemplateSpecializationDecl *D) { 1094 VisitCXXRecordDecl(D); 1095 1096 llvm::PointerUnion<ClassTemplateDecl *, 1097 ClassTemplatePartialSpecializationDecl *> InstFrom 1098 = D->getSpecializedTemplateOrPartial(); 1099 if (Decl *InstFromD = InstFrom.dyn_cast<ClassTemplateDecl *>()) { 1100 Writer.AddDeclRef(InstFromD, Record); 1101 } else { 1102 Writer.AddDeclRef(InstFrom.get<ClassTemplatePartialSpecializationDecl *>(), 1103 Record); 1104 Writer.AddTemplateArgumentList(&D->getTemplateInstantiationArgs(), Record); 1105 } 1106 1107 // Explicit info. 1108 Writer.AddTypeSourceInfo(D->getTypeAsWritten(), Record); 1109 if (D->getTypeAsWritten()) { 1110 Writer.AddSourceLocation(D->getExternLoc(), Record); 1111 Writer.AddSourceLocation(D->getTemplateKeywordLoc(), Record); 1112 } 1113 1114 Writer.AddTemplateArgumentList(&D->getTemplateArgs(), Record); 1115 Writer.AddSourceLocation(D->getPointOfInstantiation(), Record); 1116 Record.push_back(D->getSpecializationKind()); 1117 Record.push_back(D->isCanonicalDecl()); 1118 1119 if (D->isCanonicalDecl()) { 1120 // When reading, we'll add it to the folding set of the following template. 1121 Writer.AddDeclRef(D->getSpecializedTemplate()->getCanonicalDecl(), Record); 1122 } 1123 1124 Code = serialization::DECL_CLASS_TEMPLATE_SPECIALIZATION; 1125} 1126 1127void ASTDeclWriter::VisitClassTemplatePartialSpecializationDecl( 1128 ClassTemplatePartialSpecializationDecl *D) { 1129 VisitClassTemplateSpecializationDecl(D); 1130 1131 Writer.AddTemplateParameterList(D->getTemplateParameters(), Record); 1132 1133 Record.push_back(D->getNumTemplateArgsAsWritten()); 1134 for (int i = 0, e = D->getNumTemplateArgsAsWritten(); i != e; ++i) 1135 Writer.AddTemplateArgumentLoc(D->getTemplateArgsAsWritten()[i], Record); 1136 1137 Record.push_back(D->getSequenceNumber()); 1138 1139 // These are read/set from/to the first declaration. 1140 if (D->getPreviousDecl() == 0) { 1141 Writer.AddDeclRef(D->getInstantiatedFromMember(), Record); 1142 Record.push_back(D->isMemberSpecialization()); 1143 } 1144 1145 Code = serialization::DECL_CLASS_TEMPLATE_PARTIAL_SPECIALIZATION; 1146} 1147 1148void ASTDeclWriter::VisitClassScopeFunctionSpecializationDecl( 1149 ClassScopeFunctionSpecializationDecl *D) { 1150 VisitDecl(D); 1151 Writer.AddDeclRef(D->getSpecialization(), Record); 1152 Code = serialization::DECL_CLASS_SCOPE_FUNCTION_SPECIALIZATION; 1153} 1154 1155 1156void ASTDeclWriter::VisitFunctionTemplateDecl(FunctionTemplateDecl *D) { 1157 VisitRedeclarableTemplateDecl(D); 1158 1159 if (D->isFirstDeclaration()) { 1160 // This FunctionTemplateDecl owns the CommonPtr; write it. 1161 1162 // Write the function specialization declarations. 1163 Record.push_back(D->getSpecializations().size()); 1164 for (llvm::FoldingSetVector<FunctionTemplateSpecializationInfo>::iterator 1165 I = D->getSpecializations().begin(), 1166 E = D->getSpecializations().end() ; I != E; ++I) { 1167 assert(I->Function->isCanonicalDecl() && 1168 "Expected only canonical decls in set"); 1169 Writer.AddDeclRef(I->Function, Record); 1170 } 1171 } 1172 Code = serialization::DECL_FUNCTION_TEMPLATE; 1173} 1174 1175void ASTDeclWriter::VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D) { 1176 VisitTypeDecl(D); 1177 1178 Record.push_back(D->wasDeclaredWithTypename()); 1179 Record.push_back(D->defaultArgumentWasInherited()); 1180 Writer.AddTypeSourceInfo(D->getDefaultArgumentInfo(), Record); 1181 1182 Code = serialization::DECL_TEMPLATE_TYPE_PARM; 1183} 1184 1185void ASTDeclWriter::VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D) { 1186 // For an expanded parameter pack, record the number of expansion types here 1187 // so that it's easier for deserialization to allocate the right amount of 1188 // memory. 1189 if (D->isExpandedParameterPack()) 1190 Record.push_back(D->getNumExpansionTypes()); 1191 1192 VisitDeclaratorDecl(D); 1193 // TemplateParmPosition. 1194 Record.push_back(D->getDepth()); 1195 Record.push_back(D->getPosition()); 1196 1197 if (D->isExpandedParameterPack()) { 1198 for (unsigned I = 0, N = D->getNumExpansionTypes(); I != N; ++I) { 1199 Writer.AddTypeRef(D->getExpansionType(I), Record); 1200 Writer.AddTypeSourceInfo(D->getExpansionTypeSourceInfo(I), Record); 1201 } 1202 1203 Code = serialization::DECL_EXPANDED_NON_TYPE_TEMPLATE_PARM_PACK; 1204 } else { 1205 // Rest of NonTypeTemplateParmDecl. 1206 Record.push_back(D->isParameterPack()); 1207 Record.push_back(D->getDefaultArgument() != 0); 1208 if (D->getDefaultArgument()) { 1209 Writer.AddStmt(D->getDefaultArgument()); 1210 Record.push_back(D->defaultArgumentWasInherited()); 1211 } 1212 Code = serialization::DECL_NON_TYPE_TEMPLATE_PARM; 1213 } 1214} 1215 1216void ASTDeclWriter::VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D) { 1217 // For an expanded parameter pack, record the number of expansion types here 1218 // so that it's easier for deserialization to allocate the right amount of 1219 // memory. 1220 if (D->isExpandedParameterPack()) 1221 Record.push_back(D->getNumExpansionTemplateParameters()); 1222 1223 VisitTemplateDecl(D); 1224 // TemplateParmPosition. 1225 Record.push_back(D->getDepth()); 1226 Record.push_back(D->getPosition()); 1227 1228 if (D->isExpandedParameterPack()) { 1229 for (unsigned I = 0, N = D->getNumExpansionTemplateParameters(); 1230 I != N; ++I) 1231 Writer.AddTemplateParameterList(D->getExpansionTemplateParameters(I), 1232 Record); 1233 Code = serialization::DECL_EXPANDED_TEMPLATE_TEMPLATE_PARM_PACK; 1234 } else { 1235 // Rest of TemplateTemplateParmDecl. 1236 Writer.AddTemplateArgumentLoc(D->getDefaultArgument(), Record); 1237 Record.push_back(D->defaultArgumentWasInherited()); 1238 Record.push_back(D->isParameterPack()); 1239 Code = serialization::DECL_TEMPLATE_TEMPLATE_PARM; 1240 } 1241} 1242 1243void ASTDeclWriter::VisitTypeAliasTemplateDecl(TypeAliasTemplateDecl *D) { 1244 VisitRedeclarableTemplateDecl(D); 1245 Code = serialization::DECL_TYPE_ALIAS_TEMPLATE; 1246} 1247 1248void ASTDeclWriter::VisitStaticAssertDecl(StaticAssertDecl *D) { 1249 VisitDecl(D); 1250 Writer.AddStmt(D->getAssertExpr()); 1251 Record.push_back(D->isFailed()); 1252 Writer.AddStmt(D->getMessage()); 1253 Writer.AddSourceLocation(D->getRParenLoc(), Record); 1254 Code = serialization::DECL_STATIC_ASSERT; 1255} 1256 1257/// \brief Emit the DeclContext part of a declaration context decl. 1258/// 1259/// \param LexicalOffset the offset at which the DECL_CONTEXT_LEXICAL 1260/// block for this declaration context is stored. May be 0 to indicate 1261/// that there are no declarations stored within this context. 1262/// 1263/// \param VisibleOffset the offset at which the DECL_CONTEXT_VISIBLE 1264/// block for this declaration context is stored. May be 0 to indicate 1265/// that there are no declarations visible from this context. Note 1266/// that this value will not be emitted for non-primary declaration 1267/// contexts. 1268void ASTDeclWriter::VisitDeclContext(DeclContext *DC, uint64_t LexicalOffset, 1269 uint64_t VisibleOffset) { 1270 Record.push_back(LexicalOffset); 1271 Record.push_back(VisibleOffset); 1272} 1273 1274template <typename T> 1275void ASTDeclWriter::VisitRedeclarable(Redeclarable<T> *D) { 1276 T *First = D->getFirstDeclaration(); 1277 if (First->getMostRecentDecl() != First) { 1278 // There is more than one declaration of this entity, so we will need to 1279 // write a redeclaration chain. 1280 Writer.AddDeclRef(First, Record); 1281 Writer.Redeclarations.insert(First); 1282 1283 // Make sure that we serialize both the previous and the most-recent 1284 // declarations, which (transitively) ensures that all declarations in the 1285 // chain get serialized. 1286 (void)Writer.GetDeclRef(D->getPreviousDecl()); 1287 (void)Writer.GetDeclRef(First->getMostRecentDecl()); 1288 } else { 1289 // We use the sentinel value 0 to indicate an only declaration. 1290 Record.push_back(0); 1291 } 1292 1293} 1294 1295//===----------------------------------------------------------------------===// 1296// ASTWriter Implementation 1297//===----------------------------------------------------------------------===// 1298 1299void ASTWriter::WriteDeclsBlockAbbrevs() { 1300 using namespace llvm; 1301 1302 BitCodeAbbrev *Abv; 1303 1304 // Abbreviation for DECL_FIELD 1305 Abv = new BitCodeAbbrev(); 1306 Abv->Add(BitCodeAbbrevOp(serialization::DECL_FIELD)); 1307 // Decl 1308 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclContext 1309 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // LexicalDeclContext 1310 Abv->Add(BitCodeAbbrevOp(0)); // isInvalidDecl 1311 Abv->Add(BitCodeAbbrevOp(0)); // HasAttrs 1312 Abv->Add(BitCodeAbbrevOp(0)); // isImplicit 1313 Abv->Add(BitCodeAbbrevOp(0)); // isUsed 1314 Abv->Add(BitCodeAbbrevOp(0)); // isReferenced 1315 Abv->Add(BitCodeAbbrevOp(0)); // TopLevelDeclInObjCContainer 1316 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2)); // AccessSpecifier 1317 Abv->Add(BitCodeAbbrevOp(0)); // ModulePrivate 1318 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SubmoduleID 1319 // NamedDecl 1320 Abv->Add(BitCodeAbbrevOp(0)); // NameKind = Identifier 1321 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Name 1322 // ValueDecl 1323 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type 1324 // DeclaratorDecl 1325 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // InnerStartLoc 1326 Abv->Add(BitCodeAbbrevOp(0)); // hasExtInfo 1327 // FieldDecl 1328 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isMutable 1329 Abv->Add(BitCodeAbbrevOp(0)); //getBitWidth 1330 // Type Source Info 1331 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); 1332 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array)); 1333 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // TypeLoc 1334 DeclFieldAbbrev = Stream.EmitAbbrev(Abv); 1335 1336 // Abbreviation for DECL_OBJC_IVAR 1337 Abv = new BitCodeAbbrev(); 1338 Abv->Add(BitCodeAbbrevOp(serialization::DECL_OBJC_IVAR)); 1339 // Decl 1340 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclContext 1341 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // LexicalDeclContext 1342 Abv->Add(BitCodeAbbrevOp(0)); // isInvalidDecl 1343 Abv->Add(BitCodeAbbrevOp(0)); // HasAttrs 1344 Abv->Add(BitCodeAbbrevOp(0)); // isImplicit 1345 Abv->Add(BitCodeAbbrevOp(0)); // isUsed 1346 Abv->Add(BitCodeAbbrevOp(0)); // isReferenced 1347 Abv->Add(BitCodeAbbrevOp(0)); // TopLevelDeclInObjCContainer 1348 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2)); // AccessSpecifier 1349 Abv->Add(BitCodeAbbrevOp(0)); // ModulePrivate 1350 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SubmoduleID 1351 // NamedDecl 1352 Abv->Add(BitCodeAbbrevOp(0)); // NameKind = Identifier 1353 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Name 1354 // ValueDecl 1355 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type 1356 // DeclaratorDecl 1357 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // InnerStartLoc 1358 Abv->Add(BitCodeAbbrevOp(0)); // hasExtInfo 1359 // FieldDecl 1360 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isMutable 1361 Abv->Add(BitCodeAbbrevOp(0)); //getBitWidth 1362 // ObjC Ivar 1363 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // getAccessControl 1364 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // getSynthesize 1365 // Type Source Info 1366 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); 1367 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array)); 1368 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // TypeLoc 1369 DeclObjCIvarAbbrev = Stream.EmitAbbrev(Abv); 1370 1371 // Abbreviation for DECL_ENUM 1372 Abv = new BitCodeAbbrev(); 1373 Abv->Add(BitCodeAbbrevOp(serialization::DECL_ENUM)); 1374 // Redeclarable 1375 Abv->Add(BitCodeAbbrevOp(0)); // No redeclaration 1376 // Decl 1377 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclContext 1378 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // LexicalDeclContext 1379 Abv->Add(BitCodeAbbrevOp(0)); // isInvalidDecl 1380 Abv->Add(BitCodeAbbrevOp(0)); // HasAttrs 1381 Abv->Add(BitCodeAbbrevOp(0)); // isImplicit 1382 Abv->Add(BitCodeAbbrevOp(0)); // isUsed 1383 Abv->Add(BitCodeAbbrevOp(0)); // isReferenced 1384 Abv->Add(BitCodeAbbrevOp(0)); // TopLevelDeclInObjCContainer 1385 Abv->Add(BitCodeAbbrevOp(AS_none)); // C++ AccessSpecifier 1386 Abv->Add(BitCodeAbbrevOp(0)); // ModulePrivate 1387 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SubmoduleID 1388 // NamedDecl 1389 Abv->Add(BitCodeAbbrevOp(0)); // NameKind = Identifier 1390 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Name 1391 // TypeDecl 1392 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Source Location 1393 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type Ref 1394 // TagDecl 1395 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // IdentifierNamespace 1396 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // getTagKind 1397 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isCompleteDefinition 1398 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // EmbeddedInDeclarator 1399 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsFreeStanding 1400 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SourceLocation 1401 Abv->Add(BitCodeAbbrevOp(0)); // hasExtInfo 1402 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // TypedefNameAnonDecl 1403 // EnumDecl 1404 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // AddTypeRef 1405 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // IntegerType 1406 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // getPromotionType 1407 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // getNumPositiveBits 1408 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // getNumNegativeBits 1409 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isScoped 1410 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isScopedUsingClassTag 1411 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isFixed 1412 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // InstantiatedMembEnum 1413 // DC 1414 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // LexicalOffset 1415 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // VisibleOffset 1416 DeclEnumAbbrev = Stream.EmitAbbrev(Abv); 1417 1418 // Abbreviation for DECL_RECORD 1419 Abv = new BitCodeAbbrev(); 1420 Abv->Add(BitCodeAbbrevOp(serialization::DECL_RECORD)); 1421 // Redeclarable 1422 Abv->Add(BitCodeAbbrevOp(0)); // No redeclaration 1423 // Decl 1424 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclContext 1425 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // LexicalDeclContext 1426 Abv->Add(BitCodeAbbrevOp(0)); // isInvalidDecl 1427 Abv->Add(BitCodeAbbrevOp(0)); // HasAttrs 1428 Abv->Add(BitCodeAbbrevOp(0)); // isImplicit 1429 Abv->Add(BitCodeAbbrevOp(0)); // isUsed 1430 Abv->Add(BitCodeAbbrevOp(0)); // isReferenced 1431 Abv->Add(BitCodeAbbrevOp(0)); // TopLevelDeclInObjCContainer 1432 Abv->Add(BitCodeAbbrevOp(AS_none)); // C++ AccessSpecifier 1433 Abv->Add(BitCodeAbbrevOp(0)); // ModulePrivate 1434 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SubmoduleID 1435 // NamedDecl 1436 Abv->Add(BitCodeAbbrevOp(0)); // NameKind = Identifier 1437 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Name 1438 // TypeDecl 1439 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Source Location 1440 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type Ref 1441 // TagDecl 1442 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // IdentifierNamespace 1443 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // getTagKind 1444 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isCompleteDefinition 1445 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // EmbeddedInDeclarator 1446 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsFreeStanding 1447 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SourceLocation 1448 Abv->Add(BitCodeAbbrevOp(0)); // hasExtInfo 1449 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // TypedefNameAnonDecl 1450 // RecordDecl 1451 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // FlexibleArrayMember 1452 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // AnonymousStructUnion 1453 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // hasObjectMember 1454 // DC 1455 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // LexicalOffset 1456 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // VisibleOffset 1457 DeclRecordAbbrev = Stream.EmitAbbrev(Abv); 1458 1459 // Abbreviation for DECL_PARM_VAR 1460 Abv = new BitCodeAbbrev(); 1461 Abv->Add(BitCodeAbbrevOp(serialization::DECL_PARM_VAR)); 1462 // Redeclarable 1463 Abv->Add(BitCodeAbbrevOp(0)); // No redeclaration 1464 // Decl 1465 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclContext 1466 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // LexicalDeclContext 1467 Abv->Add(BitCodeAbbrevOp(0)); // isInvalidDecl 1468 Abv->Add(BitCodeAbbrevOp(0)); // HasAttrs 1469 Abv->Add(BitCodeAbbrevOp(0)); // isImplicit 1470 Abv->Add(BitCodeAbbrevOp(0)); // isUsed 1471 Abv->Add(BitCodeAbbrevOp(0)); // isReferenced 1472 Abv->Add(BitCodeAbbrevOp(0)); // TopLevelDeclInObjCContainer 1473 Abv->Add(BitCodeAbbrevOp(AS_none)); // C++ AccessSpecifier 1474 Abv->Add(BitCodeAbbrevOp(0)); // ModulePrivate 1475 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SubmoduleID 1476 // NamedDecl 1477 Abv->Add(BitCodeAbbrevOp(0)); // NameKind = Identifier 1478 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Name 1479 // ValueDecl 1480 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type 1481 // DeclaratorDecl 1482 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // InnerStartLoc 1483 Abv->Add(BitCodeAbbrevOp(0)); // hasExtInfo 1484 // VarDecl 1485 Abv->Add(BitCodeAbbrevOp(0)); // StorageClass 1486 Abv->Add(BitCodeAbbrevOp(0)); // StorageClassAsWritten 1487 Abv->Add(BitCodeAbbrevOp(0)); // isThreadSpecified 1488 Abv->Add(BitCodeAbbrevOp(0)); // hasCXXDirectInitializer 1489 Abv->Add(BitCodeAbbrevOp(0)); // isExceptionVariable 1490 Abv->Add(BitCodeAbbrevOp(0)); // isNRVOVariable 1491 Abv->Add(BitCodeAbbrevOp(0)); // isCXXForRangeDecl 1492 Abv->Add(BitCodeAbbrevOp(0)); // isARCPseudoStrong 1493 Abv->Add(BitCodeAbbrevOp(0)); // isConstexpr 1494 Abv->Add(BitCodeAbbrevOp(0)); // HasInit 1495 Abv->Add(BitCodeAbbrevOp(0)); // HasMemberSpecializationInfo 1496 // ParmVarDecl 1497 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsObjCMethodParameter 1498 Abv->Add(BitCodeAbbrevOp(0)); // ScopeDepth 1499 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // ScopeIndex 1500 Abv->Add(BitCodeAbbrevOp(0)); // ObjCDeclQualifier 1501 Abv->Add(BitCodeAbbrevOp(0)); // KNRPromoted 1502 Abv->Add(BitCodeAbbrevOp(0)); // HasInheritedDefaultArg 1503 Abv->Add(BitCodeAbbrevOp(0)); // HasUninstantiatedDefaultArg 1504 // Type Source Info 1505 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); 1506 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array)); 1507 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // TypeLoc 1508 DeclParmVarAbbrev = Stream.EmitAbbrev(Abv); 1509 1510 // Abbreviation for DECL_TYPEDEF 1511 Abv = new BitCodeAbbrev(); 1512 Abv->Add(BitCodeAbbrevOp(serialization::DECL_TYPEDEF)); 1513 // Redeclarable 1514 Abv->Add(BitCodeAbbrevOp(0)); // No redeclaration 1515 // Decl 1516 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclContext 1517 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // LexicalDeclContext 1518 Abv->Add(BitCodeAbbrevOp(0)); // isInvalidDecl 1519 Abv->Add(BitCodeAbbrevOp(0)); // HasAttrs 1520 Abv->Add(BitCodeAbbrevOp(0)); // isImplicit 1521 Abv->Add(BitCodeAbbrevOp(0)); // isUsed 1522 Abv->Add(BitCodeAbbrevOp(0)); // isReferenced 1523 Abv->Add(BitCodeAbbrevOp(0)); // TopLevelDeclInObjCContainer 1524 Abv->Add(BitCodeAbbrevOp(AS_none)); // C++ AccessSpecifier 1525 Abv->Add(BitCodeAbbrevOp(0)); // ModulePrivate 1526 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SubmoduleID 1527 // NamedDecl 1528 Abv->Add(BitCodeAbbrevOp(0)); // NameKind = Identifier 1529 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Name 1530 // TypeDecl 1531 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Source Location 1532 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type Ref 1533 // TypedefDecl 1534 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array)); 1535 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // TypeLoc 1536 DeclTypedefAbbrev = Stream.EmitAbbrev(Abv); 1537 1538 // Abbreviation for DECL_VAR 1539 Abv = new BitCodeAbbrev(); 1540 Abv->Add(BitCodeAbbrevOp(serialization::DECL_VAR)); 1541 // Redeclarable 1542 Abv->Add(BitCodeAbbrevOp(0)); // No redeclaration 1543 // Decl 1544 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclContext 1545 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // LexicalDeclContext 1546 Abv->Add(BitCodeAbbrevOp(0)); // isInvalidDecl 1547 Abv->Add(BitCodeAbbrevOp(0)); // HasAttrs 1548 Abv->Add(BitCodeAbbrevOp(0)); // isImplicit 1549 Abv->Add(BitCodeAbbrevOp(0)); // isUsed 1550 Abv->Add(BitCodeAbbrevOp(0)); // isReferenced 1551 Abv->Add(BitCodeAbbrevOp(0)); // TopLevelDeclInObjCContainer 1552 Abv->Add(BitCodeAbbrevOp(AS_none)); // C++ AccessSpecifier 1553 Abv->Add(BitCodeAbbrevOp(0)); // ModulePrivate 1554 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SubmoduleID 1555 // NamedDecl 1556 Abv->Add(BitCodeAbbrevOp(0)); // NameKind = Identifier 1557 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Name 1558 // ValueDecl 1559 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type 1560 // DeclaratorDecl 1561 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // InnerStartLoc 1562 Abv->Add(BitCodeAbbrevOp(0)); // hasExtInfo 1563 // VarDecl 1564 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // StorageClass 1565 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // StorageClassAsWritten 1566 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isThreadSpecified 1567 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // CXXDirectInitializer 1568 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isExceptionVariable 1569 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isNRVOVariable 1570 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isCXXForRangeDecl 1571 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isARCPseudoStrong 1572 Abv->Add(BitCodeAbbrevOp(0)); // isConstexpr 1573 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // HasInit 1574 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // HasMemberSpecInfo 1575 // Type Source Info 1576 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); 1577 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array)); 1578 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // TypeLoc 1579 DeclVarAbbrev = Stream.EmitAbbrev(Abv); 1580 1581 // Abbreviation for EXPR_DECL_REF 1582 Abv = new BitCodeAbbrev(); 1583 Abv->Add(BitCodeAbbrevOp(serialization::EXPR_DECL_REF)); 1584 //Stmt 1585 //Expr 1586 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type 1587 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //TypeDependent 1588 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //ValueDependent 1589 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //InstantiationDependent 1590 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //UnexpandedParamPack 1591 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); //GetValueKind 1592 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); //GetObjectKind 1593 //DeclRefExpr 1594 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //HasQualifier 1595 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //GetDeclFound 1596 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //ExplicitTemplateArgs 1597 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //HadMultipleCandidates 1598 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //RefersToEnclosingLocal 1599 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclRef 1600 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Location 1601 DeclRefExprAbbrev = Stream.EmitAbbrev(Abv); 1602 1603 // Abbreviation for EXPR_INTEGER_LITERAL 1604 Abv = new BitCodeAbbrev(); 1605 Abv->Add(BitCodeAbbrevOp(serialization::EXPR_INTEGER_LITERAL)); 1606 //Stmt 1607 //Expr 1608 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type 1609 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //TypeDependent 1610 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //ValueDependent 1611 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //InstantiationDependent 1612 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //UnexpandedParamPack 1613 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); //GetValueKind 1614 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); //GetObjectKind 1615 //Integer Literal 1616 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Location 1617 Abv->Add(BitCodeAbbrevOp(32)); // Bit Width 1618 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Value 1619 IntegerLiteralAbbrev = Stream.EmitAbbrev(Abv); 1620 1621 // Abbreviation for EXPR_CHARACTER_LITERAL 1622 Abv = new BitCodeAbbrev(); 1623 Abv->Add(BitCodeAbbrevOp(serialization::EXPR_CHARACTER_LITERAL)); 1624 //Stmt 1625 //Expr 1626 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type 1627 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //TypeDependent 1628 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //ValueDependent 1629 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //InstantiationDependent 1630 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //UnexpandedParamPack 1631 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); //GetValueKind 1632 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); //GetObjectKind 1633 //Character Literal 1634 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // getValue 1635 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Location 1636 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2)); // getKind 1637 CharacterLiteralAbbrev = Stream.EmitAbbrev(Abv); 1638 1639 Abv = new BitCodeAbbrev(); 1640 Abv->Add(BitCodeAbbrevOp(serialization::DECL_CONTEXT_LEXICAL)); 1641 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); 1642 DeclContextLexicalAbbrev = Stream.EmitAbbrev(Abv); 1643 1644 Abv = new BitCodeAbbrev(); 1645 Abv->Add(BitCodeAbbrevOp(serialization::DECL_CONTEXT_VISIBLE)); 1646 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); 1647 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); 1648 DeclContextVisibleLookupAbbrev = Stream.EmitAbbrev(Abv); 1649} 1650 1651/// isRequiredDecl - Check if this is a "required" Decl, which must be seen by 1652/// consumers of the AST. 1653/// 1654/// Such decls will always be deserialized from the AST file, so we would like 1655/// this to be as restrictive as possible. Currently the predicate is driven by 1656/// code generation requirements, if other clients have a different notion of 1657/// what is "required" then we may have to consider an alternate scheme where 1658/// clients can iterate over the top-level decls and get information on them, 1659/// without necessary deserializing them. We could explicitly require such 1660/// clients to use a separate API call to "realize" the decl. This should be 1661/// relatively painless since they would presumably only do it for top-level 1662/// decls. 1663static bool isRequiredDecl(const Decl *D, ASTContext &Context) { 1664 // An ObjCMethodDecl is never considered as "required" because its 1665 // implementation container always is. 1666 1667 // File scoped assembly or obj-c implementation must be seen. 1668 if (isa<FileScopeAsmDecl>(D) || isa<ObjCImplDecl>(D)) 1669 return true; 1670 1671 return Context.DeclMustBeEmitted(D); 1672} 1673 1674void ASTWriter::WriteDecl(ASTContext &Context, Decl *D) { 1675 // Switch case IDs are per Decl. 1676 ClearSwitchCaseIDs(); 1677 1678 RecordData Record; 1679 ASTDeclWriter W(*this, Context, Record); 1680 1681 // Determine the ID for this declaration. 1682 serialization::DeclID ID; 1683 if (D->isFromASTFile()) 1684 ID = getDeclID(D); 1685 else { 1686 serialization::DeclID &IDR = DeclIDs[D]; 1687 if (IDR == 0) 1688 IDR = NextDeclID++; 1689 1690 ID= IDR; 1691 } 1692 1693 bool isReplacingADecl = ID < FirstDeclID; 1694 1695 // If this declaration is also a DeclContext, write blocks for the 1696 // declarations that lexically stored inside its context and those 1697 // declarations that are visible from its context. These blocks 1698 // are written before the declaration itself so that we can put 1699 // their offsets into the record for the declaration. 1700 uint64_t LexicalOffset = 0; 1701 uint64_t VisibleOffset = 0; 1702 DeclContext *DC = dyn_cast<DeclContext>(D); 1703 if (DC) { 1704 if (isReplacingADecl) { 1705 // It is replacing a decl from a chained PCH; make sure that the 1706 // DeclContext is fully loaded. 1707 if (DC->hasExternalLexicalStorage()) 1708 DC->LoadLexicalDeclsFromExternalStorage(); 1709 if (DC->hasExternalVisibleStorage()) 1710 Chain->completeVisibleDeclsMap(DC); 1711 } 1712 LexicalOffset = WriteDeclContextLexicalBlock(Context, DC); 1713 VisibleOffset = WriteDeclContextVisibleBlock(Context, DC); 1714 } 1715 1716 if (isReplacingADecl) { 1717 // We're replacing a decl in a previous file. 1718 ReplacedDecls.push_back(ReplacedDeclInfo(ID, Stream.GetCurrentBitNo(), 1719 D->getLocation())); 1720 } else { 1721 unsigned Index = ID - FirstDeclID; 1722 1723 // Record the offset for this declaration 1724 SourceLocation Loc = D->getLocation(); 1725 if (DeclOffsets.size() == Index) 1726 DeclOffsets.push_back(DeclOffset(Loc, Stream.GetCurrentBitNo())); 1727 else if (DeclOffsets.size() < Index) { 1728 DeclOffsets.resize(Index+1); 1729 DeclOffsets[Index].setLocation(Loc); 1730 DeclOffsets[Index].BitOffset = Stream.GetCurrentBitNo(); 1731 } 1732 1733 SourceManager &SM = Context.getSourceManager(); 1734 if (Loc.isValid() && SM.isLocalSourceLocation(Loc)) 1735 associateDeclWithFile(D, ID); 1736 } 1737 1738 // Build and emit a record for this declaration 1739 Record.clear(); 1740 W.Code = (serialization::DeclCode)0; 1741 W.AbbrevToUse = 0; 1742 W.Visit(D); 1743 if (DC) W.VisitDeclContext(DC, LexicalOffset, VisibleOffset); 1744 1745 if (!W.Code) 1746 llvm::report_fatal_error(StringRef("unexpected declaration kind '") + 1747 D->getDeclKindName() + "'"); 1748 Stream.EmitRecord(W.Code, Record, W.AbbrevToUse); 1749 1750 // Flush any expressions that were written as part of this declaration. 1751 FlushStmts(); 1752 1753 // Flush C++ base specifiers, if there are any. 1754 FlushCXXBaseSpecifiers(); 1755 1756 // Note "external" declarations so that we can add them to a record in the 1757 // AST file later. 1758 // 1759 // FIXME: This should be renamed, the predicate is much more complicated. 1760 if (isRequiredDecl(D, Context)) 1761 ExternalDefinitions.push_back(ID); 1762} 1763