1 //===--- ASTWriterDecl.cpp - Declaration Serialization --------------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file implements serialization for Declarations.
12 //===----------------------------------------------------------------------===//
14 #include "ASTCommon.h"
15 #include "clang/AST/DeclCXX.h"
16 #include "clang/AST/DeclContextInternals.h"
17 #include "clang/AST/DeclTemplate.h"
18 #include "clang/AST/DeclVisitor.h"
19 #include "clang/AST/Expr.h"
20 #include "clang/Basic/SourceManager.h"
21 #include "clang/Serialization/ASTReader.h"
22 #include "clang/Serialization/ASTWriter.h"
23 #include "llvm/Bitcode/BitstreamWriter.h"
24 #include "llvm/Support/ErrorHandling.h"
25 using namespace clang;
26 using namespace serialization;
28 //===----------------------------------------------------------------------===//
29 // Declaration serialization
30 //===----------------------------------------------------------------------===//
33 class ASTDeclWriter : public DeclVisitor<ASTDeclWriter, void> {
36 ASTRecordWriter Record;
38 serialization::DeclCode Code;
42 ASTDeclWriter(ASTWriter &Writer, ASTContext &Context,
43 ASTWriter::RecordDataImpl &Record)
44 : Writer(Writer), Context(Context), Record(Writer, Record),
45 Code((serialization::DeclCode)0), AbbrevToUse(0) {}
47 uint64_t Emit(Decl *D) {
49 llvm::report_fatal_error(StringRef("unexpected declaration kind '") +
50 D->getDeclKindName() + "'");
51 return Record.Emit(Code, AbbrevToUse);
56 void VisitDecl(Decl *D);
57 void VisitPragmaCommentDecl(PragmaCommentDecl *D);
58 void VisitPragmaDetectMismatchDecl(PragmaDetectMismatchDecl *D);
59 void VisitTranslationUnitDecl(TranslationUnitDecl *D);
60 void VisitNamedDecl(NamedDecl *D);
61 void VisitLabelDecl(LabelDecl *LD);
62 void VisitNamespaceDecl(NamespaceDecl *D);
63 void VisitUsingDirectiveDecl(UsingDirectiveDecl *D);
64 void VisitNamespaceAliasDecl(NamespaceAliasDecl *D);
65 void VisitTypeDecl(TypeDecl *D);
66 void VisitTypedefNameDecl(TypedefNameDecl *D);
67 void VisitTypedefDecl(TypedefDecl *D);
68 void VisitTypeAliasDecl(TypeAliasDecl *D);
69 void VisitUnresolvedUsingTypenameDecl(UnresolvedUsingTypenameDecl *D);
70 void VisitTagDecl(TagDecl *D);
71 void VisitEnumDecl(EnumDecl *D);
72 void VisitRecordDecl(RecordDecl *D);
73 void VisitCXXRecordDecl(CXXRecordDecl *D);
74 void VisitClassTemplateSpecializationDecl(
75 ClassTemplateSpecializationDecl *D);
76 void VisitClassTemplatePartialSpecializationDecl(
77 ClassTemplatePartialSpecializationDecl *D);
78 void VisitVarTemplateSpecializationDecl(VarTemplateSpecializationDecl *D);
79 void VisitVarTemplatePartialSpecializationDecl(
80 VarTemplatePartialSpecializationDecl *D);
81 void VisitClassScopeFunctionSpecializationDecl(
82 ClassScopeFunctionSpecializationDecl *D);
83 void VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D);
84 void VisitValueDecl(ValueDecl *D);
85 void VisitEnumConstantDecl(EnumConstantDecl *D);
86 void VisitUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *D);
87 void VisitDeclaratorDecl(DeclaratorDecl *D);
88 void VisitFunctionDecl(FunctionDecl *D);
89 void VisitCXXMethodDecl(CXXMethodDecl *D);
90 void VisitCXXConstructorDecl(CXXConstructorDecl *D);
91 void VisitCXXDestructorDecl(CXXDestructorDecl *D);
92 void VisitCXXConversionDecl(CXXConversionDecl *D);
93 void VisitFieldDecl(FieldDecl *D);
94 void VisitMSPropertyDecl(MSPropertyDecl *D);
95 void VisitIndirectFieldDecl(IndirectFieldDecl *D);
96 void VisitVarDecl(VarDecl *D);
97 void VisitImplicitParamDecl(ImplicitParamDecl *D);
98 void VisitParmVarDecl(ParmVarDecl *D);
99 void VisitDecompositionDecl(DecompositionDecl *D);
100 void VisitBindingDecl(BindingDecl *D);
101 void VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D);
102 void VisitTemplateDecl(TemplateDecl *D);
103 void VisitRedeclarableTemplateDecl(RedeclarableTemplateDecl *D);
104 void VisitClassTemplateDecl(ClassTemplateDecl *D);
105 void VisitVarTemplateDecl(VarTemplateDecl *D);
106 void VisitFunctionTemplateDecl(FunctionTemplateDecl *D);
107 void VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D);
108 void VisitTypeAliasTemplateDecl(TypeAliasTemplateDecl *D);
109 void VisitUsingDecl(UsingDecl *D);
110 void VisitUsingPackDecl(UsingPackDecl *D);
111 void VisitUsingShadowDecl(UsingShadowDecl *D);
112 void VisitConstructorUsingShadowDecl(ConstructorUsingShadowDecl *D);
113 void VisitLinkageSpecDecl(LinkageSpecDecl *D);
114 void VisitExportDecl(ExportDecl *D);
115 void VisitFileScopeAsmDecl(FileScopeAsmDecl *D);
116 void VisitImportDecl(ImportDecl *D);
117 void VisitAccessSpecDecl(AccessSpecDecl *D);
118 void VisitFriendDecl(FriendDecl *D);
119 void VisitFriendTemplateDecl(FriendTemplateDecl *D);
120 void VisitStaticAssertDecl(StaticAssertDecl *D);
121 void VisitBlockDecl(BlockDecl *D);
122 void VisitCapturedDecl(CapturedDecl *D);
123 void VisitEmptyDecl(EmptyDecl *D);
125 void VisitDeclContext(DeclContext *DC);
126 template <typename T> void VisitRedeclarable(Redeclarable<T> *D);
129 // FIXME: Put in the same order is DeclNodes.td?
130 void VisitObjCMethodDecl(ObjCMethodDecl *D);
131 void VisitObjCTypeParamDecl(ObjCTypeParamDecl *D);
132 void VisitObjCContainerDecl(ObjCContainerDecl *D);
133 void VisitObjCInterfaceDecl(ObjCInterfaceDecl *D);
134 void VisitObjCIvarDecl(ObjCIvarDecl *D);
135 void VisitObjCProtocolDecl(ObjCProtocolDecl *D);
136 void VisitObjCAtDefsFieldDecl(ObjCAtDefsFieldDecl *D);
137 void VisitObjCCategoryDecl(ObjCCategoryDecl *D);
138 void VisitObjCImplDecl(ObjCImplDecl *D);
139 void VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D);
140 void VisitObjCImplementationDecl(ObjCImplementationDecl *D);
141 void VisitObjCCompatibleAliasDecl(ObjCCompatibleAliasDecl *D);
142 void VisitObjCPropertyDecl(ObjCPropertyDecl *D);
143 void VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D);
144 void VisitOMPThreadPrivateDecl(OMPThreadPrivateDecl *D);
145 void VisitOMPDeclareReductionDecl(OMPDeclareReductionDecl *D);
146 void VisitOMPCapturedExprDecl(OMPCapturedExprDecl *D);
148 /// Add an Objective-C type parameter list to the given record.
149 void AddObjCTypeParamList(ObjCTypeParamList *typeParams) {
150 // Empty type parameter list.
156 Record.push_back(typeParams->size());
157 for (auto typeParam : *typeParams) {
158 Record.AddDeclRef(typeParam);
160 Record.AddSourceLocation(typeParams->getLAngleLoc());
161 Record.AddSourceLocation(typeParams->getRAngleLoc());
164 /// Add to the record the first declaration from each module file that
165 /// provides a declaration of D. The intent is to provide a sufficient
166 /// set such that reloading this set will load all current redeclarations.
167 void AddFirstDeclFromEachModule(const Decl *D, bool IncludeLocal) {
168 llvm::MapVector<ModuleFile*, const Decl*> Firsts;
169 // FIXME: We can skip entries that we know are implied by others.
170 for (const Decl *R = D->getMostRecentDecl(); R; R = R->getPreviousDecl()) {
171 if (R->isFromASTFile())
172 Firsts[Writer.Chain->getOwningModuleFile(R)] = R;
173 else if (IncludeLocal)
176 for (const auto &F : Firsts)
177 Record.AddDeclRef(F.second);
180 /// Get the specialization decl from an entry in the specialization list.
181 template <typename EntryType>
182 typename RedeclarableTemplateDecl::SpecEntryTraits<EntryType>::DeclType *
183 getSpecializationDecl(EntryType &T) {
184 return RedeclarableTemplateDecl::SpecEntryTraits<EntryType>::getDecl(&T);
187 /// Get the list of partial specializations from a template's common ptr.
189 decltype(T::PartialSpecializations) &getPartialSpecializations(T *Common) {
190 return Common->PartialSpecializations;
192 ArrayRef<Decl> getPartialSpecializations(FunctionTemplateDecl::Common *) {
196 template<typename DeclTy>
197 void AddTemplateSpecializations(DeclTy *D) {
198 auto *Common = D->getCommonPtr();
200 // If we have any lazy specializations, and the external AST source is
201 // our chained AST reader, we can just write out the DeclIDs. Otherwise,
202 // we need to resolve them to actual declarations.
203 if (Writer.Chain != Writer.Context->getExternalSource() &&
204 Common->LazySpecializations) {
205 D->LoadLazySpecializations();
206 assert(!Common->LazySpecializations);
209 ArrayRef<DeclID> LazySpecializations;
210 if (auto *LS = Common->LazySpecializations)
211 LazySpecializations = llvm::makeArrayRef(LS + 1, LS[0]);
213 // Add a slot to the record for the number of specializations.
214 unsigned I = Record.size();
217 // AddFirstDeclFromEachModule might trigger deserialization, invalidating
218 // *Specializations iterators.
219 llvm::SmallVector<const Decl*, 16> Specs;
220 for (auto &Entry : Common->Specializations)
221 Specs.push_back(getSpecializationDecl(Entry));
222 for (auto &Entry : getPartialSpecializations(Common))
223 Specs.push_back(getSpecializationDecl(Entry));
225 for (auto *D : Specs) {
226 assert(D->isCanonicalDecl() && "non-canonical decl in set");
227 AddFirstDeclFromEachModule(D, /*IncludeLocal*/true);
229 Record.append(LazySpecializations.begin(), LazySpecializations.end());
231 // Update the size entry we added earlier.
232 Record[I] = Record.size() - I - 1;
235 /// Ensure that this template specialization is associated with the specified
236 /// template on reload.
237 void RegisterTemplateSpecialization(const Decl *Template,
238 const Decl *Specialization) {
239 Template = Template->getCanonicalDecl();
241 // If the canonical template is local, we'll write out this specialization
243 // FIXME: We can do the same thing if there is any local declaration of
244 // the template, to avoid emitting an update record.
245 if (!Template->isFromASTFile())
248 // We only need to associate the first local declaration of the
249 // specialization. The other declarations will get pulled in by it.
250 if (Writer.getFirstLocalDecl(Specialization) != Specialization)
253 Writer.DeclUpdates[Template].push_back(ASTWriter::DeclUpdate(
254 UPD_CXX_ADDED_TEMPLATE_SPECIALIZATION, Specialization));
259 void ASTDeclWriter::Visit(Decl *D) {
260 DeclVisitor<ASTDeclWriter>::Visit(D);
262 // Source locations require array (variable-length) abbreviations. The
263 // abbreviation infrastructure requires that arrays are encoded last, so
264 // we handle it here in the case of those classes derived from DeclaratorDecl
265 if (DeclaratorDecl *DD = dyn_cast<DeclaratorDecl>(D)) {
266 Record.AddTypeSourceInfo(DD->getTypeSourceInfo());
269 // Handle FunctionDecl's body here and write it after all other Stmts/Exprs
270 // have been written. We want it last because we will not read it back when
271 // retrieving it from the AST, we'll just lazily set the offset.
272 if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
273 Record.push_back(FD->doesThisDeclarationHaveABody());
274 if (FD->doesThisDeclarationHaveABody())
275 Record.AddFunctionDefinition(FD);
278 // If this declaration is also a DeclContext, write blocks for the
279 // declarations that lexically stored inside its context and those
280 // declarations that are visible from its context.
281 if (DeclContext *DC = dyn_cast<DeclContext>(D))
282 VisitDeclContext(DC);
285 void ASTDeclWriter::VisitDecl(Decl *D) {
286 Record.AddDeclRef(cast_or_null<Decl>(D->getDeclContext()));
287 if (D->getDeclContext() != D->getLexicalDeclContext())
288 Record.AddDeclRef(cast_or_null<Decl>(D->getLexicalDeclContext()));
291 Record.push_back(D->isInvalidDecl());
292 Record.push_back(D->hasAttrs());
294 Record.AddAttributes(D->getAttrs());
295 Record.push_back(D->isImplicit());
296 Record.push_back(D->isUsed(false));
297 Record.push_back(D->isReferenced());
298 Record.push_back(D->isTopLevelDeclInObjCContainer());
299 Record.push_back(D->getAccess());
300 Record.push_back(D->isModulePrivate());
301 Record.push_back(Writer.inferSubmoduleIDFromLocation(D->getLocation()));
303 // If this declaration injected a name into a context different from its
304 // lexical context, and that context is an imported namespace, we need to
305 // update its visible declarations to include this name.
307 // This happens when we instantiate a class with a friend declaration or a
308 // function with a local extern declaration, for instance.
310 // FIXME: Can we handle this in AddedVisibleDecl instead?
311 if (D->isOutOfLine()) {
312 auto *DC = D->getDeclContext();
313 while (auto *NS = dyn_cast<NamespaceDecl>(DC->getRedeclContext())) {
314 if (!NS->isFromASTFile())
316 Writer.UpdatedDeclContexts.insert(NS->getPrimaryContext());
317 if (!NS->isInlineNamespace())
319 DC = NS->getParent();
324 void ASTDeclWriter::VisitPragmaCommentDecl(PragmaCommentDecl *D) {
325 StringRef Arg = D->getArg();
326 Record.push_back(Arg.size());
328 Record.AddSourceLocation(D->getLocStart());
329 Record.push_back(D->getCommentKind());
330 Record.AddString(Arg);
331 Code = serialization::DECL_PRAGMA_COMMENT;
334 void ASTDeclWriter::VisitPragmaDetectMismatchDecl(
335 PragmaDetectMismatchDecl *D) {
336 StringRef Name = D->getName();
337 StringRef Value = D->getValue();
338 Record.push_back(Name.size() + 1 + Value.size());
340 Record.AddSourceLocation(D->getLocStart());
341 Record.AddString(Name);
342 Record.AddString(Value);
343 Code = serialization::DECL_PRAGMA_DETECT_MISMATCH;
346 void ASTDeclWriter::VisitTranslationUnitDecl(TranslationUnitDecl *D) {
347 llvm_unreachable("Translation units aren't directly serialized");
350 void ASTDeclWriter::VisitNamedDecl(NamedDecl *D) {
352 Record.AddDeclarationName(D->getDeclName());
353 Record.push_back(needsAnonymousDeclarationNumber(D)
354 ? Writer.getAnonymousDeclarationNumber(D)
358 void ASTDeclWriter::VisitTypeDecl(TypeDecl *D) {
360 Record.AddSourceLocation(D->getLocStart());
361 Record.AddTypeRef(QualType(D->getTypeForDecl(), 0));
364 void ASTDeclWriter::VisitTypedefNameDecl(TypedefNameDecl *D) {
365 VisitRedeclarable(D);
367 Record.AddTypeSourceInfo(D->getTypeSourceInfo());
368 Record.push_back(D->isModed());
370 Record.AddTypeRef(D->getUnderlyingType());
373 void ASTDeclWriter::VisitTypedefDecl(TypedefDecl *D) {
374 VisitTypedefNameDecl(D);
375 if (D->getDeclContext() == D->getLexicalDeclContext() &&
378 D->getFirstDecl() == D->getMostRecentDecl() &&
379 !D->isInvalidDecl() &&
380 !D->isTopLevelDeclInObjCContainer() &&
381 !D->isModulePrivate() &&
382 !needsAnonymousDeclarationNumber(D) &&
383 D->getDeclName().getNameKind() == DeclarationName::Identifier)
384 AbbrevToUse = Writer.getDeclTypedefAbbrev();
386 Code = serialization::DECL_TYPEDEF;
389 void ASTDeclWriter::VisitTypeAliasDecl(TypeAliasDecl *D) {
390 VisitTypedefNameDecl(D);
391 Record.AddDeclRef(D->getDescribedAliasTemplate());
392 Code = serialization::DECL_TYPEALIAS;
395 void ASTDeclWriter::VisitTagDecl(TagDecl *D) {
396 VisitRedeclarable(D);
398 Record.push_back(D->getIdentifierNamespace());
399 Record.push_back((unsigned)D->getTagKind()); // FIXME: stable encoding
400 if (!isa<CXXRecordDecl>(D))
401 Record.push_back(D->isCompleteDefinition());
402 Record.push_back(D->isEmbeddedInDeclarator());
403 Record.push_back(D->isFreeStanding());
404 Record.push_back(D->isCompleteDefinitionRequired());
405 Record.AddSourceRange(D->getBraceRange());
407 if (D->hasExtInfo()) {
409 Record.AddQualifierInfo(*D->getExtInfo());
410 } else if (auto *TD = D->getTypedefNameForAnonDecl()) {
412 Record.AddDeclRef(TD);
413 Record.AddIdentifierRef(TD->getDeclName().getAsIdentifierInfo());
419 void ASTDeclWriter::VisitEnumDecl(EnumDecl *D) {
421 Record.AddTypeSourceInfo(D->getIntegerTypeSourceInfo());
422 if (!D->getIntegerTypeSourceInfo())
423 Record.AddTypeRef(D->getIntegerType());
424 Record.AddTypeRef(D->getPromotionType());
425 Record.push_back(D->getNumPositiveBits());
426 Record.push_back(D->getNumNegativeBits());
427 Record.push_back(D->isScoped());
428 Record.push_back(D->isScopedUsingClassTag());
429 Record.push_back(D->isFixed());
430 if (MemberSpecializationInfo *MemberInfo = D->getMemberSpecializationInfo()) {
431 Record.AddDeclRef(MemberInfo->getInstantiatedFrom());
432 Record.push_back(MemberInfo->getTemplateSpecializationKind());
433 Record.AddSourceLocation(MemberInfo->getPointOfInstantiation());
435 Record.AddDeclRef(nullptr);
438 if (D->getDeclContext() == D->getLexicalDeclContext() &&
443 !D->getTypedefNameForAnonDecl() &&
444 D->getFirstDecl() == D->getMostRecentDecl() &&
445 !D->isInvalidDecl() &&
446 !D->isReferenced() &&
447 !D->isTopLevelDeclInObjCContainer() &&
448 D->getAccess() == AS_none &&
449 !D->isModulePrivate() &&
450 !CXXRecordDecl::classofKind(D->getKind()) &&
451 !D->getIntegerTypeSourceInfo() &&
452 !D->getMemberSpecializationInfo() &&
453 !needsAnonymousDeclarationNumber(D) &&
454 D->getDeclName().getNameKind() == DeclarationName::Identifier)
455 AbbrevToUse = Writer.getDeclEnumAbbrev();
457 Code = serialization::DECL_ENUM;
460 void ASTDeclWriter::VisitRecordDecl(RecordDecl *D) {
462 Record.push_back(D->hasFlexibleArrayMember());
463 Record.push_back(D->isAnonymousStructOrUnion());
464 Record.push_back(D->hasObjectMember());
465 Record.push_back(D->hasVolatileMember());
467 if (D->getDeclContext() == D->getLexicalDeclContext() &&
472 !D->getTypedefNameForAnonDecl() &&
473 D->getFirstDecl() == D->getMostRecentDecl() &&
474 !D->isInvalidDecl() &&
475 !D->isReferenced() &&
476 !D->isTopLevelDeclInObjCContainer() &&
477 D->getAccess() == AS_none &&
478 !D->isModulePrivate() &&
479 !CXXRecordDecl::classofKind(D->getKind()) &&
480 !needsAnonymousDeclarationNumber(D) &&
481 D->getDeclName().getNameKind() == DeclarationName::Identifier)
482 AbbrevToUse = Writer.getDeclRecordAbbrev();
484 Code = serialization::DECL_RECORD;
487 void ASTDeclWriter::VisitValueDecl(ValueDecl *D) {
489 Record.AddTypeRef(D->getType());
492 void ASTDeclWriter::VisitEnumConstantDecl(EnumConstantDecl *D) {
494 Record.push_back(D->getInitExpr()? 1 : 0);
495 if (D->getInitExpr())
496 Record.AddStmt(D->getInitExpr());
497 Record.AddAPSInt(D->getInitVal());
499 Code = serialization::DECL_ENUM_CONSTANT;
502 void ASTDeclWriter::VisitDeclaratorDecl(DeclaratorDecl *D) {
504 Record.AddSourceLocation(D->getInnerLocStart());
505 Record.push_back(D->hasExtInfo());
507 Record.AddQualifierInfo(*D->getExtInfo());
510 void ASTDeclWriter::VisitFunctionDecl(FunctionDecl *D) {
511 VisitRedeclarable(D);
512 VisitDeclaratorDecl(D);
513 Record.AddDeclarationNameLoc(D->DNLoc, D->getDeclName());
514 Record.push_back(D->getIdentifierNamespace());
516 // FunctionDecl's body is handled last at ASTWriterDecl::Visit,
517 // after everything else is written.
519 Record.push_back((int)D->SClass); // FIXME: stable encoding
520 Record.push_back(D->IsInline);
521 Record.push_back(D->IsInlineSpecified);
522 Record.push_back(D->IsVirtualAsWritten);
523 Record.push_back(D->IsPure);
524 Record.push_back(D->HasInheritedPrototype);
525 Record.push_back(D->HasWrittenPrototype);
526 Record.push_back(D->IsDeleted);
527 Record.push_back(D->IsTrivial);
528 Record.push_back(D->IsDefaulted);
529 Record.push_back(D->IsExplicitlyDefaulted);
530 Record.push_back(D->HasImplicitReturnZero);
531 Record.push_back(D->IsConstexpr);
532 Record.push_back(D->UsesSEHTry);
533 Record.push_back(D->HasSkippedBody);
534 Record.push_back(D->IsLateTemplateParsed);
535 Record.push_back(D->getLinkageInternal());
536 Record.AddSourceLocation(D->getLocEnd());
538 Record.push_back(D->getTemplatedKind());
539 switch (D->getTemplatedKind()) {
540 case FunctionDecl::TK_NonTemplate:
542 case FunctionDecl::TK_FunctionTemplate:
543 Record.AddDeclRef(D->getDescribedFunctionTemplate());
545 case FunctionDecl::TK_MemberSpecialization: {
546 MemberSpecializationInfo *MemberInfo = D->getMemberSpecializationInfo();
547 Record.AddDeclRef(MemberInfo->getInstantiatedFrom());
548 Record.push_back(MemberInfo->getTemplateSpecializationKind());
549 Record.AddSourceLocation(MemberInfo->getPointOfInstantiation());
552 case FunctionDecl::TK_FunctionTemplateSpecialization: {
553 FunctionTemplateSpecializationInfo *
554 FTSInfo = D->getTemplateSpecializationInfo();
556 RegisterTemplateSpecialization(FTSInfo->getTemplate(), D);
558 Record.AddDeclRef(FTSInfo->getTemplate());
559 Record.push_back(FTSInfo->getTemplateSpecializationKind());
561 // Template arguments.
562 Record.AddTemplateArgumentList(FTSInfo->TemplateArguments);
564 // Template args as written.
565 Record.push_back(FTSInfo->TemplateArgumentsAsWritten != nullptr);
566 if (FTSInfo->TemplateArgumentsAsWritten) {
567 Record.push_back(FTSInfo->TemplateArgumentsAsWritten->NumTemplateArgs);
568 for (int i=0, e = FTSInfo->TemplateArgumentsAsWritten->NumTemplateArgs;
570 Record.AddTemplateArgumentLoc(
571 (*FTSInfo->TemplateArgumentsAsWritten)[i]);
572 Record.AddSourceLocation(FTSInfo->TemplateArgumentsAsWritten->LAngleLoc);
573 Record.AddSourceLocation(FTSInfo->TemplateArgumentsAsWritten->RAngleLoc);
576 Record.AddSourceLocation(FTSInfo->getPointOfInstantiation());
578 if (D->isCanonicalDecl()) {
579 // Write the template that contains the specializations set. We will
580 // add a FunctionTemplateSpecializationInfo to it when reading.
581 Record.AddDeclRef(FTSInfo->getTemplate()->getCanonicalDecl());
585 case FunctionDecl::TK_DependentFunctionTemplateSpecialization: {
586 DependentFunctionTemplateSpecializationInfo *
587 DFTSInfo = D->getDependentSpecializationInfo();
590 Record.push_back(DFTSInfo->getNumTemplates());
591 for (int i=0, e = DFTSInfo->getNumTemplates(); i != e; ++i)
592 Record.AddDeclRef(DFTSInfo->getTemplate(i));
595 Record.push_back(DFTSInfo->getNumTemplateArgs());
596 for (int i=0, e = DFTSInfo->getNumTemplateArgs(); i != e; ++i)
597 Record.AddTemplateArgumentLoc(DFTSInfo->getTemplateArg(i));
598 Record.AddSourceLocation(DFTSInfo->getLAngleLoc());
599 Record.AddSourceLocation(DFTSInfo->getRAngleLoc());
604 Record.push_back(D->param_size());
605 for (auto P : D->parameters())
606 Record.AddDeclRef(P);
607 Code = serialization::DECL_FUNCTION;
610 void ASTDeclWriter::VisitObjCMethodDecl(ObjCMethodDecl *D) {
612 // FIXME: convert to LazyStmtPtr?
613 // Unlike C/C++, method bodies will never be in header files.
614 bool HasBodyStuff = D->getBody() != nullptr ||
615 D->getSelfDecl() != nullptr || D->getCmdDecl() != nullptr;
616 Record.push_back(HasBodyStuff);
618 Record.AddStmt(D->getBody());
619 Record.AddDeclRef(D->getSelfDecl());
620 Record.AddDeclRef(D->getCmdDecl());
622 Record.push_back(D->isInstanceMethod());
623 Record.push_back(D->isVariadic());
624 Record.push_back(D->isPropertyAccessor());
625 Record.push_back(D->isDefined());
626 Record.push_back(D->IsOverriding);
627 Record.push_back(D->HasSkippedBody);
629 Record.push_back(D->IsRedeclaration);
630 Record.push_back(D->HasRedeclaration);
631 if (D->HasRedeclaration) {
632 assert(Context.getObjCMethodRedeclaration(D));
633 Record.AddDeclRef(Context.getObjCMethodRedeclaration(D));
636 // FIXME: stable encoding for @required/@optional
637 Record.push_back(D->getImplementationControl());
638 // FIXME: stable encoding for in/out/inout/bycopy/byref/oneway/nullability
639 Record.push_back(D->getObjCDeclQualifier());
640 Record.push_back(D->hasRelatedResultType());
641 Record.AddTypeRef(D->getReturnType());
642 Record.AddTypeSourceInfo(D->getReturnTypeSourceInfo());
643 Record.AddSourceLocation(D->getLocEnd());
644 Record.push_back(D->param_size());
645 for (const auto *P : D->parameters())
646 Record.AddDeclRef(P);
648 Record.push_back(D->SelLocsKind);
649 unsigned NumStoredSelLocs = D->getNumStoredSelLocs();
650 SourceLocation *SelLocs = D->getStoredSelLocs();
651 Record.push_back(NumStoredSelLocs);
652 for (unsigned i = 0; i != NumStoredSelLocs; ++i)
653 Record.AddSourceLocation(SelLocs[i]);
655 Code = serialization::DECL_OBJC_METHOD;
658 void ASTDeclWriter::VisitObjCTypeParamDecl(ObjCTypeParamDecl *D) {
659 VisitTypedefNameDecl(D);
660 Record.push_back(D->Variance);
661 Record.push_back(D->Index);
662 Record.AddSourceLocation(D->VarianceLoc);
663 Record.AddSourceLocation(D->ColonLoc);
665 Code = serialization::DECL_OBJC_TYPE_PARAM;
668 void ASTDeclWriter::VisitObjCContainerDecl(ObjCContainerDecl *D) {
670 Record.AddSourceLocation(D->getAtStartLoc());
671 Record.AddSourceRange(D->getAtEndRange());
672 // Abstract class (no need to define a stable serialization::DECL code).
675 void ASTDeclWriter::VisitObjCInterfaceDecl(ObjCInterfaceDecl *D) {
676 VisitRedeclarable(D);
677 VisitObjCContainerDecl(D);
678 Record.AddTypeRef(QualType(D->getTypeForDecl(), 0));
679 AddObjCTypeParamList(D->TypeParamList);
681 Record.push_back(D->isThisDeclarationADefinition());
682 if (D->isThisDeclarationADefinition()) {
683 // Write the DefinitionData
684 ObjCInterfaceDecl::DefinitionData &Data = D->data();
686 Record.AddTypeSourceInfo(D->getSuperClassTInfo());
687 Record.AddSourceLocation(D->getEndOfDefinitionLoc());
688 Record.push_back(Data.HasDesignatedInitializers);
690 // Write out the protocols that are directly referenced by the @interface.
691 Record.push_back(Data.ReferencedProtocols.size());
692 for (const auto *P : D->protocols())
693 Record.AddDeclRef(P);
694 for (const auto &PL : D->protocol_locs())
695 Record.AddSourceLocation(PL);
697 // Write out the protocols that are transitively referenced.
698 Record.push_back(Data.AllReferencedProtocols.size());
699 for (ObjCList<ObjCProtocolDecl>::iterator
700 P = Data.AllReferencedProtocols.begin(),
701 PEnd = Data.AllReferencedProtocols.end();
703 Record.AddDeclRef(*P);
706 if (ObjCCategoryDecl *Cat = D->getCategoryListRaw()) {
707 // Ensure that we write out the set of categories for this class.
708 Writer.ObjCClassesWithCategories.insert(D);
710 // Make sure that the categories get serialized.
711 for (; Cat; Cat = Cat->getNextClassCategoryRaw())
712 (void)Writer.GetDeclRef(Cat);
716 Code = serialization::DECL_OBJC_INTERFACE;
719 void ASTDeclWriter::VisitObjCIvarDecl(ObjCIvarDecl *D) {
721 // FIXME: stable encoding for @public/@private/@protected/@package
722 Record.push_back(D->getAccessControl());
723 Record.push_back(D->getSynthesize());
725 if (D->getDeclContext() == D->getLexicalDeclContext() &&
729 !D->isInvalidDecl() &&
730 !D->isReferenced() &&
731 !D->isModulePrivate() &&
735 AbbrevToUse = Writer.getDeclObjCIvarAbbrev();
737 Code = serialization::DECL_OBJC_IVAR;
740 void ASTDeclWriter::VisitObjCProtocolDecl(ObjCProtocolDecl *D) {
741 VisitRedeclarable(D);
742 VisitObjCContainerDecl(D);
744 Record.push_back(D->isThisDeclarationADefinition());
745 if (D->isThisDeclarationADefinition()) {
746 Record.push_back(D->protocol_size());
747 for (const auto *I : D->protocols())
748 Record.AddDeclRef(I);
749 for (const auto &PL : D->protocol_locs())
750 Record.AddSourceLocation(PL);
753 Code = serialization::DECL_OBJC_PROTOCOL;
756 void ASTDeclWriter::VisitObjCAtDefsFieldDecl(ObjCAtDefsFieldDecl *D) {
758 Code = serialization::DECL_OBJC_AT_DEFS_FIELD;
761 void ASTDeclWriter::VisitObjCCategoryDecl(ObjCCategoryDecl *D) {
762 VisitObjCContainerDecl(D);
763 Record.AddSourceLocation(D->getCategoryNameLoc());
764 Record.AddSourceLocation(D->getIvarLBraceLoc());
765 Record.AddSourceLocation(D->getIvarRBraceLoc());
766 Record.AddDeclRef(D->getClassInterface());
767 AddObjCTypeParamList(D->TypeParamList);
768 Record.push_back(D->protocol_size());
769 for (const auto *I : D->protocols())
770 Record.AddDeclRef(I);
771 for (const auto &PL : D->protocol_locs())
772 Record.AddSourceLocation(PL);
773 Code = serialization::DECL_OBJC_CATEGORY;
776 void ASTDeclWriter::VisitObjCCompatibleAliasDecl(ObjCCompatibleAliasDecl *D) {
778 Record.AddDeclRef(D->getClassInterface());
779 Code = serialization::DECL_OBJC_COMPATIBLE_ALIAS;
782 void ASTDeclWriter::VisitObjCPropertyDecl(ObjCPropertyDecl *D) {
784 Record.AddSourceLocation(D->getAtLoc());
785 Record.AddSourceLocation(D->getLParenLoc());
786 Record.AddTypeRef(D->getType());
787 Record.AddTypeSourceInfo(D->getTypeSourceInfo());
788 // FIXME: stable encoding
789 Record.push_back((unsigned)D->getPropertyAttributes());
790 Record.push_back((unsigned)D->getPropertyAttributesAsWritten());
791 // FIXME: stable encoding
792 Record.push_back((unsigned)D->getPropertyImplementation());
793 Record.AddDeclarationName(D->getGetterName());
794 Record.AddDeclarationName(D->getSetterName());
795 Record.AddDeclRef(D->getGetterMethodDecl());
796 Record.AddDeclRef(D->getSetterMethodDecl());
797 Record.AddDeclRef(D->getPropertyIvarDecl());
798 Code = serialization::DECL_OBJC_PROPERTY;
801 void ASTDeclWriter::VisitObjCImplDecl(ObjCImplDecl *D) {
802 VisitObjCContainerDecl(D);
803 Record.AddDeclRef(D->getClassInterface());
804 // Abstract class (no need to define a stable serialization::DECL code).
807 void ASTDeclWriter::VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D) {
808 VisitObjCImplDecl(D);
809 Record.AddIdentifierRef(D->getIdentifier());
810 Record.AddSourceLocation(D->getCategoryNameLoc());
811 Code = serialization::DECL_OBJC_CATEGORY_IMPL;
814 void ASTDeclWriter::VisitObjCImplementationDecl(ObjCImplementationDecl *D) {
815 VisitObjCImplDecl(D);
816 Record.AddDeclRef(D->getSuperClass());
817 Record.AddSourceLocation(D->getSuperClassLoc());
818 Record.AddSourceLocation(D->getIvarLBraceLoc());
819 Record.AddSourceLocation(D->getIvarRBraceLoc());
820 Record.push_back(D->hasNonZeroConstructors());
821 Record.push_back(D->hasDestructors());
822 Record.push_back(D->NumIvarInitializers);
823 if (D->NumIvarInitializers)
824 Record.AddCXXCtorInitializers(
825 llvm::makeArrayRef(D->init_begin(), D->init_end()));
826 Code = serialization::DECL_OBJC_IMPLEMENTATION;
829 void ASTDeclWriter::VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D) {
831 Record.AddSourceLocation(D->getLocStart());
832 Record.AddDeclRef(D->getPropertyDecl());
833 Record.AddDeclRef(D->getPropertyIvarDecl());
834 Record.AddSourceLocation(D->getPropertyIvarDeclLoc());
835 Record.AddStmt(D->getGetterCXXConstructor());
836 Record.AddStmt(D->getSetterCXXAssignment());
837 Code = serialization::DECL_OBJC_PROPERTY_IMPL;
840 void ASTDeclWriter::VisitFieldDecl(FieldDecl *D) {
841 VisitDeclaratorDecl(D);
842 Record.push_back(D->isMutable());
843 if (D->InitStorage.getInt() == FieldDecl::ISK_BitWidthOrNothing &&
844 D->InitStorage.getPointer() == nullptr) {
846 } else if (D->InitStorage.getInt() == FieldDecl::ISK_CapturedVLAType) {
847 Record.push_back(D->InitStorage.getInt() + 1);
849 QualType(static_cast<Type *>(D->InitStorage.getPointer()), 0));
851 Record.push_back(D->InitStorage.getInt() + 1);
852 Record.AddStmt(static_cast<Expr *>(D->InitStorage.getPointer()));
854 if (!D->getDeclName())
855 Record.AddDeclRef(Context.getInstantiatedFromUnnamedFieldDecl(D));
857 if (D->getDeclContext() == D->getLexicalDeclContext() &&
861 !D->isInvalidDecl() &&
862 !D->isReferenced() &&
863 !D->isTopLevelDeclInObjCContainer() &&
864 !D->isModulePrivate() &&
866 !D->hasInClassInitializer() &&
868 !ObjCIvarDecl::classofKind(D->getKind()) &&
869 !ObjCAtDefsFieldDecl::classofKind(D->getKind()) &&
871 AbbrevToUse = Writer.getDeclFieldAbbrev();
873 Code = serialization::DECL_FIELD;
876 void ASTDeclWriter::VisitMSPropertyDecl(MSPropertyDecl *D) {
877 VisitDeclaratorDecl(D);
878 Record.AddIdentifierRef(D->getGetterId());
879 Record.AddIdentifierRef(D->getSetterId());
880 Code = serialization::DECL_MS_PROPERTY;
883 void ASTDeclWriter::VisitIndirectFieldDecl(IndirectFieldDecl *D) {
885 Record.push_back(D->getChainingSize());
887 for (const auto *P : D->chain())
888 Record.AddDeclRef(P);
889 Code = serialization::DECL_INDIRECTFIELD;
892 void ASTDeclWriter::VisitVarDecl(VarDecl *D) {
893 VisitRedeclarable(D);
894 VisitDeclaratorDecl(D);
895 Record.push_back(D->getStorageClass());
896 Record.push_back(D->getTSCSpec());
897 Record.push_back(D->getInitStyle());
898 if (!isa<ParmVarDecl>(D)) {
899 Record.push_back(D->isThisDeclarationADemotedDefinition());
900 Record.push_back(D->isExceptionVariable());
901 Record.push_back(D->isNRVOVariable());
902 Record.push_back(D->isCXXForRangeDecl());
903 Record.push_back(D->isARCPseudoStrong());
904 Record.push_back(D->isInline());
905 Record.push_back(D->isInlineSpecified());
906 Record.push_back(D->isConstexpr());
907 Record.push_back(D->isInitCapture());
908 Record.push_back(D->isPreviousDeclInSameBlockScope());
910 Record.push_back(D->getLinkageInternal());
913 Record.push_back(!D->isInitKnownICE() ? 1 : (D->isInitICE() ? 3 : 2));
914 Record.AddStmt(D->getInit());
920 VarNotTemplate = 0, VarTemplate, StaticDataMemberSpecialization
922 if (VarTemplateDecl *TemplD = D->getDescribedVarTemplate()) {
923 Record.push_back(VarTemplate);
924 Record.AddDeclRef(TemplD);
925 } else if (MemberSpecializationInfo *SpecInfo
926 = D->getMemberSpecializationInfo()) {
927 Record.push_back(StaticDataMemberSpecialization);
928 Record.AddDeclRef(SpecInfo->getInstantiatedFrom());
929 Record.push_back(SpecInfo->getTemplateSpecializationKind());
930 Record.AddSourceLocation(SpecInfo->getPointOfInstantiation());
932 Record.push_back(VarNotTemplate);
935 if (D->getDeclContext() == D->getLexicalDeclContext() &&
939 !D->isInvalidDecl() &&
940 !D->isReferenced() &&
941 !D->isTopLevelDeclInObjCContainer() &&
942 D->getAccess() == AS_none &&
943 !D->isModulePrivate() &&
944 !needsAnonymousDeclarationNumber(D) &&
945 D->getDeclName().getNameKind() == DeclarationName::Identifier &&
947 D->getFirstDecl() == D->getMostRecentDecl() &&
948 D->getKind() == Decl::Var &&
951 !D->isInitCapture() &&
952 !D->isPreviousDeclInSameBlockScope() &&
953 !D->getMemberSpecializationInfo())
954 AbbrevToUse = Writer.getDeclVarAbbrev();
956 Code = serialization::DECL_VAR;
959 void ASTDeclWriter::VisitImplicitParamDecl(ImplicitParamDecl *D) {
961 Code = serialization::DECL_IMPLICIT_PARAM;
964 void ASTDeclWriter::VisitParmVarDecl(ParmVarDecl *D) {
966 Record.push_back(D->isObjCMethodParameter());
967 Record.push_back(D->getFunctionScopeDepth());
968 Record.push_back(D->getFunctionScopeIndex());
969 Record.push_back(D->getObjCDeclQualifier()); // FIXME: stable encoding
970 Record.push_back(D->isKNRPromoted());
971 Record.push_back(D->hasInheritedDefaultArg());
972 Record.push_back(D->hasUninstantiatedDefaultArg());
973 if (D->hasUninstantiatedDefaultArg())
974 Record.AddStmt(D->getUninstantiatedDefaultArg());
975 Code = serialization::DECL_PARM_VAR;
977 assert(!D->isARCPseudoStrong()); // can be true of ImplicitParamDecl
979 // If the assumptions about the DECL_PARM_VAR abbrev are true, use it. Here
980 // we dynamically check for the properties that we optimize for, but don't
981 // know are true of all PARM_VAR_DECLs.
982 if (D->getDeclContext() == D->getLexicalDeclContext() &&
987 !D->isInvalidDecl() &&
988 !D->isReferenced() &&
989 D->getAccess() == AS_none &&
990 !D->isModulePrivate() &&
991 D->getStorageClass() == 0 &&
992 D->getInitStyle() == VarDecl::CInit && // Can params have anything else?
993 D->getFunctionScopeDepth() == 0 &&
994 D->getObjCDeclQualifier() == 0 &&
995 !D->isKNRPromoted() &&
996 !D->hasInheritedDefaultArg() &&
997 D->getInit() == nullptr &&
998 !D->hasUninstantiatedDefaultArg()) // No default expr.
999 AbbrevToUse = Writer.getDeclParmVarAbbrev();
1001 // Check things we know are true of *every* PARM_VAR_DECL, which is more than
1002 // just us assuming it.
1003 assert(!D->getTSCSpec() && "PARM_VAR_DECL can't use TLS");
1004 assert(!D->isThisDeclarationADemotedDefinition()
1005 && "PARM_VAR_DECL can't be demoted definition.");
1006 assert(D->getAccess() == AS_none && "PARM_VAR_DECL can't be public/private");
1007 assert(!D->isExceptionVariable() && "PARM_VAR_DECL can't be exception var");
1008 assert(D->getPreviousDecl() == nullptr && "PARM_VAR_DECL can't be redecl");
1009 assert(!D->isStaticDataMember() &&
1010 "PARM_VAR_DECL can't be static data member");
1013 void ASTDeclWriter::VisitDecompositionDecl(DecompositionDecl *D) {
1014 // Record the number of bindings first to simplify deserialization.
1015 Record.push_back(D->bindings().size());
1018 for (auto *B : D->bindings())
1019 Record.AddDeclRef(B);
1020 Code = serialization::DECL_DECOMPOSITION;
1023 void ASTDeclWriter::VisitBindingDecl(BindingDecl *D) {
1025 Record.AddStmt(D->getBinding());
1026 Code = serialization::DECL_BINDING;
1029 void ASTDeclWriter::VisitFileScopeAsmDecl(FileScopeAsmDecl *D) {
1031 Record.AddStmt(D->getAsmString());
1032 Record.AddSourceLocation(D->getRParenLoc());
1033 Code = serialization::DECL_FILE_SCOPE_ASM;
1036 void ASTDeclWriter::VisitEmptyDecl(EmptyDecl *D) {
1038 Code = serialization::DECL_EMPTY;
1041 void ASTDeclWriter::VisitBlockDecl(BlockDecl *D) {
1043 Record.AddStmt(D->getBody());
1044 Record.AddTypeSourceInfo(D->getSignatureAsWritten());
1045 Record.push_back(D->param_size());
1046 for (ParmVarDecl *P : D->parameters())
1047 Record.AddDeclRef(P);
1048 Record.push_back(D->isVariadic());
1049 Record.push_back(D->blockMissingReturnType());
1050 Record.push_back(D->isConversionFromLambda());
1051 Record.push_back(D->capturesCXXThis());
1052 Record.push_back(D->getNumCaptures());
1053 for (const auto &capture : D->captures()) {
1054 Record.AddDeclRef(capture.getVariable());
1057 if (capture.isByRef()) flags |= 1;
1058 if (capture.isNested()) flags |= 2;
1059 if (capture.hasCopyExpr()) flags |= 4;
1060 Record.push_back(flags);
1062 if (capture.hasCopyExpr()) Record.AddStmt(capture.getCopyExpr());
1065 Code = serialization::DECL_BLOCK;
1068 void ASTDeclWriter::VisitCapturedDecl(CapturedDecl *CD) {
1069 Record.push_back(CD->getNumParams());
1071 Record.push_back(CD->getContextParamPosition());
1072 Record.push_back(CD->isNothrow() ? 1 : 0);
1073 // Body is stored by VisitCapturedStmt.
1074 for (unsigned I = 0; I < CD->getNumParams(); ++I)
1075 Record.AddDeclRef(CD->getParam(I));
1076 Code = serialization::DECL_CAPTURED;
1079 void ASTDeclWriter::VisitLinkageSpecDecl(LinkageSpecDecl *D) {
1081 Record.push_back(D->getLanguage());
1082 Record.AddSourceLocation(D->getExternLoc());
1083 Record.AddSourceLocation(D->getRBraceLoc());
1084 Code = serialization::DECL_LINKAGE_SPEC;
1087 void ASTDeclWriter::VisitExportDecl(ExportDecl *D) {
1089 Record.AddSourceLocation(D->getRBraceLoc());
1090 Code = serialization::DECL_EXPORT;
1093 void ASTDeclWriter::VisitLabelDecl(LabelDecl *D) {
1095 Record.AddSourceLocation(D->getLocStart());
1096 Code = serialization::DECL_LABEL;
1100 void ASTDeclWriter::VisitNamespaceDecl(NamespaceDecl *D) {
1101 VisitRedeclarable(D);
1103 Record.push_back(D->isInline());
1104 Record.AddSourceLocation(D->getLocStart());
1105 Record.AddSourceLocation(D->getRBraceLoc());
1107 if (D->isOriginalNamespace())
1108 Record.AddDeclRef(D->getAnonymousNamespace());
1109 Code = serialization::DECL_NAMESPACE;
1111 if (Writer.hasChain() && D->isAnonymousNamespace() &&
1112 D == D->getMostRecentDecl()) {
1113 // This is a most recent reopening of the anonymous namespace. If its parent
1114 // is in a previous PCH (or is the TU), mark that parent for update, because
1115 // the original namespace always points to the latest re-opening of its
1116 // anonymous namespace.
1117 Decl *Parent = cast<Decl>(
1118 D->getParent()->getRedeclContext()->getPrimaryContext());
1119 if (Parent->isFromASTFile() || isa<TranslationUnitDecl>(Parent)) {
1120 Writer.DeclUpdates[Parent].push_back(
1121 ASTWriter::DeclUpdate(UPD_CXX_ADDED_ANONYMOUS_NAMESPACE, D));
1126 void ASTDeclWriter::VisitNamespaceAliasDecl(NamespaceAliasDecl *D) {
1127 VisitRedeclarable(D);
1129 Record.AddSourceLocation(D->getNamespaceLoc());
1130 Record.AddSourceLocation(D->getTargetNameLoc());
1131 Record.AddNestedNameSpecifierLoc(D->getQualifierLoc());
1132 Record.AddDeclRef(D->getNamespace());
1133 Code = serialization::DECL_NAMESPACE_ALIAS;
1136 void ASTDeclWriter::VisitUsingDecl(UsingDecl *D) {
1138 Record.AddSourceLocation(D->getUsingLoc());
1139 Record.AddNestedNameSpecifierLoc(D->getQualifierLoc());
1140 Record.AddDeclarationNameLoc(D->DNLoc, D->getDeclName());
1141 Record.AddDeclRef(D->FirstUsingShadow.getPointer());
1142 Record.push_back(D->hasTypename());
1143 Record.AddDeclRef(Context.getInstantiatedFromUsingDecl(D));
1144 Code = serialization::DECL_USING;
1147 void ASTDeclWriter::VisitUsingPackDecl(UsingPackDecl *D) {
1148 Record.push_back(D->NumExpansions);
1150 Record.AddDeclRef(D->getInstantiatedFromUsingDecl());
1151 for (auto *E : D->expansions())
1152 Record.AddDeclRef(E);
1153 Code = serialization::DECL_USING_PACK;
1156 void ASTDeclWriter::VisitUsingShadowDecl(UsingShadowDecl *D) {
1157 VisitRedeclarable(D);
1159 Record.AddDeclRef(D->getTargetDecl());
1160 Record.AddDeclRef(D->UsingOrNextShadow);
1161 Record.AddDeclRef(Context.getInstantiatedFromUsingShadowDecl(D));
1162 Code = serialization::DECL_USING_SHADOW;
1165 void ASTDeclWriter::VisitConstructorUsingShadowDecl(
1166 ConstructorUsingShadowDecl *D) {
1167 VisitUsingShadowDecl(D);
1168 Record.AddDeclRef(D->NominatedBaseClassShadowDecl);
1169 Record.AddDeclRef(D->ConstructedBaseClassShadowDecl);
1170 Record.push_back(D->IsVirtual);
1171 Code = serialization::DECL_CONSTRUCTOR_USING_SHADOW;
1174 void ASTDeclWriter::VisitUsingDirectiveDecl(UsingDirectiveDecl *D) {
1176 Record.AddSourceLocation(D->getUsingLoc());
1177 Record.AddSourceLocation(D->getNamespaceKeyLocation());
1178 Record.AddNestedNameSpecifierLoc(D->getQualifierLoc());
1179 Record.AddDeclRef(D->getNominatedNamespace());
1180 Record.AddDeclRef(dyn_cast<Decl>(D->getCommonAncestor()));
1181 Code = serialization::DECL_USING_DIRECTIVE;
1184 void ASTDeclWriter::VisitUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *D) {
1186 Record.AddSourceLocation(D->getUsingLoc());
1187 Record.AddNestedNameSpecifierLoc(D->getQualifierLoc());
1188 Record.AddDeclarationNameLoc(D->DNLoc, D->getDeclName());
1189 Record.AddSourceLocation(D->getEllipsisLoc());
1190 Code = serialization::DECL_UNRESOLVED_USING_VALUE;
1193 void ASTDeclWriter::VisitUnresolvedUsingTypenameDecl(
1194 UnresolvedUsingTypenameDecl *D) {
1196 Record.AddSourceLocation(D->getTypenameLoc());
1197 Record.AddNestedNameSpecifierLoc(D->getQualifierLoc());
1198 Record.AddSourceLocation(D->getEllipsisLoc());
1199 Code = serialization::DECL_UNRESOLVED_USING_TYPENAME;
1202 void ASTDeclWriter::VisitCXXRecordDecl(CXXRecordDecl *D) {
1206 CXXRecNotTemplate = 0, CXXRecTemplate, CXXRecMemberSpecialization
1208 if (ClassTemplateDecl *TemplD = D->getDescribedClassTemplate()) {
1209 Record.push_back(CXXRecTemplate);
1210 Record.AddDeclRef(TemplD);
1211 } else if (MemberSpecializationInfo *MSInfo
1212 = D->getMemberSpecializationInfo()) {
1213 Record.push_back(CXXRecMemberSpecialization);
1214 Record.AddDeclRef(MSInfo->getInstantiatedFrom());
1215 Record.push_back(MSInfo->getTemplateSpecializationKind());
1216 Record.AddSourceLocation(MSInfo->getPointOfInstantiation());
1218 Record.push_back(CXXRecNotTemplate);
1221 Record.push_back(D->isThisDeclarationADefinition());
1222 if (D->isThisDeclarationADefinition())
1223 Record.AddCXXDefinitionData(D);
1225 // Store (what we currently believe to be) the key function to avoid
1226 // deserializing every method so we can compute it.
1227 if (D->IsCompleteDefinition)
1228 Record.AddDeclRef(Context.getCurrentKeyFunction(D));
1230 Code = serialization::DECL_CXX_RECORD;
1233 void ASTDeclWriter::VisitCXXMethodDecl(CXXMethodDecl *D) {
1234 VisitFunctionDecl(D);
1235 if (D->isCanonicalDecl()) {
1236 Record.push_back(D->size_overridden_methods());
1237 for (CXXMethodDecl::method_iterator
1238 I = D->begin_overridden_methods(), E = D->end_overridden_methods();
1240 Record.AddDeclRef(*I);
1242 // We only need to record overridden methods once for the canonical decl.
1243 Record.push_back(0);
1246 if (D->getDeclContext() == D->getLexicalDeclContext() &&
1247 D->getFirstDecl() == D->getMostRecentDecl() &&
1248 !D->isInvalidDecl() &&
1250 !D->isTopLevelDeclInObjCContainer() &&
1251 D->getDeclName().getNameKind() == DeclarationName::Identifier &&
1253 !D->hasInheritedPrototype() &&
1254 D->hasWrittenPrototype())
1255 AbbrevToUse = Writer.getDeclCXXMethodAbbrev();
1257 Code = serialization::DECL_CXX_METHOD;
1260 void ASTDeclWriter::VisitCXXConstructorDecl(CXXConstructorDecl *D) {
1261 if (auto Inherited = D->getInheritedConstructor()) {
1262 Record.AddDeclRef(Inherited.getShadowDecl());
1263 Record.AddDeclRef(Inherited.getConstructor());
1264 Code = serialization::DECL_CXX_INHERITED_CONSTRUCTOR;
1266 Code = serialization::DECL_CXX_CONSTRUCTOR;
1269 VisitCXXMethodDecl(D);
1271 Record.push_back(D->IsExplicitSpecified);
1273 Code = D->isInheritingConstructor()
1274 ? serialization::DECL_CXX_INHERITED_CONSTRUCTOR
1275 : serialization::DECL_CXX_CONSTRUCTOR;
1278 void ASTDeclWriter::VisitCXXDestructorDecl(CXXDestructorDecl *D) {
1279 VisitCXXMethodDecl(D);
1281 Record.AddDeclRef(D->getOperatorDelete());
1283 Code = serialization::DECL_CXX_DESTRUCTOR;
1286 void ASTDeclWriter::VisitCXXConversionDecl(CXXConversionDecl *D) {
1287 VisitCXXMethodDecl(D);
1288 Record.push_back(D->IsExplicitSpecified);
1289 Code = serialization::DECL_CXX_CONVERSION;
1292 void ASTDeclWriter::VisitImportDecl(ImportDecl *D) {
1294 Record.push_back(Writer.getSubmoduleID(D->getImportedModule()));
1295 ArrayRef<SourceLocation> IdentifierLocs = D->getIdentifierLocs();
1296 Record.push_back(!IdentifierLocs.empty());
1297 if (IdentifierLocs.empty()) {
1298 Record.AddSourceLocation(D->getLocEnd());
1299 Record.push_back(1);
1301 for (unsigned I = 0, N = IdentifierLocs.size(); I != N; ++I)
1302 Record.AddSourceLocation(IdentifierLocs[I]);
1303 Record.push_back(IdentifierLocs.size());
1305 // Note: the number of source locations must always be the last element in
1307 Code = serialization::DECL_IMPORT;
1310 void ASTDeclWriter::VisitAccessSpecDecl(AccessSpecDecl *D) {
1312 Record.AddSourceLocation(D->getColonLoc());
1313 Code = serialization::DECL_ACCESS_SPEC;
1316 void ASTDeclWriter::VisitFriendDecl(FriendDecl *D) {
1317 // Record the number of friend type template parameter lists here
1318 // so as to simplify memory allocation during deserialization.
1319 Record.push_back(D->NumTPLists);
1321 bool hasFriendDecl = D->Friend.is<NamedDecl*>();
1322 Record.push_back(hasFriendDecl);
1324 Record.AddDeclRef(D->getFriendDecl());
1326 Record.AddTypeSourceInfo(D->getFriendType());
1327 for (unsigned i = 0; i < D->NumTPLists; ++i)
1328 Record.AddTemplateParameterList(D->getFriendTypeTemplateParameterList(i));
1329 Record.AddDeclRef(D->getNextFriend());
1330 Record.push_back(D->UnsupportedFriend);
1331 Record.AddSourceLocation(D->FriendLoc);
1332 Code = serialization::DECL_FRIEND;
1335 void ASTDeclWriter::VisitFriendTemplateDecl(FriendTemplateDecl *D) {
1337 Record.push_back(D->getNumTemplateParameters());
1338 for (unsigned i = 0, e = D->getNumTemplateParameters(); i != e; ++i)
1339 Record.AddTemplateParameterList(D->getTemplateParameterList(i));
1340 Record.push_back(D->getFriendDecl() != nullptr);
1341 if (D->getFriendDecl())
1342 Record.AddDeclRef(D->getFriendDecl());
1344 Record.AddTypeSourceInfo(D->getFriendType());
1345 Record.AddSourceLocation(D->getFriendLoc());
1346 Code = serialization::DECL_FRIEND_TEMPLATE;
1349 void ASTDeclWriter::VisitTemplateDecl(TemplateDecl *D) {
1352 Record.AddDeclRef(D->getTemplatedDecl());
1353 Record.AddTemplateParameterList(D->getTemplateParameters());
1356 void ASTDeclWriter::VisitRedeclarableTemplateDecl(RedeclarableTemplateDecl *D) {
1357 VisitRedeclarable(D);
1359 // Emit data to initialize CommonOrPrev before VisitTemplateDecl so that
1360 // getCommonPtr() can be used while this is still initializing.
1361 if (D->isFirstDecl()) {
1362 // This declaration owns the 'common' pointer, so serialize that data now.
1363 Record.AddDeclRef(D->getInstantiatedFromMemberTemplate());
1364 if (D->getInstantiatedFromMemberTemplate())
1365 Record.push_back(D->isMemberSpecialization());
1368 VisitTemplateDecl(D);
1369 Record.push_back(D->getIdentifierNamespace());
1372 void ASTDeclWriter::VisitClassTemplateDecl(ClassTemplateDecl *D) {
1373 VisitRedeclarableTemplateDecl(D);
1375 if (D->isFirstDecl())
1376 AddTemplateSpecializations(D);
1377 Code = serialization::DECL_CLASS_TEMPLATE;
1380 void ASTDeclWriter::VisitClassTemplateSpecializationDecl(
1381 ClassTemplateSpecializationDecl *D) {
1382 RegisterTemplateSpecialization(D->getSpecializedTemplate(), D);
1384 VisitCXXRecordDecl(D);
1386 llvm::PointerUnion<ClassTemplateDecl *,
1387 ClassTemplatePartialSpecializationDecl *> InstFrom
1388 = D->getSpecializedTemplateOrPartial();
1389 if (Decl *InstFromD = InstFrom.dyn_cast<ClassTemplateDecl *>()) {
1390 Record.AddDeclRef(InstFromD);
1392 Record.AddDeclRef(InstFrom.get<ClassTemplatePartialSpecializationDecl *>());
1393 Record.AddTemplateArgumentList(&D->getTemplateInstantiationArgs());
1396 Record.AddTemplateArgumentList(&D->getTemplateArgs());
1397 Record.AddSourceLocation(D->getPointOfInstantiation());
1398 Record.push_back(D->getSpecializationKind());
1399 Record.push_back(D->isCanonicalDecl());
1401 if (D->isCanonicalDecl()) {
1402 // When reading, we'll add it to the folding set of the following template.
1403 Record.AddDeclRef(D->getSpecializedTemplate()->getCanonicalDecl());
1407 Record.AddTypeSourceInfo(D->getTypeAsWritten());
1408 if (D->getTypeAsWritten()) {
1409 Record.AddSourceLocation(D->getExternLoc());
1410 Record.AddSourceLocation(D->getTemplateKeywordLoc());
1413 Code = serialization::DECL_CLASS_TEMPLATE_SPECIALIZATION;
1416 void ASTDeclWriter::VisitClassTemplatePartialSpecializationDecl(
1417 ClassTemplatePartialSpecializationDecl *D) {
1418 VisitClassTemplateSpecializationDecl(D);
1420 Record.AddTemplateParameterList(D->getTemplateParameters());
1421 Record.AddASTTemplateArgumentListInfo(D->getTemplateArgsAsWritten());
1423 // These are read/set from/to the first declaration.
1424 if (D->getPreviousDecl() == nullptr) {
1425 Record.AddDeclRef(D->getInstantiatedFromMember());
1426 Record.push_back(D->isMemberSpecialization());
1429 Code = serialization::DECL_CLASS_TEMPLATE_PARTIAL_SPECIALIZATION;
1432 void ASTDeclWriter::VisitVarTemplateDecl(VarTemplateDecl *D) {
1433 VisitRedeclarableTemplateDecl(D);
1435 if (D->isFirstDecl())
1436 AddTemplateSpecializations(D);
1437 Code = serialization::DECL_VAR_TEMPLATE;
1440 void ASTDeclWriter::VisitVarTemplateSpecializationDecl(
1441 VarTemplateSpecializationDecl *D) {
1442 RegisterTemplateSpecialization(D->getSpecializedTemplate(), D);
1446 llvm::PointerUnion<VarTemplateDecl *, VarTemplatePartialSpecializationDecl *>
1447 InstFrom = D->getSpecializedTemplateOrPartial();
1448 if (Decl *InstFromD = InstFrom.dyn_cast<VarTemplateDecl *>()) {
1449 Record.AddDeclRef(InstFromD);
1451 Record.AddDeclRef(InstFrom.get<VarTemplatePartialSpecializationDecl *>());
1452 Record.AddTemplateArgumentList(&D->getTemplateInstantiationArgs());
1456 Record.AddTypeSourceInfo(D->getTypeAsWritten());
1457 if (D->getTypeAsWritten()) {
1458 Record.AddSourceLocation(D->getExternLoc());
1459 Record.AddSourceLocation(D->getTemplateKeywordLoc());
1462 Record.AddTemplateArgumentList(&D->getTemplateArgs());
1463 Record.AddSourceLocation(D->getPointOfInstantiation());
1464 Record.push_back(D->getSpecializationKind());
1465 Record.push_back(D->isCanonicalDecl());
1467 if (D->isCanonicalDecl()) {
1468 // When reading, we'll add it to the folding set of the following template.
1469 Record.AddDeclRef(D->getSpecializedTemplate()->getCanonicalDecl());
1472 Code = serialization::DECL_VAR_TEMPLATE_SPECIALIZATION;
1475 void ASTDeclWriter::VisitVarTemplatePartialSpecializationDecl(
1476 VarTemplatePartialSpecializationDecl *D) {
1477 VisitVarTemplateSpecializationDecl(D);
1479 Record.AddTemplateParameterList(D->getTemplateParameters());
1480 Record.AddASTTemplateArgumentListInfo(D->getTemplateArgsAsWritten());
1482 // These are read/set from/to the first declaration.
1483 if (D->getPreviousDecl() == nullptr) {
1484 Record.AddDeclRef(D->getInstantiatedFromMember());
1485 Record.push_back(D->isMemberSpecialization());
1488 Code = serialization::DECL_VAR_TEMPLATE_PARTIAL_SPECIALIZATION;
1491 void ASTDeclWriter::VisitClassScopeFunctionSpecializationDecl(
1492 ClassScopeFunctionSpecializationDecl *D) {
1494 Record.AddDeclRef(D->getSpecialization());
1495 Code = serialization::DECL_CLASS_SCOPE_FUNCTION_SPECIALIZATION;
1499 void ASTDeclWriter::VisitFunctionTemplateDecl(FunctionTemplateDecl *D) {
1500 VisitRedeclarableTemplateDecl(D);
1502 if (D->isFirstDecl())
1503 AddTemplateSpecializations(D);
1504 Code = serialization::DECL_FUNCTION_TEMPLATE;
1507 void ASTDeclWriter::VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D) {
1510 Record.push_back(D->wasDeclaredWithTypename());
1512 bool OwnsDefaultArg = D->hasDefaultArgument() &&
1513 !D->defaultArgumentWasInherited();
1514 Record.push_back(OwnsDefaultArg);
1516 Record.AddTypeSourceInfo(D->getDefaultArgumentInfo());
1518 Code = serialization::DECL_TEMPLATE_TYPE_PARM;
1521 void ASTDeclWriter::VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D) {
1522 // For an expanded parameter pack, record the number of expansion types here
1523 // so that it's easier for deserialization to allocate the right amount of
1525 if (D->isExpandedParameterPack())
1526 Record.push_back(D->getNumExpansionTypes());
1528 VisitDeclaratorDecl(D);
1529 // TemplateParmPosition.
1530 Record.push_back(D->getDepth());
1531 Record.push_back(D->getPosition());
1533 if (D->isExpandedParameterPack()) {
1534 for (unsigned I = 0, N = D->getNumExpansionTypes(); I != N; ++I) {
1535 Record.AddTypeRef(D->getExpansionType(I));
1536 Record.AddTypeSourceInfo(D->getExpansionTypeSourceInfo(I));
1539 Code = serialization::DECL_EXPANDED_NON_TYPE_TEMPLATE_PARM_PACK;
1541 // Rest of NonTypeTemplateParmDecl.
1542 Record.push_back(D->isParameterPack());
1543 bool OwnsDefaultArg = D->hasDefaultArgument() &&
1544 !D->defaultArgumentWasInherited();
1545 Record.push_back(OwnsDefaultArg);
1547 Record.AddStmt(D->getDefaultArgument());
1548 Code = serialization::DECL_NON_TYPE_TEMPLATE_PARM;
1552 void ASTDeclWriter::VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D) {
1553 // For an expanded parameter pack, record the number of expansion types here
1554 // so that it's easier for deserialization to allocate the right amount of
1556 if (D->isExpandedParameterPack())
1557 Record.push_back(D->getNumExpansionTemplateParameters());
1559 VisitTemplateDecl(D);
1560 // TemplateParmPosition.
1561 Record.push_back(D->getDepth());
1562 Record.push_back(D->getPosition());
1564 if (D->isExpandedParameterPack()) {
1565 for (unsigned I = 0, N = D->getNumExpansionTemplateParameters();
1567 Record.AddTemplateParameterList(D->getExpansionTemplateParameters(I));
1568 Code = serialization::DECL_EXPANDED_TEMPLATE_TEMPLATE_PARM_PACK;
1570 // Rest of TemplateTemplateParmDecl.
1571 Record.push_back(D->isParameterPack());
1572 bool OwnsDefaultArg = D->hasDefaultArgument() &&
1573 !D->defaultArgumentWasInherited();
1574 Record.push_back(OwnsDefaultArg);
1576 Record.AddTemplateArgumentLoc(D->getDefaultArgument());
1577 Code = serialization::DECL_TEMPLATE_TEMPLATE_PARM;
1581 void ASTDeclWriter::VisitTypeAliasTemplateDecl(TypeAliasTemplateDecl *D) {
1582 VisitRedeclarableTemplateDecl(D);
1583 Code = serialization::DECL_TYPE_ALIAS_TEMPLATE;
1586 void ASTDeclWriter::VisitStaticAssertDecl(StaticAssertDecl *D) {
1588 Record.AddStmt(D->getAssertExpr());
1589 Record.push_back(D->isFailed());
1590 Record.AddStmt(D->getMessage());
1591 Record.AddSourceLocation(D->getRParenLoc());
1592 Code = serialization::DECL_STATIC_ASSERT;
1595 /// \brief Emit the DeclContext part of a declaration context decl.
1596 void ASTDeclWriter::VisitDeclContext(DeclContext *DC) {
1597 Record.AddOffset(Writer.WriteDeclContextLexicalBlock(Context, DC));
1598 Record.AddOffset(Writer.WriteDeclContextVisibleBlock(Context, DC));
1601 const Decl *ASTWriter::getFirstLocalDecl(const Decl *D) {
1602 assert(IsLocalDecl(D) && "expected a local declaration");
1604 const Decl *Canon = D->getCanonicalDecl();
1605 if (IsLocalDecl(Canon))
1608 const Decl *&CacheEntry = FirstLocalDeclCache[Canon];
1612 for (const Decl *Redecl = D; Redecl; Redecl = Redecl->getPreviousDecl())
1613 if (IsLocalDecl(Redecl))
1615 return CacheEntry = D;
1618 template <typename T>
1619 void ASTDeclWriter::VisitRedeclarable(Redeclarable<T> *D) {
1620 T *First = D->getFirstDecl();
1621 T *MostRecent = First->getMostRecentDecl();
1622 T *DAsT = static_cast<T *>(D);
1623 if (MostRecent != First) {
1624 assert(isRedeclarableDeclKind(DAsT->getKind()) &&
1625 "Not considered redeclarable?");
1627 Record.AddDeclRef(First);
1629 // Write out a list of local redeclarations of this declaration if it's the
1630 // first local declaration in the chain.
1631 const Decl *FirstLocal = Writer.getFirstLocalDecl(DAsT);
1632 if (DAsT == FirstLocal) {
1633 // Emit a list of all imported first declarations so that we can be sure
1634 // that all redeclarations visible to this module are before D in the
1636 unsigned I = Record.size();
1637 Record.push_back(0);
1639 AddFirstDeclFromEachModule(DAsT, /*IncludeLocal*/false);
1640 // This is the number of imported first declarations + 1.
1641 Record[I] = Record.size() - I;
1643 // Collect the set of local redeclarations of this declaration, from
1644 // newest to oldest.
1645 ASTWriter::RecordData LocalRedecls;
1646 ASTRecordWriter LocalRedeclWriter(Record, LocalRedecls);
1647 for (const Decl *Prev = FirstLocal->getMostRecentDecl();
1648 Prev != FirstLocal; Prev = Prev->getPreviousDecl())
1649 if (!Prev->isFromASTFile())
1650 LocalRedeclWriter.AddDeclRef(Prev);
1652 // If we have any redecls, write them now as a separate record preceding
1653 // the declaration itself.
1654 if (LocalRedecls.empty())
1655 Record.push_back(0);
1657 Record.AddOffset(LocalRedeclWriter.Emit(LOCAL_REDECLARATIONS));
1659 Record.push_back(0);
1660 Record.AddDeclRef(FirstLocal);
1663 // Make sure that we serialize both the previous and the most-recent
1664 // declarations, which (transitively) ensures that all declarations in the
1665 // chain get serialized.
1667 // FIXME: This is not correct; when we reach an imported declaration we
1668 // won't emit its previous declaration.
1669 (void)Writer.GetDeclRef(D->getPreviousDecl());
1670 (void)Writer.GetDeclRef(MostRecent);
1672 // We use the sentinel value 0 to indicate an only declaration.
1673 Record.push_back(0);
1677 void ASTDeclWriter::VisitOMPThreadPrivateDecl(OMPThreadPrivateDecl *D) {
1678 Record.push_back(D->varlist_size());
1680 for (auto *I : D->varlists())
1682 Code = serialization::DECL_OMP_THREADPRIVATE;
1685 void ASTDeclWriter::VisitOMPDeclareReductionDecl(OMPDeclareReductionDecl *D) {
1687 Record.AddSourceLocation(D->getLocStart());
1688 Record.AddStmt(D->getCombiner());
1689 Record.AddStmt(D->getInitializer());
1690 Record.AddDeclRef(D->getPrevDeclInScope());
1691 Code = serialization::DECL_OMP_DECLARE_REDUCTION;
1694 void ASTDeclWriter::VisitOMPCapturedExprDecl(OMPCapturedExprDecl *D) {
1696 Code = serialization::DECL_OMP_CAPTUREDEXPR;
1699 //===----------------------------------------------------------------------===//
1700 // ASTWriter Implementation
1701 //===----------------------------------------------------------------------===//
1703 void ASTWriter::WriteDeclAbbrevs() {
1704 using namespace llvm;
1706 std::shared_ptr<BitCodeAbbrev> Abv;
1708 // Abbreviation for DECL_FIELD
1709 Abv = std::make_shared<BitCodeAbbrev>();
1710 Abv->Add(BitCodeAbbrevOp(serialization::DECL_FIELD));
1712 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclContext
1713 Abv->Add(BitCodeAbbrevOp(0)); // LexicalDeclContext
1714 Abv->Add(BitCodeAbbrevOp(0)); // isInvalidDecl
1715 Abv->Add(BitCodeAbbrevOp(0)); // HasAttrs
1716 Abv->Add(BitCodeAbbrevOp(0)); // isImplicit
1717 Abv->Add(BitCodeAbbrevOp(0)); // isUsed
1718 Abv->Add(BitCodeAbbrevOp(0)); // isReferenced
1719 Abv->Add(BitCodeAbbrevOp(0)); // TopLevelDeclInObjCContainer
1720 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2)); // AccessSpecifier
1721 Abv->Add(BitCodeAbbrevOp(0)); // ModulePrivate
1722 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SubmoduleID
1724 Abv->Add(BitCodeAbbrevOp(0)); // NameKind = Identifier
1725 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Name
1726 Abv->Add(BitCodeAbbrevOp(0)); // AnonDeclNumber
1728 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type
1730 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // InnerStartLoc
1731 Abv->Add(BitCodeAbbrevOp(0)); // hasExtInfo
1733 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isMutable
1734 Abv->Add(BitCodeAbbrevOp(0)); //getBitWidth
1736 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));
1737 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
1738 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // TypeLoc
1739 DeclFieldAbbrev = Stream.EmitAbbrev(std::move(Abv));
1741 // Abbreviation for DECL_OBJC_IVAR
1742 Abv = std::make_shared<BitCodeAbbrev>();
1743 Abv->Add(BitCodeAbbrevOp(serialization::DECL_OBJC_IVAR));
1745 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclContext
1746 Abv->Add(BitCodeAbbrevOp(0)); // LexicalDeclContext
1747 Abv->Add(BitCodeAbbrevOp(0)); // isInvalidDecl
1748 Abv->Add(BitCodeAbbrevOp(0)); // HasAttrs
1749 Abv->Add(BitCodeAbbrevOp(0)); // isImplicit
1750 Abv->Add(BitCodeAbbrevOp(0)); // isUsed
1751 Abv->Add(BitCodeAbbrevOp(0)); // isReferenced
1752 Abv->Add(BitCodeAbbrevOp(0)); // TopLevelDeclInObjCContainer
1753 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2)); // AccessSpecifier
1754 Abv->Add(BitCodeAbbrevOp(0)); // ModulePrivate
1755 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SubmoduleID
1757 Abv->Add(BitCodeAbbrevOp(0)); // NameKind = Identifier
1758 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Name
1759 Abv->Add(BitCodeAbbrevOp(0)); // AnonDeclNumber
1761 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type
1763 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // InnerStartLoc
1764 Abv->Add(BitCodeAbbrevOp(0)); // hasExtInfo
1766 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isMutable
1767 Abv->Add(BitCodeAbbrevOp(0)); //getBitWidth
1769 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // getAccessControl
1770 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // getSynthesize
1772 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));
1773 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
1774 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // TypeLoc
1775 DeclObjCIvarAbbrev = Stream.EmitAbbrev(std::move(Abv));
1777 // Abbreviation for DECL_ENUM
1778 Abv = std::make_shared<BitCodeAbbrev>();
1779 Abv->Add(BitCodeAbbrevOp(serialization::DECL_ENUM));
1781 Abv->Add(BitCodeAbbrevOp(0)); // No redeclaration
1783 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclContext
1784 Abv->Add(BitCodeAbbrevOp(0)); // LexicalDeclContext
1785 Abv->Add(BitCodeAbbrevOp(0)); // isInvalidDecl
1786 Abv->Add(BitCodeAbbrevOp(0)); // HasAttrs
1787 Abv->Add(BitCodeAbbrevOp(0)); // isImplicit
1788 Abv->Add(BitCodeAbbrevOp(0)); // isUsed
1789 Abv->Add(BitCodeAbbrevOp(0)); // isReferenced
1790 Abv->Add(BitCodeAbbrevOp(0)); // TopLevelDeclInObjCContainer
1791 Abv->Add(BitCodeAbbrevOp(AS_none)); // C++ AccessSpecifier
1792 Abv->Add(BitCodeAbbrevOp(0)); // ModulePrivate
1793 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SubmoduleID
1795 Abv->Add(BitCodeAbbrevOp(0)); // NameKind = Identifier
1796 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Name
1797 Abv->Add(BitCodeAbbrevOp(0)); // AnonDeclNumber
1799 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Source Location
1800 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type Ref
1802 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // IdentifierNamespace
1803 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // getTagKind
1804 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isCompleteDefinition
1805 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // EmbeddedInDeclarator
1806 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsFreeStanding
1807 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsCompleteDefinitionRequired
1808 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SourceLocation
1809 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SourceLocation
1810 Abv->Add(BitCodeAbbrevOp(0)); // ExtInfoKind
1812 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // AddTypeRef
1813 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // IntegerType
1814 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // getPromotionType
1815 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // getNumPositiveBits
1816 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // getNumNegativeBits
1817 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isScoped
1818 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isScopedUsingClassTag
1819 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isFixed
1820 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // InstantiatedMembEnum
1822 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // LexicalOffset
1823 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // VisibleOffset
1824 DeclEnumAbbrev = Stream.EmitAbbrev(std::move(Abv));
1826 // Abbreviation for DECL_RECORD
1827 Abv = std::make_shared<BitCodeAbbrev>();
1828 Abv->Add(BitCodeAbbrevOp(serialization::DECL_RECORD));
1830 Abv->Add(BitCodeAbbrevOp(0)); // No redeclaration
1832 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclContext
1833 Abv->Add(BitCodeAbbrevOp(0)); // LexicalDeclContext
1834 Abv->Add(BitCodeAbbrevOp(0)); // isInvalidDecl
1835 Abv->Add(BitCodeAbbrevOp(0)); // HasAttrs
1836 Abv->Add(BitCodeAbbrevOp(0)); // isImplicit
1837 Abv->Add(BitCodeAbbrevOp(0)); // isUsed
1838 Abv->Add(BitCodeAbbrevOp(0)); // isReferenced
1839 Abv->Add(BitCodeAbbrevOp(0)); // TopLevelDeclInObjCContainer
1840 Abv->Add(BitCodeAbbrevOp(AS_none)); // C++ AccessSpecifier
1841 Abv->Add(BitCodeAbbrevOp(0)); // ModulePrivate
1842 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SubmoduleID
1844 Abv->Add(BitCodeAbbrevOp(0)); // NameKind = Identifier
1845 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Name
1846 Abv->Add(BitCodeAbbrevOp(0)); // AnonDeclNumber
1848 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Source Location
1849 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type Ref
1851 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // IdentifierNamespace
1852 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // getTagKind
1853 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isCompleteDefinition
1854 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // EmbeddedInDeclarator
1855 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsFreeStanding
1856 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsCompleteDefinitionRequired
1857 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SourceLocation
1858 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SourceLocation
1859 Abv->Add(BitCodeAbbrevOp(0)); // ExtInfoKind
1861 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // FlexibleArrayMember
1862 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // AnonymousStructUnion
1863 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // hasObjectMember
1864 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // hasVolatileMember
1866 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // LexicalOffset
1867 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // VisibleOffset
1868 DeclRecordAbbrev = Stream.EmitAbbrev(std::move(Abv));
1870 // Abbreviation for DECL_PARM_VAR
1871 Abv = std::make_shared<BitCodeAbbrev>();
1872 Abv->Add(BitCodeAbbrevOp(serialization::DECL_PARM_VAR));
1874 Abv->Add(BitCodeAbbrevOp(0)); // No redeclaration
1876 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclContext
1877 Abv->Add(BitCodeAbbrevOp(0)); // LexicalDeclContext
1878 Abv->Add(BitCodeAbbrevOp(0)); // isInvalidDecl
1879 Abv->Add(BitCodeAbbrevOp(0)); // HasAttrs
1880 Abv->Add(BitCodeAbbrevOp(0)); // isImplicit
1881 Abv->Add(BitCodeAbbrevOp(0)); // isUsed
1882 Abv->Add(BitCodeAbbrevOp(0)); // isReferenced
1883 Abv->Add(BitCodeAbbrevOp(0)); // TopLevelDeclInObjCContainer
1884 Abv->Add(BitCodeAbbrevOp(AS_none)); // C++ AccessSpecifier
1885 Abv->Add(BitCodeAbbrevOp(0)); // ModulePrivate
1886 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SubmoduleID
1888 Abv->Add(BitCodeAbbrevOp(0)); // NameKind = Identifier
1889 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Name
1890 Abv->Add(BitCodeAbbrevOp(0)); // AnonDeclNumber
1892 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type
1894 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // InnerStartLoc
1895 Abv->Add(BitCodeAbbrevOp(0)); // hasExtInfo
1897 Abv->Add(BitCodeAbbrevOp(0)); // SClass
1898 Abv->Add(BitCodeAbbrevOp(0)); // TSCSpec
1899 Abv->Add(BitCodeAbbrevOp(0)); // InitStyle
1900 Abv->Add(BitCodeAbbrevOp(0)); // Linkage
1901 Abv->Add(BitCodeAbbrevOp(0)); // HasInit
1902 Abv->Add(BitCodeAbbrevOp(0)); // HasMemberSpecializationInfo
1904 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsObjCMethodParameter
1905 Abv->Add(BitCodeAbbrevOp(0)); // ScopeDepth
1906 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // ScopeIndex
1907 Abv->Add(BitCodeAbbrevOp(0)); // ObjCDeclQualifier
1908 Abv->Add(BitCodeAbbrevOp(0)); // KNRPromoted
1909 Abv->Add(BitCodeAbbrevOp(0)); // HasInheritedDefaultArg
1910 Abv->Add(BitCodeAbbrevOp(0)); // HasUninstantiatedDefaultArg
1912 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));
1913 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
1914 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // TypeLoc
1915 DeclParmVarAbbrev = Stream.EmitAbbrev(std::move(Abv));
1917 // Abbreviation for DECL_TYPEDEF
1918 Abv = std::make_shared<BitCodeAbbrev>();
1919 Abv->Add(BitCodeAbbrevOp(serialization::DECL_TYPEDEF));
1921 Abv->Add(BitCodeAbbrevOp(0)); // No redeclaration
1923 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclContext
1924 Abv->Add(BitCodeAbbrevOp(0)); // LexicalDeclContext
1925 Abv->Add(BitCodeAbbrevOp(0)); // isInvalidDecl
1926 Abv->Add(BitCodeAbbrevOp(0)); // HasAttrs
1927 Abv->Add(BitCodeAbbrevOp(0)); // isImplicit
1928 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isUsed
1929 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isReferenced
1930 Abv->Add(BitCodeAbbrevOp(0)); // TopLevelDeclInObjCContainer
1931 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2)); // C++ AccessSpecifier
1932 Abv->Add(BitCodeAbbrevOp(0)); // ModulePrivate
1933 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SubmoduleID
1935 Abv->Add(BitCodeAbbrevOp(0)); // NameKind = Identifier
1936 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Name
1937 Abv->Add(BitCodeAbbrevOp(0)); // AnonDeclNumber
1939 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Source Location
1940 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type Ref
1942 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
1943 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // TypeLoc
1944 DeclTypedefAbbrev = Stream.EmitAbbrev(std::move(Abv));
1946 // Abbreviation for DECL_VAR
1947 Abv = std::make_shared<BitCodeAbbrev>();
1948 Abv->Add(BitCodeAbbrevOp(serialization::DECL_VAR));
1950 Abv->Add(BitCodeAbbrevOp(0)); // No redeclaration
1952 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclContext
1953 Abv->Add(BitCodeAbbrevOp(0)); // LexicalDeclContext
1954 Abv->Add(BitCodeAbbrevOp(0)); // isInvalidDecl
1955 Abv->Add(BitCodeAbbrevOp(0)); // HasAttrs
1956 Abv->Add(BitCodeAbbrevOp(0)); // isImplicit
1957 Abv->Add(BitCodeAbbrevOp(0)); // isUsed
1958 Abv->Add(BitCodeAbbrevOp(0)); // isReferenced
1959 Abv->Add(BitCodeAbbrevOp(0)); // TopLevelDeclInObjCContainer
1960 Abv->Add(BitCodeAbbrevOp(AS_none)); // C++ AccessSpecifier
1961 Abv->Add(BitCodeAbbrevOp(0)); // ModulePrivate
1962 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SubmoduleID
1964 Abv->Add(BitCodeAbbrevOp(0)); // NameKind = Identifier
1965 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Name
1966 Abv->Add(BitCodeAbbrevOp(0)); // AnonDeclNumber
1968 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type
1970 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // InnerStartLoc
1971 Abv->Add(BitCodeAbbrevOp(0)); // hasExtInfo
1973 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); // SClass
1974 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2)); // TSCSpec
1975 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2)); // InitStyle
1976 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsThisDeclarationADemotedDefinition
1977 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isExceptionVariable
1978 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isNRVOVariable
1979 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isCXXForRangeDecl
1980 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isARCPseudoStrong
1981 Abv->Add(BitCodeAbbrevOp(0)); // isInline
1982 Abv->Add(BitCodeAbbrevOp(0)); // isInlineSpecified
1983 Abv->Add(BitCodeAbbrevOp(0)); // isConstexpr
1984 Abv->Add(BitCodeAbbrevOp(0)); // isInitCapture
1985 Abv->Add(BitCodeAbbrevOp(0)); // isPrevDeclInSameScope
1986 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); // Linkage
1987 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2)); // IsInitICE (local)
1988 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2)); // VarKind (local enum)
1990 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));
1991 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
1992 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // TypeLoc
1993 DeclVarAbbrev = Stream.EmitAbbrev(std::move(Abv));
1995 // Abbreviation for DECL_CXX_METHOD
1996 Abv = std::make_shared<BitCodeAbbrev>();
1997 Abv->Add(BitCodeAbbrevOp(serialization::DECL_CXX_METHOD));
1999 Abv->Add(BitCodeAbbrevOp(0)); // CanonicalDecl
2001 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclContext
2002 Abv->Add(BitCodeAbbrevOp(0)); // LexicalDeclContext
2003 Abv->Add(BitCodeAbbrevOp(0)); // Invalid
2004 Abv->Add(BitCodeAbbrevOp(0)); // HasAttrs
2005 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Implicit
2006 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Used
2007 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Referenced
2008 Abv->Add(BitCodeAbbrevOp(0)); // InObjCContainer
2009 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2)); // Access
2010 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // ModulePrivate
2011 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SubmoduleID
2013 Abv->Add(BitCodeAbbrevOp(DeclarationName::Identifier)); // NameKind
2014 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Identifier
2015 Abv->Add(BitCodeAbbrevOp(0)); // AnonDeclNumber
2017 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type
2019 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // InnerLocStart
2020 Abv->Add(BitCodeAbbrevOp(0)); // HasExtInfo
2022 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 11)); // IDNS
2023 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); // StorageClass
2024 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Inline
2025 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // InlineSpecified
2026 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // VirtualAsWritten
2027 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Pure
2028 Abv->Add(BitCodeAbbrevOp(0)); // HasInheritedProto
2029 Abv->Add(BitCodeAbbrevOp(1)); // HasWrittenProto
2030 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Deleted
2031 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Trivial
2032 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Defaulted
2033 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // ExplicitlyDefaulted
2034 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // ImplicitReturnZero
2035 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Constexpr
2036 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // UsesSEHTry
2037 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // SkippedBody
2038 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // LateParsed
2039 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); // Linkage
2040 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // LocEnd
2041 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); // TemplateKind
2042 // This Array slurps the rest of the record. Fortunately we want to encode
2043 // (nearly) all the remaining (variable number of) fields in the same way.
2045 // This is the function template information if any, then
2046 // NumParams and Params[] from FunctionDecl, and
2047 // NumOverriddenMethods, OverriddenMethods[] from CXXMethodDecl.
2049 // Add an AbbrevOp for 'size then elements' and use it here.
2050 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
2051 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));
2052 DeclCXXMethodAbbrev = Stream.EmitAbbrev(std::move(Abv));
2054 // Abbreviation for EXPR_DECL_REF
2055 Abv = std::make_shared<BitCodeAbbrev>();
2056 Abv->Add(BitCodeAbbrevOp(serialization::EXPR_DECL_REF));
2059 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type
2060 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //TypeDependent
2061 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //ValueDependent
2062 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //InstantiationDependent
2063 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //UnexpandedParamPack
2064 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); //GetValueKind
2065 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); //GetObjectKind
2067 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //HasQualifier
2068 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //GetDeclFound
2069 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //ExplicitTemplateArgs
2070 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //HadMultipleCandidates
2071 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed,
2072 1)); // RefersToEnclosingVariableOrCapture
2073 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclRef
2074 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Location
2075 DeclRefExprAbbrev = Stream.EmitAbbrev(std::move(Abv));
2077 // Abbreviation for EXPR_INTEGER_LITERAL
2078 Abv = std::make_shared<BitCodeAbbrev>();
2079 Abv->Add(BitCodeAbbrevOp(serialization::EXPR_INTEGER_LITERAL));
2082 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type
2083 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //TypeDependent
2084 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //ValueDependent
2085 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //InstantiationDependent
2086 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //UnexpandedParamPack
2087 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); //GetValueKind
2088 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); //GetObjectKind
2090 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Location
2091 Abv->Add(BitCodeAbbrevOp(32)); // Bit Width
2092 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Value
2093 IntegerLiteralAbbrev = Stream.EmitAbbrev(std::move(Abv));
2095 // Abbreviation for EXPR_CHARACTER_LITERAL
2096 Abv = std::make_shared<BitCodeAbbrev>();
2097 Abv->Add(BitCodeAbbrevOp(serialization::EXPR_CHARACTER_LITERAL));
2100 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type
2101 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //TypeDependent
2102 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //ValueDependent
2103 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //InstantiationDependent
2104 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //UnexpandedParamPack
2105 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); //GetValueKind
2106 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); //GetObjectKind
2108 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // getValue
2109 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Location
2110 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); // getKind
2111 CharacterLiteralAbbrev = Stream.EmitAbbrev(std::move(Abv));
2113 // Abbreviation for EXPR_IMPLICIT_CAST
2114 Abv = std::make_shared<BitCodeAbbrev>();
2115 Abv->Add(BitCodeAbbrevOp(serialization::EXPR_IMPLICIT_CAST));
2118 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type
2119 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //TypeDependent
2120 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //ValueDependent
2121 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //InstantiationDependent
2122 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //UnexpandedParamPack
2123 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); //GetValueKind
2124 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); //GetObjectKind
2126 Abv->Add(BitCodeAbbrevOp(0)); // PathSize
2127 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 6)); // CastKind
2129 ExprImplicitCastAbbrev = Stream.EmitAbbrev(std::move(Abv));
2131 Abv = std::make_shared<BitCodeAbbrev>();
2132 Abv->Add(BitCodeAbbrevOp(serialization::DECL_CONTEXT_LEXICAL));
2133 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
2134 DeclContextLexicalAbbrev = Stream.EmitAbbrev(std::move(Abv));
2136 Abv = std::make_shared<BitCodeAbbrev>();
2137 Abv->Add(BitCodeAbbrevOp(serialization::DECL_CONTEXT_VISIBLE));
2138 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
2139 DeclContextVisibleLookupAbbrev = Stream.EmitAbbrev(std::move(Abv));
2142 /// isRequiredDecl - Check if this is a "required" Decl, which must be seen by
2143 /// consumers of the AST.
2145 /// Such decls will always be deserialized from the AST file, so we would like
2146 /// this to be as restrictive as possible. Currently the predicate is driven by
2147 /// code generation requirements, if other clients have a different notion of
2148 /// what is "required" then we may have to consider an alternate scheme where
2149 /// clients can iterate over the top-level decls and get information on them,
2150 /// without necessary deserializing them. We could explicitly require such
2151 /// clients to use a separate API call to "realize" the decl. This should be
2152 /// relatively painless since they would presumably only do it for top-level
2154 static bool isRequiredDecl(const Decl *D, ASTContext &Context,
2155 bool WritingModule) {
2156 // An ObjCMethodDecl is never considered as "required" because its
2157 // implementation container always is.
2159 // File scoped assembly or obj-c or OMP declare target implementation must be
2161 if (isa<FileScopeAsmDecl>(D) || isa<ObjCImplDecl>(D) ||
2162 D->hasAttr<OMPDeclareTargetDeclAttr>())
2165 if (WritingModule && (isa<VarDecl>(D) || isa<ImportDecl>(D))) {
2166 // These declarations are part of the module initializer, and are emitted
2167 // if and when the module is imported, rather than being emitted eagerly.
2171 return Context.DeclMustBeEmitted(D);
2174 void ASTWriter::WriteDecl(ASTContext &Context, Decl *D) {
2175 // Determine the ID for this declaration.
2176 serialization::DeclID ID;
2177 assert(!D->isFromASTFile() && "should not be emitting imported decl");
2178 serialization::DeclID &IDR = DeclIDs[D];
2184 assert(ID >= FirstDeclID && "invalid decl ID");
2187 ASTDeclWriter W(*this, Context, Record);
2189 // Build a record for this declaration
2192 // Emit this declaration to the bitstream.
2193 uint64_t Offset = W.Emit(D);
2195 // Record the offset for this declaration
2196 SourceLocation Loc = D->getLocation();
2197 unsigned Index = ID - FirstDeclID;
2198 if (DeclOffsets.size() == Index)
2199 DeclOffsets.push_back(DeclOffset(Loc, Offset));
2200 else if (DeclOffsets.size() < Index) {
2201 // FIXME: Can/should this happen?
2202 DeclOffsets.resize(Index+1);
2203 DeclOffsets[Index].setLocation(Loc);
2204 DeclOffsets[Index].BitOffset = Offset;
2206 llvm_unreachable("declarations should be emitted in ID order");
2209 SourceManager &SM = Context.getSourceManager();
2210 if (Loc.isValid() && SM.isLocalSourceLocation(Loc))
2211 associateDeclWithFile(D, ID);
2213 // Note declarations that should be deserialized eagerly so that we can add
2214 // them to a record in the AST file later.
2215 if (isRequiredDecl(D, Context, WritingModule))
2216 EagerlyDeserializedDecls.push_back(ID);
2219 void ASTRecordWriter::AddFunctionDefinition(const FunctionDecl *FD) {
2220 // Switch case IDs are per function body.
2221 Writer->ClearSwitchCaseIDs();
2223 assert(FD->doesThisDeclarationHaveABody());
2224 if (auto *CD = dyn_cast<CXXConstructorDecl>(FD)) {
2225 Record->push_back(CD->getNumCtorInitializers());
2226 if (CD->getNumCtorInitializers())
2227 AddCXXCtorInitializers(
2228 llvm::makeArrayRef(CD->init_begin(), CD->init_end()));
2230 AddStmt(FD->getBody());