1//===--- ASTWriterDecl.cpp - Declaration Serialization --------------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This file implements serialization for Declarations.
10//
11//===----------------------------------------------------------------------===//
12
13#include "ASTCommon.h"
14#include "clang/AST/Attr.h"
15#include "clang/AST/DeclCXX.h"
16#include "clang/AST/DeclTemplate.h"
17#include "clang/AST/DeclVisitor.h"
18#include "clang/AST/Expr.h"
19#include "clang/AST/OpenMPClause.h"
20#include "clang/AST/PrettyDeclStackTrace.h"
21#include "clang/Basic/SourceManager.h"
22#include "clang/Serialization/ASTReader.h"
23#include "clang/Serialization/ASTRecordWriter.h"
24#include "llvm/Bitstream/BitstreamWriter.h"
25#include "llvm/Support/ErrorHandling.h"
26using namespace clang;
27using namespace serialization;
28
29//===----------------------------------------------------------------------===//
30// Utility functions
31//===----------------------------------------------------------------------===//
32
33namespace {
34
35// Helper function that returns true if the decl passed in the argument is
36// a defintion in dependent contxt.
37template <typename DT> bool isDefinitionInDependentContext(DT *D) {
38 return D->isDependentContext() && D->isThisDeclarationADefinition();
39}
40
41} // namespace
42
43//===----------------------------------------------------------------------===//
44// Declaration serialization
45//===----------------------------------------------------------------------===//
46
47namespace clang {
48 class ASTDeclWriter : public DeclVisitor<ASTDeclWriter, void> {
49 ASTWriter &Writer;
50 ASTRecordWriter Record;
51
52 serialization::DeclCode Code;
53 unsigned AbbrevToUse;
54
55 bool GeneratingReducedBMI = false;
56
57 public:
58 ASTDeclWriter(ASTWriter &Writer, ASTContext &Context,
59 ASTWriter::RecordDataImpl &Record, bool GeneratingReducedBMI)
60 : Writer(Writer), Record(Context, Writer, Record),
61 Code((serialization::DeclCode)0), AbbrevToUse(0),
62 GeneratingReducedBMI(GeneratingReducedBMI) {}
63
64 uint64_t Emit(Decl *D) {
65 if (!Code)
66 llvm::report_fatal_error(reason: StringRef("unexpected declaration kind '") +
67 D->getDeclKindName() + "'");
68 return Record.Emit(Code, Abbrev: AbbrevToUse);
69 }
70
71 void Visit(Decl *D);
72
73 void VisitDecl(Decl *D);
74 void VisitPragmaCommentDecl(PragmaCommentDecl *D);
75 void VisitPragmaDetectMismatchDecl(PragmaDetectMismatchDecl *D);
76 void VisitTranslationUnitDecl(TranslationUnitDecl *D);
77 void VisitNamedDecl(NamedDecl *D);
78 void VisitLabelDecl(LabelDecl *LD);
79 void VisitNamespaceDecl(NamespaceDecl *D);
80 void VisitUsingDirectiveDecl(UsingDirectiveDecl *D);
81 void VisitNamespaceAliasDecl(NamespaceAliasDecl *D);
82 void VisitTypeDecl(TypeDecl *D);
83 void VisitTypedefNameDecl(TypedefNameDecl *D);
84 void VisitTypedefDecl(TypedefDecl *D);
85 void VisitTypeAliasDecl(TypeAliasDecl *D);
86 void VisitUnresolvedUsingTypenameDecl(UnresolvedUsingTypenameDecl *D);
87 void VisitUnresolvedUsingIfExistsDecl(UnresolvedUsingIfExistsDecl *D);
88 void VisitTagDecl(TagDecl *D);
89 void VisitEnumDecl(EnumDecl *D);
90 void VisitRecordDecl(RecordDecl *D);
91 void VisitCXXRecordDecl(CXXRecordDecl *D);
92 void VisitClassTemplateSpecializationDecl(
93 ClassTemplateSpecializationDecl *D);
94 void VisitClassTemplatePartialSpecializationDecl(
95 ClassTemplatePartialSpecializationDecl *D);
96 void VisitVarTemplateSpecializationDecl(VarTemplateSpecializationDecl *D);
97 void VisitVarTemplatePartialSpecializationDecl(
98 VarTemplatePartialSpecializationDecl *D);
99 void VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D);
100 void VisitValueDecl(ValueDecl *D);
101 void VisitEnumConstantDecl(EnumConstantDecl *D);
102 void VisitUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *D);
103 void VisitDeclaratorDecl(DeclaratorDecl *D);
104 void VisitFunctionDecl(FunctionDecl *D);
105 void VisitCXXDeductionGuideDecl(CXXDeductionGuideDecl *D);
106 void VisitCXXMethodDecl(CXXMethodDecl *D);
107 void VisitCXXConstructorDecl(CXXConstructorDecl *D);
108 void VisitCXXDestructorDecl(CXXDestructorDecl *D);
109 void VisitCXXConversionDecl(CXXConversionDecl *D);
110 void VisitFieldDecl(FieldDecl *D);
111 void VisitMSPropertyDecl(MSPropertyDecl *D);
112 void VisitMSGuidDecl(MSGuidDecl *D);
113 void VisitUnnamedGlobalConstantDecl(UnnamedGlobalConstantDecl *D);
114 void VisitTemplateParamObjectDecl(TemplateParamObjectDecl *D);
115 void VisitIndirectFieldDecl(IndirectFieldDecl *D);
116 void VisitVarDecl(VarDecl *D);
117 void VisitImplicitParamDecl(ImplicitParamDecl *D);
118 void VisitParmVarDecl(ParmVarDecl *D);
119 void VisitDecompositionDecl(DecompositionDecl *D);
120 void VisitBindingDecl(BindingDecl *D);
121 void VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D);
122 void VisitTemplateDecl(TemplateDecl *D);
123 void VisitConceptDecl(ConceptDecl *D);
124 void VisitImplicitConceptSpecializationDecl(
125 ImplicitConceptSpecializationDecl *D);
126 void VisitRequiresExprBodyDecl(RequiresExprBodyDecl *D);
127 void VisitRedeclarableTemplateDecl(RedeclarableTemplateDecl *D);
128 void VisitClassTemplateDecl(ClassTemplateDecl *D);
129 void VisitVarTemplateDecl(VarTemplateDecl *D);
130 void VisitFunctionTemplateDecl(FunctionTemplateDecl *D);
131 void VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D);
132 void VisitTypeAliasTemplateDecl(TypeAliasTemplateDecl *D);
133 void VisitUsingDecl(UsingDecl *D);
134 void VisitUsingEnumDecl(UsingEnumDecl *D);
135 void VisitUsingPackDecl(UsingPackDecl *D);
136 void VisitUsingShadowDecl(UsingShadowDecl *D);
137 void VisitConstructorUsingShadowDecl(ConstructorUsingShadowDecl *D);
138 void VisitLinkageSpecDecl(LinkageSpecDecl *D);
139 void VisitExportDecl(ExportDecl *D);
140 void VisitFileScopeAsmDecl(FileScopeAsmDecl *D);
141 void VisitTopLevelStmtDecl(TopLevelStmtDecl *D);
142 void VisitImportDecl(ImportDecl *D);
143 void VisitAccessSpecDecl(AccessSpecDecl *D);
144 void VisitFriendDecl(FriendDecl *D);
145 void VisitFriendTemplateDecl(FriendTemplateDecl *D);
146 void VisitStaticAssertDecl(StaticAssertDecl *D);
147 void VisitBlockDecl(BlockDecl *D);
148 void VisitOutlinedFunctionDecl(OutlinedFunctionDecl *D);
149 void VisitCapturedDecl(CapturedDecl *D);
150 void VisitEmptyDecl(EmptyDecl *D);
151 void VisitLifetimeExtendedTemporaryDecl(LifetimeExtendedTemporaryDecl *D);
152 void VisitDeclContext(DeclContext *DC);
153 template <typename T> void VisitRedeclarable(Redeclarable<T> *D);
154 void VisitHLSLBufferDecl(HLSLBufferDecl *D);
155
156 // FIXME: Put in the same order is DeclNodes.td?
157 void VisitObjCMethodDecl(ObjCMethodDecl *D);
158 void VisitObjCTypeParamDecl(ObjCTypeParamDecl *D);
159 void VisitObjCContainerDecl(ObjCContainerDecl *D);
160 void VisitObjCInterfaceDecl(ObjCInterfaceDecl *D);
161 void VisitObjCIvarDecl(ObjCIvarDecl *D);
162 void VisitObjCProtocolDecl(ObjCProtocolDecl *D);
163 void VisitObjCAtDefsFieldDecl(ObjCAtDefsFieldDecl *D);
164 void VisitObjCCategoryDecl(ObjCCategoryDecl *D);
165 void VisitObjCImplDecl(ObjCImplDecl *D);
166 void VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D);
167 void VisitObjCImplementationDecl(ObjCImplementationDecl *D);
168 void VisitObjCCompatibleAliasDecl(ObjCCompatibleAliasDecl *D);
169 void VisitObjCPropertyDecl(ObjCPropertyDecl *D);
170 void VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D);
171 void VisitOMPThreadPrivateDecl(OMPThreadPrivateDecl *D);
172 void VisitOMPAllocateDecl(OMPAllocateDecl *D);
173 void VisitOMPRequiresDecl(OMPRequiresDecl *D);
174 void VisitOMPDeclareReductionDecl(OMPDeclareReductionDecl *D);
175 void VisitOMPDeclareMapperDecl(OMPDeclareMapperDecl *D);
176 void VisitOMPCapturedExprDecl(OMPCapturedExprDecl *D);
177
178 void VisitOpenACCDeclareDecl(OpenACCDeclareDecl *D);
179 void VisitOpenACCRoutineDecl(OpenACCRoutineDecl *D);
180
181 /// Add an Objective-C type parameter list to the given record.
182 void AddObjCTypeParamList(ObjCTypeParamList *typeParams) {
183 // Empty type parameter list.
184 if (!typeParams) {
185 Record.push_back(N: 0);
186 return;
187 }
188
189 Record.push_back(N: typeParams->size());
190 for (auto *typeParam : *typeParams) {
191 Record.AddDeclRef(D: typeParam);
192 }
193 Record.AddSourceLocation(Loc: typeParams->getLAngleLoc());
194 Record.AddSourceLocation(Loc: typeParams->getRAngleLoc());
195 }
196
197 /// Add to the record the first declaration from each module file that
198 /// provides a declaration of D. The intent is to provide a sufficient
199 /// set such that reloading this set will load all current redeclarations.
200 void AddFirstDeclFromEachModule(const Decl *D, bool IncludeLocal) {
201 auto Firsts = Writer.CollectFirstDeclFromEachModule(D, IncludeLocal);
202 for (const auto &[_, First] : Firsts)
203 Record.AddDeclRef(D: First);
204 }
205
206 template <typename T> bool shouldSkipWritingSpecializations(T *Spec) {
207 // Now we will only avoid writing specializations if we're generating
208 // reduced BMI.
209 if (!GeneratingReducedBMI)
210 return false;
211
212 assert((isa<FunctionDecl, ClassTemplateSpecializationDecl,
213 VarTemplateSpecializationDecl>(Spec)));
214
215 ArrayRef<TemplateArgument> Args;
216 if (auto *CTSD = dyn_cast<ClassTemplateSpecializationDecl>(Spec))
217 Args = CTSD->getTemplateArgs().asArray();
218 else if (auto *VTSD = dyn_cast<VarTemplateSpecializationDecl>(Spec))
219 Args = VTSD->getTemplateArgs().asArray();
220 else
221 Args = cast<FunctionDecl>(Spec)
222 ->getTemplateSpecializationArgs()
223 ->asArray();
224
225 // If there is any template argument is TULocal, we can avoid writing the
226 // specialization since the consumers of reduced BMI won't get the
227 // specialization anyway.
228 for (const TemplateArgument &TA : Args) {
229 switch (TA.getKind()) {
230 case TemplateArgument::Type: {
231 Linkage L = TA.getAsType()->getLinkage();
232 if (!isExternallyVisible(L))
233 return true;
234 break;
235 }
236 case TemplateArgument::Declaration:
237 if (!TA.getAsDecl()->isExternallyVisible())
238 return true;
239 break;
240 default:
241 break;
242 }
243 }
244
245 return false;
246 }
247
248 /// Add to the record the first template specialization from each module
249 /// file that provides a declaration of D. We store the DeclId and an
250 /// ODRHash of the template arguments of D which should provide enough
251 /// information to load D only if the template instantiator needs it.
252 void AddFirstSpecializationDeclFromEachModule(
253 const Decl *D, llvm::SmallVectorImpl<const Decl *> &SpecsInMap,
254 llvm::SmallVectorImpl<const Decl *> &PartialSpecsInMap) {
255 assert((isa<ClassTemplateSpecializationDecl>(D) ||
256 isa<VarTemplateSpecializationDecl>(D) || isa<FunctionDecl>(D)) &&
257 "Must not be called with other decls");
258 auto Firsts =
259 Writer.CollectFirstDeclFromEachModule(D, /*IncludeLocal=*/true);
260 for (const auto &[_, First] : Firsts) {
261 if (shouldSkipWritingSpecializations(Spec: First))
262 continue;
263
264 if (isa<ClassTemplatePartialSpecializationDecl,
265 VarTemplatePartialSpecializationDecl>(Val: First))
266 PartialSpecsInMap.push_back(Elt: First);
267 else
268 SpecsInMap.push_back(Elt: First);
269 }
270 }
271
272 /// Get the specialization decl from an entry in the specialization list.
273 template <typename EntryType>
274 typename RedeclarableTemplateDecl::SpecEntryTraits<EntryType>::DeclType *
275 getSpecializationDecl(EntryType &T) {
276 return RedeclarableTemplateDecl::SpecEntryTraits<EntryType>::getDecl(&T);
277 }
278
279 /// Get the list of partial specializations from a template's common ptr.
280 template<typename T>
281 decltype(T::PartialSpecializations) &getPartialSpecializations(T *Common) {
282 return Common->PartialSpecializations;
283 }
284 MutableArrayRef<FunctionTemplateSpecializationInfo>
285 getPartialSpecializations(FunctionTemplateDecl::Common *) {
286 return {};
287 }
288
289 template<typename DeclTy>
290 void AddTemplateSpecializations(DeclTy *D) {
291 auto *Common = D->getCommonPtr();
292
293 // If we have any lazy specializations, and the external AST source is
294 // our chained AST reader, we can just write out the DeclIDs. Otherwise,
295 // we need to resolve them to actual declarations.
296 if (Writer.Chain != Record.getASTContext().getExternalSource() &&
297 Writer.Chain && Writer.Chain->haveUnloadedSpecializations(D)) {
298 D->LoadLazySpecializations();
299 assert(!Writer.Chain->haveUnloadedSpecializations(D));
300 }
301
302 // AddFirstSpecializationDeclFromEachModule might trigger deserialization,
303 // invalidating *Specializations iterators.
304 llvm::SmallVector<const Decl *, 16> AllSpecs;
305 for (auto &Entry : Common->Specializations)
306 AllSpecs.push_back(Elt: getSpecializationDecl(Entry));
307 for (auto &Entry : getPartialSpecializations(Common))
308 AllSpecs.push_back(Elt: getSpecializationDecl(Entry));
309
310 llvm::SmallVector<const Decl *, 16> Specs;
311 llvm::SmallVector<const Decl *, 16> PartialSpecs;
312 for (auto *D : AllSpecs) {
313 assert(D->isCanonicalDecl() && "non-canonical decl in set");
314 AddFirstSpecializationDeclFromEachModule(D, SpecsInMap&: Specs, PartialSpecsInMap&: PartialSpecs);
315 }
316
317 Record.AddOffset(BitOffset: Writer.WriteSpecializationInfoLookupTable(
318 D, Specializations&: Specs, /*IsPartial=*/false));
319
320 // Function Template Decl doesn't have partial decls.
321 if (isa<FunctionTemplateDecl>(D)) {
322 assert(PartialSpecs.empty());
323 return;
324 }
325
326 Record.AddOffset(BitOffset: Writer.WriteSpecializationInfoLookupTable(
327 D, Specializations&: PartialSpecs, /*IsPartial=*/true));
328 }
329
330 /// Ensure that this template specialization is associated with the specified
331 /// template on reload.
332 void RegisterTemplateSpecialization(const Decl *Template,
333 const Decl *Specialization) {
334 Template = Template->getCanonicalDecl();
335
336 // If the canonical template is local, we'll write out this specialization
337 // when we emit it.
338 // FIXME: We can do the same thing if there is any local declaration of
339 // the template, to avoid emitting an update record.
340 if (!Template->isFromASTFile())
341 return;
342
343 // We only need to associate the first local declaration of the
344 // specialization. The other declarations will get pulled in by it.
345 if (Writer.getFirstLocalDecl(D: Specialization) != Specialization)
346 return;
347
348 if (isa<ClassTemplatePartialSpecializationDecl,
349 VarTemplatePartialSpecializationDecl>(Val: Specialization))
350 Writer.PartialSpecializationsUpdates[cast<NamedDecl>(Val: Template)]
351 .push_back(Elt: cast<NamedDecl>(Val: Specialization));
352 else
353 Writer.SpecializationsUpdates[cast<NamedDecl>(Val: Template)].push_back(
354 Elt: cast<NamedDecl>(Val: Specialization));
355 }
356 };
357}
358
359// When building a C++20 module interface unit or a partition unit, a
360// strong definition in the module interface is provided by the
361// compilation of that unit, not by its users. (Inline variables are still
362// emitted in module users.)
363static bool shouldVarGenerateHereOnly(const VarDecl *VD) {
364 if (VD->getStorageDuration() != SD_Static &&
365 VD->getStorageDuration() != SD_Thread)
366 return false;
367
368 if (VD->getDescribedVarTemplate())
369 return false;
370
371 Module *M = VD->getOwningModule();
372 if (!M)
373 return false;
374
375 M = M->getTopLevelModule();
376 ASTContext &Ctx = VD->getASTContext();
377 if (!M->isInterfaceOrPartition() &&
378 (!VD->hasAttr<DLLExportAttr>() ||
379 !Ctx.getLangOpts().BuildingPCHWithObjectFile))
380 return false;
381
382 return Ctx.GetGVALinkageForVariable(VD) >= GVA_StrongExternal;
383}
384
385static bool shouldFunctionGenerateHereOnly(const FunctionDecl *FD) {
386 if (FD->isDependentContext())
387 return false;
388
389 ASTContext &Ctx = FD->getASTContext();
390 auto Linkage = Ctx.GetGVALinkageForFunction(FD);
391 if (Ctx.getLangOpts().ModulesCodegen ||
392 (FD->hasAttr<DLLExportAttr>() &&
393 Ctx.getLangOpts().BuildingPCHWithObjectFile))
394 // Under -fmodules-codegen, codegen is performed for all non-internal,
395 // non-always_inline functions, unless they are available elsewhere.
396 if (!FD->hasAttr<AlwaysInlineAttr>() && Linkage != GVA_Internal &&
397 Linkage != GVA_AvailableExternally)
398 return true;
399
400 Module *M = FD->getOwningModule();
401 if (!M)
402 return false;
403
404 M = M->getTopLevelModule();
405 if (M->isInterfaceOrPartition())
406 if (Linkage >= GVA_StrongExternal)
407 return true;
408
409 return false;
410}
411
412bool clang::CanElideDeclDef(const Decl *D) {
413 if (auto *FD = dyn_cast<FunctionDecl>(Val: D)) {
414 if (FD->isInlined() || FD->isConstexpr() || FD->isConsteval())
415 return false;
416
417 // If the function should be generated somewhere else, we shouldn't elide
418 // it.
419 if (!shouldFunctionGenerateHereOnly(FD))
420 return false;
421 }
422
423 if (auto *VD = dyn_cast<VarDecl>(Val: D)) {
424 if (VD->getDeclContext()->isDependentContext())
425 return false;
426
427 // Constant initialized variable may not affect the ABI, but they
428 // may be used in constant evaluation in the frontend, so we have
429 // to remain them.
430 if (VD->hasConstantInitialization() || VD->isConstexpr())
431 return false;
432
433 // If the variable should be generated somewhere else, we shouldn't elide
434 // it.
435 if (!shouldVarGenerateHereOnly(VD))
436 return false;
437 }
438
439 return true;
440}
441
442void ASTDeclWriter::Visit(Decl *D) {
443 DeclVisitor<ASTDeclWriter>::Visit(D);
444
445 // Source locations require array (variable-length) abbreviations. The
446 // abbreviation infrastructure requires that arrays are encoded last, so
447 // we handle it here in the case of those classes derived from DeclaratorDecl
448 if (auto *DD = dyn_cast<DeclaratorDecl>(Val: D)) {
449 if (auto *TInfo = DD->getTypeSourceInfo())
450 Record.AddTypeLoc(TL: TInfo->getTypeLoc());
451 }
452
453 // Handle FunctionDecl's body here and write it after all other Stmts/Exprs
454 // have been written. We want it last because we will not read it back when
455 // retrieving it from the AST, we'll just lazily set the offset.
456 if (auto *FD = dyn_cast<FunctionDecl>(Val: D)) {
457 if (!GeneratingReducedBMI || !CanElideDeclDef(D: FD)) {
458 Record.push_back(N: FD->doesThisDeclarationHaveABody());
459 if (FD->doesThisDeclarationHaveABody())
460 Record.AddFunctionDefinition(FD);
461 } else
462 Record.push_back(N: 0);
463 }
464
465 // Similar to FunctionDecls, handle VarDecl's initializer here and write it
466 // after all other Stmts/Exprs. We will not read the initializer until after
467 // we have finished recursive deserialization, because it can recursively
468 // refer back to the variable.
469 if (auto *VD = dyn_cast<VarDecl>(Val: D)) {
470 if (!GeneratingReducedBMI || !CanElideDeclDef(D: VD))
471 Record.AddVarDeclInit(VD);
472 else
473 Record.push_back(N: 0);
474 }
475
476 // And similarly for FieldDecls. We already serialized whether there is a
477 // default member initializer.
478 if (auto *FD = dyn_cast<FieldDecl>(Val: D)) {
479 if (FD->hasInClassInitializer()) {
480 if (Expr *Init = FD->getInClassInitializer()) {
481 Record.push_back(N: 1);
482 Record.AddStmt(S: Init);
483 } else {
484 Record.push_back(N: 0);
485 // Initializer has not been instantiated yet.
486 }
487 }
488 }
489
490 // If this declaration is also a DeclContext, write blocks for the
491 // declarations that lexically stored inside its context and those
492 // declarations that are visible from its context.
493 if (auto *DC = dyn_cast<DeclContext>(Val: D))
494 VisitDeclContext(DC);
495}
496
497void ASTDeclWriter::VisitDecl(Decl *D) {
498 BitsPacker DeclBits;
499
500 // The order matters here. It will be better to put the bit with higher
501 // probability to be 0 in the end of the bits.
502 //
503 // Since we're using VBR6 format to store it.
504 // It will be pretty effient if all the higher bits are 0.
505 // For example, if we need to pack 8 bits into a value and the stored value
506 // is 0xf0, the actual stored value will be 0b000111'110000, which takes 12
507 // bits actually. However, if we changed the order to be 0x0f, then we can
508 // store it as 0b001111, which takes 6 bits only now.
509 DeclBits.addBits(Value: (uint64_t)D->getModuleOwnershipKind(), /*BitWidth=*/BitsWidth: 3);
510 DeclBits.addBit(Value: D->isThisDeclarationReferenced());
511 // If we're writing a BMI for a named module unit, we can treat all decls as in
512 // the BMI as used. Otherwise, the consumer need to mark it as used again, this
513 // simply waste time.
514 DeclBits.addBit(Value: Writer.isWritingStdCXXNamedModules() ? true : D->isUsed(CheckUsedAttr: false));
515 DeclBits.addBits(Value: D->getAccess(), /*BitWidth=*/BitsWidth: 2);
516 DeclBits.addBit(Value: D->isImplicit());
517 DeclBits.addBit(Value: D->getDeclContext() != D->getLexicalDeclContext());
518 DeclBits.addBit(Value: D->hasAttrs());
519 DeclBits.addBit(Value: D->isTopLevelDeclInObjCContainer());
520 DeclBits.addBit(Value: D->isInvalidDecl());
521 Record.push_back(N: DeclBits);
522
523 Record.AddDeclRef(D: cast_or_null<Decl>(Val: D->getDeclContext()));
524 if (D->getDeclContext() != D->getLexicalDeclContext())
525 Record.AddDeclRef(D: cast_or_null<Decl>(Val: D->getLexicalDeclContext()));
526
527 if (D->hasAttrs())
528 Record.AddAttributes(Attrs: D->getAttrs());
529
530 Record.push_back(N: Writer.getSubmoduleID(Mod: D->getOwningModule()));
531
532 // If this declaration injected a name into a context different from its
533 // lexical context, and that context is an imported namespace, we need to
534 // update its visible declarations to include this name.
535 //
536 // This happens when we instantiate a class with a friend declaration or a
537 // function with a local extern declaration, for instance.
538 //
539 // FIXME: Can we handle this in AddedVisibleDecl instead?
540 if (D->isOutOfLine()) {
541 auto *DC = D->getDeclContext();
542 while (auto *NS = dyn_cast<NamespaceDecl>(Val: DC->getRedeclContext())) {
543 if (!NS->isFromASTFile())
544 break;
545 Writer.UpdatedDeclContexts.insert(X: NS->getPrimaryContext());
546 if (!NS->isInlineNamespace())
547 break;
548 DC = NS->getParent();
549 }
550 }
551}
552
553void ASTDeclWriter::VisitPragmaCommentDecl(PragmaCommentDecl *D) {
554 StringRef Arg = D->getArg();
555 Record.push_back(N: Arg.size());
556 VisitDecl(D);
557 Record.AddSourceLocation(Loc: D->getBeginLoc());
558 Record.push_back(N: D->getCommentKind());
559 Record.AddString(Str: Arg);
560 Code = serialization::DECL_PRAGMA_COMMENT;
561}
562
563void ASTDeclWriter::VisitPragmaDetectMismatchDecl(
564 PragmaDetectMismatchDecl *D) {
565 StringRef Name = D->getName();
566 StringRef Value = D->getValue();
567 Record.push_back(N: Name.size() + 1 + Value.size());
568 VisitDecl(D);
569 Record.AddSourceLocation(Loc: D->getBeginLoc());
570 Record.AddString(Str: Name);
571 Record.AddString(Str: Value);
572 Code = serialization::DECL_PRAGMA_DETECT_MISMATCH;
573}
574
575void ASTDeclWriter::VisitTranslationUnitDecl(TranslationUnitDecl *D) {
576 llvm_unreachable("Translation units aren't directly serialized");
577}
578
579void ASTDeclWriter::VisitNamedDecl(NamedDecl *D) {
580 VisitDecl(D);
581 Record.AddDeclarationName(Name: D->getDeclName());
582 Record.push_back(N: needsAnonymousDeclarationNumber(D)
583 ? Writer.getAnonymousDeclarationNumber(D)
584 : 0);
585}
586
587void ASTDeclWriter::VisitTypeDecl(TypeDecl *D) {
588 VisitNamedDecl(D);
589 Record.AddSourceLocation(Loc: D->getBeginLoc());
590 if (!isa<TagDecl, TypedefDecl, TypeAliasDecl>(Val: D))
591 Record.AddTypeRef(T: QualType(D->getTypeForDecl(), 0));
592}
593
594void ASTDeclWriter::VisitTypedefNameDecl(TypedefNameDecl *D) {
595 VisitRedeclarable(D);
596 VisitTypeDecl(D);
597 Record.AddTypeSourceInfo(TInfo: D->getTypeSourceInfo());
598 Record.push_back(N: D->isModed());
599 if (D->isModed())
600 Record.AddTypeRef(T: D->getUnderlyingType());
601 Record.AddDeclRef(D: D->getAnonDeclWithTypedefName(AnyRedecl: false));
602}
603
604void ASTDeclWriter::VisitTypedefDecl(TypedefDecl *D) {
605 VisitTypedefNameDecl(D);
606 if (D->getDeclContext() == D->getLexicalDeclContext() &&
607 !D->hasAttrs() &&
608 !D->isImplicit() &&
609 D->getFirstDecl() == D->getMostRecentDecl() &&
610 !D->isInvalidDecl() &&
611 !D->isTopLevelDeclInObjCContainer() &&
612 !D->isModulePrivate() &&
613 !needsAnonymousDeclarationNumber(D) &&
614 D->getDeclName().getNameKind() == DeclarationName::Identifier)
615 AbbrevToUse = Writer.getDeclTypedefAbbrev();
616
617 Code = serialization::DECL_TYPEDEF;
618}
619
620void ASTDeclWriter::VisitTypeAliasDecl(TypeAliasDecl *D) {
621 VisitTypedefNameDecl(D);
622 Record.AddDeclRef(D: D->getDescribedAliasTemplate());
623 Code = serialization::DECL_TYPEALIAS;
624}
625
626void ASTDeclWriter::VisitTagDecl(TagDecl *D) {
627 static_assert(DeclContext::NumTagDeclBits == 23,
628 "You need to update the serializer after you change the "
629 "TagDeclBits");
630
631 VisitRedeclarable(D);
632 VisitTypeDecl(D);
633 Record.push_back(N: D->getIdentifierNamespace());
634
635 BitsPacker TagDeclBits;
636 TagDeclBits.addBits(Value: llvm::to_underlying(E: D->getTagKind()), /*BitWidth=*/BitsWidth: 3);
637 TagDeclBits.addBit(Value: !isa<CXXRecordDecl>(Val: D) ? D->isCompleteDefinition() : 0);
638 TagDeclBits.addBit(Value: D->isEmbeddedInDeclarator());
639 TagDeclBits.addBit(Value: D->isFreeStanding());
640 TagDeclBits.addBit(Value: D->isCompleteDefinitionRequired());
641 TagDeclBits.addBits(
642 Value: D->hasExtInfo() ? 1 : (D->getTypedefNameForAnonDecl() ? 2 : 0),
643 /*BitWidth=*/BitsWidth: 2);
644 Record.push_back(N: TagDeclBits);
645
646 Record.AddSourceRange(Range: D->getBraceRange());
647
648 if (D->hasExtInfo()) {
649 Record.AddQualifierInfo(Info: *D->getExtInfo());
650 } else if (auto *TD = D->getTypedefNameForAnonDecl()) {
651 Record.AddDeclRef(D: TD);
652 Record.AddIdentifierRef(II: TD->getDeclName().getAsIdentifierInfo());
653 }
654}
655
656void ASTDeclWriter::VisitEnumDecl(EnumDecl *D) {
657 static_assert(DeclContext::NumEnumDeclBits == 43,
658 "You need to update the serializer after you change the "
659 "EnumDeclBits");
660
661 VisitTagDecl(D);
662 Record.AddTypeSourceInfo(TInfo: D->getIntegerTypeSourceInfo());
663 if (!D->getIntegerTypeSourceInfo())
664 Record.AddTypeRef(T: D->getIntegerType());
665 Record.AddTypeRef(T: D->getPromotionType());
666
667 BitsPacker EnumDeclBits;
668 EnumDeclBits.addBits(Value: D->getNumPositiveBits(), /*BitWidth=*/BitsWidth: 8);
669 EnumDeclBits.addBits(Value: D->getNumNegativeBits(), /*BitWidth=*/BitsWidth: 8);
670 EnumDeclBits.addBit(Value: D->isScoped());
671 EnumDeclBits.addBit(Value: D->isScopedUsingClassTag());
672 EnumDeclBits.addBit(Value: D->isFixed());
673 Record.push_back(N: EnumDeclBits);
674
675 Record.push_back(N: D->getODRHash());
676
677 if (MemberSpecializationInfo *MemberInfo = D->getMemberSpecializationInfo()) {
678 Record.AddDeclRef(D: MemberInfo->getInstantiatedFrom());
679 Record.push_back(N: MemberInfo->getTemplateSpecializationKind());
680 Record.AddSourceLocation(Loc: MemberInfo->getPointOfInstantiation());
681 } else {
682 Record.AddDeclRef(D: nullptr);
683 }
684
685 if (D->getDeclContext() == D->getLexicalDeclContext() && !D->hasAttrs() &&
686 !D->isInvalidDecl() && !D->isImplicit() && !D->hasExtInfo() &&
687 !D->getTypedefNameForAnonDecl() &&
688 D->getFirstDecl() == D->getMostRecentDecl() &&
689 !D->isTopLevelDeclInObjCContainer() &&
690 !CXXRecordDecl::classofKind(K: D->getKind()) &&
691 !D->getIntegerTypeSourceInfo() && !D->getMemberSpecializationInfo() &&
692 !needsAnonymousDeclarationNumber(D) &&
693 D->getDeclName().getNameKind() == DeclarationName::Identifier)
694 AbbrevToUse = Writer.getDeclEnumAbbrev();
695
696 Code = serialization::DECL_ENUM;
697}
698
699void ASTDeclWriter::VisitRecordDecl(RecordDecl *D) {
700 static_assert(DeclContext::NumRecordDeclBits == 64,
701 "You need to update the serializer after you change the "
702 "RecordDeclBits");
703
704 VisitTagDecl(D);
705
706 BitsPacker RecordDeclBits;
707 RecordDeclBits.addBit(Value: D->hasFlexibleArrayMember());
708 RecordDeclBits.addBit(Value: D->isAnonymousStructOrUnion());
709 RecordDeclBits.addBit(Value: D->hasObjectMember());
710 RecordDeclBits.addBit(Value: D->hasVolatileMember());
711 RecordDeclBits.addBit(Value: D->isNonTrivialToPrimitiveDefaultInitialize());
712 RecordDeclBits.addBit(Value: D->isNonTrivialToPrimitiveCopy());
713 RecordDeclBits.addBit(Value: D->isNonTrivialToPrimitiveDestroy());
714 RecordDeclBits.addBit(Value: D->hasNonTrivialToPrimitiveDefaultInitializeCUnion());
715 RecordDeclBits.addBit(Value: D->hasNonTrivialToPrimitiveDestructCUnion());
716 RecordDeclBits.addBit(Value: D->hasNonTrivialToPrimitiveCopyCUnion());
717 RecordDeclBits.addBit(Value: D->hasUninitializedExplicitInitFields());
718 RecordDeclBits.addBit(Value: D->isParamDestroyedInCallee());
719 RecordDeclBits.addBits(Value: llvm::to_underlying(E: D->getArgPassingRestrictions()), BitsWidth: 2);
720 Record.push_back(N: RecordDeclBits);
721
722 // Only compute this for C/Objective-C, in C++ this is computed as part
723 // of CXXRecordDecl.
724 if (!isa<CXXRecordDecl>(Val: D))
725 Record.push_back(N: D->getODRHash());
726
727 if (D->getDeclContext() == D->getLexicalDeclContext() && !D->hasAttrs() &&
728 !D->isImplicit() && !D->isInvalidDecl() && !D->hasExtInfo() &&
729 !D->getTypedefNameForAnonDecl() &&
730 D->getFirstDecl() == D->getMostRecentDecl() &&
731 !D->isTopLevelDeclInObjCContainer() &&
732 !CXXRecordDecl::classofKind(K: D->getKind()) &&
733 !needsAnonymousDeclarationNumber(D) &&
734 D->getDeclName().getNameKind() == DeclarationName::Identifier)
735 AbbrevToUse = Writer.getDeclRecordAbbrev();
736
737 Code = serialization::DECL_RECORD;
738}
739
740void ASTDeclWriter::VisitValueDecl(ValueDecl *D) {
741 VisitNamedDecl(D);
742 Record.AddTypeRef(T: D->getType());
743}
744
745void ASTDeclWriter::VisitEnumConstantDecl(EnumConstantDecl *D) {
746 VisitValueDecl(D);
747 Record.push_back(N: D->getInitExpr()? 1 : 0);
748 if (D->getInitExpr())
749 Record.AddStmt(S: D->getInitExpr());
750 Record.AddAPSInt(Value: D->getInitVal());
751
752 Code = serialization::DECL_ENUM_CONSTANT;
753}
754
755void ASTDeclWriter::VisitDeclaratorDecl(DeclaratorDecl *D) {
756 VisitValueDecl(D);
757 Record.AddSourceLocation(Loc: D->getInnerLocStart());
758 Record.push_back(N: D->hasExtInfo());
759 if (D->hasExtInfo()) {
760 DeclaratorDecl::ExtInfo *Info = D->getExtInfo();
761 Record.AddQualifierInfo(Info: *Info);
762 Record.AddStmt(
763 S: const_cast<Expr *>(Info->TrailingRequiresClause.ConstraintExpr));
764 Record.writeUnsignedOrNone(Value: Info->TrailingRequiresClause.ArgPackSubstIndex);
765 }
766 // The location information is deferred until the end of the record.
767 Record.AddTypeRef(T: D->getTypeSourceInfo() ? D->getTypeSourceInfo()->getType()
768 : QualType());
769}
770
771void ASTDeclWriter::VisitFunctionDecl(FunctionDecl *D) {
772 static_assert(DeclContext::NumFunctionDeclBits == 45,
773 "You need to update the serializer after you change the "
774 "FunctionDeclBits");
775
776 VisitRedeclarable(D);
777
778 Record.push_back(N: D->getTemplatedKind());
779 switch (D->getTemplatedKind()) {
780 case FunctionDecl::TK_NonTemplate:
781 break;
782 case FunctionDecl::TK_DependentNonTemplate:
783 Record.AddDeclRef(D: D->getInstantiatedFromDecl());
784 break;
785 case FunctionDecl::TK_FunctionTemplate:
786 Record.AddDeclRef(D: D->getDescribedFunctionTemplate());
787 break;
788 case FunctionDecl::TK_MemberSpecialization: {
789 MemberSpecializationInfo *MemberInfo = D->getMemberSpecializationInfo();
790 Record.AddDeclRef(D: MemberInfo->getInstantiatedFrom());
791 Record.push_back(N: MemberInfo->getTemplateSpecializationKind());
792 Record.AddSourceLocation(Loc: MemberInfo->getPointOfInstantiation());
793 break;
794 }
795 case FunctionDecl::TK_FunctionTemplateSpecialization: {
796 FunctionTemplateSpecializationInfo *
797 FTSInfo = D->getTemplateSpecializationInfo();
798
799 RegisterTemplateSpecialization(Template: FTSInfo->getTemplate(), Specialization: D);
800
801 Record.AddDeclRef(D: FTSInfo->getTemplate());
802 Record.push_back(N: FTSInfo->getTemplateSpecializationKind());
803
804 // Template arguments.
805 Record.AddTemplateArgumentList(TemplateArgs: FTSInfo->TemplateArguments);
806
807 // Template args as written.
808 Record.push_back(N: FTSInfo->TemplateArgumentsAsWritten != nullptr);
809 if (FTSInfo->TemplateArgumentsAsWritten)
810 Record.AddASTTemplateArgumentListInfo(
811 ASTTemplArgList: FTSInfo->TemplateArgumentsAsWritten);
812
813 Record.AddSourceLocation(Loc: FTSInfo->getPointOfInstantiation());
814
815 if (MemberSpecializationInfo *MemberInfo =
816 FTSInfo->getMemberSpecializationInfo()) {
817 Record.push_back(N: 1);
818 Record.AddDeclRef(D: MemberInfo->getInstantiatedFrom());
819 Record.push_back(N: MemberInfo->getTemplateSpecializationKind());
820 Record.AddSourceLocation(Loc: MemberInfo->getPointOfInstantiation());
821 } else {
822 Record.push_back(N: 0);
823 }
824
825 if (D->isCanonicalDecl()) {
826 // Write the template that contains the specializations set. We will
827 // add a FunctionTemplateSpecializationInfo to it when reading.
828 Record.AddDeclRef(D: FTSInfo->getTemplate()->getCanonicalDecl());
829 }
830 break;
831 }
832 case FunctionDecl::TK_DependentFunctionTemplateSpecialization: {
833 DependentFunctionTemplateSpecializationInfo *
834 DFTSInfo = D->getDependentSpecializationInfo();
835
836 // Candidates.
837 Record.push_back(N: DFTSInfo->getCandidates().size());
838 for (FunctionTemplateDecl *FTD : DFTSInfo->getCandidates())
839 Record.AddDeclRef(D: FTD);
840
841 // Templates args.
842 Record.push_back(N: DFTSInfo->TemplateArgumentsAsWritten != nullptr);
843 if (DFTSInfo->TemplateArgumentsAsWritten)
844 Record.AddASTTemplateArgumentListInfo(
845 ASTTemplArgList: DFTSInfo->TemplateArgumentsAsWritten);
846 break;
847 }
848 }
849
850 VisitDeclaratorDecl(D);
851 Record.AddDeclarationNameLoc(DNLoc: D->DNLoc, Name: D->getDeclName());
852 Record.push_back(N: D->getIdentifierNamespace());
853
854 // The order matters here. It will be better to put the bit with higher
855 // probability to be 0 in the end of the bits. See the comments in VisitDecl
856 // for details.
857 BitsPacker FunctionDeclBits;
858 // FIXME: stable encoding
859 FunctionDeclBits.addBits(Value: llvm::to_underlying(E: D->getLinkageInternal()), BitsWidth: 3);
860 FunctionDeclBits.addBits(Value: (uint32_t)D->getStorageClass(), /*BitWidth=*/BitsWidth: 3);
861 FunctionDeclBits.addBit(Value: D->isInlineSpecified());
862 FunctionDeclBits.addBit(Value: D->isInlined());
863 FunctionDeclBits.addBit(Value: D->hasSkippedBody());
864 FunctionDeclBits.addBit(Value: D->isVirtualAsWritten());
865 FunctionDeclBits.addBit(Value: D->isPureVirtual());
866 FunctionDeclBits.addBit(Value: D->hasInheritedPrototype());
867 FunctionDeclBits.addBit(Value: D->hasWrittenPrototype());
868 FunctionDeclBits.addBit(Value: D->isDeletedBit());
869 FunctionDeclBits.addBit(Value: D->isTrivial());
870 FunctionDeclBits.addBit(Value: D->isTrivialForCall());
871 FunctionDeclBits.addBit(Value: D->isDefaulted());
872 FunctionDeclBits.addBit(Value: D->isExplicitlyDefaulted());
873 FunctionDeclBits.addBit(Value: D->isIneligibleOrNotSelected());
874 FunctionDeclBits.addBits(Value: (uint64_t)(D->getConstexprKind()), /*BitWidth=*/BitsWidth: 2);
875 FunctionDeclBits.addBit(Value: D->hasImplicitReturnZero());
876 FunctionDeclBits.addBit(Value: D->isMultiVersion());
877 FunctionDeclBits.addBit(Value: D->isLateTemplateParsed());
878 FunctionDeclBits.addBit(Value: D->isInstantiatedFromMemberTemplate());
879 FunctionDeclBits.addBit(Value: D->FriendConstraintRefersToEnclosingTemplate());
880 FunctionDeclBits.addBit(Value: D->usesSEHTry());
881 FunctionDeclBits.addBit(Value: D->isDestroyingOperatorDelete());
882 FunctionDeclBits.addBit(Value: D->isTypeAwareOperatorNewOrDelete());
883 Record.push_back(N: FunctionDeclBits);
884
885 Record.AddSourceLocation(Loc: D->getEndLoc());
886 if (D->isExplicitlyDefaulted())
887 Record.AddSourceLocation(Loc: D->getDefaultLoc());
888
889 Record.push_back(N: D->getODRHash());
890
891 if (D->isDefaulted() || D->isDeletedAsWritten()) {
892 if (auto *FDI = D->getDefaultedOrDeletedInfo()) {
893 // Store both that there is an DefaultedOrDeletedInfo and whether it
894 // contains a DeletedMessage.
895 StringLiteral *DeletedMessage = FDI->getDeletedMessage();
896 Record.push_back(N: 1 | (DeletedMessage ? 2 : 0));
897 if (DeletedMessage)
898 Record.AddStmt(S: DeletedMessage);
899
900 Record.push_back(N: FDI->getUnqualifiedLookups().size());
901 for (DeclAccessPair P : FDI->getUnqualifiedLookups()) {
902 Record.AddDeclRef(D: P.getDecl());
903 Record.push_back(N: P.getAccess());
904 }
905 } else {
906 Record.push_back(N: 0);
907 }
908 }
909
910 if (D->getFriendObjectKind()) {
911 // For a friend function defined inline within a class template, we have to
912 // force the definition to be the one inside the definition of the template
913 // class. Remember this relation to deserialize them together.
914 if (auto *RD = dyn_cast<CXXRecordDecl>(Val: D->getLexicalParent());
915 RD && isDefinitionInDependentContext(D: RD)) {
916 Writer.RelatedDeclsMap[Writer.GetDeclRef(D: RD)].push_back(
917 Elt: Writer.GetDeclRef(D));
918 }
919 }
920
921 Record.push_back(N: D->param_size());
922 for (auto *P : D->parameters())
923 Record.AddDeclRef(D: P);
924 Code = serialization::DECL_FUNCTION;
925}
926
927static void addExplicitSpecifier(ExplicitSpecifier ES,
928 ASTRecordWriter &Record) {
929 uint64_t Kind = static_cast<uint64_t>(ES.getKind());
930 Kind = Kind << 1 | static_cast<bool>(ES.getExpr());
931 Record.push_back(N: Kind);
932 if (ES.getExpr()) {
933 Record.AddStmt(S: ES.getExpr());
934 }
935}
936
937void ASTDeclWriter::VisitCXXDeductionGuideDecl(CXXDeductionGuideDecl *D) {
938 addExplicitSpecifier(ES: D->getExplicitSpecifier(), Record);
939 Record.AddDeclRef(D: D->Ctor);
940 VisitFunctionDecl(D);
941 Record.push_back(N: static_cast<unsigned char>(D->getDeductionCandidateKind()));
942 Record.AddDeclRef(D: D->getSourceDeductionGuide());
943 Record.push_back(
944 N: static_cast<unsigned char>(D->getSourceDeductionGuideKind()));
945 Code = serialization::DECL_CXX_DEDUCTION_GUIDE;
946}
947
948void ASTDeclWriter::VisitObjCMethodDecl(ObjCMethodDecl *D) {
949 static_assert(DeclContext::NumObjCMethodDeclBits == 37,
950 "You need to update the serializer after you change the "
951 "ObjCMethodDeclBits");
952
953 VisitNamedDecl(D);
954 // FIXME: convert to LazyStmtPtr?
955 // Unlike C/C++, method bodies will never be in header files.
956 bool HasBodyStuff = D->getBody() != nullptr;
957 Record.push_back(N: HasBodyStuff);
958 if (HasBodyStuff) {
959 Record.AddStmt(S: D->getBody());
960 }
961 Record.AddDeclRef(D: D->getSelfDecl());
962 Record.AddDeclRef(D: D->getCmdDecl());
963 Record.push_back(N: D->isInstanceMethod());
964 Record.push_back(N: D->isVariadic());
965 Record.push_back(N: D->isPropertyAccessor());
966 Record.push_back(N: D->isSynthesizedAccessorStub());
967 Record.push_back(N: D->isDefined());
968 Record.push_back(N: D->isOverriding());
969 Record.push_back(N: D->hasSkippedBody());
970
971 Record.push_back(N: D->isRedeclaration());
972 Record.push_back(N: D->hasRedeclaration());
973 if (D->hasRedeclaration()) {
974 assert(Record.getASTContext().getObjCMethodRedeclaration(D));
975 Record.AddDeclRef(D: Record.getASTContext().getObjCMethodRedeclaration(MD: D));
976 }
977
978 // FIXME: stable encoding for @required/@optional
979 Record.push_back(N: llvm::to_underlying(E: D->getImplementationControl()));
980 // FIXME: stable encoding for in/out/inout/bycopy/byref/oneway/nullability
981 Record.push_back(N: D->getObjCDeclQualifier());
982 Record.push_back(N: D->hasRelatedResultType());
983 Record.AddTypeRef(T: D->getReturnType());
984 Record.AddTypeSourceInfo(TInfo: D->getReturnTypeSourceInfo());
985 Record.AddSourceLocation(Loc: D->getEndLoc());
986 Record.push_back(N: D->param_size());
987 for (const auto *P : D->parameters())
988 Record.AddDeclRef(D: P);
989
990 Record.push_back(N: D->getSelLocsKind());
991 unsigned NumStoredSelLocs = D->getNumStoredSelLocs();
992 SourceLocation *SelLocs = D->getStoredSelLocs();
993 Record.push_back(N: NumStoredSelLocs);
994 for (unsigned i = 0; i != NumStoredSelLocs; ++i)
995 Record.AddSourceLocation(Loc: SelLocs[i]);
996
997 Code = serialization::DECL_OBJC_METHOD;
998}
999
1000void ASTDeclWriter::VisitObjCTypeParamDecl(ObjCTypeParamDecl *D) {
1001 VisitTypedefNameDecl(D);
1002 Record.push_back(N: D->Variance);
1003 Record.push_back(N: D->Index);
1004 Record.AddSourceLocation(Loc: D->VarianceLoc);
1005 Record.AddSourceLocation(Loc: D->ColonLoc);
1006
1007 Code = serialization::DECL_OBJC_TYPE_PARAM;
1008}
1009
1010void ASTDeclWriter::VisitObjCContainerDecl(ObjCContainerDecl *D) {
1011 static_assert(DeclContext::NumObjCContainerDeclBits == 64,
1012 "You need to update the serializer after you change the "
1013 "ObjCContainerDeclBits");
1014
1015 VisitNamedDecl(D);
1016 Record.AddSourceLocation(Loc: D->getAtStartLoc());
1017 Record.AddSourceRange(Range: D->getAtEndRange());
1018 // Abstract class (no need to define a stable serialization::DECL code).
1019}
1020
1021void ASTDeclWriter::VisitObjCInterfaceDecl(ObjCInterfaceDecl *D) {
1022 VisitRedeclarable(D);
1023 VisitObjCContainerDecl(D);
1024 Record.AddTypeRef(T: QualType(D->getTypeForDecl(), 0));
1025 AddObjCTypeParamList(typeParams: D->TypeParamList);
1026
1027 Record.push_back(N: D->isThisDeclarationADefinition());
1028 if (D->isThisDeclarationADefinition()) {
1029 // Write the DefinitionData
1030 ObjCInterfaceDecl::DefinitionData &Data = D->data();
1031
1032 Record.AddTypeSourceInfo(TInfo: D->getSuperClassTInfo());
1033 Record.AddSourceLocation(Loc: D->getEndOfDefinitionLoc());
1034 Record.push_back(N: Data.HasDesignatedInitializers);
1035 Record.push_back(N: D->getODRHash());
1036
1037 // Write out the protocols that are directly referenced by the @interface.
1038 Record.push_back(N: Data.ReferencedProtocols.size());
1039 for (const auto *P : D->protocols())
1040 Record.AddDeclRef(D: P);
1041 for (const auto &PL : D->protocol_locs())
1042 Record.AddSourceLocation(Loc: PL);
1043
1044 // Write out the protocols that are transitively referenced.
1045 Record.push_back(N: Data.AllReferencedProtocols.size());
1046 for (ObjCList<ObjCProtocolDecl>::iterator
1047 P = Data.AllReferencedProtocols.begin(),
1048 PEnd = Data.AllReferencedProtocols.end();
1049 P != PEnd; ++P)
1050 Record.AddDeclRef(D: *P);
1051
1052
1053 if (ObjCCategoryDecl *Cat = D->getCategoryListRaw()) {
1054 // Ensure that we write out the set of categories for this class.
1055 Writer.ObjCClassesWithCategories.insert(X: D);
1056
1057 // Make sure that the categories get serialized.
1058 for (; Cat; Cat = Cat->getNextClassCategoryRaw())
1059 (void)Writer.GetDeclRef(D: Cat);
1060 }
1061 }
1062
1063 Code = serialization::DECL_OBJC_INTERFACE;
1064}
1065
1066void ASTDeclWriter::VisitObjCIvarDecl(ObjCIvarDecl *D) {
1067 VisitFieldDecl(D);
1068 // FIXME: stable encoding for @public/@private/@protected/@package
1069 Record.push_back(N: D->getAccessControl());
1070 Record.push_back(N: D->getSynthesize());
1071
1072 if (D->getDeclContext() == D->getLexicalDeclContext() &&
1073 !D->hasAttrs() &&
1074 !D->isImplicit() &&
1075 !D->isUsed(CheckUsedAttr: false) &&
1076 !D->isInvalidDecl() &&
1077 !D->isReferenced() &&
1078 !D->isModulePrivate() &&
1079 !D->getBitWidth() &&
1080 !D->hasExtInfo() &&
1081 D->getDeclName())
1082 AbbrevToUse = Writer.getDeclObjCIvarAbbrev();
1083
1084 Code = serialization::DECL_OBJC_IVAR;
1085}
1086
1087void ASTDeclWriter::VisitObjCProtocolDecl(ObjCProtocolDecl *D) {
1088 VisitRedeclarable(D);
1089 VisitObjCContainerDecl(D);
1090
1091 Record.push_back(N: D->isThisDeclarationADefinition());
1092 if (D->isThisDeclarationADefinition()) {
1093 Record.push_back(N: D->protocol_size());
1094 for (const auto *I : D->protocols())
1095 Record.AddDeclRef(D: I);
1096 for (const auto &PL : D->protocol_locs())
1097 Record.AddSourceLocation(Loc: PL);
1098 Record.push_back(N: D->getODRHash());
1099 }
1100
1101 Code = serialization::DECL_OBJC_PROTOCOL;
1102}
1103
1104void ASTDeclWriter::VisitObjCAtDefsFieldDecl(ObjCAtDefsFieldDecl *D) {
1105 VisitFieldDecl(D);
1106 Code = serialization::DECL_OBJC_AT_DEFS_FIELD;
1107}
1108
1109void ASTDeclWriter::VisitObjCCategoryDecl(ObjCCategoryDecl *D) {
1110 VisitObjCContainerDecl(D);
1111 Record.AddSourceLocation(Loc: D->getCategoryNameLoc());
1112 Record.AddSourceLocation(Loc: D->getIvarLBraceLoc());
1113 Record.AddSourceLocation(Loc: D->getIvarRBraceLoc());
1114 Record.AddDeclRef(D: D->getClassInterface());
1115 AddObjCTypeParamList(typeParams: D->TypeParamList);
1116 Record.push_back(N: D->protocol_size());
1117 for (const auto *I : D->protocols())
1118 Record.AddDeclRef(D: I);
1119 for (const auto &PL : D->protocol_locs())
1120 Record.AddSourceLocation(Loc: PL);
1121 Code = serialization::DECL_OBJC_CATEGORY;
1122}
1123
1124void ASTDeclWriter::VisitObjCCompatibleAliasDecl(ObjCCompatibleAliasDecl *D) {
1125 VisitNamedDecl(D);
1126 Record.AddDeclRef(D: D->getClassInterface());
1127 Code = serialization::DECL_OBJC_COMPATIBLE_ALIAS;
1128}
1129
1130void ASTDeclWriter::VisitObjCPropertyDecl(ObjCPropertyDecl *D) {
1131 VisitNamedDecl(D);
1132 Record.AddSourceLocation(Loc: D->getAtLoc());
1133 Record.AddSourceLocation(Loc: D->getLParenLoc());
1134 Record.AddTypeRef(T: D->getType());
1135 Record.AddTypeSourceInfo(TInfo: D->getTypeSourceInfo());
1136 // FIXME: stable encoding
1137 Record.push_back(N: (unsigned)D->getPropertyAttributes());
1138 Record.push_back(N: (unsigned)D->getPropertyAttributesAsWritten());
1139 // FIXME: stable encoding
1140 Record.push_back(N: (unsigned)D->getPropertyImplementation());
1141 Record.AddDeclarationName(Name: D->getGetterName());
1142 Record.AddSourceLocation(Loc: D->getGetterNameLoc());
1143 Record.AddDeclarationName(Name: D->getSetterName());
1144 Record.AddSourceLocation(Loc: D->getSetterNameLoc());
1145 Record.AddDeclRef(D: D->getGetterMethodDecl());
1146 Record.AddDeclRef(D: D->getSetterMethodDecl());
1147 Record.AddDeclRef(D: D->getPropertyIvarDecl());
1148 Code = serialization::DECL_OBJC_PROPERTY;
1149}
1150
1151void ASTDeclWriter::VisitObjCImplDecl(ObjCImplDecl *D) {
1152 VisitObjCContainerDecl(D);
1153 Record.AddDeclRef(D: D->getClassInterface());
1154 // Abstract class (no need to define a stable serialization::DECL code).
1155}
1156
1157void ASTDeclWriter::VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D) {
1158 VisitObjCImplDecl(D);
1159 Record.AddSourceLocation(Loc: D->getCategoryNameLoc());
1160 Code = serialization::DECL_OBJC_CATEGORY_IMPL;
1161}
1162
1163void ASTDeclWriter::VisitObjCImplementationDecl(ObjCImplementationDecl *D) {
1164 VisitObjCImplDecl(D);
1165 Record.AddDeclRef(D: D->getSuperClass());
1166 Record.AddSourceLocation(Loc: D->getSuperClassLoc());
1167 Record.AddSourceLocation(Loc: D->getIvarLBraceLoc());
1168 Record.AddSourceLocation(Loc: D->getIvarRBraceLoc());
1169 Record.push_back(N: D->hasNonZeroConstructors());
1170 Record.push_back(N: D->hasDestructors());
1171 Record.push_back(N: D->NumIvarInitializers);
1172 if (D->NumIvarInitializers)
1173 Record.AddCXXCtorInitializers(
1174 CtorInits: llvm::ArrayRef(D->init_begin(), D->init_end()));
1175 Code = serialization::DECL_OBJC_IMPLEMENTATION;
1176}
1177
1178void ASTDeclWriter::VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D) {
1179 VisitDecl(D);
1180 Record.AddSourceLocation(Loc: D->getBeginLoc());
1181 Record.AddDeclRef(D: D->getPropertyDecl());
1182 Record.AddDeclRef(D: D->getPropertyIvarDecl());
1183 Record.AddSourceLocation(Loc: D->getPropertyIvarDeclLoc());
1184 Record.AddDeclRef(D: D->getGetterMethodDecl());
1185 Record.AddDeclRef(D: D->getSetterMethodDecl());
1186 Record.AddStmt(S: D->getGetterCXXConstructor());
1187 Record.AddStmt(S: D->getSetterCXXAssignment());
1188 Code = serialization::DECL_OBJC_PROPERTY_IMPL;
1189}
1190
1191void ASTDeclWriter::VisitFieldDecl(FieldDecl *D) {
1192 VisitDeclaratorDecl(D);
1193 Record.push_back(N: D->isMutable());
1194
1195 Record.push_back(N: (D->StorageKind << 1) | D->BitField);
1196 if (D->StorageKind == FieldDecl::ISK_CapturedVLAType)
1197 Record.AddTypeRef(T: QualType(D->getCapturedVLAType(), 0));
1198 else if (D->BitField)
1199 Record.AddStmt(S: D->getBitWidth());
1200
1201 if (!D->getDeclName() || D->isPlaceholderVar(LangOpts: Writer.getLangOpts()))
1202 Record.AddDeclRef(
1203 D: Record.getASTContext().getInstantiatedFromUnnamedFieldDecl(Field: D));
1204
1205 if (D->getDeclContext() == D->getLexicalDeclContext() &&
1206 !D->hasAttrs() &&
1207 !D->isImplicit() &&
1208 !D->isUsed(CheckUsedAttr: false) &&
1209 !D->isInvalidDecl() &&
1210 !D->isReferenced() &&
1211 !D->isTopLevelDeclInObjCContainer() &&
1212 !D->isModulePrivate() &&
1213 !D->getBitWidth() &&
1214 !D->hasInClassInitializer() &&
1215 !D->hasCapturedVLAType() &&
1216 !D->hasExtInfo() &&
1217 !ObjCIvarDecl::classofKind(K: D->getKind()) &&
1218 !ObjCAtDefsFieldDecl::classofKind(K: D->getKind()) &&
1219 D->getDeclName())
1220 AbbrevToUse = Writer.getDeclFieldAbbrev();
1221
1222 Code = serialization::DECL_FIELD;
1223}
1224
1225void ASTDeclWriter::VisitMSPropertyDecl(MSPropertyDecl *D) {
1226 VisitDeclaratorDecl(D);
1227 Record.AddIdentifierRef(II: D->getGetterId());
1228 Record.AddIdentifierRef(II: D->getSetterId());
1229 Code = serialization::DECL_MS_PROPERTY;
1230}
1231
1232void ASTDeclWriter::VisitMSGuidDecl(MSGuidDecl *D) {
1233 VisitValueDecl(D);
1234 MSGuidDecl::Parts Parts = D->getParts();
1235 Record.push_back(N: Parts.Part1);
1236 Record.push_back(N: Parts.Part2);
1237 Record.push_back(N: Parts.Part3);
1238 Record.append(begin: std::begin(arr&: Parts.Part4And5), end: std::end(arr&: Parts.Part4And5));
1239 Code = serialization::DECL_MS_GUID;
1240}
1241
1242void ASTDeclWriter::VisitUnnamedGlobalConstantDecl(
1243 UnnamedGlobalConstantDecl *D) {
1244 VisitValueDecl(D);
1245 Record.AddAPValue(Value: D->getValue());
1246 Code = serialization::DECL_UNNAMED_GLOBAL_CONSTANT;
1247}
1248
1249void ASTDeclWriter::VisitTemplateParamObjectDecl(TemplateParamObjectDecl *D) {
1250 VisitValueDecl(D);
1251 Record.AddAPValue(Value: D->getValue());
1252 Code = serialization::DECL_TEMPLATE_PARAM_OBJECT;
1253}
1254
1255void ASTDeclWriter::VisitIndirectFieldDecl(IndirectFieldDecl *D) {
1256 VisitValueDecl(D);
1257 Record.push_back(N: D->getChainingSize());
1258
1259 for (const auto *P : D->chain())
1260 Record.AddDeclRef(D: P);
1261 Code = serialization::DECL_INDIRECTFIELD;
1262}
1263
1264void ASTDeclWriter::VisitVarDecl(VarDecl *D) {
1265 VisitRedeclarable(D);
1266 VisitDeclaratorDecl(D);
1267
1268 // The order matters here. It will be better to put the bit with higher
1269 // probability to be 0 in the end of the bits. See the comments in VisitDecl
1270 // for details.
1271 BitsPacker VarDeclBits;
1272 VarDeclBits.addBits(Value: llvm::to_underlying(E: D->getLinkageInternal()),
1273 /*BitWidth=*/BitsWidth: 3);
1274
1275 bool ModulesCodegen = shouldVarGenerateHereOnly(VD: D);
1276 VarDeclBits.addBit(Value: ModulesCodegen);
1277
1278 VarDeclBits.addBits(Value: D->getStorageClass(), /*BitWidth=*/BitsWidth: 3);
1279 VarDeclBits.addBits(Value: D->getTSCSpec(), /*BitWidth=*/BitsWidth: 2);
1280 VarDeclBits.addBits(Value: D->getInitStyle(), /*BitWidth=*/BitsWidth: 2);
1281 VarDeclBits.addBit(Value: D->isARCPseudoStrong());
1282
1283 bool HasDeducedType = false;
1284 if (!isa<ParmVarDecl>(Val: D)) {
1285 VarDeclBits.addBit(Value: D->isThisDeclarationADemotedDefinition());
1286 VarDeclBits.addBit(Value: D->isExceptionVariable());
1287 VarDeclBits.addBit(Value: D->isNRVOVariable());
1288 VarDeclBits.addBit(Value: D->isCXXForRangeDecl());
1289
1290 VarDeclBits.addBit(Value: D->isInline());
1291 VarDeclBits.addBit(Value: D->isInlineSpecified());
1292 VarDeclBits.addBit(Value: D->isConstexpr());
1293 VarDeclBits.addBit(Value: D->isInitCapture());
1294 VarDeclBits.addBit(Value: D->isPreviousDeclInSameBlockScope());
1295
1296 VarDeclBits.addBit(Value: D->isEscapingByref());
1297 HasDeducedType = D->getType()->getContainedDeducedType();
1298 VarDeclBits.addBit(Value: HasDeducedType);
1299
1300 if (const auto *IPD = dyn_cast<ImplicitParamDecl>(Val: D))
1301 VarDeclBits.addBits(Value: llvm::to_underlying(E: IPD->getParameterKind()),
1302 /*Width=*/BitsWidth: 3);
1303 else
1304 VarDeclBits.addBits(Value: 0, /*Width=*/BitsWidth: 3);
1305
1306 VarDeclBits.addBit(Value: D->isObjCForDecl());
1307 VarDeclBits.addBit(Value: D->isCXXForRangeImplicitVar());
1308 }
1309
1310 Record.push_back(N: VarDeclBits);
1311
1312 if (ModulesCodegen)
1313 Writer.AddDeclRef(D, Record&: Writer.ModularCodegenDecls);
1314
1315 if (D->hasAttr<BlocksAttr>()) {
1316 BlockVarCopyInit Init = Record.getASTContext().getBlockVarCopyInit(VD: D);
1317 Record.AddStmt(S: Init.getCopyExpr());
1318 if (Init.getCopyExpr())
1319 Record.push_back(N: Init.canThrow());
1320 }
1321
1322 enum {
1323 VarNotTemplate = 0, VarTemplate, StaticDataMemberSpecialization
1324 };
1325 if (VarTemplateDecl *TemplD = D->getDescribedVarTemplate()) {
1326 Record.push_back(N: VarTemplate);
1327 Record.AddDeclRef(D: TemplD);
1328 } else if (MemberSpecializationInfo *SpecInfo
1329 = D->getMemberSpecializationInfo()) {
1330 Record.push_back(N: StaticDataMemberSpecialization);
1331 Record.AddDeclRef(D: SpecInfo->getInstantiatedFrom());
1332 Record.push_back(N: SpecInfo->getTemplateSpecializationKind());
1333 Record.AddSourceLocation(Loc: SpecInfo->getPointOfInstantiation());
1334 } else {
1335 Record.push_back(N: VarNotTemplate);
1336 }
1337
1338 if (D->getDeclContext() == D->getLexicalDeclContext() && !D->hasAttrs() &&
1339 !D->isTopLevelDeclInObjCContainer() &&
1340 !needsAnonymousDeclarationNumber(D) &&
1341 D->getDeclName().getNameKind() == DeclarationName::Identifier &&
1342 !D->hasExtInfo() && D->getFirstDecl() == D->getMostRecentDecl() &&
1343 D->getKind() == Decl::Var && !D->isInline() && !D->isConstexpr() &&
1344 !D->isInitCapture() && !D->isPreviousDeclInSameBlockScope() &&
1345 !D->hasInitWithSideEffects() && !D->isEscapingByref() &&
1346 !HasDeducedType && D->getStorageDuration() != SD_Static &&
1347 !D->getDescribedVarTemplate() && !D->getMemberSpecializationInfo() &&
1348 !D->isObjCForDecl() && !isa<ImplicitParamDecl>(Val: D) &&
1349 !D->isEscapingByref())
1350 AbbrevToUse = Writer.getDeclVarAbbrev();
1351
1352 Code = serialization::DECL_VAR;
1353}
1354
1355void ASTDeclWriter::VisitImplicitParamDecl(ImplicitParamDecl *D) {
1356 VisitVarDecl(D);
1357 Code = serialization::DECL_IMPLICIT_PARAM;
1358}
1359
1360void ASTDeclWriter::VisitParmVarDecl(ParmVarDecl *D) {
1361 VisitVarDecl(D);
1362
1363 // See the implementation of `ParmVarDecl::getParameterIndex()`, which may
1364 // exceed the size of the normal bitfield. So it may be better to not pack
1365 // these bits.
1366 Record.push_back(N: D->getFunctionScopeIndex());
1367
1368 BitsPacker ParmVarDeclBits;
1369 ParmVarDeclBits.addBit(Value: D->isObjCMethodParameter());
1370 ParmVarDeclBits.addBits(Value: D->getFunctionScopeDepth(), /*BitsWidth=*/7);
1371 // FIXME: stable encoding
1372 ParmVarDeclBits.addBits(Value: D->getObjCDeclQualifier(), /*BitsWidth=*/7);
1373 ParmVarDeclBits.addBit(Value: D->isKNRPromoted());
1374 ParmVarDeclBits.addBit(Value: D->hasInheritedDefaultArg());
1375 ParmVarDeclBits.addBit(Value: D->hasUninstantiatedDefaultArg());
1376 ParmVarDeclBits.addBit(Value: D->getExplicitObjectParamThisLoc().isValid());
1377 Record.push_back(N: ParmVarDeclBits);
1378
1379 if (D->hasUninstantiatedDefaultArg())
1380 Record.AddStmt(S: D->getUninstantiatedDefaultArg());
1381 if (D->getExplicitObjectParamThisLoc().isValid())
1382 Record.AddSourceLocation(Loc: D->getExplicitObjectParamThisLoc());
1383 Code = serialization::DECL_PARM_VAR;
1384
1385 // If the assumptions about the DECL_PARM_VAR abbrev are true, use it. Here
1386 // we dynamically check for the properties that we optimize for, but don't
1387 // know are true of all PARM_VAR_DECLs.
1388 if (D->getDeclContext() == D->getLexicalDeclContext() && !D->hasAttrs() &&
1389 !D->hasExtInfo() && D->getStorageClass() == 0 && !D->isInvalidDecl() &&
1390 !D->isTopLevelDeclInObjCContainer() &&
1391 D->getInitStyle() == VarDecl::CInit && // Can params have anything else?
1392 D->getInit() == nullptr) // No default expr.
1393 AbbrevToUse = Writer.getDeclParmVarAbbrev();
1394
1395 // Check things we know are true of *every* PARM_VAR_DECL, which is more than
1396 // just us assuming it.
1397 assert(!D->getTSCSpec() && "PARM_VAR_DECL can't use TLS");
1398 assert(!D->isThisDeclarationADemotedDefinition()
1399 && "PARM_VAR_DECL can't be demoted definition.");
1400 assert(D->getAccess() == AS_none && "PARM_VAR_DECL can't be public/private");
1401 assert(!D->isExceptionVariable() && "PARM_VAR_DECL can't be exception var");
1402 assert(D->getPreviousDecl() == nullptr && "PARM_VAR_DECL can't be redecl");
1403 assert(!D->isStaticDataMember() &&
1404 "PARM_VAR_DECL can't be static data member");
1405}
1406
1407void ASTDeclWriter::VisitDecompositionDecl(DecompositionDecl *D) {
1408 // Record the number of bindings first to simplify deserialization.
1409 Record.push_back(N: D->bindings().size());
1410
1411 VisitVarDecl(D);
1412 for (auto *B : D->bindings())
1413 Record.AddDeclRef(D: B);
1414 Code = serialization::DECL_DECOMPOSITION;
1415}
1416
1417void ASTDeclWriter::VisitBindingDecl(BindingDecl *D) {
1418 VisitValueDecl(D);
1419 Record.AddStmt(S: D->getBinding());
1420 Code = serialization::DECL_BINDING;
1421}
1422
1423void ASTDeclWriter::VisitFileScopeAsmDecl(FileScopeAsmDecl *D) {
1424 VisitDecl(D);
1425 Record.AddStmt(S: D->getAsmStringExpr());
1426 Record.AddSourceLocation(Loc: D->getRParenLoc());
1427 Code = serialization::DECL_FILE_SCOPE_ASM;
1428}
1429
1430void ASTDeclWriter::VisitTopLevelStmtDecl(TopLevelStmtDecl *D) {
1431 VisitDecl(D);
1432 Record.AddStmt(S: D->getStmt());
1433 Code = serialization::DECL_TOP_LEVEL_STMT_DECL;
1434}
1435
1436void ASTDeclWriter::VisitEmptyDecl(EmptyDecl *D) {
1437 VisitDecl(D);
1438 Code = serialization::DECL_EMPTY;
1439}
1440
1441void ASTDeclWriter::VisitLifetimeExtendedTemporaryDecl(
1442 LifetimeExtendedTemporaryDecl *D) {
1443 VisitDecl(D);
1444 Record.AddDeclRef(D: D->getExtendingDecl());
1445 Record.AddStmt(S: D->getTemporaryExpr());
1446 Record.push_back(N: static_cast<bool>(D->getValue()));
1447 if (D->getValue())
1448 Record.AddAPValue(Value: *D->getValue());
1449 Record.push_back(N: D->getManglingNumber());
1450 Code = serialization::DECL_LIFETIME_EXTENDED_TEMPORARY;
1451}
1452void ASTDeclWriter::VisitBlockDecl(BlockDecl *D) {
1453 VisitDecl(D);
1454 Record.AddStmt(S: D->getBody());
1455 Record.AddTypeSourceInfo(TInfo: D->getSignatureAsWritten());
1456 Record.push_back(N: D->param_size());
1457 for (ParmVarDecl *P : D->parameters())
1458 Record.AddDeclRef(D: P);
1459 Record.push_back(N: D->isVariadic());
1460 Record.push_back(N: D->blockMissingReturnType());
1461 Record.push_back(N: D->isConversionFromLambda());
1462 Record.push_back(N: D->doesNotEscape());
1463 Record.push_back(N: D->canAvoidCopyToHeap());
1464 Record.push_back(N: D->capturesCXXThis());
1465 Record.push_back(N: D->getNumCaptures());
1466 for (const auto &capture : D->captures()) {
1467 Record.AddDeclRef(D: capture.getVariable());
1468
1469 unsigned flags = 0;
1470 if (capture.isByRef()) flags |= 1;
1471 if (capture.isNested()) flags |= 2;
1472 if (capture.hasCopyExpr()) flags |= 4;
1473 Record.push_back(N: flags);
1474
1475 if (capture.hasCopyExpr()) Record.AddStmt(S: capture.getCopyExpr());
1476 }
1477
1478 Code = serialization::DECL_BLOCK;
1479}
1480
1481void ASTDeclWriter::VisitOutlinedFunctionDecl(OutlinedFunctionDecl *D) {
1482 Record.push_back(N: D->getNumParams());
1483 VisitDecl(D);
1484 for (unsigned I = 0; I < D->getNumParams(); ++I)
1485 Record.AddDeclRef(D: D->getParam(i: I));
1486 Record.push_back(N: D->isNothrow() ? 1 : 0);
1487 Record.AddStmt(S: D->getBody());
1488 Code = serialization::DECL_OUTLINEDFUNCTION;
1489}
1490
1491void ASTDeclWriter::VisitCapturedDecl(CapturedDecl *CD) {
1492 Record.push_back(N: CD->getNumParams());
1493 VisitDecl(D: CD);
1494 Record.push_back(N: CD->getContextParamPosition());
1495 Record.push_back(N: CD->isNothrow() ? 1 : 0);
1496 // Body is stored by VisitCapturedStmt.
1497 for (unsigned I = 0; I < CD->getNumParams(); ++I)
1498 Record.AddDeclRef(D: CD->getParam(i: I));
1499 Code = serialization::DECL_CAPTURED;
1500}
1501
1502void ASTDeclWriter::VisitLinkageSpecDecl(LinkageSpecDecl *D) {
1503 static_assert(DeclContext::NumLinkageSpecDeclBits == 17,
1504 "You need to update the serializer after you change the"
1505 "LinkageSpecDeclBits");
1506
1507 VisitDecl(D);
1508 Record.push_back(N: llvm::to_underlying(E: D->getLanguage()));
1509 Record.AddSourceLocation(Loc: D->getExternLoc());
1510 Record.AddSourceLocation(Loc: D->getRBraceLoc());
1511 Code = serialization::DECL_LINKAGE_SPEC;
1512}
1513
1514void ASTDeclWriter::VisitExportDecl(ExportDecl *D) {
1515 VisitDecl(D);
1516 Record.AddSourceLocation(Loc: D->getRBraceLoc());
1517 Code = serialization::DECL_EXPORT;
1518}
1519
1520void ASTDeclWriter::VisitLabelDecl(LabelDecl *D) {
1521 VisitNamedDecl(D);
1522 Record.AddSourceLocation(Loc: D->getBeginLoc());
1523 Code = serialization::DECL_LABEL;
1524}
1525
1526
1527void ASTDeclWriter::VisitNamespaceDecl(NamespaceDecl *D) {
1528 VisitRedeclarable(D);
1529 VisitNamedDecl(D);
1530
1531 BitsPacker NamespaceDeclBits;
1532 NamespaceDeclBits.addBit(Value: D->isInline());
1533 NamespaceDeclBits.addBit(Value: D->isNested());
1534 Record.push_back(N: NamespaceDeclBits);
1535
1536 Record.AddSourceLocation(Loc: D->getBeginLoc());
1537 Record.AddSourceLocation(Loc: D->getRBraceLoc());
1538
1539 if (D->isFirstDecl())
1540 Record.AddDeclRef(D: D->getAnonymousNamespace());
1541 Code = serialization::DECL_NAMESPACE;
1542
1543 if (Writer.hasChain() && D->isAnonymousNamespace() &&
1544 D == D->getMostRecentDecl()) {
1545 // This is a most recent reopening of the anonymous namespace. If its parent
1546 // is in a previous PCH (or is the TU), mark that parent for update, because
1547 // the original namespace always points to the latest re-opening of its
1548 // anonymous namespace.
1549 Decl *Parent = cast<Decl>(
1550 Val: D->getParent()->getRedeclContext()->getPrimaryContext());
1551 if (Parent->isFromASTFile() || isa<TranslationUnitDecl>(Val: Parent)) {
1552 Writer.DeclUpdates[Parent].push_back(
1553 Elt: ASTWriter::DeclUpdate(DeclUpdateKind::CXXAddedAnonymousNamespace, D));
1554 }
1555 }
1556}
1557
1558void ASTDeclWriter::VisitNamespaceAliasDecl(NamespaceAliasDecl *D) {
1559 VisitRedeclarable(D);
1560 VisitNamedDecl(D);
1561 Record.AddSourceLocation(Loc: D->getNamespaceLoc());
1562 Record.AddSourceLocation(Loc: D->getTargetNameLoc());
1563 Record.AddNestedNameSpecifierLoc(NNS: D->getQualifierLoc());
1564 Record.AddDeclRef(D: D->getNamespace());
1565 Code = serialization::DECL_NAMESPACE_ALIAS;
1566}
1567
1568void ASTDeclWriter::VisitUsingDecl(UsingDecl *D) {
1569 VisitNamedDecl(D);
1570 Record.AddSourceLocation(Loc: D->getUsingLoc());
1571 Record.AddNestedNameSpecifierLoc(NNS: D->getQualifierLoc());
1572 Record.AddDeclarationNameLoc(DNLoc: D->DNLoc, Name: D->getDeclName());
1573 Record.AddDeclRef(D: D->FirstUsingShadow.getPointer());
1574 Record.push_back(N: D->hasTypename());
1575 Record.AddDeclRef(D: Record.getASTContext().getInstantiatedFromUsingDecl(Inst: D));
1576 Code = serialization::DECL_USING;
1577}
1578
1579void ASTDeclWriter::VisitUsingEnumDecl(UsingEnumDecl *D) {
1580 VisitNamedDecl(D);
1581 Record.AddSourceLocation(Loc: D->getUsingLoc());
1582 Record.AddSourceLocation(Loc: D->getEnumLoc());
1583 Record.AddTypeSourceInfo(TInfo: D->getEnumType());
1584 Record.AddDeclRef(D: D->FirstUsingShadow.getPointer());
1585 Record.AddDeclRef(D: Record.getASTContext().getInstantiatedFromUsingEnumDecl(Inst: D));
1586 Code = serialization::DECL_USING_ENUM;
1587}
1588
1589void ASTDeclWriter::VisitUsingPackDecl(UsingPackDecl *D) {
1590 Record.push_back(N: D->NumExpansions);
1591 VisitNamedDecl(D);
1592 Record.AddDeclRef(D: D->getInstantiatedFromUsingDecl());
1593 for (auto *E : D->expansions())
1594 Record.AddDeclRef(D: E);
1595 Code = serialization::DECL_USING_PACK;
1596}
1597
1598void ASTDeclWriter::VisitUsingShadowDecl(UsingShadowDecl *D) {
1599 VisitRedeclarable(D);
1600 VisitNamedDecl(D);
1601 Record.AddDeclRef(D: D->getTargetDecl());
1602 Record.push_back(N: D->getIdentifierNamespace());
1603 Record.AddDeclRef(D: D->UsingOrNextShadow);
1604 Record.AddDeclRef(
1605 D: Record.getASTContext().getInstantiatedFromUsingShadowDecl(Inst: D));
1606
1607 if (D->getDeclContext() == D->getLexicalDeclContext() &&
1608 D->getFirstDecl() == D->getMostRecentDecl() && !D->hasAttrs() &&
1609 !needsAnonymousDeclarationNumber(D) &&
1610 D->getDeclName().getNameKind() == DeclarationName::Identifier)
1611 AbbrevToUse = Writer.getDeclUsingShadowAbbrev();
1612
1613 Code = serialization::DECL_USING_SHADOW;
1614}
1615
1616void ASTDeclWriter::VisitConstructorUsingShadowDecl(
1617 ConstructorUsingShadowDecl *D) {
1618 VisitUsingShadowDecl(D);
1619 Record.AddDeclRef(D: D->NominatedBaseClassShadowDecl);
1620 Record.AddDeclRef(D: D->ConstructedBaseClassShadowDecl);
1621 Record.push_back(N: D->IsVirtual);
1622 Code = serialization::DECL_CONSTRUCTOR_USING_SHADOW;
1623}
1624
1625void ASTDeclWriter::VisitUsingDirectiveDecl(UsingDirectiveDecl *D) {
1626 VisitNamedDecl(D);
1627 Record.AddSourceLocation(Loc: D->getUsingLoc());
1628 Record.AddSourceLocation(Loc: D->getNamespaceKeyLocation());
1629 Record.AddNestedNameSpecifierLoc(NNS: D->getQualifierLoc());
1630 Record.AddDeclRef(D: D->getNominatedNamespace());
1631 Record.AddDeclRef(D: dyn_cast<Decl>(Val: D->getCommonAncestor()));
1632 Code = serialization::DECL_USING_DIRECTIVE;
1633}
1634
1635void ASTDeclWriter::VisitUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *D) {
1636 VisitValueDecl(D);
1637 Record.AddSourceLocation(Loc: D->getUsingLoc());
1638 Record.AddNestedNameSpecifierLoc(NNS: D->getQualifierLoc());
1639 Record.AddDeclarationNameLoc(DNLoc: D->DNLoc, Name: D->getDeclName());
1640 Record.AddSourceLocation(Loc: D->getEllipsisLoc());
1641 Code = serialization::DECL_UNRESOLVED_USING_VALUE;
1642}
1643
1644void ASTDeclWriter::VisitUnresolvedUsingTypenameDecl(
1645 UnresolvedUsingTypenameDecl *D) {
1646 VisitTypeDecl(D);
1647 Record.AddSourceLocation(Loc: D->getTypenameLoc());
1648 Record.AddNestedNameSpecifierLoc(NNS: D->getQualifierLoc());
1649 Record.AddSourceLocation(Loc: D->getEllipsisLoc());
1650 Code = serialization::DECL_UNRESOLVED_USING_TYPENAME;
1651}
1652
1653void ASTDeclWriter::VisitUnresolvedUsingIfExistsDecl(
1654 UnresolvedUsingIfExistsDecl *D) {
1655 VisitNamedDecl(D);
1656 Code = serialization::DECL_UNRESOLVED_USING_IF_EXISTS;
1657}
1658
1659void ASTDeclWriter::VisitCXXRecordDecl(CXXRecordDecl *D) {
1660 VisitRecordDecl(D);
1661
1662 enum {
1663 CXXRecNotTemplate = 0,
1664 CXXRecTemplate,
1665 CXXRecMemberSpecialization,
1666 CXXLambda
1667 };
1668 if (ClassTemplateDecl *TemplD = D->getDescribedClassTemplate()) {
1669 Record.push_back(N: CXXRecTemplate);
1670 Record.AddDeclRef(D: TemplD);
1671 } else if (MemberSpecializationInfo *MSInfo
1672 = D->getMemberSpecializationInfo()) {
1673 Record.push_back(N: CXXRecMemberSpecialization);
1674 Record.AddDeclRef(D: MSInfo->getInstantiatedFrom());
1675 Record.push_back(N: MSInfo->getTemplateSpecializationKind());
1676 Record.AddSourceLocation(Loc: MSInfo->getPointOfInstantiation());
1677 } else if (D->isLambda()) {
1678 // For a lambda, we need some information early for merging.
1679 Record.push_back(N: CXXLambda);
1680 if (auto *Context = D->getLambdaContextDecl()) {
1681 Record.AddDeclRef(D: Context);
1682 Record.push_back(N: D->getLambdaIndexInContext());
1683 } else {
1684 Record.push_back(N: 0);
1685 }
1686 // For lambdas inside template functions, remember the mapping to
1687 // deserialize them together.
1688 if (auto *FD = llvm::dyn_cast_or_null<FunctionDecl>(Val: D->getDeclContext());
1689 FD && isDefinitionInDependentContext(D: FD)) {
1690 Writer.RelatedDeclsMap[Writer.GetDeclRef(D: FD)].push_back(
1691 Elt: Writer.GetDeclRef(D: D->getLambdaCallOperator()));
1692 }
1693 } else {
1694 Record.push_back(N: CXXRecNotTemplate);
1695 }
1696
1697 Record.push_back(N: D->isThisDeclarationADefinition());
1698 if (D->isThisDeclarationADefinition())
1699 Record.AddCXXDefinitionData(D);
1700
1701 if (D->isCompleteDefinition() && D->isInNamedModule())
1702 Writer.AddDeclRef(D, Record&: Writer.ModularCodegenDecls);
1703
1704 // Store (what we currently believe to be) the key function to avoid
1705 // deserializing every method so we can compute it.
1706 //
1707 // FIXME: Avoid adding the key function if the class is defined in
1708 // module purview since in that case the key function is meaningless.
1709 if (D->isCompleteDefinition())
1710 Record.AddDeclRef(D: Record.getASTContext().getCurrentKeyFunction(RD: D));
1711
1712 Code = serialization::DECL_CXX_RECORD;
1713}
1714
1715void ASTDeclWriter::VisitCXXMethodDecl(CXXMethodDecl *D) {
1716 VisitFunctionDecl(D);
1717 if (D->isCanonicalDecl()) {
1718 Record.push_back(N: D->size_overridden_methods());
1719 for (const CXXMethodDecl *MD : D->overridden_methods())
1720 Record.AddDeclRef(D: MD);
1721 } else {
1722 // We only need to record overridden methods once for the canonical decl.
1723 Record.push_back(N: 0);
1724 }
1725
1726 if (D->getDeclContext() == D->getLexicalDeclContext() &&
1727 D->getFirstDecl() == D->getMostRecentDecl() && !D->isInvalidDecl() &&
1728 !D->hasAttrs() && !D->isTopLevelDeclInObjCContainer() &&
1729 D->getDeclName().getNameKind() == DeclarationName::Identifier &&
1730 !D->hasExtInfo() && !D->isExplicitlyDefaulted()) {
1731 if (D->getTemplatedKind() == FunctionDecl::TK_NonTemplate ||
1732 D->getTemplatedKind() == FunctionDecl::TK_FunctionTemplate ||
1733 D->getTemplatedKind() == FunctionDecl::TK_MemberSpecialization ||
1734 D->getTemplatedKind() == FunctionDecl::TK_DependentNonTemplate)
1735 AbbrevToUse = Writer.getDeclCXXMethodAbbrev(Kind: D->getTemplatedKind());
1736 else if (D->getTemplatedKind() ==
1737 FunctionDecl::TK_FunctionTemplateSpecialization) {
1738 FunctionTemplateSpecializationInfo *FTSInfo =
1739 D->getTemplateSpecializationInfo();
1740
1741 if (FTSInfo->TemplateArguments->size() == 1) {
1742 const TemplateArgument &TA = FTSInfo->TemplateArguments->get(Idx: 0);
1743 if (TA.getKind() == TemplateArgument::Type &&
1744 !FTSInfo->TemplateArgumentsAsWritten &&
1745 !FTSInfo->getMemberSpecializationInfo())
1746 AbbrevToUse = Writer.getDeclCXXMethodAbbrev(Kind: D->getTemplatedKind());
1747 }
1748 } else if (D->getTemplatedKind() ==
1749 FunctionDecl::TK_DependentFunctionTemplateSpecialization) {
1750 DependentFunctionTemplateSpecializationInfo *DFTSInfo =
1751 D->getDependentSpecializationInfo();
1752 if (!DFTSInfo->TemplateArgumentsAsWritten)
1753 AbbrevToUse = Writer.getDeclCXXMethodAbbrev(Kind: D->getTemplatedKind());
1754 }
1755 }
1756
1757 Code = serialization::DECL_CXX_METHOD;
1758}
1759
1760void ASTDeclWriter::VisitCXXConstructorDecl(CXXConstructorDecl *D) {
1761 static_assert(DeclContext::NumCXXConstructorDeclBits == 64,
1762 "You need to update the serializer after you change the "
1763 "CXXConstructorDeclBits");
1764
1765 Record.push_back(N: D->getTrailingAllocKind());
1766 addExplicitSpecifier(ES: D->getExplicitSpecifierInternal(), Record);
1767 if (auto Inherited = D->getInheritedConstructor()) {
1768 Record.AddDeclRef(D: Inherited.getShadowDecl());
1769 Record.AddDeclRef(D: Inherited.getConstructor());
1770 }
1771
1772 VisitCXXMethodDecl(D);
1773 Code = serialization::DECL_CXX_CONSTRUCTOR;
1774}
1775
1776void ASTDeclWriter::VisitCXXDestructorDecl(CXXDestructorDecl *D) {
1777 VisitCXXMethodDecl(D);
1778
1779 Record.AddDeclRef(D: D->getOperatorDelete());
1780 if (D->getOperatorDelete())
1781 Record.AddStmt(S: D->getOperatorDeleteThisArg());
1782 Record.AddDeclRef(D: D->getOperatorGlobalDelete());
1783 Record.AddDeclRef(D: D->getArrayOperatorDelete());
1784 Record.AddDeclRef(D: D->getGlobalArrayOperatorDelete());
1785
1786 Code = serialization::DECL_CXX_DESTRUCTOR;
1787}
1788
1789void ASTDeclWriter::VisitCXXConversionDecl(CXXConversionDecl *D) {
1790 addExplicitSpecifier(ES: D->getExplicitSpecifier(), Record);
1791 VisitCXXMethodDecl(D);
1792 Code = serialization::DECL_CXX_CONVERSION;
1793}
1794
1795void ASTDeclWriter::VisitImportDecl(ImportDecl *D) {
1796 VisitDecl(D);
1797 Record.push_back(N: Writer.getSubmoduleID(Mod: D->getImportedModule()));
1798 ArrayRef<SourceLocation> IdentifierLocs = D->getIdentifierLocs();
1799 Record.push_back(N: !IdentifierLocs.empty());
1800 if (IdentifierLocs.empty()) {
1801 Record.AddSourceLocation(Loc: D->getEndLoc());
1802 Record.push_back(N: 1);
1803 } else {
1804 for (unsigned I = 0, N = IdentifierLocs.size(); I != N; ++I)
1805 Record.AddSourceLocation(Loc: IdentifierLocs[I]);
1806 Record.push_back(N: IdentifierLocs.size());
1807 }
1808 // Note: the number of source locations must always be the last element in
1809 // the record.
1810 Code = serialization::DECL_IMPORT;
1811}
1812
1813void ASTDeclWriter::VisitAccessSpecDecl(AccessSpecDecl *D) {
1814 VisitDecl(D);
1815 Record.AddSourceLocation(Loc: D->getColonLoc());
1816 Code = serialization::DECL_ACCESS_SPEC;
1817}
1818
1819void ASTDeclWriter::VisitFriendDecl(FriendDecl *D) {
1820 // Record the number of friend type template parameter lists here
1821 // so as to simplify memory allocation during deserialization.
1822 Record.push_back(N: D->NumTPLists);
1823 VisitDecl(D);
1824 bool hasFriendDecl = isa<NamedDecl *>(Val: D->Friend);
1825 Record.push_back(N: hasFriendDecl);
1826 if (hasFriendDecl)
1827 Record.AddDeclRef(D: D->getFriendDecl());
1828 else
1829 Record.AddTypeSourceInfo(TInfo: D->getFriendType());
1830 for (unsigned i = 0; i < D->NumTPLists; ++i)
1831 Record.AddTemplateParameterList(TemplateParams: D->getFriendTypeTemplateParameterList(N: i));
1832 Record.AddDeclRef(D: D->getNextFriend());
1833 Record.push_back(N: D->UnsupportedFriend);
1834 Record.AddSourceLocation(Loc: D->FriendLoc);
1835 Record.AddSourceLocation(Loc: D->EllipsisLoc);
1836 Code = serialization::DECL_FRIEND;
1837}
1838
1839void ASTDeclWriter::VisitFriendTemplateDecl(FriendTemplateDecl *D) {
1840 VisitDecl(D);
1841 Record.push_back(N: D->getNumTemplateParameters());
1842 for (unsigned i = 0, e = D->getNumTemplateParameters(); i != e; ++i)
1843 Record.AddTemplateParameterList(TemplateParams: D->getTemplateParameterList(i));
1844 Record.push_back(N: D->getFriendDecl() != nullptr);
1845 if (D->getFriendDecl())
1846 Record.AddDeclRef(D: D->getFriendDecl());
1847 else
1848 Record.AddTypeSourceInfo(TInfo: D->getFriendType());
1849 Record.AddSourceLocation(Loc: D->getFriendLoc());
1850 Code = serialization::DECL_FRIEND_TEMPLATE;
1851}
1852
1853void ASTDeclWriter::VisitTemplateDecl(TemplateDecl *D) {
1854 VisitNamedDecl(D);
1855
1856 Record.AddTemplateParameterList(TemplateParams: D->getTemplateParameters());
1857 Record.AddDeclRef(D: D->getTemplatedDecl());
1858}
1859
1860void ASTDeclWriter::VisitConceptDecl(ConceptDecl *D) {
1861 VisitTemplateDecl(D);
1862 Record.AddStmt(S: D->getConstraintExpr());
1863 Code = serialization::DECL_CONCEPT;
1864}
1865
1866void ASTDeclWriter::VisitImplicitConceptSpecializationDecl(
1867 ImplicitConceptSpecializationDecl *D) {
1868 Record.push_back(N: D->getTemplateArguments().size());
1869 VisitDecl(D);
1870 for (const TemplateArgument &Arg : D->getTemplateArguments())
1871 Record.AddTemplateArgument(Arg);
1872 Code = serialization::DECL_IMPLICIT_CONCEPT_SPECIALIZATION;
1873}
1874
1875void ASTDeclWriter::VisitRequiresExprBodyDecl(RequiresExprBodyDecl *D) {
1876 Code = serialization::DECL_REQUIRES_EXPR_BODY;
1877}
1878
1879void ASTDeclWriter::VisitRedeclarableTemplateDecl(RedeclarableTemplateDecl *D) {
1880 VisitRedeclarable(D);
1881
1882 // Emit data to initialize CommonOrPrev before VisitTemplateDecl so that
1883 // getCommonPtr() can be used while this is still initializing.
1884 if (D->isFirstDecl()) {
1885 // This declaration owns the 'common' pointer, so serialize that data now.
1886 Record.AddDeclRef(D: D->getInstantiatedFromMemberTemplate());
1887 if (D->getInstantiatedFromMemberTemplate())
1888 Record.push_back(N: D->isMemberSpecialization());
1889 }
1890
1891 VisitTemplateDecl(D);
1892 Record.push_back(N: D->getIdentifierNamespace());
1893}
1894
1895void ASTDeclWriter::VisitClassTemplateDecl(ClassTemplateDecl *D) {
1896 VisitRedeclarableTemplateDecl(D);
1897
1898 if (D->isFirstDecl())
1899 AddTemplateSpecializations(D);
1900
1901 // Force emitting the corresponding deduction guide in reduced BMI mode.
1902 // Otherwise, the deduction guide may be optimized out incorrectly.
1903 if (Writer.isGeneratingReducedBMI()) {
1904 auto Name =
1905 Record.getASTContext().DeclarationNames.getCXXDeductionGuideName(TD: D);
1906 for (auto *DG : D->getDeclContext()->noload_lookup(Name))
1907 Writer.GetDeclRef(D: DG->getCanonicalDecl());
1908 }
1909
1910 Code = serialization::DECL_CLASS_TEMPLATE;
1911}
1912
1913void ASTDeclWriter::VisitClassTemplateSpecializationDecl(
1914 ClassTemplateSpecializationDecl *D) {
1915 RegisterTemplateSpecialization(Template: D->getSpecializedTemplate(), Specialization: D);
1916
1917 VisitCXXRecordDecl(D);
1918
1919 llvm::PointerUnion<ClassTemplateDecl *,
1920 ClassTemplatePartialSpecializationDecl *> InstFrom
1921 = D->getSpecializedTemplateOrPartial();
1922 if (Decl *InstFromD = InstFrom.dyn_cast<ClassTemplateDecl *>()) {
1923 Record.AddDeclRef(D: InstFromD);
1924 } else {
1925 Record.AddDeclRef(D: cast<ClassTemplatePartialSpecializationDecl *>(Val&: InstFrom));
1926 Record.AddTemplateArgumentList(TemplateArgs: &D->getTemplateInstantiationArgs());
1927 }
1928
1929 Record.AddTemplateArgumentList(TemplateArgs: &D->getTemplateArgs());
1930 Record.AddSourceLocation(Loc: D->getPointOfInstantiation());
1931 Record.push_back(N: D->getSpecializationKind());
1932 Record.push_back(N: D->hasStrictPackMatch());
1933 Record.push_back(N: D->isCanonicalDecl());
1934
1935 if (D->isCanonicalDecl()) {
1936 // When reading, we'll add it to the folding set of the following template.
1937 Record.AddDeclRef(D: D->getSpecializedTemplate()->getCanonicalDecl());
1938 }
1939
1940 bool ExplicitInstantiation =
1941 D->getTemplateSpecializationKind() ==
1942 TSK_ExplicitInstantiationDeclaration ||
1943 D->getTemplateSpecializationKind() == TSK_ExplicitInstantiationDefinition;
1944 Record.push_back(N: ExplicitInstantiation);
1945 if (ExplicitInstantiation) {
1946 Record.AddSourceLocation(Loc: D->getExternKeywordLoc());
1947 Record.AddSourceLocation(Loc: D->getTemplateKeywordLoc());
1948 }
1949
1950 const ASTTemplateArgumentListInfo *ArgsWritten =
1951 D->getTemplateArgsAsWritten();
1952 Record.push_back(N: !!ArgsWritten);
1953 if (ArgsWritten)
1954 Record.AddASTTemplateArgumentListInfo(ASTTemplArgList: ArgsWritten);
1955
1956 // Mention the implicitly generated C++ deduction guide to make sure the
1957 // deduction guide will be rewritten as expected.
1958 //
1959 // FIXME: Would it be more efficient to add a callback register function
1960 // in sema to register the deduction guide?
1961 if (Writer.isWritingStdCXXNamedModules()) {
1962 auto Name =
1963 Record.getASTContext().DeclarationNames.getCXXDeductionGuideName(
1964 TD: D->getSpecializedTemplate());
1965 for (auto *DG : D->getDeclContext()->noload_lookup(Name))
1966 Writer.GetDeclRef(D: DG->getCanonicalDecl());
1967 }
1968
1969 Code = serialization::DECL_CLASS_TEMPLATE_SPECIALIZATION;
1970}
1971
1972void ASTDeclWriter::VisitClassTemplatePartialSpecializationDecl(
1973 ClassTemplatePartialSpecializationDecl *D) {
1974 Record.AddTemplateParameterList(TemplateParams: D->getTemplateParameters());
1975
1976 VisitClassTemplateSpecializationDecl(D);
1977
1978 // These are read/set from/to the first declaration.
1979 if (D->getPreviousDecl() == nullptr) {
1980 Record.AddDeclRef(D: D->getInstantiatedFromMember());
1981 Record.push_back(N: D->isMemberSpecialization());
1982 }
1983
1984 Code = serialization::DECL_CLASS_TEMPLATE_PARTIAL_SPECIALIZATION;
1985}
1986
1987void ASTDeclWriter::VisitVarTemplateDecl(VarTemplateDecl *D) {
1988 VisitRedeclarableTemplateDecl(D);
1989
1990 if (D->isFirstDecl())
1991 AddTemplateSpecializations(D);
1992 Code = serialization::DECL_VAR_TEMPLATE;
1993}
1994
1995void ASTDeclWriter::VisitVarTemplateSpecializationDecl(
1996 VarTemplateSpecializationDecl *D) {
1997 RegisterTemplateSpecialization(Template: D->getSpecializedTemplate(), Specialization: D);
1998
1999 llvm::PointerUnion<VarTemplateDecl *, VarTemplatePartialSpecializationDecl *>
2000 InstFrom = D->getSpecializedTemplateOrPartial();
2001 if (Decl *InstFromD = InstFrom.dyn_cast<VarTemplateDecl *>()) {
2002 Record.AddDeclRef(D: InstFromD);
2003 } else {
2004 Record.AddDeclRef(D: cast<VarTemplatePartialSpecializationDecl *>(Val&: InstFrom));
2005 Record.AddTemplateArgumentList(TemplateArgs: &D->getTemplateInstantiationArgs());
2006 }
2007
2008 bool ExplicitInstantiation =
2009 D->getTemplateSpecializationKind() ==
2010 TSK_ExplicitInstantiationDeclaration ||
2011 D->getTemplateSpecializationKind() == TSK_ExplicitInstantiationDefinition;
2012 Record.push_back(N: ExplicitInstantiation);
2013 if (ExplicitInstantiation) {
2014 Record.AddSourceLocation(Loc: D->getExternKeywordLoc());
2015 Record.AddSourceLocation(Loc: D->getTemplateKeywordLoc());
2016 }
2017
2018 const ASTTemplateArgumentListInfo *ArgsWritten =
2019 D->getTemplateArgsAsWritten();
2020 Record.push_back(N: !!ArgsWritten);
2021 if (ArgsWritten)
2022 Record.AddASTTemplateArgumentListInfo(ASTTemplArgList: ArgsWritten);
2023
2024 Record.AddTemplateArgumentList(TemplateArgs: &D->getTemplateArgs());
2025 Record.AddSourceLocation(Loc: D->getPointOfInstantiation());
2026 Record.push_back(N: D->getSpecializationKind());
2027 Record.push_back(N: D->IsCompleteDefinition);
2028
2029 VisitVarDecl(D);
2030
2031 Record.push_back(N: D->isCanonicalDecl());
2032
2033 if (D->isCanonicalDecl()) {
2034 // When reading, we'll add it to the folding set of the following template.
2035 Record.AddDeclRef(D: D->getSpecializedTemplate()->getCanonicalDecl());
2036 }
2037
2038 Code = serialization::DECL_VAR_TEMPLATE_SPECIALIZATION;
2039}
2040
2041void ASTDeclWriter::VisitVarTemplatePartialSpecializationDecl(
2042 VarTemplatePartialSpecializationDecl *D) {
2043 Record.AddTemplateParameterList(TemplateParams: D->getTemplateParameters());
2044
2045 VisitVarTemplateSpecializationDecl(D);
2046
2047 // These are read/set from/to the first declaration.
2048 if (D->getPreviousDecl() == nullptr) {
2049 Record.AddDeclRef(D: D->getInstantiatedFromMember());
2050 Record.push_back(N: D->isMemberSpecialization());
2051 }
2052
2053 Code = serialization::DECL_VAR_TEMPLATE_PARTIAL_SPECIALIZATION;
2054}
2055
2056void ASTDeclWriter::VisitFunctionTemplateDecl(FunctionTemplateDecl *D) {
2057 VisitRedeclarableTemplateDecl(D);
2058
2059 if (D->isFirstDecl())
2060 AddTemplateSpecializations(D);
2061 Code = serialization::DECL_FUNCTION_TEMPLATE;
2062}
2063
2064void ASTDeclWriter::VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D) {
2065 Record.push_back(N: D->hasTypeConstraint());
2066 VisitTypeDecl(D);
2067
2068 Record.push_back(N: D->wasDeclaredWithTypename());
2069
2070 const TypeConstraint *TC = D->getTypeConstraint();
2071 if (D->hasTypeConstraint())
2072 Record.push_back(/*TypeConstraintInitialized=*/N: TC != nullptr);
2073 if (TC) {
2074 auto *CR = TC->getConceptReference();
2075 Record.push_back(N: CR != nullptr);
2076 if (CR)
2077 Record.AddConceptReference(CR);
2078 Record.AddStmt(S: TC->getImmediatelyDeclaredConstraint());
2079 Record.writeUnsignedOrNone(Value: TC->getArgPackSubstIndex());
2080 Record.writeUnsignedOrNone(Value: D->getNumExpansionParameters());
2081 }
2082
2083 bool OwnsDefaultArg = D->hasDefaultArgument() &&
2084 !D->defaultArgumentWasInherited();
2085 Record.push_back(N: OwnsDefaultArg);
2086 if (OwnsDefaultArg)
2087 Record.AddTemplateArgumentLoc(Arg: D->getDefaultArgument());
2088
2089 if (!D->hasTypeConstraint() && !OwnsDefaultArg &&
2090 D->getDeclContext() == D->getLexicalDeclContext() &&
2091 !D->isInvalidDecl() && !D->hasAttrs() &&
2092 !D->isTopLevelDeclInObjCContainer() && !D->isImplicit() &&
2093 D->getDeclName().getNameKind() == DeclarationName::Identifier)
2094 AbbrevToUse = Writer.getDeclTemplateTypeParmAbbrev();
2095
2096 Code = serialization::DECL_TEMPLATE_TYPE_PARM;
2097}
2098
2099void ASTDeclWriter::VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D) {
2100 // For an expanded parameter pack, record the number of expansion types here
2101 // so that it's easier for deserialization to allocate the right amount of
2102 // memory.
2103 Record.push_back(N: D->hasPlaceholderTypeConstraint());
2104 if (D->isExpandedParameterPack())
2105 Record.push_back(N: D->getNumExpansionTypes());
2106
2107 VisitDeclaratorDecl(D);
2108 // TemplateParmPosition.
2109 Record.push_back(N: D->getDepth());
2110 Record.push_back(N: D->getPosition());
2111
2112 if (D->hasPlaceholderTypeConstraint())
2113 Record.AddStmt(S: D->getPlaceholderTypeConstraint());
2114
2115 if (D->isExpandedParameterPack()) {
2116 for (unsigned I = 0, N = D->getNumExpansionTypes(); I != N; ++I) {
2117 Record.AddTypeRef(T: D->getExpansionType(I));
2118 Record.AddTypeSourceInfo(TInfo: D->getExpansionTypeSourceInfo(I));
2119 }
2120
2121 Code = serialization::DECL_EXPANDED_NON_TYPE_TEMPLATE_PARM_PACK;
2122 } else {
2123 // Rest of NonTypeTemplateParmDecl.
2124 Record.push_back(N: D->isParameterPack());
2125 bool OwnsDefaultArg = D->hasDefaultArgument() &&
2126 !D->defaultArgumentWasInherited();
2127 Record.push_back(N: OwnsDefaultArg);
2128 if (OwnsDefaultArg)
2129 Record.AddTemplateArgumentLoc(Arg: D->getDefaultArgument());
2130 Code = serialization::DECL_NON_TYPE_TEMPLATE_PARM;
2131 }
2132}
2133
2134void ASTDeclWriter::VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D) {
2135 // For an expanded parameter pack, record the number of expansion types here
2136 // so that it's easier for deserialization to allocate the right amount of
2137 // memory.
2138 if (D->isExpandedParameterPack())
2139 Record.push_back(N: D->getNumExpansionTemplateParameters());
2140
2141 VisitTemplateDecl(D);
2142 Record.push_back(N: D->templateParameterKind());
2143 Record.push_back(N: D->wasDeclaredWithTypename());
2144 // TemplateParmPosition.
2145 Record.push_back(N: D->getDepth());
2146 Record.push_back(N: D->getPosition());
2147
2148 if (D->isExpandedParameterPack()) {
2149 for (unsigned I = 0, N = D->getNumExpansionTemplateParameters();
2150 I != N; ++I)
2151 Record.AddTemplateParameterList(TemplateParams: D->getExpansionTemplateParameters(I));
2152 Code = serialization::DECL_EXPANDED_TEMPLATE_TEMPLATE_PARM_PACK;
2153 } else {
2154 // Rest of TemplateTemplateParmDecl.
2155 Record.push_back(N: D->isParameterPack());
2156 bool OwnsDefaultArg = D->hasDefaultArgument() &&
2157 !D->defaultArgumentWasInherited();
2158 Record.push_back(N: OwnsDefaultArg);
2159 if (OwnsDefaultArg)
2160 Record.AddTemplateArgumentLoc(Arg: D->getDefaultArgument());
2161 Code = serialization::DECL_TEMPLATE_TEMPLATE_PARM;
2162 }
2163}
2164
2165void ASTDeclWriter::VisitTypeAliasTemplateDecl(TypeAliasTemplateDecl *D) {
2166 VisitRedeclarableTemplateDecl(D);
2167 Code = serialization::DECL_TYPE_ALIAS_TEMPLATE;
2168}
2169
2170void ASTDeclWriter::VisitStaticAssertDecl(StaticAssertDecl *D) {
2171 VisitDecl(D);
2172 Record.AddStmt(S: D->getAssertExpr());
2173 Record.push_back(N: D->isFailed());
2174 Record.AddStmt(S: D->getMessage());
2175 Record.AddSourceLocation(Loc: D->getRParenLoc());
2176 Code = serialization::DECL_STATIC_ASSERT;
2177}
2178
2179/// Emit the DeclContext part of a declaration context decl.
2180void ASTDeclWriter::VisitDeclContext(DeclContext *DC) {
2181 static_assert(DeclContext::NumDeclContextBits == 13,
2182 "You need to update the serializer after you change the "
2183 "DeclContextBits");
2184 LookupBlockOffsets Offsets;
2185
2186 if (Writer.isGeneratingReducedBMI() && isa<NamespaceDecl>(Val: DC) &&
2187 cast<NamespaceDecl>(Val: DC)->isFromExplicitGlobalModule()) {
2188 // In reduced BMI, delay writing lexical and visible block for namespace
2189 // in the global module fragment. See the comments of DelayedNamespace for
2190 // details.
2191 Writer.DelayedNamespace.push_back(Elt: cast<NamespaceDecl>(Val: DC));
2192 } else {
2193 Offsets.LexicalOffset =
2194 Writer.WriteDeclContextLexicalBlock(Context&: Record.getASTContext(), DC);
2195 Writer.WriteDeclContextVisibleBlock(Context&: Record.getASTContext(), DC, Offsets);
2196 }
2197
2198 Record.AddLookupOffsets(Offsets);
2199}
2200
2201const Decl *ASTWriter::getFirstLocalDecl(const Decl *D) {
2202 assert(IsLocalDecl(D) && "expected a local declaration");
2203
2204 const Decl *Canon = D->getCanonicalDecl();
2205 if (IsLocalDecl(D: Canon))
2206 return Canon;
2207
2208 const Decl *&CacheEntry = FirstLocalDeclCache[Canon];
2209 if (CacheEntry)
2210 return CacheEntry;
2211
2212 for (const Decl *Redecl = D; Redecl; Redecl = Redecl->getPreviousDecl())
2213 if (IsLocalDecl(D: Redecl))
2214 D = Redecl;
2215 return CacheEntry = D;
2216}
2217
2218template <typename T>
2219void ASTDeclWriter::VisitRedeclarable(Redeclarable<T> *D) {
2220 T *First = D->getFirstDecl();
2221 T *MostRecent = First->getMostRecentDecl();
2222 T *DAsT = static_cast<T *>(D);
2223 if (MostRecent != First) {
2224 assert(isRedeclarableDeclKind(DAsT->getKind()) &&
2225 "Not considered redeclarable?");
2226
2227 Record.AddDeclRef(D: First);
2228
2229 // Write out a list of local redeclarations of this declaration if it's the
2230 // first local declaration in the chain.
2231 const Decl *FirstLocal = Writer.getFirstLocalDecl(D: DAsT);
2232 if (DAsT == FirstLocal) {
2233 // Emit a list of all imported first declarations so that we can be sure
2234 // that all redeclarations visible to this module are before D in the
2235 // redecl chain.
2236 unsigned I = Record.size();
2237 Record.push_back(N: 0);
2238 if (Writer.Chain)
2239 AddFirstDeclFromEachModule(D: DAsT, /*IncludeLocal*/false);
2240 // This is the number of imported first declarations + 1.
2241 Record[I] = Record.size() - I;
2242
2243 // Collect the set of local redeclarations of this declaration, from
2244 // newest to oldest.
2245 ASTWriter::RecordData LocalRedecls;
2246 ASTRecordWriter LocalRedeclWriter(Record, LocalRedecls);
2247 for (const Decl *Prev = FirstLocal->getMostRecentDecl();
2248 Prev != FirstLocal; Prev = Prev->getPreviousDecl())
2249 if (!Prev->isFromASTFile())
2250 LocalRedeclWriter.AddDeclRef(D: Prev);
2251
2252 // If we have any redecls, write them now as a separate record preceding
2253 // the declaration itself.
2254 if (LocalRedecls.empty())
2255 Record.push_back(N: 0);
2256 else
2257 Record.AddOffset(BitOffset: LocalRedeclWriter.Emit(Code: LOCAL_REDECLARATIONS));
2258 } else {
2259 Record.push_back(N: 0);
2260 Record.AddDeclRef(D: FirstLocal);
2261 }
2262
2263 // Make sure that we serialize both the previous and the most-recent
2264 // declarations, which (transitively) ensures that all declarations in the
2265 // chain get serialized.
2266 //
2267 // FIXME: This is not correct; when we reach an imported declaration we
2268 // won't emit its previous declaration.
2269 (void)Writer.GetDeclRef(D: D->getPreviousDecl());
2270 (void)Writer.GetDeclRef(D: MostRecent);
2271 } else {
2272 // We use the sentinel value 0 to indicate an only declaration.
2273 Record.push_back(N: 0);
2274 }
2275}
2276
2277void ASTDeclWriter::VisitHLSLBufferDecl(HLSLBufferDecl *D) {
2278 VisitNamedDecl(D);
2279 VisitDeclContext(DC: D);
2280 Record.push_back(N: D->isCBuffer());
2281 Record.AddSourceLocation(Loc: D->getLocStart());
2282 Record.AddSourceLocation(Loc: D->getLBraceLoc());
2283 Record.AddSourceLocation(Loc: D->getRBraceLoc());
2284
2285 Code = serialization::DECL_HLSL_BUFFER;
2286}
2287
2288void ASTDeclWriter::VisitOMPThreadPrivateDecl(OMPThreadPrivateDecl *D) {
2289 Record.writeOMPChildren(Data: D->Data);
2290 VisitDecl(D);
2291 Code = serialization::DECL_OMP_THREADPRIVATE;
2292}
2293
2294void ASTDeclWriter::VisitOMPAllocateDecl(OMPAllocateDecl *D) {
2295 Record.writeOMPChildren(Data: D->Data);
2296 VisitDecl(D);
2297 Code = serialization::DECL_OMP_ALLOCATE;
2298}
2299
2300void ASTDeclWriter::VisitOMPRequiresDecl(OMPRequiresDecl *D) {
2301 Record.writeOMPChildren(Data: D->Data);
2302 VisitDecl(D);
2303 Code = serialization::DECL_OMP_REQUIRES;
2304}
2305
2306void ASTDeclWriter::VisitOMPDeclareReductionDecl(OMPDeclareReductionDecl *D) {
2307 static_assert(DeclContext::NumOMPDeclareReductionDeclBits == 15,
2308 "You need to update the serializer after you change the "
2309 "NumOMPDeclareReductionDeclBits");
2310
2311 VisitValueDecl(D);
2312 Record.AddSourceLocation(Loc: D->getBeginLoc());
2313 Record.AddStmt(S: D->getCombinerIn());
2314 Record.AddStmt(S: D->getCombinerOut());
2315 Record.AddStmt(S: D->getCombiner());
2316 Record.AddStmt(S: D->getInitOrig());
2317 Record.AddStmt(S: D->getInitPriv());
2318 Record.AddStmt(S: D->getInitializer());
2319 Record.push_back(N: llvm::to_underlying(E: D->getInitializerKind()));
2320 Record.AddDeclRef(D: D->getPrevDeclInScope());
2321 Code = serialization::DECL_OMP_DECLARE_REDUCTION;
2322}
2323
2324void ASTDeclWriter::VisitOMPDeclareMapperDecl(OMPDeclareMapperDecl *D) {
2325 Record.writeOMPChildren(Data: D->Data);
2326 VisitValueDecl(D);
2327 Record.AddDeclarationName(Name: D->getVarName());
2328 Record.AddDeclRef(D: D->getPrevDeclInScope());
2329 Code = serialization::DECL_OMP_DECLARE_MAPPER;
2330}
2331
2332void ASTDeclWriter::VisitOMPCapturedExprDecl(OMPCapturedExprDecl *D) {
2333 VisitVarDecl(D);
2334 Code = serialization::DECL_OMP_CAPTUREDEXPR;
2335}
2336
2337void ASTDeclWriter::VisitOpenACCDeclareDecl(OpenACCDeclareDecl *D) {
2338 Record.writeUInt32(Value: D->clauses().size());
2339 VisitDecl(D);
2340 Record.writeEnum(value: D->DirKind);
2341 Record.AddSourceLocation(Loc: D->DirectiveLoc);
2342 Record.AddSourceLocation(Loc: D->EndLoc);
2343 Record.writeOpenACCClauseList(Clauses: D->clauses());
2344 Code = serialization::DECL_OPENACC_DECLARE;
2345}
2346void ASTDeclWriter::VisitOpenACCRoutineDecl(OpenACCRoutineDecl *D) {
2347 Record.writeUInt32(Value: D->clauses().size());
2348 VisitDecl(D);
2349 Record.writeEnum(value: D->DirKind);
2350 Record.AddSourceLocation(Loc: D->DirectiveLoc);
2351 Record.AddSourceLocation(Loc: D->EndLoc);
2352 Record.AddSourceRange(Range: D->ParensLoc);
2353 Record.AddStmt(S: D->FuncRef);
2354 Record.writeOpenACCClauseList(Clauses: D->clauses());
2355 Code = serialization::DECL_OPENACC_ROUTINE;
2356}
2357
2358//===----------------------------------------------------------------------===//
2359// ASTWriter Implementation
2360//===----------------------------------------------------------------------===//
2361
2362namespace {
2363template <FunctionDecl::TemplatedKind Kind>
2364std::shared_ptr<llvm::BitCodeAbbrev>
2365getFunctionDeclAbbrev(serialization::DeclCode Code) {
2366 using namespace llvm;
2367
2368 auto Abv = std::make_shared<BitCodeAbbrev>();
2369 Abv->Add(OpInfo: BitCodeAbbrevOp(Code));
2370 // RedeclarableDecl
2371 Abv->Add(OpInfo: BitCodeAbbrevOp(0)); // CanonicalDecl
2372 Abv->Add(OpInfo: BitCodeAbbrevOp(Kind));
2373 if constexpr (Kind == FunctionDecl::TK_NonTemplate) {
2374
2375 } else if constexpr (Kind == FunctionDecl::TK_FunctionTemplate) {
2376 // DescribedFunctionTemplate
2377 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));
2378 } else if constexpr (Kind == FunctionDecl::TK_DependentNonTemplate) {
2379 // Instantiated From Decl
2380 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));
2381 } else if constexpr (Kind == FunctionDecl::TK_MemberSpecialization) {
2382 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // InstantiatedFrom
2383 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed,
2384 3)); // TemplateSpecializationKind
2385 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Specialized Location
2386 } else if constexpr (Kind ==
2387 FunctionDecl::TK_FunctionTemplateSpecialization) {
2388 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Template
2389 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed,
2390 3)); // TemplateSpecializationKind
2391 Abv->Add(OpInfo: BitCodeAbbrevOp(1)); // Template Argument Size
2392 Abv->Add(OpInfo: BitCodeAbbrevOp(TemplateArgument::Type)); // Template Argument Kind
2393 Abv->Add(
2394 OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Template Argument Type
2395 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Is Defaulted
2396 Abv->Add(OpInfo: BitCodeAbbrevOp(0)); // TemplateArgumentsAsWritten
2397 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SourceLocation
2398 Abv->Add(OpInfo: BitCodeAbbrevOp(0));
2399 Abv->Add(
2400 OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Canonical Decl of template
2401 } else if constexpr (Kind == FunctionDecl::
2402 TK_DependentFunctionTemplateSpecialization) {
2403 // Candidates of specialization
2404 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
2405 Abv->Add(OpInfo: BitCodeAbbrevOp(0)); // TemplateArgumentsAsWritten
2406 } else {
2407 llvm_unreachable("Unknown templated kind?");
2408 }
2409 // Decl
2410 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed,
2411 8)); // Packed DeclBits: ModuleOwnershipKind,
2412 // isUsed, isReferenced, AccessSpecifier,
2413 // isImplicit
2414 //
2415 // The following bits should be 0:
2416 // HasStandaloneLexicalDC, HasAttrs,
2417 // TopLevelDeclInObjCContainer,
2418 // isInvalidDecl
2419 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclContext
2420 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SubmoduleID
2421 // NamedDecl
2422 Abv->Add(OpInfo: BitCodeAbbrevOp(DeclarationName::Identifier)); // NameKind
2423 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Identifier
2424 Abv->Add(OpInfo: BitCodeAbbrevOp(0)); // AnonDeclNumber
2425 // ValueDecl
2426 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type
2427 // DeclaratorDecl
2428 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // InnerLocStart
2429 Abv->Add(OpInfo: BitCodeAbbrevOp(0)); // HasExtInfo
2430 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // TSIType
2431 // FunctionDecl
2432 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 11)); // IDNS
2433 Abv->Add(OpInfo: BitCodeAbbrevOp(
2434 BitCodeAbbrevOp::Fixed,
2435 28)); // Packed Function Bits: StorageClass, Inline, InlineSpecified,
2436 // VirtualAsWritten, Pure, HasInheritedProto, HasWrittenProto,
2437 // Deleted, Trivial, TrivialForCall, Defaulted, ExplicitlyDefaulted,
2438 // IsIneligibleOrNotSelected, ImplicitReturnZero, Constexpr,
2439 // UsesSEHTry, SkippedBody, MultiVersion, LateParsed,
2440 // FriendConstraintRefersToEnclosingTemplate, Linkage,
2441 // ShouldSkipCheckingODR
2442 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // LocEnd
2443 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // ODRHash
2444 // This Array slurps the rest of the record. Fortunately we want to encode
2445 // (nearly) all the remaining (variable number of) fields in the same way.
2446 //
2447 // This is:
2448 // NumParams and Params[] from FunctionDecl, and
2449 // NumOverriddenMethods, OverriddenMethods[] from CXXMethodDecl.
2450 //
2451 // Add an AbbrevOp for 'size then elements' and use it here.
2452 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
2453 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));
2454 return Abv;
2455}
2456
2457template <FunctionDecl::TemplatedKind Kind>
2458std::shared_ptr<llvm::BitCodeAbbrev> getCXXMethodAbbrev() {
2459 return getFunctionDeclAbbrev<Kind>(serialization::DECL_CXX_METHOD);
2460}
2461} // namespace
2462
2463void ASTWriter::WriteDeclAbbrevs() {
2464 using namespace llvm;
2465
2466 std::shared_ptr<BitCodeAbbrev> Abv;
2467
2468 // Abbreviation for DECL_FIELD
2469 Abv = std::make_shared<BitCodeAbbrev>();
2470 Abv->Add(OpInfo: BitCodeAbbrevOp(serialization::DECL_FIELD));
2471 // Decl
2472 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed,
2473 7)); // Packed DeclBits: ModuleOwnershipKind,
2474 // isUsed, isReferenced, AccessSpecifier,
2475 //
2476 // The following bits should be 0:
2477 // isImplicit, HasStandaloneLexicalDC, HasAttrs,
2478 // TopLevelDeclInObjCContainer,
2479 // isInvalidDecl
2480 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclContext
2481 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SubmoduleID
2482 // NamedDecl
2483 Abv->Add(OpInfo: BitCodeAbbrevOp(0)); // NameKind = Identifier
2484 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Name
2485 Abv->Add(OpInfo: BitCodeAbbrevOp(0)); // AnonDeclNumber
2486 // ValueDecl
2487 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type
2488 // DeclaratorDecl
2489 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // InnerStartLoc
2490 Abv->Add(OpInfo: BitCodeAbbrevOp(0)); // hasExtInfo
2491 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // TSIType
2492 // FieldDecl
2493 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isMutable
2494 Abv->Add(OpInfo: BitCodeAbbrevOp(0)); // StorageKind
2495 // Type Source Info
2496 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
2497 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // TypeLoc
2498 DeclFieldAbbrev = Stream.EmitAbbrev(Abbv: std::move(Abv));
2499
2500 // Abbreviation for DECL_OBJC_IVAR
2501 Abv = std::make_shared<BitCodeAbbrev>();
2502 Abv->Add(OpInfo: BitCodeAbbrevOp(serialization::DECL_OBJC_IVAR));
2503 // Decl
2504 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed,
2505 12)); // Packed DeclBits: HasStandaloneLexicalDC,
2506 // isInvalidDecl, HasAttrs, isImplicit, isUsed,
2507 // isReferenced, TopLevelDeclInObjCContainer,
2508 // AccessSpecifier, ModuleOwnershipKind
2509 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclContext
2510 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SubmoduleID
2511 // NamedDecl
2512 Abv->Add(OpInfo: BitCodeAbbrevOp(0)); // NameKind = Identifier
2513 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Name
2514 Abv->Add(OpInfo: BitCodeAbbrevOp(0)); // AnonDeclNumber
2515 // ValueDecl
2516 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type
2517 // DeclaratorDecl
2518 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // InnerStartLoc
2519 Abv->Add(OpInfo: BitCodeAbbrevOp(0)); // hasExtInfo
2520 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // TSIType
2521 // FieldDecl
2522 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isMutable
2523 Abv->Add(OpInfo: BitCodeAbbrevOp(0)); // InitStyle
2524 // ObjC Ivar
2525 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // getAccessControl
2526 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // getSynthesize
2527 // Type Source Info
2528 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
2529 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // TypeLoc
2530 DeclObjCIvarAbbrev = Stream.EmitAbbrev(Abbv: std::move(Abv));
2531
2532 // Abbreviation for DECL_ENUM
2533 Abv = std::make_shared<BitCodeAbbrev>();
2534 Abv->Add(OpInfo: BitCodeAbbrevOp(serialization::DECL_ENUM));
2535 // Redeclarable
2536 Abv->Add(OpInfo: BitCodeAbbrevOp(0)); // No redeclaration
2537 // Decl
2538 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed,
2539 7)); // Packed DeclBits: ModuleOwnershipKind,
2540 // isUsed, isReferenced, AccessSpecifier,
2541 //
2542 // The following bits should be 0:
2543 // isImplicit, HasStandaloneLexicalDC, HasAttrs,
2544 // TopLevelDeclInObjCContainer,
2545 // isInvalidDecl
2546 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclContext
2547 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SubmoduleID
2548 // NamedDecl
2549 Abv->Add(OpInfo: BitCodeAbbrevOp(0)); // NameKind = Identifier
2550 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Name
2551 Abv->Add(OpInfo: BitCodeAbbrevOp(0)); // AnonDeclNumber
2552 // TypeDecl
2553 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Source Location
2554 // TagDecl
2555 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // IdentifierNamespace
2556 Abv->Add(OpInfo: BitCodeAbbrevOp(
2557 BitCodeAbbrevOp::Fixed,
2558 9)); // Packed Tag Decl Bits: getTagKind, isCompleteDefinition,
2559 // EmbeddedInDeclarator, IsFreeStanding,
2560 // isCompleteDefinitionRequired, ExtInfoKind
2561 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SourceLocation
2562 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SourceLocation
2563 // EnumDecl
2564 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // AddTypeRef
2565 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // IntegerType
2566 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // getPromotionType
2567 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 20)); // Enum Decl Bits
2568 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));// ODRHash
2569 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // InstantiatedMembEnum
2570 // DC
2571 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // LexicalOffset
2572 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // VisibleOffset
2573 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // ModuleLocalOffset
2574 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // TULocalOffset
2575 DeclEnumAbbrev = Stream.EmitAbbrev(Abbv: std::move(Abv));
2576
2577 // Abbreviation for DECL_RECORD
2578 Abv = std::make_shared<BitCodeAbbrev>();
2579 Abv->Add(OpInfo: BitCodeAbbrevOp(serialization::DECL_RECORD));
2580 // Redeclarable
2581 Abv->Add(OpInfo: BitCodeAbbrevOp(0)); // No redeclaration
2582 // Decl
2583 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed,
2584 7)); // Packed DeclBits: ModuleOwnershipKind,
2585 // isUsed, isReferenced, AccessSpecifier,
2586 //
2587 // The following bits should be 0:
2588 // isImplicit, HasStandaloneLexicalDC, HasAttrs,
2589 // TopLevelDeclInObjCContainer,
2590 // isInvalidDecl
2591 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclContext
2592 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SubmoduleID
2593 // NamedDecl
2594 Abv->Add(OpInfo: BitCodeAbbrevOp(0)); // NameKind = Identifier
2595 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Name
2596 Abv->Add(OpInfo: BitCodeAbbrevOp(0)); // AnonDeclNumber
2597 // TypeDecl
2598 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Source Location
2599 // TagDecl
2600 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // IdentifierNamespace
2601 Abv->Add(OpInfo: BitCodeAbbrevOp(
2602 BitCodeAbbrevOp::Fixed,
2603 9)); // Packed Tag Decl Bits: getTagKind, isCompleteDefinition,
2604 // EmbeddedInDeclarator, IsFreeStanding,
2605 // isCompleteDefinitionRequired, ExtInfoKind
2606 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SourceLocation
2607 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SourceLocation
2608 // RecordDecl
2609 Abv->Add(OpInfo: BitCodeAbbrevOp(
2610 BitCodeAbbrevOp::Fixed,
2611 14)); // Packed Record Decl Bits: FlexibleArrayMember,
2612 // AnonymousStructUnion, hasObjectMember, hasVolatileMember,
2613 // isNonTrivialToPrimitiveDefaultInitialize,
2614 // isNonTrivialToPrimitiveCopy, isNonTrivialToPrimitiveDestroy,
2615 // hasNonTrivialToPrimitiveDefaultInitializeCUnion,
2616 // hasNonTrivialToPrimitiveDestructCUnion,
2617 // hasNonTrivialToPrimitiveCopyCUnion,
2618 // hasUninitializedExplicitInitFields, isParamDestroyedInCallee,
2619 // getArgPassingRestrictions
2620 // ODRHash
2621 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 26));
2622
2623 // DC
2624 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // LexicalOffset
2625 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // VisibleOffset
2626 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // ModuleLocalOffset
2627 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // TULocalOffset
2628 DeclRecordAbbrev = Stream.EmitAbbrev(Abbv: std::move(Abv));
2629
2630 // Abbreviation for DECL_PARM_VAR
2631 Abv = std::make_shared<BitCodeAbbrev>();
2632 Abv->Add(OpInfo: BitCodeAbbrevOp(serialization::DECL_PARM_VAR));
2633 // Redeclarable
2634 Abv->Add(OpInfo: BitCodeAbbrevOp(0)); // No redeclaration
2635 // Decl
2636 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed,
2637 8)); // Packed DeclBits: ModuleOwnershipKind, isUsed,
2638 // isReferenced, AccessSpecifier,
2639 // HasStandaloneLexicalDC, HasAttrs, isImplicit,
2640 // TopLevelDeclInObjCContainer,
2641 // isInvalidDecl,
2642 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclContext
2643 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SubmoduleID
2644 // NamedDecl
2645 Abv->Add(OpInfo: BitCodeAbbrevOp(0)); // NameKind = Identifier
2646 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Name
2647 Abv->Add(OpInfo: BitCodeAbbrevOp(0)); // AnonDeclNumber
2648 // ValueDecl
2649 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type
2650 // DeclaratorDecl
2651 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // InnerStartLoc
2652 Abv->Add(OpInfo: BitCodeAbbrevOp(0)); // hasExtInfo
2653 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // TSIType
2654 // VarDecl
2655 Abv->Add(
2656 OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed,
2657 12)); // Packed Var Decl bits: SClass, TSCSpec, InitStyle,
2658 // isARCPseudoStrong, Linkage, ModulesCodegen
2659 Abv->Add(OpInfo: BitCodeAbbrevOp(0)); // VarKind (local enum)
2660 // ParmVarDecl
2661 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // ScopeIndex
2662 Abv->Add(OpInfo: BitCodeAbbrevOp(
2663 BitCodeAbbrevOp::Fixed,
2664 19)); // Packed Parm Var Decl bits: IsObjCMethodParameter, ScopeDepth,
2665 // ObjCDeclQualifier, KNRPromoted,
2666 // HasInheritedDefaultArg, HasUninstantiatedDefaultArg
2667 // Type Source Info
2668 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
2669 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // TypeLoc
2670 DeclParmVarAbbrev = Stream.EmitAbbrev(Abbv: std::move(Abv));
2671
2672 // Abbreviation for DECL_TYPEDEF
2673 Abv = std::make_shared<BitCodeAbbrev>();
2674 Abv->Add(OpInfo: BitCodeAbbrevOp(serialization::DECL_TYPEDEF));
2675 // Redeclarable
2676 Abv->Add(OpInfo: BitCodeAbbrevOp(0)); // No redeclaration
2677 // Decl
2678 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed,
2679 7)); // Packed DeclBits: ModuleOwnershipKind,
2680 // isReferenced, isUsed, AccessSpecifier. Other
2681 // higher bits should be 0: isImplicit,
2682 // HasStandaloneLexicalDC, HasAttrs,
2683 // TopLevelDeclInObjCContainer, isInvalidDecl
2684 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclContext
2685 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SubmoduleID
2686 // NamedDecl
2687 Abv->Add(OpInfo: BitCodeAbbrevOp(0)); // NameKind = Identifier
2688 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Name
2689 Abv->Add(OpInfo: BitCodeAbbrevOp(0)); // AnonDeclNumber
2690 // TypeDecl
2691 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Source Location
2692 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type Ref
2693 // TypedefDecl
2694 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
2695 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // TypeLoc
2696 DeclTypedefAbbrev = Stream.EmitAbbrev(Abbv: std::move(Abv));
2697
2698 // Abbreviation for DECL_VAR
2699 Abv = std::make_shared<BitCodeAbbrev>();
2700 Abv->Add(OpInfo: BitCodeAbbrevOp(serialization::DECL_VAR));
2701 // Redeclarable
2702 Abv->Add(OpInfo: BitCodeAbbrevOp(0)); // No redeclaration
2703 // Decl
2704 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed,
2705 12)); // Packed DeclBits: HasStandaloneLexicalDC,
2706 // isInvalidDecl, HasAttrs, isImplicit, isUsed,
2707 // isReferenced, TopLevelDeclInObjCContainer,
2708 // AccessSpecifier, ModuleOwnershipKind
2709 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclContext
2710 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SubmoduleID
2711 // NamedDecl
2712 Abv->Add(OpInfo: BitCodeAbbrevOp(0)); // NameKind = Identifier
2713 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Name
2714 Abv->Add(OpInfo: BitCodeAbbrevOp(0)); // AnonDeclNumber
2715 // ValueDecl
2716 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type
2717 // DeclaratorDecl
2718 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // InnerStartLoc
2719 Abv->Add(OpInfo: BitCodeAbbrevOp(0)); // hasExtInfo
2720 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // TSIType
2721 // VarDecl
2722 Abv->Add(OpInfo: BitCodeAbbrevOp(
2723 BitCodeAbbrevOp::Fixed,
2724 22)); // Packed Var Decl bits: Linkage, ModulesCodegen,
2725 // SClass, TSCSpec, InitStyle,
2726 // isARCPseudoStrong, IsThisDeclarationADemotedDefinition,
2727 // isExceptionVariable, isNRVOVariable, isCXXForRangeDecl,
2728 // isInline, isInlineSpecified, isConstexpr,
2729 // isInitCapture, isPrevDeclInSameScope, hasInitWithSideEffects,
2730 // EscapingByref, HasDeducedType, ImplicitParamKind, isObjCForDecl
2731 // IsCXXForRangeImplicitVar
2732 Abv->Add(OpInfo: BitCodeAbbrevOp(0)); // VarKind (local enum)
2733 // Type Source Info
2734 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
2735 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // TypeLoc
2736 DeclVarAbbrev = Stream.EmitAbbrev(Abbv: std::move(Abv));
2737
2738 // Abbreviation for DECL_CXX_METHOD
2739 DeclCXXMethodAbbrev =
2740 Stream.EmitAbbrev(Abbv: getCXXMethodAbbrev<FunctionDecl::TK_NonTemplate>());
2741 DeclTemplateCXXMethodAbbrev = Stream.EmitAbbrev(
2742 Abbv: getCXXMethodAbbrev<FunctionDecl::TK_FunctionTemplate>());
2743 DeclDependentNonTemplateCXXMethodAbbrev = Stream.EmitAbbrev(
2744 Abbv: getCXXMethodAbbrev<FunctionDecl::TK_DependentNonTemplate>());
2745 DeclMemberSpecializedCXXMethodAbbrev = Stream.EmitAbbrev(
2746 Abbv: getCXXMethodAbbrev<FunctionDecl::TK_MemberSpecialization>());
2747 DeclTemplateSpecializedCXXMethodAbbrev = Stream.EmitAbbrev(
2748 Abbv: getCXXMethodAbbrev<FunctionDecl::TK_FunctionTemplateSpecialization>());
2749 DeclDependentSpecializationCXXMethodAbbrev = Stream.EmitAbbrev(
2750 Abbv: getCXXMethodAbbrev<
2751 FunctionDecl::TK_DependentFunctionTemplateSpecialization>());
2752
2753 // Abbreviation for DECL_TEMPLATE_TYPE_PARM
2754 Abv = std::make_shared<BitCodeAbbrev>();
2755 Abv->Add(OpInfo: BitCodeAbbrevOp(serialization::DECL_TEMPLATE_TYPE_PARM));
2756 Abv->Add(OpInfo: BitCodeAbbrevOp(0)); // hasTypeConstraint
2757 // Decl
2758 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed,
2759 7)); // Packed DeclBits: ModuleOwnershipKind,
2760 // isReferenced, isUsed, AccessSpecifier. Other
2761 // higher bits should be 0: isImplicit,
2762 // HasStandaloneLexicalDC, HasAttrs,
2763 // TopLevelDeclInObjCContainer, isInvalidDecl
2764 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclContext
2765 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SubmoduleID
2766 // NamedDecl
2767 Abv->Add(OpInfo: BitCodeAbbrevOp(0)); // NameKind = Identifier
2768 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Name
2769 Abv->Add(OpInfo: BitCodeAbbrevOp(0));
2770 // TypeDecl
2771 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Source Location
2772 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type Ref
2773 // TemplateTypeParmDecl
2774 Abv->Add(
2775 OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // wasDeclaredWithTypename
2776 Abv->Add(OpInfo: BitCodeAbbrevOp(0)); // OwnsDefaultArg
2777 DeclTemplateTypeParmAbbrev = Stream.EmitAbbrev(Abbv: std::move(Abv));
2778
2779 // Abbreviation for DECL_USING_SHADOW
2780 Abv = std::make_shared<BitCodeAbbrev>();
2781 Abv->Add(OpInfo: BitCodeAbbrevOp(serialization::DECL_USING_SHADOW));
2782 // Redeclarable
2783 Abv->Add(OpInfo: BitCodeAbbrevOp(0)); // No redeclaration
2784 // Decl
2785 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed,
2786 12)); // Packed DeclBits: HasStandaloneLexicalDC,
2787 // isInvalidDecl, HasAttrs, isImplicit, isUsed,
2788 // isReferenced, TopLevelDeclInObjCContainer,
2789 // AccessSpecifier, ModuleOwnershipKind
2790 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclContext
2791 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SubmoduleID
2792 // NamedDecl
2793 Abv->Add(OpInfo: BitCodeAbbrevOp(0)); // NameKind = Identifier
2794 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Name
2795 Abv->Add(OpInfo: BitCodeAbbrevOp(0));
2796 // UsingShadowDecl
2797 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // TargetDecl
2798 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 11)); // IDNS
2799 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // UsingOrNextShadow
2800 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR,
2801 6)); // InstantiatedFromUsingShadowDecl
2802 DeclUsingShadowAbbrev = Stream.EmitAbbrev(Abbv: std::move(Abv));
2803
2804 // Abbreviation for EXPR_DECL_REF
2805 Abv = std::make_shared<BitCodeAbbrev>();
2806 Abv->Add(OpInfo: BitCodeAbbrevOp(serialization::EXPR_DECL_REF));
2807 // Stmt
2808 // Expr
2809 // PackingBits: DependenceKind, ValueKind. ObjectKind should be 0.
2810 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 7));
2811 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type
2812 // DeclRefExpr
2813 // Packing Bits: , HadMultipleCandidates, RefersToEnclosingVariableOrCapture,
2814 // IsImmediateEscalating, NonOdrUseReason.
2815 // GetDeclFound, HasQualifier and ExplicitTemplateArgs should be 0.
2816 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 5));
2817 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclRef
2818 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Location
2819 DeclRefExprAbbrev = Stream.EmitAbbrev(Abbv: std::move(Abv));
2820
2821 // Abbreviation for EXPR_INTEGER_LITERAL
2822 Abv = std::make_shared<BitCodeAbbrev>();
2823 Abv->Add(OpInfo: BitCodeAbbrevOp(serialization::EXPR_INTEGER_LITERAL));
2824 //Stmt
2825 // Expr
2826 // DependenceKind, ValueKind, ObjectKind
2827 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 10));
2828 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type
2829 // Integer Literal
2830 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Location
2831 Abv->Add(OpInfo: BitCodeAbbrevOp(32)); // Bit Width
2832 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Value
2833 IntegerLiteralAbbrev = Stream.EmitAbbrev(Abbv: std::move(Abv));
2834
2835 // Abbreviation for EXPR_CHARACTER_LITERAL
2836 Abv = std::make_shared<BitCodeAbbrev>();
2837 Abv->Add(OpInfo: BitCodeAbbrevOp(serialization::EXPR_CHARACTER_LITERAL));
2838 //Stmt
2839 // Expr
2840 // DependenceKind, ValueKind, ObjectKind
2841 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 10));
2842 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type
2843 // Character Literal
2844 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // getValue
2845 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Location
2846 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); // getKind
2847 CharacterLiteralAbbrev = Stream.EmitAbbrev(Abbv: std::move(Abv));
2848
2849 // Abbreviation for EXPR_IMPLICIT_CAST
2850 Abv = std::make_shared<BitCodeAbbrev>();
2851 Abv->Add(OpInfo: BitCodeAbbrevOp(serialization::EXPR_IMPLICIT_CAST));
2852 // Stmt
2853 // Expr
2854 // Packing Bits: DependenceKind, ValueKind, ObjectKind,
2855 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 10));
2856 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type
2857 // CastExpr
2858 Abv->Add(OpInfo: BitCodeAbbrevOp(0)); // PathSize
2859 // Packing Bits: CastKind, StoredFPFeatures, isPartOfExplicitCast
2860 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 9));
2861 // ImplicitCastExpr
2862 ExprImplicitCastAbbrev = Stream.EmitAbbrev(Abbv: std::move(Abv));
2863
2864 // Abbreviation for EXPR_BINARY_OPERATOR
2865 Abv = std::make_shared<BitCodeAbbrev>();
2866 Abv->Add(OpInfo: BitCodeAbbrevOp(serialization::EXPR_BINARY_OPERATOR));
2867 // Stmt
2868 // Expr
2869 // Packing Bits: DependenceKind. ValueKind and ObjectKind should
2870 // be 0 in this case.
2871 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 5));
2872 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type
2873 // BinaryOperator
2874 Abv->Add(
2875 OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // OpCode and HasFPFeatures
2876 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Source Location
2877 BinaryOperatorAbbrev = Stream.EmitAbbrev(Abbv: std::move(Abv));
2878
2879 // Abbreviation for EXPR_COMPOUND_ASSIGN_OPERATOR
2880 Abv = std::make_shared<BitCodeAbbrev>();
2881 Abv->Add(OpInfo: BitCodeAbbrevOp(serialization::EXPR_COMPOUND_ASSIGN_OPERATOR));
2882 // Stmt
2883 // Expr
2884 // Packing Bits: DependenceKind. ValueKind and ObjectKind should
2885 // be 0 in this case.
2886 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 5));
2887 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type
2888 // BinaryOperator
2889 // Packing Bits: OpCode. The HasFPFeatures bit should be 0
2890 Abv->Add(
2891 OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // OpCode and HasFPFeatures
2892 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Source Location
2893 // CompoundAssignOperator
2894 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // LHSType
2895 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Result Type
2896 CompoundAssignOperatorAbbrev = Stream.EmitAbbrev(Abbv: std::move(Abv));
2897
2898 // Abbreviation for EXPR_CALL
2899 Abv = std::make_shared<BitCodeAbbrev>();
2900 Abv->Add(OpInfo: BitCodeAbbrevOp(serialization::EXPR_CALL));
2901 // Stmt
2902 // Expr
2903 // Packing Bits: DependenceKind, ValueKind, ObjectKind,
2904 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 10));
2905 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type
2906 // CallExpr
2907 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // NumArgs
2908 Abv->Add(OpInfo: BitCodeAbbrevOp(0)); // ADLCallKind
2909 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Source Location
2910 CallExprAbbrev = Stream.EmitAbbrev(Abbv: std::move(Abv));
2911
2912 // Abbreviation for EXPR_CXX_OPERATOR_CALL
2913 Abv = std::make_shared<BitCodeAbbrev>();
2914 Abv->Add(OpInfo: BitCodeAbbrevOp(serialization::EXPR_CXX_OPERATOR_CALL));
2915 // Stmt
2916 // Expr
2917 // Packing Bits: DependenceKind, ValueKind, ObjectKind,
2918 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 10));
2919 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type
2920 // CallExpr
2921 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // NumArgs
2922 Abv->Add(OpInfo: BitCodeAbbrevOp(0)); // ADLCallKind
2923 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Source Location
2924 // CXXOperatorCallExpr
2925 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Operator Kind
2926 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Source Location
2927 CXXOperatorCallExprAbbrev = Stream.EmitAbbrev(Abbv: std::move(Abv));
2928
2929 // Abbreviation for EXPR_CXX_MEMBER_CALL
2930 Abv = std::make_shared<BitCodeAbbrev>();
2931 Abv->Add(OpInfo: BitCodeAbbrevOp(serialization::EXPR_CXX_MEMBER_CALL));
2932 // Stmt
2933 // Expr
2934 // Packing Bits: DependenceKind, ValueKind, ObjectKind,
2935 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 10));
2936 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type
2937 // CallExpr
2938 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // NumArgs
2939 Abv->Add(OpInfo: BitCodeAbbrevOp(0)); // ADLCallKind
2940 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Source Location
2941 // CXXMemberCallExpr
2942 CXXMemberCallExprAbbrev = Stream.EmitAbbrev(Abbv: std::move(Abv));
2943
2944 // Abbreviation for STMT_COMPOUND
2945 Abv = std::make_shared<BitCodeAbbrev>();
2946 Abv->Add(OpInfo: BitCodeAbbrevOp(serialization::STMT_COMPOUND));
2947 // Stmt
2948 // CompoundStmt
2949 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Num Stmts
2950 Abv->Add(OpInfo: BitCodeAbbrevOp(0)); // hasStoredFPFeatures
2951 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Source Location
2952 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Source Location
2953 CompoundStmtAbbrev = Stream.EmitAbbrev(Abbv: std::move(Abv));
2954
2955 Abv = std::make_shared<BitCodeAbbrev>();
2956 Abv->Add(OpInfo: BitCodeAbbrevOp(serialization::DECL_CONTEXT_LEXICAL));
2957 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
2958 DeclContextLexicalAbbrev = Stream.EmitAbbrev(Abbv: std::move(Abv));
2959
2960 Abv = std::make_shared<BitCodeAbbrev>();
2961 Abv->Add(OpInfo: BitCodeAbbrevOp(serialization::DECL_CONTEXT_VISIBLE));
2962 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
2963 DeclContextVisibleLookupAbbrev = Stream.EmitAbbrev(Abbv: std::move(Abv));
2964
2965 Abv = std::make_shared<BitCodeAbbrev>();
2966 Abv->Add(OpInfo: BitCodeAbbrevOp(serialization::DECL_CONTEXT_MODULE_LOCAL_VISIBLE));
2967 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
2968 DeclModuleLocalVisibleLookupAbbrev = Stream.EmitAbbrev(Abbv: std::move(Abv));
2969
2970 Abv = std::make_shared<BitCodeAbbrev>();
2971 Abv->Add(OpInfo: BitCodeAbbrevOp(serialization::DECL_CONTEXT_TU_LOCAL_VISIBLE));
2972 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
2973 DeclTULocalLookupAbbrev = Stream.EmitAbbrev(Abbv: std::move(Abv));
2974
2975 Abv = std::make_shared<BitCodeAbbrev>();
2976 Abv->Add(OpInfo: BitCodeAbbrevOp(serialization::DECL_SPECIALIZATIONS));
2977 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
2978 DeclSpecializationsAbbrev = Stream.EmitAbbrev(Abbv: std::move(Abv));
2979
2980 Abv = std::make_shared<BitCodeAbbrev>();
2981 Abv->Add(OpInfo: BitCodeAbbrevOp(serialization::DECL_PARTIAL_SPECIALIZATIONS));
2982 Abv->Add(OpInfo: BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
2983 DeclPartialSpecializationsAbbrev = Stream.EmitAbbrev(Abbv: std::move(Abv));
2984}
2985
2986/// isRequiredDecl - Check if this is a "required" Decl, which must be seen by
2987/// consumers of the AST.
2988///
2989/// Such decls will always be deserialized from the AST file, so we would like
2990/// this to be as restrictive as possible. Currently the predicate is driven by
2991/// code generation requirements, if other clients have a different notion of
2992/// what is "required" then we may have to consider an alternate scheme where
2993/// clients can iterate over the top-level decls and get information on them,
2994/// without necessary deserializing them. We could explicitly require such
2995/// clients to use a separate API call to "realize" the decl. This should be
2996/// relatively painless since they would presumably only do it for top-level
2997/// decls.
2998static bool isRequiredDecl(const Decl *D, ASTContext &Context,
2999 Module *WritingModule) {
3000 // Named modules have different semantics than header modules. Every named
3001 // module units owns a translation unit. So the importer of named modules
3002 // doesn't need to deserilize everything ahead of time.
3003 if (WritingModule && WritingModule->isNamedModule()) {
3004 // The PragmaCommentDecl and PragmaDetectMismatchDecl are MSVC's extension.
3005 // And the behavior of MSVC for such cases will leak this to the module
3006 // users. Given pragma is not a standard thing, the compiler has the space
3007 // to do their own decision. Let's follow MSVC here.
3008 if (isa<PragmaCommentDecl, PragmaDetectMismatchDecl>(Val: D))
3009 return true;
3010 return false;
3011 }
3012
3013 // An ObjCMethodDecl is never considered as "required" because its
3014 // implementation container always is.
3015
3016 // File scoped assembly or obj-c or OMP declare target implementation must be
3017 // seen.
3018 if (isa<FileScopeAsmDecl, TopLevelStmtDecl, ObjCImplDecl>(Val: D))
3019 return true;
3020
3021 if (WritingModule && isPartOfPerModuleInitializer(D)) {
3022 // These declarations are part of the module initializer, and are emitted
3023 // if and when the module is imported, rather than being emitted eagerly.
3024 return false;
3025 }
3026
3027 return Context.DeclMustBeEmitted(D);
3028}
3029
3030void ASTWriter::WriteDecl(ASTContext &Context, Decl *D) {
3031 PrettyDeclStackTraceEntry CrashInfo(Context, D, SourceLocation(),
3032 "serializing");
3033
3034 // Determine the ID for this declaration.
3035 LocalDeclID ID;
3036 assert(!D->isFromASTFile() && "should not be emitting imported decl");
3037 LocalDeclID &IDR = DeclIDs[D];
3038 if (IDR.isInvalid())
3039 IDR = NextDeclID++;
3040
3041 ID = IDR;
3042
3043 assert(ID >= FirstDeclID && "invalid decl ID");
3044
3045 RecordData Record;
3046 ASTDeclWriter W(*this, Context, Record, GeneratingReducedBMI);
3047
3048 // Build a record for this declaration
3049 W.Visit(D);
3050
3051 // Emit this declaration to the bitstream.
3052 uint64_t Offset = W.Emit(D);
3053
3054 // Record the offset for this declaration
3055 SourceLocation Loc = D->getLocation();
3056 SourceLocationEncoding::RawLocEncoding RawLoc =
3057 getRawSourceLocationEncoding(Loc: getAdjustedLocation(Loc));
3058
3059 unsigned Index = ID.getRawValue() - FirstDeclID.getRawValue();
3060 if (DeclOffsets.size() == Index)
3061 DeclOffsets.emplace_back(args&: RawLoc, args&: Offset, args&: DeclTypesBlockStartOffset);
3062 else if (DeclOffsets.size() < Index) {
3063 // FIXME: Can/should this happen?
3064 DeclOffsets.resize(new_size: Index+1);
3065 DeclOffsets[Index].setRawLoc(RawLoc);
3066 DeclOffsets[Index].setBitOffset(Offset, DeclTypesBlockStartOffset);
3067 } else {
3068 llvm_unreachable("declarations should be emitted in ID order");
3069 }
3070
3071 SourceManager &SM = Context.getSourceManager();
3072 if (Loc.isValid() && SM.isLocalSourceLocation(Loc))
3073 associateDeclWithFile(D, ID);
3074
3075 // Note declarations that should be deserialized eagerly so that we can add
3076 // them to a record in the AST file later.
3077 if (isRequiredDecl(D, Context, WritingModule))
3078 AddDeclRef(D, Record&: EagerlyDeserializedDecls);
3079}
3080
3081void ASTRecordWriter::AddFunctionDefinition(const FunctionDecl *FD) {
3082 // Switch case IDs are per function body.
3083 Writer->ClearSwitchCaseIDs();
3084
3085 assert(FD->doesThisDeclarationHaveABody());
3086 bool ModulesCodegen = shouldFunctionGenerateHereOnly(FD);
3087 Record->push_back(Elt: ModulesCodegen);
3088 if (ModulesCodegen)
3089 Writer->AddDeclRef(D: FD, Record&: Writer->ModularCodegenDecls);
3090 if (auto *CD = dyn_cast<CXXConstructorDecl>(Val: FD)) {
3091 Record->push_back(Elt: CD->getNumCtorInitializers());
3092 if (CD->getNumCtorInitializers())
3093 AddCXXCtorInitializers(CtorInits: llvm::ArrayRef(CD->init_begin(), CD->init_end()));
3094 }
3095 AddStmt(S: FD->getBody());
3096}
3097