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