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