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