blob: 472136d99a1316777ecb0b9f5a0d5c0338cf1aa0 [file] [log] [blame]
Sebastian Redld6522cf2010-08-18 23:56:31 +00001//===--- ASTWriterDecl.cpp - Declaration Serialization --------------------===//
Chris Lattner7099dbc2009-04-27 06:16:06 +00002//
Chandler Carruth2946cd72019-01-19 08:50:56 +00003// 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
Chris Lattner7099dbc2009-04-27 06:16:06 +00006//
7//===----------------------------------------------------------------------===//
8//
9// This file implements serialization for Declarations.
10//
11//===----------------------------------------------------------------------===//
12
Sebastian Redlfa1f3702011-04-24 16:28:13 +000013#include "ASTCommon.h"
Reid Kleckner60573ae2019-11-15 17:31:55 -080014#include "clang/AST/Attr.h"
Chris Lattnerca025db2010-05-07 21:43:38 +000015#include "clang/AST/DeclCXX.h"
Argyrios Kyrtzidis3317d982010-10-20 16:22:56 +000016#include "clang/AST/DeclContextInternals.h"
Chandler Carruth3a022472012-12-04 09:13:33 +000017#include "clang/AST/DeclTemplate.h"
18#include "clang/AST/DeclVisitor.h"
19#include "clang/AST/Expr.h"
Kelvin Li1408f912018-09-26 04:28:39 +000020#include "clang/AST/OpenMPClause.h"
Jordan Rose1e879d82018-03-23 00:07:18 +000021#include "clang/AST/PrettyDeclStackTrace.h"
Argyrios Kyrtzidis5fc727a2011-10-28 22:54:21 +000022#include "clang/Basic/SourceManager.h"
Chandler Carruth3a022472012-12-04 09:13:33 +000023#include "clang/Serialization/ASTReader.h"
John McCall2ac702a2019-12-14 03:17:03 -050024#include "clang/Serialization/ASTRecordWriter.h"
Francis Visoiu Mistrihe0308272019-07-03 22:40:07 +000025#include "llvm/Bitstream/BitstreamWriter.h"
Daniel Dunbarf5bda7b2009-12-03 09:13:36 +000026#include "llvm/Support/ErrorHandling.h"
Chris Lattner7099dbc2009-04-27 06:16:06 +000027using namespace clang;
Sebastian Redlfa1f3702011-04-24 16:28:13 +000028using namespace serialization;
Chris Lattner7099dbc2009-04-27 06:16:06 +000029
30//===----------------------------------------------------------------------===//
31// Declaration serialization
32//===----------------------------------------------------------------------===//
33
Argyrios Kyrtzidis74d28bd2010-06-29 22:47:00 +000034namespace clang {
Sebastian Redl42a0f6a2010-08-18 23:56:27 +000035 class ASTDeclWriter : public DeclVisitor<ASTDeclWriter, void> {
Sebastian Redl55c0ad52010-08-18 23:56:21 +000036 ASTWriter &Writer;
Chris Lattner7099dbc2009-04-27 06:16:06 +000037 ASTContext &Context;
Richard Smith69c82bf2016-04-01 22:52:03 +000038 ASTRecordWriter Record;
Chris Lattner7099dbc2009-04-27 06:16:06 +000039
Sebastian Redl539c5062010-08-18 23:57:32 +000040 serialization::DeclCode Code;
Chris Lattner258172e2009-04-27 07:35:58 +000041 unsigned AbbrevToUse;
Chris Lattner7099dbc2009-04-27 06:16:06 +000042
Richard Smith69c82bf2016-04-01 22:52:03 +000043 public:
44 ASTDeclWriter(ASTWriter &Writer, ASTContext &Context,
45 ASTWriter::RecordDataImpl &Record)
46 : Writer(Writer), Context(Context), Record(Writer, Record),
47 Code((serialization::DeclCode)0), AbbrevToUse(0) {}
48
49 uint64_t Emit(Decl *D) {
50 if (!Code)
51 llvm::report_fatal_error(StringRef("unexpected declaration kind '") +
52 D->getDeclKindName() + "'");
Richard Smith645d2cf2016-04-14 00:29:55 +000053 return Record.Emit(Code, AbbrevToUse);
Chris Lattner258172e2009-04-27 07:35:58 +000054 }
Argyrios Kyrtzidis8b200a52010-10-24 17:26:27 +000055
Argyrios Kyrtzidis33575162010-07-02 15:58:43 +000056 void Visit(Decl *D);
Chris Lattner7099dbc2009-04-27 06:16:06 +000057
58 void VisitDecl(Decl *D);
Nico Weber66220292016-03-02 17:28:48 +000059 void VisitPragmaCommentDecl(PragmaCommentDecl *D);
Nico Webercbbaeb12016-03-02 19:28:54 +000060 void VisitPragmaDetectMismatchDecl(PragmaDetectMismatchDecl *D);
Chris Lattner7099dbc2009-04-27 06:16:06 +000061 void VisitTranslationUnitDecl(TranslationUnitDecl *D);
62 void VisitNamedDecl(NamedDecl *D);
Chris Lattnerc8e630e2011-02-17 07:39:24 +000063 void VisitLabelDecl(LabelDecl *LD);
Douglas Gregore31bbd92010-02-21 18:22:14 +000064 void VisitNamespaceDecl(NamespaceDecl *D);
Chris Lattnerca025db2010-05-07 21:43:38 +000065 void VisitUsingDirectiveDecl(UsingDirectiveDecl *D);
66 void VisitNamespaceAliasDecl(NamespaceAliasDecl *D);
Chris Lattner7099dbc2009-04-27 06:16:06 +000067 void VisitTypeDecl(TypeDecl *D);
Douglas Gregor1f179062011-12-19 14:40:25 +000068 void VisitTypedefNameDecl(TypedefNameDecl *D);
Chris Lattner7099dbc2009-04-27 06:16:06 +000069 void VisitTypedefDecl(TypedefDecl *D);
Richard Smithdda56e42011-04-15 14:24:37 +000070 void VisitTypeAliasDecl(TypeAliasDecl *D);
Argyrios Kyrtzidisbd8ac8c2010-06-30 08:49:30 +000071 void VisitUnresolvedUsingTypenameDecl(UnresolvedUsingTypenameDecl *D);
Chris Lattner7099dbc2009-04-27 06:16:06 +000072 void VisitTagDecl(TagDecl *D);
73 void VisitEnumDecl(EnumDecl *D);
74 void VisitRecordDecl(RecordDecl *D);
Chris Lattnerca025db2010-05-07 21:43:38 +000075 void VisitCXXRecordDecl(CXXRecordDecl *D);
76 void VisitClassTemplateSpecializationDecl(
77 ClassTemplateSpecializationDecl *D);
78 void VisitClassTemplatePartialSpecializationDecl(
79 ClassTemplatePartialSpecializationDecl *D);
Larisse Voufo39a1e502013-08-06 01:03:05 +000080 void VisitVarTemplateSpecializationDecl(VarTemplateSpecializationDecl *D);
81 void VisitVarTemplatePartialSpecializationDecl(
82 VarTemplatePartialSpecializationDecl *D);
Fariborz Jahanian3a039e32011-08-27 20:50:59 +000083 void VisitClassScopeFunctionSpecializationDecl(
84 ClassScopeFunctionSpecializationDecl *D);
Chris Lattnerca025db2010-05-07 21:43:38 +000085 void VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D);
Chris Lattner7099dbc2009-04-27 06:16:06 +000086 void VisitValueDecl(ValueDecl *D);
87 void VisitEnumConstantDecl(EnumConstantDecl *D);
Argyrios Kyrtzidisbd8ac8c2010-06-30 08:49:30 +000088 void VisitUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *D);
Argyrios Kyrtzidis560ac972009-08-19 01:28:35 +000089 void VisitDeclaratorDecl(DeclaratorDecl *D);
Chris Lattner7099dbc2009-04-27 06:16:06 +000090 void VisitFunctionDecl(FunctionDecl *D);
Richard Smithbc491202017-02-17 20:05:37 +000091 void VisitCXXDeductionGuideDecl(CXXDeductionGuideDecl *D);
Chris Lattnerca025db2010-05-07 21:43:38 +000092 void VisitCXXMethodDecl(CXXMethodDecl *D);
93 void VisitCXXConstructorDecl(CXXConstructorDecl *D);
94 void VisitCXXDestructorDecl(CXXDestructorDecl *D);
95 void VisitCXXConversionDecl(CXXConversionDecl *D);
Chris Lattner7099dbc2009-04-27 06:16:06 +000096 void VisitFieldDecl(FieldDecl *D);
John McCall5e77d762013-04-16 07:28:30 +000097 void VisitMSPropertyDecl(MSPropertyDecl *D);
Francois Pichet783dd6e2010-11-21 06:08:52 +000098 void VisitIndirectFieldDecl(IndirectFieldDecl *D);
Chris Lattner7099dbc2009-04-27 06:16:06 +000099 void VisitVarDecl(VarDecl *D);
100 void VisitImplicitParamDecl(ImplicitParamDecl *D);
101 void VisitParmVarDecl(ParmVarDecl *D);
Richard Smith7b76d812016-08-12 02:21:25 +0000102 void VisitDecompositionDecl(DecompositionDecl *D);
103 void VisitBindingDecl(BindingDecl *D);
Chris Lattnerca025db2010-05-07 21:43:38 +0000104 void VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D);
105 void VisitTemplateDecl(TemplateDecl *D);
Saar Razd7aae332019-07-10 21:25:49 +0000106 void VisitConceptDecl(ConceptDecl *D);
Saar Raza0f50d72020-01-18 09:11:43 +0200107 void VisitRequiresExprBodyDecl(RequiresExprBodyDecl *D);
Peter Collingbourne91b25b72010-07-29 16:11:51 +0000108 void VisitRedeclarableTemplateDecl(RedeclarableTemplateDecl *D);
Chris Lattnerca025db2010-05-07 21:43:38 +0000109 void VisitClassTemplateDecl(ClassTemplateDecl *D);
Larisse Voufo39a1e502013-08-06 01:03:05 +0000110 void VisitVarTemplateDecl(VarTemplateDecl *D);
Argyrios Kyrtzidis69da4a82010-06-22 09:55:07 +0000111 void VisitFunctionTemplateDecl(FunctionTemplateDecl *D);
Chris Lattnerca025db2010-05-07 21:43:38 +0000112 void VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D);
Richard Smith3f1b5d02011-05-05 21:57:07 +0000113 void VisitTypeAliasTemplateDecl(TypeAliasTemplateDecl *D);
Argyrios Kyrtzidis41d45622010-06-20 14:40:59 +0000114 void VisitUsingDecl(UsingDecl *D);
Richard Smith151c4562016-12-20 21:35:28 +0000115 void VisitUsingPackDecl(UsingPackDecl *D);
Argyrios Kyrtzidis41d45622010-06-20 14:40:59 +0000116 void VisitUsingShadowDecl(UsingShadowDecl *D);
Richard Smith5179eb72016-06-28 19:03:57 +0000117 void VisitConstructorUsingShadowDecl(ConstructorUsingShadowDecl *D);
Chris Lattnerca025db2010-05-07 21:43:38 +0000118 void VisitLinkageSpecDecl(LinkageSpecDecl *D);
Richard Smith8df390f2016-09-08 23:14:54 +0000119 void VisitExportDecl(ExportDecl *D);
Chris Lattner7099dbc2009-04-27 06:16:06 +0000120 void VisitFileScopeAsmDecl(FileScopeAsmDecl *D);
Douglas Gregorba345522011-12-02 23:23:56 +0000121 void VisitImportDecl(ImportDecl *D);
Abramo Bagnarad7340582010-06-05 05:09:32 +0000122 void VisitAccessSpecDecl(AccessSpecDecl *D);
Argyrios Kyrtzidis74d28bd2010-06-29 22:47:00 +0000123 void VisitFriendDecl(FriendDecl *D);
Chris Lattnerca025db2010-05-07 21:43:38 +0000124 void VisitFriendTemplateDecl(FriendTemplateDecl *D);
125 void VisitStaticAssertDecl(StaticAssertDecl *D);
Chris Lattner7099dbc2009-04-27 06:16:06 +0000126 void VisitBlockDecl(BlockDecl *D);
Tareq A. Siraj6dfa25a2013-04-16 19:37:38 +0000127 void VisitCapturedDecl(CapturedDecl *D);
Michael Han84324352013-02-22 17:15:32 +0000128 void VisitEmptyDecl(EmptyDecl *D);
Tykerb0561b32019-11-17 11:41:55 +0100129 void VisitLifetimeExtendedTemporaryDecl(LifetimeExtendedTemporaryDecl *D);
Chris Lattnerca025db2010-05-07 21:43:38 +0000130
Richard Smithf1c23dc2016-04-13 02:12:03 +0000131 void VisitDeclContext(DeclContext *DC);
Argyrios Kyrtzidis839bbac2010-08-03 17:30:10 +0000132 template <typename T> void VisitRedeclarable(Redeclarable<T> *D);
Chris Lattnerca025db2010-05-07 21:43:38 +0000133
134
Alexis Hunted053252010-05-30 07:21:58 +0000135 // FIXME: Put in the same order is DeclNodes.td?
Chris Lattner7099dbc2009-04-27 06:16:06 +0000136 void VisitObjCMethodDecl(ObjCMethodDecl *D);
Douglas Gregor85f3f952015-07-07 03:57:15 +0000137 void VisitObjCTypeParamDecl(ObjCTypeParamDecl *D);
Chris Lattner7099dbc2009-04-27 06:16:06 +0000138 void VisitObjCContainerDecl(ObjCContainerDecl *D);
139 void VisitObjCInterfaceDecl(ObjCInterfaceDecl *D);
140 void VisitObjCIvarDecl(ObjCIvarDecl *D);
141 void VisitObjCProtocolDecl(ObjCProtocolDecl *D);
142 void VisitObjCAtDefsFieldDecl(ObjCAtDefsFieldDecl *D);
Chris Lattner7099dbc2009-04-27 06:16:06 +0000143 void VisitObjCCategoryDecl(ObjCCategoryDecl *D);
144 void VisitObjCImplDecl(ObjCImplDecl *D);
145 void VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D);
146 void VisitObjCImplementationDecl(ObjCImplementationDecl *D);
147 void VisitObjCCompatibleAliasDecl(ObjCCompatibleAliasDecl *D);
148 void VisitObjCPropertyDecl(ObjCPropertyDecl *D);
149 void VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D);
Alexey Bataeva769e072013-03-22 06:34:35 +0000150 void VisitOMPThreadPrivateDecl(OMPThreadPrivateDecl *D);
Alexey Bataev25ed0c02019-03-07 17:54:44 +0000151 void VisitOMPAllocateDecl(OMPAllocateDecl *D);
Kelvin Li1408f912018-09-26 04:28:39 +0000152 void VisitOMPRequiresDecl(OMPRequiresDecl *D);
Alexey Bataev94a4f0c2016-03-03 05:21:39 +0000153 void VisitOMPDeclareReductionDecl(OMPDeclareReductionDecl *D);
Michael Kruse251e1482019-02-01 20:25:04 +0000154 void VisitOMPDeclareMapperDecl(OMPDeclareMapperDecl *D);
Alexey Bataev4244be22016-02-11 05:35:55 +0000155 void VisitOMPCapturedExprDecl(OMPCapturedExprDecl *D);
Richard Smithd28ac5b2014-03-22 23:33:22 +0000156
Douglas Gregor85f3f952015-07-07 03:57:15 +0000157 /// Add an Objective-C type parameter list to the given record.
158 void AddObjCTypeParamList(ObjCTypeParamList *typeParams) {
159 // Empty type parameter list.
160 if (!typeParams) {
161 Record.push_back(0);
162 return;
163 }
164
165 Record.push_back(typeParams->size());
166 for (auto typeParam : *typeParams) {
Richard Smith69c82bf2016-04-01 22:52:03 +0000167 Record.AddDeclRef(typeParam);
Douglas Gregor85f3f952015-07-07 03:57:15 +0000168 }
Richard Smith69c82bf2016-04-01 22:52:03 +0000169 Record.AddSourceLocation(typeParams->getLAngleLoc());
170 Record.AddSourceLocation(typeParams->getRAngleLoc());
Douglas Gregor85f3f952015-07-07 03:57:15 +0000171 }
172
Richard Smithd8a83712015-08-22 01:47:18 +0000173 /// Add to the record the first declaration from each module file that
174 /// provides a declaration of D. The intent is to provide a sufficient
175 /// set such that reloading this set will load all current redeclarations.
176 void AddFirstDeclFromEachModule(const Decl *D, bool IncludeLocal) {
177 llvm::MapVector<ModuleFile*, const Decl*> Firsts;
178 // FIXME: We can skip entries that we know are implied by others.
Richard Smith5f55d932015-08-27 21:38:25 +0000179 for (const Decl *R = D->getMostRecentDecl(); R; R = R->getPreviousDecl()) {
180 if (R->isFromASTFile())
Richard Smithd8a83712015-08-22 01:47:18 +0000181 Firsts[Writer.Chain->getOwningModuleFile(R)] = R;
Richard Smith5f55d932015-08-27 21:38:25 +0000182 else if (IncludeLocal)
183 Firsts[nullptr] = R;
184 }
Richard Smithd8a83712015-08-22 01:47:18 +0000185 for (const auto &F : Firsts)
Richard Smith69c82bf2016-04-01 22:52:03 +0000186 Record.AddDeclRef(F.second);
Richard Smithd8a83712015-08-22 01:47:18 +0000187 }
188
Richard Smith509fc852015-02-27 23:05:10 +0000189 /// Get the specialization decl from an entry in the specialization list.
190 template <typename EntryType>
191 typename RedeclarableTemplateDecl::SpecEntryTraits<EntryType>::DeclType *
192 getSpecializationDecl(EntryType &T) {
193 return RedeclarableTemplateDecl::SpecEntryTraits<EntryType>::getDecl(&T);
194 }
195
196 /// Get the list of partial specializations from a template's common ptr.
197 template<typename T>
198 decltype(T::PartialSpecializations) &getPartialSpecializations(T *Common) {
199 return Common->PartialSpecializations;
200 }
201 ArrayRef<Decl> getPartialSpecializations(FunctionTemplateDecl::Common *) {
202 return None;
203 }
204
Richard Smith8ab0cfd2016-02-24 21:59:10 +0000205 template<typename DeclTy>
206 void AddTemplateSpecializations(DeclTy *D) {
Richard Smith509fc852015-02-27 23:05:10 +0000207 auto *Common = D->getCommonPtr();
208
209 // If we have any lazy specializations, and the external AST source is
210 // our chained AST reader, we can just write out the DeclIDs. Otherwise,
211 // we need to resolve them to actual declarations.
212 if (Writer.Chain != Writer.Context->getExternalSource() &&
213 Common->LazySpecializations) {
214 D->LoadLazySpecializations();
215 assert(!Common->LazySpecializations);
216 }
217
Richard Smith509fc852015-02-27 23:05:10 +0000218 ArrayRef<DeclID> LazySpecializations;
219 if (auto *LS = Common->LazySpecializations)
Craig Topper55e39a72015-09-29 04:53:28 +0000220 LazySpecializations = llvm::makeArrayRef(LS + 1, LS[0]);
Richard Smith509fc852015-02-27 23:05:10 +0000221
Richard Smithd8a83712015-08-22 01:47:18 +0000222 // Add a slot to the record for the number of specializations.
223 unsigned I = Record.size();
224 Record.push_back(0);
225
Richard Smith8ab0cfd2016-02-24 21:59:10 +0000226 // AddFirstDeclFromEachModule might trigger deserialization, invalidating
227 // *Specializations iterators.
228 llvm::SmallVector<const Decl*, 16> Specs;
229 for (auto &Entry : Common->Specializations)
230 Specs.push_back(getSpecializationDecl(Entry));
231 for (auto &Entry : getPartialSpecializations(Common))
232 Specs.push_back(getSpecializationDecl(Entry));
233
234 for (auto *D : Specs) {
Richard Smith509fc852015-02-27 23:05:10 +0000235 assert(D->isCanonicalDecl() && "non-canonical decl in set");
Richard Smithd8a83712015-08-22 01:47:18 +0000236 AddFirstDeclFromEachModule(D, /*IncludeLocal*/true);
Richard Smith509fc852015-02-27 23:05:10 +0000237 }
Benjamin Kramerf367dd92015-06-12 15:31:50 +0000238 Record.append(LazySpecializations.begin(), LazySpecializations.end());
Richard Smithd8a83712015-08-22 01:47:18 +0000239
240 // Update the size entry we added earlier.
241 Record[I] = Record.size() - I - 1;
242 }
243
244 /// Ensure that this template specialization is associated with the specified
245 /// template on reload.
246 void RegisterTemplateSpecialization(const Decl *Template,
247 const Decl *Specialization) {
248 Template = Template->getCanonicalDecl();
249
250 // If the canonical template is local, we'll write out this specialization
251 // when we emit it.
252 // FIXME: We can do the same thing if there is any local declaration of
253 // the template, to avoid emitting an update record.
254 if (!Template->isFromASTFile())
255 return;
256
257 // We only need to associate the first local declaration of the
258 // specialization. The other declarations will get pulled in by it.
259 if (Writer.getFirstLocalDecl(Specialization) != Specialization)
260 return;
261
262 Writer.DeclUpdates[Template].push_back(ASTWriter::DeclUpdate(
263 UPD_CXX_ADDED_TEMPLATE_SPECIALIZATION, Specialization));
Richard Smith509fc852015-02-27 23:05:10 +0000264 }
Chris Lattner7099dbc2009-04-27 06:16:06 +0000265 };
Alexander Kornienkoab9db512015-06-22 23:07:51 +0000266}
Chris Lattner7099dbc2009-04-27 06:16:06 +0000267
Sebastian Redl42a0f6a2010-08-18 23:56:27 +0000268void ASTDeclWriter::Visit(Decl *D) {
269 DeclVisitor<ASTDeclWriter>::Visit(D);
Argyrios Kyrtzidis33575162010-07-02 15:58:43 +0000270
Jonathan D. Turner205c7d52011-06-03 23:11:16 +0000271 // Source locations require array (variable-length) abbreviations. The
272 // abbreviation infrastructure requires that arrays are encoded last, so
273 // we handle it here in the case of those classes derived from DeclaratorDecl
Nick Lewycky4b81fc872015-10-18 20:32:12 +0000274 if (DeclaratorDecl *DD = dyn_cast<DeclaratorDecl>(D)) {
Richard Smithc23d7342018-06-29 20:46:25 +0000275 if (auto *TInfo = DD->getTypeSourceInfo())
276 Record.AddTypeLoc(TInfo->getTypeLoc());
Jonathan D. Turner205c7d52011-06-03 23:11:16 +0000277 }
278
Argyrios Kyrtzidis33575162010-07-02 15:58:43 +0000279 // Handle FunctionDecl's body here and write it after all other Stmts/Exprs
280 // have been written. We want it last because we will not read it back when
Fangrui Song6907ce22018-07-30 19:24:48 +0000281 // retrieving it from the AST, we'll just lazily set the offset.
Argyrios Kyrtzidis33575162010-07-02 15:58:43 +0000282 if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
Alexis Hunt4a8ea102011-05-06 20:44:56 +0000283 Record.push_back(FD->doesThisDeclarationHaveABody());
284 if (FD->doesThisDeclarationHaveABody())
Richard Smith290d8012016-04-06 17:06:00 +0000285 Record.AddFunctionDefinition(FD);
Argyrios Kyrtzidis33575162010-07-02 15:58:43 +0000286 }
Richard Smithf1c23dc2016-04-13 02:12:03 +0000287
288 // If this declaration is also a DeclContext, write blocks for the
289 // declarations that lexically stored inside its context and those
290 // declarations that are visible from its context.
291 if (DeclContext *DC = dyn_cast<DeclContext>(D))
292 VisitDeclContext(DC);
Argyrios Kyrtzidis33575162010-07-02 15:58:43 +0000293}
294
Sebastian Redl42a0f6a2010-08-18 23:56:27 +0000295void ASTDeclWriter::VisitDecl(Decl *D) {
Richard Smith69c82bf2016-04-01 22:52:03 +0000296 Record.AddDeclRef(cast_or_null<Decl>(D->getDeclContext()));
Richard Smith8aed4222015-12-11 22:41:00 +0000297 if (D->getDeclContext() != D->getLexicalDeclContext())
Richard Smith69c82bf2016-04-01 22:52:03 +0000298 Record.AddDeclRef(cast_or_null<Decl>(D->getLexicalDeclContext()));
Richard Smith8aed4222015-12-11 22:41:00 +0000299 else
300 Record.push_back(0);
Chris Lattner7099dbc2009-04-27 06:16:06 +0000301 Record.push_back(D->isInvalidDecl());
302 Record.push_back(D->hasAttrs());
Argyrios Kyrtzidis9beef8e2010-10-18 19:20:11 +0000303 if (D->hasAttrs())
Richard Smith69c82bf2016-04-01 22:52:03 +0000304 Record.AddAttributes(D->getAttrs());
Chris Lattner7099dbc2009-04-27 06:16:06 +0000305 Record.push_back(D->isImplicit());
Douglas Gregorebada0772010-06-17 23:14:26 +0000306 Record.push_back(D->isUsed(false));
Argyrios Kyrtzidis16180232011-04-19 19:51:10 +0000307 Record.push_back(D->isReferenced());
Douglas Gregor781f7132012-01-06 16:59:53 +0000308 Record.push_back(D->isTopLevelDeclInObjCContainer());
Chris Lattner7099dbc2009-04-27 06:16:06 +0000309 Record.push_back(D->getAccess());
Douglas Gregor781f7132012-01-06 16:59:53 +0000310 Record.push_back(D->isModulePrivate());
Richard Smith54f04402017-05-18 02:29:20 +0000311 Record.push_back(Writer.getSubmoduleID(D->getOwningModule()));
Richard Smithc264d352014-03-23 02:30:01 +0000312
313 // If this declaration injected a name into a context different from its
314 // lexical context, and that context is an imported namespace, we need to
315 // update its visible declarations to include this name.
316 //
317 // This happens when we instantiate a class with a friend declaration or a
318 // function with a local extern declaration, for instance.
Richard Smith5fc18a92015-07-12 23:43:21 +0000319 //
320 // FIXME: Can we handle this in AddedVisibleDecl instead?
Richard Smithc264d352014-03-23 02:30:01 +0000321 if (D->isOutOfLine()) {
Richard Smithe3a97022014-03-23 20:41:56 +0000322 auto *DC = D->getDeclContext();
323 while (auto *NS = dyn_cast<NamespaceDecl>(DC->getRedeclContext())) {
324 if (!NS->isFromASTFile())
325 break;
Chandler Carruth8a3d24d2015-03-26 04:27:10 +0000326 Writer.UpdatedDeclContexts.insert(NS->getPrimaryContext());
Richard Smithe3a97022014-03-23 20:41:56 +0000327 if (!NS->isInlineNamespace())
328 break;
329 DC = NS->getParent();
330 }
Richard Smithc264d352014-03-23 02:30:01 +0000331 }
Chris Lattner7099dbc2009-04-27 06:16:06 +0000332}
333
Nico Weber66220292016-03-02 17:28:48 +0000334void ASTDeclWriter::VisitPragmaCommentDecl(PragmaCommentDecl *D) {
335 StringRef Arg = D->getArg();
336 Record.push_back(Arg.size());
337 VisitDecl(D);
Stephen Kellyf2ceec42018-08-09 21:08:08 +0000338 Record.AddSourceLocation(D->getBeginLoc());
Nico Weber66220292016-03-02 17:28:48 +0000339 Record.push_back(D->getCommentKind());
Richard Smith69c82bf2016-04-01 22:52:03 +0000340 Record.AddString(Arg);
Nico Weber66220292016-03-02 17:28:48 +0000341 Code = serialization::DECL_PRAGMA_COMMENT;
342}
343
Nico Webercbbaeb12016-03-02 19:28:54 +0000344void ASTDeclWriter::VisitPragmaDetectMismatchDecl(
345 PragmaDetectMismatchDecl *D) {
346 StringRef Name = D->getName();
347 StringRef Value = D->getValue();
348 Record.push_back(Name.size() + 1 + Value.size());
349 VisitDecl(D);
Stephen Kellyf2ceec42018-08-09 21:08:08 +0000350 Record.AddSourceLocation(D->getBeginLoc());
Richard Smith69c82bf2016-04-01 22:52:03 +0000351 Record.AddString(Name);
352 Record.AddString(Value);
Nico Webercbbaeb12016-03-02 19:28:54 +0000353 Code = serialization::DECL_PRAGMA_DETECT_MISMATCH;
354}
355
Sebastian Redl42a0f6a2010-08-18 23:56:27 +0000356void ASTDeclWriter::VisitTranslationUnitDecl(TranslationUnitDecl *D) {
Douglas Gregordab42432011-08-12 00:15:20 +0000357 llvm_unreachable("Translation units aren't directly serialized");
Chris Lattner7099dbc2009-04-27 06:16:06 +0000358}
359
Sebastian Redl42a0f6a2010-08-18 23:56:27 +0000360void ASTDeclWriter::VisitNamedDecl(NamedDecl *D) {
Chris Lattner7099dbc2009-04-27 06:16:06 +0000361 VisitDecl(D);
Richard Smith69c82bf2016-04-01 22:52:03 +0000362 Record.AddDeclarationName(D->getDeclName());
Richard Smith2b560572015-02-07 03:11:11 +0000363 Record.push_back(needsAnonymousDeclarationNumber(D)
364 ? Writer.getAnonymousDeclarationNumber(D)
365 : 0);
Chris Lattner7099dbc2009-04-27 06:16:06 +0000366}
367
Sebastian Redl42a0f6a2010-08-18 23:56:27 +0000368void ASTDeclWriter::VisitTypeDecl(TypeDecl *D) {
Chris Lattner7099dbc2009-04-27 06:16:06 +0000369 VisitNamedDecl(D);
Stephen Kellyf2ceec42018-08-09 21:08:08 +0000370 Record.AddSourceLocation(D->getBeginLoc());
Richard Smith69c82bf2016-04-01 22:52:03 +0000371 Record.AddTypeRef(QualType(D->getTypeForDecl(), 0));
Chris Lattner7099dbc2009-04-27 06:16:06 +0000372}
373
Douglas Gregor1f179062011-12-19 14:40:25 +0000374void ASTDeclWriter::VisitTypedefNameDecl(TypedefNameDecl *D) {
Douglas Gregor05f10352011-12-17 23:38:30 +0000375 VisitRedeclarable(D);
Chris Lattner7099dbc2009-04-27 06:16:06 +0000376 VisitTypeDecl(D);
Richard Smith69c82bf2016-04-01 22:52:03 +0000377 Record.AddTypeSourceInfo(D->getTypeSourceInfo());
Enea Zaffanellaa86d88c2013-06-20 12:46:19 +0000378 Record.push_back(D->isModed());
379 if (D->isModed())
Richard Smith69c82bf2016-04-01 22:52:03 +0000380 Record.AddTypeRef(D->getUnderlyingType());
Richard Smithc0ca4c22017-01-26 22:39:55 +0000381 Record.AddDeclRef(D->getAnonDeclWithTypedefName(false));
Douglas Gregor1f179062011-12-19 14:40:25 +0000382}
Jonathan D. Turner205c7d52011-06-03 23:11:16 +0000383
Douglas Gregor1f179062011-12-19 14:40:25 +0000384void ASTDeclWriter::VisitTypedefDecl(TypedefDecl *D) {
385 VisitTypedefNameDecl(D);
Richard Smith8aed4222015-12-11 22:41:00 +0000386 if (D->getDeclContext() == D->getLexicalDeclContext() &&
387 !D->hasAttrs() &&
Jonathan D. Turner205c7d52011-06-03 23:11:16 +0000388 !D->isImplicit() &&
Rafael Espindola8db352d2013-10-17 15:37:26 +0000389 D->getFirstDecl() == D->getMostRecentDecl() &&
Jonathan D. Turner205c7d52011-06-03 23:11:16 +0000390 !D->isInvalidDecl() &&
Argyrios Kyrtzidisa7245002011-11-23 21:11:23 +0000391 !D->isTopLevelDeclInObjCContainer() &&
Douglas Gregor26701a42011-09-09 02:06:17 +0000392 !D->isModulePrivate() &&
Richard Smithd08aeb62014-08-28 01:33:39 +0000393 !needsAnonymousDeclarationNumber(D) &&
Jonathan D. Turner205c7d52011-06-03 23:11:16 +0000394 D->getDeclName().getNameKind() == DeclarationName::Identifier)
395 AbbrevToUse = Writer.getDeclTypedefAbbrev();
396
Sebastian Redl539c5062010-08-18 23:57:32 +0000397 Code = serialization::DECL_TYPEDEF;
Chris Lattner7099dbc2009-04-27 06:16:06 +0000398}
399
Richard Smithdda56e42011-04-15 14:24:37 +0000400void ASTDeclWriter::VisitTypeAliasDecl(TypeAliasDecl *D) {
Douglas Gregor1f179062011-12-19 14:40:25 +0000401 VisitTypedefNameDecl(D);
Richard Smith69c82bf2016-04-01 22:52:03 +0000402 Record.AddDeclRef(D->getDescribedAliasTemplate());
Richard Smithdda56e42011-04-15 14:24:37 +0000403 Code = serialization::DECL_TYPEALIAS;
404}
405
Sebastian Redl42a0f6a2010-08-18 23:56:27 +0000406void ASTDeclWriter::VisitTagDecl(TagDecl *D) {
Argyrios Kyrtzidis839bbac2010-08-03 17:30:10 +0000407 VisitRedeclarable(D);
Douglas Gregor3e300102011-10-26 17:53:41 +0000408 VisitTypeDecl(D);
Argyrios Kyrtzidisf4bc0d82010-09-08 19:31:22 +0000409 Record.push_back(D->getIdentifierNamespace());
Chris Lattner7099dbc2009-04-27 06:16:06 +0000410 Record.push_back((unsigned)D->getTagKind()); // FIXME: stable encoding
Richard Smith2c381642014-08-27 23:11:59 +0000411 if (!isa<CXXRecordDecl>(D))
412 Record.push_back(D->isCompleteDefinition());
Douglas Gregor5089c762010-02-12 17:40:34 +0000413 Record.push_back(D->isEmbeddedInDeclarator());
Argyrios Kyrtzidis201d3772011-09-30 22:11:31 +0000414 Record.push_back(D->isFreeStanding());
David Blaikiea8d23ce2013-07-14 01:07:41 +0000415 Record.push_back(D->isCompleteDefinitionRequired());
Argyrios Kyrtzidisd798c052016-07-15 18:11:33 +0000416 Record.AddSourceRange(D->getBraceRange());
Richard Smith70d58502014-08-30 00:04:23 +0000417
418 if (D->hasExtInfo()) {
419 Record.push_back(1);
Richard Smith69c82bf2016-04-01 22:52:03 +0000420 Record.AddQualifierInfo(*D->getExtInfo());
Richard Smith70d58502014-08-30 00:04:23 +0000421 } else if (auto *TD = D->getTypedefNameForAnonDecl()) {
422 Record.push_back(2);
Richard Smith69c82bf2016-04-01 22:52:03 +0000423 Record.AddDeclRef(TD);
424 Record.AddIdentifierRef(TD->getDeclName().getAsIdentifierInfo());
Richard Smith70d58502014-08-30 00:04:23 +0000425 } else {
426 Record.push_back(0);
427 }
Chris Lattner7099dbc2009-04-27 06:16:06 +0000428}
429
Sebastian Redl42a0f6a2010-08-18 23:56:27 +0000430void ASTDeclWriter::VisitEnumDecl(EnumDecl *D) {
Chris Lattner7099dbc2009-04-27 06:16:06 +0000431 VisitTagDecl(D);
Richard Smith69c82bf2016-04-01 22:52:03 +0000432 Record.AddTypeSourceInfo(D->getIntegerTypeSourceInfo());
Douglas Gregor0bf31402010-10-08 23:50:27 +0000433 if (!D->getIntegerTypeSourceInfo())
Richard Smith69c82bf2016-04-01 22:52:03 +0000434 Record.AddTypeRef(D->getIntegerType());
435 Record.AddTypeRef(D->getPromotionType());
John McCall9aa35be2010-05-06 08:49:23 +0000436 Record.push_back(D->getNumPositiveBits());
437 Record.push_back(D->getNumNegativeBits());
Douglas Gregor0bf31402010-10-08 23:50:27 +0000438 Record.push_back(D->isScoped());
Abramo Bagnara0e05e242010-12-03 18:54:17 +0000439 Record.push_back(D->isScopedUsingClassTag());
Douglas Gregor0bf31402010-10-08 23:50:27 +0000440 Record.push_back(D->isFixed());
Richard Trieuab4d7302018-07-25 22:52:05 +0000441 Record.push_back(D->getODRHash());
442
Richard Smith4b38ded2012-03-14 23:13:10 +0000443 if (MemberSpecializationInfo *MemberInfo = D->getMemberSpecializationInfo()) {
Richard Smith69c82bf2016-04-01 22:52:03 +0000444 Record.AddDeclRef(MemberInfo->getInstantiatedFrom());
Richard Smith4b38ded2012-03-14 23:13:10 +0000445 Record.push_back(MemberInfo->getTemplateSpecializationKind());
Richard Smith69c82bf2016-04-01 22:52:03 +0000446 Record.AddSourceLocation(MemberInfo->getPointOfInstantiation());
Richard Smith4b38ded2012-03-14 23:13:10 +0000447 } else {
Richard Smith69c82bf2016-04-01 22:52:03 +0000448 Record.AddDeclRef(nullptr);
Richard Smith4b38ded2012-03-14 23:13:10 +0000449 }
Jonathan D. Turner205c7d52011-06-03 23:11:16 +0000450
Richard Smith8aed4222015-12-11 22:41:00 +0000451 if (D->getDeclContext() == D->getLexicalDeclContext() &&
452 !D->hasAttrs() &&
Jonathan D. Turner205c7d52011-06-03 23:11:16 +0000453 !D->isImplicit() &&
454 !D->isUsed(false) &&
Jonathan D. Turner205c7d52011-06-03 23:11:16 +0000455 !D->hasExtInfo() &&
Richard Smith70d58502014-08-30 00:04:23 +0000456 !D->getTypedefNameForAnonDecl() &&
Rafael Espindola8db352d2013-10-17 15:37:26 +0000457 D->getFirstDecl() == D->getMostRecentDecl() &&
Jonathan D. Turner205c7d52011-06-03 23:11:16 +0000458 !D->isInvalidDecl() &&
459 !D->isReferenced() &&
Argyrios Kyrtzidisa7245002011-11-23 21:11:23 +0000460 !D->isTopLevelDeclInObjCContainer() &&
Jonathan D. Turner205c7d52011-06-03 23:11:16 +0000461 D->getAccess() == AS_none &&
Douglas Gregor26701a42011-09-09 02:06:17 +0000462 !D->isModulePrivate() &&
Jonathan D. Turner205c7d52011-06-03 23:11:16 +0000463 !CXXRecordDecl::classofKind(D->getKind()) &&
464 !D->getIntegerTypeSourceInfo() &&
Argyrios Kyrtzidisca370b0d2013-03-18 22:23:49 +0000465 !D->getMemberSpecializationInfo() &&
Richard Smithd08aeb62014-08-28 01:33:39 +0000466 !needsAnonymousDeclarationNumber(D) &&
Jonathan D. Turner205c7d52011-06-03 23:11:16 +0000467 D->getDeclName().getNameKind() == DeclarationName::Identifier)
468 AbbrevToUse = Writer.getDeclEnumAbbrev();
469
Sebastian Redl539c5062010-08-18 23:57:32 +0000470 Code = serialization::DECL_ENUM;
Chris Lattner7099dbc2009-04-27 06:16:06 +0000471}
472
Sebastian Redl42a0f6a2010-08-18 23:56:27 +0000473void ASTDeclWriter::VisitRecordDecl(RecordDecl *D) {
Chris Lattner7099dbc2009-04-27 06:16:06 +0000474 VisitTagDecl(D);
475 Record.push_back(D->hasFlexibleArrayMember());
476 Record.push_back(D->isAnonymousStructOrUnion());
Fariborz Jahanian8e0d0422009-07-08 16:37:44 +0000477 Record.push_back(D->hasObjectMember());
Fariborz Jahanian78652202013-01-25 23:57:05 +0000478 Record.push_back(D->hasVolatileMember());
Akira Hatanaka34fb2642018-03-13 18:58:25 +0000479 Record.push_back(D->isNonTrivialToPrimitiveDefaultInitialize());
480 Record.push_back(D->isNonTrivialToPrimitiveCopy());
481 Record.push_back(D->isNonTrivialToPrimitiveDestroy());
Akira Hatanaka09051062019-09-07 00:34:43 +0000482 Record.push_back(D->hasNonTrivialToPrimitiveDefaultInitializeCUnion());
483 Record.push_back(D->hasNonTrivialToPrimitiveDestructCUnion());
484 Record.push_back(D->hasNonTrivialToPrimitiveCopyCUnion());
Akira Hatanakafcbe17c2018-03-28 21:13:14 +0000485 Record.push_back(D->isParamDestroyedInCallee());
Akira Hatanakae6313ac2018-04-09 22:48:22 +0000486 Record.push_back(D->getArgPassingRestrictions());
Douglas Gregor03412ba2011-06-03 02:27:19 +0000487
Richard Smith8aed4222015-12-11 22:41:00 +0000488 if (D->getDeclContext() == D->getLexicalDeclContext() &&
489 !D->hasAttrs() &&
Douglas Gregor03412ba2011-06-03 02:27:19 +0000490 !D->isImplicit() &&
491 !D->isUsed(false) &&
Douglas Gregor03412ba2011-06-03 02:27:19 +0000492 !D->hasExtInfo() &&
Richard Smith70d58502014-08-30 00:04:23 +0000493 !D->getTypedefNameForAnonDecl() &&
Rafael Espindola8db352d2013-10-17 15:37:26 +0000494 D->getFirstDecl() == D->getMostRecentDecl() &&
Douglas Gregor03412ba2011-06-03 02:27:19 +0000495 !D->isInvalidDecl() &&
496 !D->isReferenced() &&
Argyrios Kyrtzidisa7245002011-11-23 21:11:23 +0000497 !D->isTopLevelDeclInObjCContainer() &&
Douglas Gregor03412ba2011-06-03 02:27:19 +0000498 D->getAccess() == AS_none &&
Douglas Gregor26701a42011-09-09 02:06:17 +0000499 !D->isModulePrivate() &&
Douglas Gregor03412ba2011-06-03 02:27:19 +0000500 !CXXRecordDecl::classofKind(D->getKind()) &&
Richard Smithd08aeb62014-08-28 01:33:39 +0000501 !needsAnonymousDeclarationNumber(D) &&
Douglas Gregor03412ba2011-06-03 02:27:19 +0000502 D->getDeclName().getNameKind() == DeclarationName::Identifier)
Douglas Gregor03412ba2011-06-03 02:27:19 +0000503 AbbrevToUse = Writer.getDeclRecordAbbrev();
504
Sebastian Redl539c5062010-08-18 23:57:32 +0000505 Code = serialization::DECL_RECORD;
Chris Lattner7099dbc2009-04-27 06:16:06 +0000506}
507
Sebastian Redl42a0f6a2010-08-18 23:56:27 +0000508void ASTDeclWriter::VisitValueDecl(ValueDecl *D) {
Chris Lattner7099dbc2009-04-27 06:16:06 +0000509 VisitNamedDecl(D);
Richard Smith69c82bf2016-04-01 22:52:03 +0000510 Record.AddTypeRef(D->getType());
Chris Lattner7099dbc2009-04-27 06:16:06 +0000511}
512
Sebastian Redl42a0f6a2010-08-18 23:56:27 +0000513void ASTDeclWriter::VisitEnumConstantDecl(EnumConstantDecl *D) {
Chris Lattner7099dbc2009-04-27 06:16:06 +0000514 VisitValueDecl(D);
515 Record.push_back(D->getInitExpr()? 1 : 0);
516 if (D->getInitExpr())
Richard Smith290d8012016-04-06 17:06:00 +0000517 Record.AddStmt(D->getInitExpr());
Richard Smith69c82bf2016-04-01 22:52:03 +0000518 Record.AddAPSInt(D->getInitVal());
Douglas Gregor03412ba2011-06-03 02:27:19 +0000519
Sebastian Redl539c5062010-08-18 23:57:32 +0000520 Code = serialization::DECL_ENUM_CONSTANT;
Chris Lattner7099dbc2009-04-27 06:16:06 +0000521}
Argyrios Kyrtzidis560ac972009-08-19 01:28:35 +0000522
Sebastian Redl42a0f6a2010-08-18 23:56:27 +0000523void ASTDeclWriter::VisitDeclaratorDecl(DeclaratorDecl *D) {
Argyrios Kyrtzidis560ac972009-08-19 01:28:35 +0000524 VisitValueDecl(D);
Richard Smith69c82bf2016-04-01 22:52:03 +0000525 Record.AddSourceLocation(D->getInnerLocStart());
Argyrios Kyrtzidis434383d2010-10-15 18:21:24 +0000526 Record.push_back(D->hasExtInfo());
Saar Razb65b1f32020-01-09 15:07:51 +0200527 if (D->hasExtInfo()) {
528 DeclaratorDecl::ExtInfo *Info = D->getExtInfo();
529 Record.AddQualifierInfo(*Info);
530 Record.AddStmt(Info->TrailingRequiresClause);
531 }
Richard Smithc23d7342018-06-29 20:46:25 +0000532 // The location information is deferred until the end of the record.
533 Record.AddTypeRef(D->getTypeSourceInfo() ? D->getTypeSourceInfo()->getType()
534 : QualType());
Argyrios Kyrtzidis560ac972009-08-19 01:28:35 +0000535}
Chris Lattner7099dbc2009-04-27 06:16:06 +0000536
Sebastian Redl42a0f6a2010-08-18 23:56:27 +0000537void ASTDeclWriter::VisitFunctionDecl(FunctionDecl *D) {
Argyrios Kyrtzidisf4bc0d82010-09-08 19:31:22 +0000538 VisitRedeclarable(D);
Douglas Gregor3e300102011-10-26 17:53:41 +0000539 VisitDeclaratorDecl(D);
Richard Smith69c82bf2016-04-01 22:52:03 +0000540 Record.AddDeclarationNameLoc(D->DNLoc, D->getDeclName());
Argyrios Kyrtzidisa95d0192010-07-05 10:38:01 +0000541 Record.push_back(D->getIdentifierNamespace());
Fangrui Song6907ce22018-07-30 19:24:48 +0000542
Douglas Gregorb2585692012-01-04 17:13:46 +0000543 // FunctionDecl's body is handled last at ASTWriterDecl::Visit,
544 // after everything else is written.
Erich Keane9c665062018-08-01 21:02:40 +0000545 Record.push_back(static_cast<int>(D->getStorageClass())); // FIXME: stable encoding
546 Record.push_back(D->isInlineSpecified());
547 Record.push_back(D->isInlined());
Erich Keane9c665062018-08-01 21:02:40 +0000548 Record.push_back(D->isVirtualAsWritten());
549 Record.push_back(D->isPure());
550 Record.push_back(D->hasInheritedPrototype());
551 Record.push_back(D->hasWrittenPrototype());
552 Record.push_back(D->isDeletedBit());
553 Record.push_back(D->isTrivial());
554 Record.push_back(D->isTrivialForCall());
555 Record.push_back(D->isDefaulted());
556 Record.push_back(D->isExplicitlyDefaulted());
557 Record.push_back(D->hasImplicitReturnZero());
Gauthier Harnisch796ed032019-06-14 08:56:20 +0000558 Record.push_back(D->getConstexprKind());
Erich Keane9c665062018-08-01 21:02:40 +0000559 Record.push_back(D->usesSEHTry());
560 Record.push_back(D->hasSkippedBody());
561 Record.push_back(D->isMultiVersion());
562 Record.push_back(D->isLateTemplateParsed());
Rafael Espindola3ae00052013-05-13 00:12:11 +0000563 Record.push_back(D->getLinkageInternal());
Stephen Kelly1c301dc2018-08-09 21:09:38 +0000564 Record.AddSourceLocation(D->getEndLoc());
Douglas Gregorb2585692012-01-04 17:13:46 +0000565
Richard Trieue6caa262017-12-23 00:41:01 +0000566 Record.push_back(D->getODRHash());
Melanie Blower7f9b5132019-12-04 12:23:46 -0800567 Record.push_back(D->usesFPIntrin());
Richard Trieue6caa262017-12-23 00:41:01 +0000568
Richard Smith848934c2019-12-05 13:37:35 -0800569 if (D->isDefaulted()) {
570 if (auto *FDI = D->getDefaultedFunctionInfo()) {
571 Record.push_back(FDI->getUnqualifiedLookups().size());
572 for (DeclAccessPair P : FDI->getUnqualifiedLookups()) {
573 Record.AddDeclRef(P.getDecl());
574 Record.push_back(P.getAccess());
575 }
576 } else {
577 Record.push_back(0);
578 }
579 }
580
Argyrios Kyrtzidis69da4a82010-06-22 09:55:07 +0000581 Record.push_back(D->getTemplatedKind());
582 switch (D->getTemplatedKind()) {
583 case FunctionDecl::TK_NonTemplate:
584 break;
585 case FunctionDecl::TK_FunctionTemplate:
Richard Smith69c82bf2016-04-01 22:52:03 +0000586 Record.AddDeclRef(D->getDescribedFunctionTemplate());
Argyrios Kyrtzidis69da4a82010-06-22 09:55:07 +0000587 break;
588 case FunctionDecl::TK_MemberSpecialization: {
589 MemberSpecializationInfo *MemberInfo = D->getMemberSpecializationInfo();
Richard Smith69c82bf2016-04-01 22:52:03 +0000590 Record.AddDeclRef(MemberInfo->getInstantiatedFrom());
Argyrios Kyrtzidis69da4a82010-06-22 09:55:07 +0000591 Record.push_back(MemberInfo->getTemplateSpecializationKind());
Richard Smith69c82bf2016-04-01 22:52:03 +0000592 Record.AddSourceLocation(MemberInfo->getPointOfInstantiation());
Argyrios Kyrtzidis69da4a82010-06-22 09:55:07 +0000593 break;
594 }
595 case FunctionDecl::TK_FunctionTemplateSpecialization: {
596 FunctionTemplateSpecializationInfo *
597 FTSInfo = D->getTemplateSpecializationInfo();
Richard Smithd8a83712015-08-22 01:47:18 +0000598
599 RegisterTemplateSpecialization(FTSInfo->getTemplate(), D);
600
Richard Smith69c82bf2016-04-01 22:52:03 +0000601 Record.AddDeclRef(FTSInfo->getTemplate());
Argyrios Kyrtzidis69da4a82010-06-22 09:55:07 +0000602 Record.push_back(FTSInfo->getTemplateSpecializationKind());
Fangrui Song6907ce22018-07-30 19:24:48 +0000603
Argyrios Kyrtzidis69da4a82010-06-22 09:55:07 +0000604 // Template arguments.
Richard Smith69c82bf2016-04-01 22:52:03 +0000605 Record.AddTemplateArgumentList(FTSInfo->TemplateArguments);
Fangrui Song6907ce22018-07-30 19:24:48 +0000606
Argyrios Kyrtzidis69da4a82010-06-22 09:55:07 +0000607 // Template args as written.
Craig Toppera13603a2014-05-22 05:54:18 +0000608 Record.push_back(FTSInfo->TemplateArgumentsAsWritten != nullptr);
Argyrios Kyrtzidis69da4a82010-06-22 09:55:07 +0000609 if (FTSInfo->TemplateArgumentsAsWritten) {
Argyrios Kyrtzidise9a24432011-09-22 20:07:09 +0000610 Record.push_back(FTSInfo->TemplateArgumentsAsWritten->NumTemplateArgs);
611 for (int i=0, e = FTSInfo->TemplateArgumentsAsWritten->NumTemplateArgs;
612 i!=e; ++i)
Richard Smith69c82bf2016-04-01 22:52:03 +0000613 Record.AddTemplateArgumentLoc(
614 (*FTSInfo->TemplateArgumentsAsWritten)[i]);
615 Record.AddSourceLocation(FTSInfo->TemplateArgumentsAsWritten->LAngleLoc);
616 Record.AddSourceLocation(FTSInfo->TemplateArgumentsAsWritten->RAngleLoc);
Argyrios Kyrtzidis69da4a82010-06-22 09:55:07 +0000617 }
Fangrui Song6907ce22018-07-30 19:24:48 +0000618
Richard Smith69c82bf2016-04-01 22:52:03 +0000619 Record.AddSourceLocation(FTSInfo->getPointOfInstantiation());
Argyrios Kyrtzidisf24d5692010-09-13 11:45:48 +0000620
Richard Smithf19a8b02019-05-02 00:49:14 +0000621 if (MemberSpecializationInfo *MemberInfo =
622 FTSInfo->getMemberSpecializationInfo()) {
623 Record.push_back(1);
624 Record.AddDeclRef(MemberInfo->getInstantiatedFrom());
625 Record.push_back(MemberInfo->getTemplateSpecializationKind());
626 Record.AddSourceLocation(MemberInfo->getPointOfInstantiation());
627 } else {
628 Record.push_back(0);
629 }
630
Argyrios Kyrtzidisf24d5692010-09-13 11:45:48 +0000631 if (D->isCanonicalDecl()) {
632 // Write the template that contains the specializations set. We will
633 // add a FunctionTemplateSpecializationInfo to it when reading.
Richard Smith69c82bf2016-04-01 22:52:03 +0000634 Record.AddDeclRef(FTSInfo->getTemplate()->getCanonicalDecl());
Argyrios Kyrtzidisf24d5692010-09-13 11:45:48 +0000635 }
Argyrios Kyrtzidisdc9ca0a2010-06-25 16:24:51 +0000636 break;
Argyrios Kyrtzidis69da4a82010-06-22 09:55:07 +0000637 }
638 case FunctionDecl::TK_DependentFunctionTemplateSpecialization: {
639 DependentFunctionTemplateSpecializationInfo *
640 DFTSInfo = D->getDependentSpecializationInfo();
Fangrui Song6907ce22018-07-30 19:24:48 +0000641
Argyrios Kyrtzidis69da4a82010-06-22 09:55:07 +0000642 // Templates.
643 Record.push_back(DFTSInfo->getNumTemplates());
644 for (int i=0, e = DFTSInfo->getNumTemplates(); i != e; ++i)
Richard Smith69c82bf2016-04-01 22:52:03 +0000645 Record.AddDeclRef(DFTSInfo->getTemplate(i));
Fangrui Song6907ce22018-07-30 19:24:48 +0000646
Argyrios Kyrtzidis69da4a82010-06-22 09:55:07 +0000647 // Templates args.
648 Record.push_back(DFTSInfo->getNumTemplateArgs());
649 for (int i=0, e = DFTSInfo->getNumTemplateArgs(); i != e; ++i)
Richard Smith69c82bf2016-04-01 22:52:03 +0000650 Record.AddTemplateArgumentLoc(DFTSInfo->getTemplateArg(i));
651 Record.AddSourceLocation(DFTSInfo->getLAngleLoc());
652 Record.AddSourceLocation(DFTSInfo->getRAngleLoc());
Argyrios Kyrtzidisdc9ca0a2010-06-25 16:24:51 +0000653 break;
Argyrios Kyrtzidis69da4a82010-06-22 09:55:07 +0000654 }
655 }
Chris Lattnerca025db2010-05-07 21:43:38 +0000656
Chris Lattner7099dbc2009-04-27 06:16:06 +0000657 Record.push_back(D->param_size());
David Majnemer59f77922016-06-24 04:05:48 +0000658 for (auto P : D->parameters())
Richard Smith69c82bf2016-04-01 22:52:03 +0000659 Record.AddDeclRef(P);
Sebastian Redl539c5062010-08-18 23:57:32 +0000660 Code = serialization::DECL_FUNCTION;
Chris Lattner7099dbc2009-04-27 06:16:06 +0000661}
662
Richard Smith76b90272019-05-09 03:59:21 +0000663static void addExplicitSpecifier(ExplicitSpecifier ES,
664 ASTRecordWriter &Record) {
665 uint64_t Kind = static_cast<uint64_t>(ES.getKind());
666 Kind = Kind << 1 | static_cast<bool>(ES.getExpr());
667 Record.push_back(Kind);
668 if (ES.getExpr()) {
669 Record.AddStmt(ES.getExpr());
670 }
671}
672
Richard Smithbc491202017-02-17 20:05:37 +0000673void ASTDeclWriter::VisitCXXDeductionGuideDecl(CXXDeductionGuideDecl *D) {
Richard Smith76b90272019-05-09 03:59:21 +0000674 addExplicitSpecifier(D->getExplicitSpecifier(), Record);
Richard Smithbc491202017-02-17 20:05:37 +0000675 VisitFunctionDecl(D);
Erich Keane9c665062018-08-01 21:02:40 +0000676 Record.push_back(D->isCopyDeductionCandidate());
Richard Smithbc491202017-02-17 20:05:37 +0000677 Code = serialization::DECL_CXX_DEDUCTION_GUIDE;
678}
679
Sebastian Redl42a0f6a2010-08-18 23:56:27 +0000680void ASTDeclWriter::VisitObjCMethodDecl(ObjCMethodDecl *D) {
Chris Lattner7099dbc2009-04-27 06:16:06 +0000681 VisitNamedDecl(D);
682 // FIXME: convert to LazyStmtPtr?
Mike Stump11289f42009-09-09 15:08:12 +0000683 // Unlike C/C++, method bodies will never be in header files.
Alex Lorenzf3efd692019-12-06 14:24:37 -0800684 bool HasBodyStuff = D->getBody() != nullptr;
Argyrios Kyrtzidisa8607772010-08-09 10:54:37 +0000685 Record.push_back(HasBodyStuff);
686 if (HasBodyStuff) {
Richard Smith290d8012016-04-06 17:06:00 +0000687 Record.AddStmt(D->getBody());
Chris Lattner7099dbc2009-04-27 06:16:06 +0000688 }
Alex Lorenzf3efd692019-12-06 14:24:37 -0800689 Record.AddDeclRef(D->getSelfDecl());
690 Record.AddDeclRef(D->getCmdDecl());
Chris Lattner7099dbc2009-04-27 06:16:06 +0000691 Record.push_back(D->isInstanceMethod());
692 Record.push_back(D->isVariadic());
Jordan Rosed01e83a2012-10-10 16:42:25 +0000693 Record.push_back(D->isPropertyAccessor());
Adrian Prantl2073dd22019-11-04 14:28:14 -0800694 Record.push_back(D->isSynthesizedAccessorStub());
Fariborz Jahanian6e7e8cc2010-07-22 18:24:20 +0000695 Record.push_back(D->isDefined());
Erich Keane9b18eca2018-08-01 21:31:08 +0000696 Record.push_back(D->isOverriding());
697 Record.push_back(D->hasSkippedBody());
Argyrios Kyrtzidisdb215962011-10-14 17:41:52 +0000698
Erich Keane9b18eca2018-08-01 21:31:08 +0000699 Record.push_back(D->isRedeclaration());
700 Record.push_back(D->hasRedeclaration());
701 if (D->hasRedeclaration()) {
Argyrios Kyrtzidisdb215962011-10-14 17:41:52 +0000702 assert(Context.getObjCMethodRedeclaration(D));
Richard Smith69c82bf2016-04-01 22:52:03 +0000703 Record.AddDeclRef(Context.getObjCMethodRedeclaration(D));
Argyrios Kyrtzidisdb215962011-10-14 17:41:52 +0000704 }
705
Chris Lattner7099dbc2009-04-27 06:16:06 +0000706 // FIXME: stable encoding for @required/@optional
Mike Stump11289f42009-09-09 15:08:12 +0000707 Record.push_back(D->getImplementationControl());
Douglas Gregor813a0662015-06-19 18:14:38 +0000708 // FIXME: stable encoding for in/out/inout/bycopy/byref/oneway/nullability
Mike Stump11289f42009-09-09 15:08:12 +0000709 Record.push_back(D->getObjCDeclQualifier());
Douglas Gregor33823722011-06-11 01:09:30 +0000710 Record.push_back(D->hasRelatedResultType());
Richard Smith69c82bf2016-04-01 22:52:03 +0000711 Record.AddTypeRef(D->getReturnType());
712 Record.AddTypeSourceInfo(D->getReturnTypeSourceInfo());
Stephen Kelly1c301dc2018-08-09 21:09:38 +0000713 Record.AddSourceLocation(D->getEndLoc());
Chris Lattner7099dbc2009-04-27 06:16:06 +0000714 Record.push_back(D->param_size());
David Majnemer59f77922016-06-24 04:05:48 +0000715 for (const auto *P : D->parameters())
Richard Smith69c82bf2016-04-01 22:52:03 +0000716 Record.AddDeclRef(P);
Argyrios Kyrtzidisb8c3aaf2011-10-03 06:37:04 +0000717
Erich Keane9b18eca2018-08-01 21:31:08 +0000718 Record.push_back(D->getSelLocsKind());
Argyrios Kyrtzidisb8c3aaf2011-10-03 06:37:04 +0000719 unsigned NumStoredSelLocs = D->getNumStoredSelLocs();
720 SourceLocation *SelLocs = D->getStoredSelLocs();
721 Record.push_back(NumStoredSelLocs);
722 for (unsigned i = 0; i != NumStoredSelLocs; ++i)
Richard Smith69c82bf2016-04-01 22:52:03 +0000723 Record.AddSourceLocation(SelLocs[i]);
Argyrios Kyrtzidisb8c3aaf2011-10-03 06:37:04 +0000724
Sebastian Redl539c5062010-08-18 23:57:32 +0000725 Code = serialization::DECL_OBJC_METHOD;
Chris Lattner7099dbc2009-04-27 06:16:06 +0000726}
727
Douglas Gregor85f3f952015-07-07 03:57:15 +0000728void ASTDeclWriter::VisitObjCTypeParamDecl(ObjCTypeParamDecl *D) {
729 VisitTypedefNameDecl(D);
Douglas Gregor1ac1b632015-07-07 03:58:54 +0000730 Record.push_back(D->Variance);
Douglas Gregore83b9562015-07-07 03:57:53 +0000731 Record.push_back(D->Index);
Richard Smith69c82bf2016-04-01 22:52:03 +0000732 Record.AddSourceLocation(D->VarianceLoc);
733 Record.AddSourceLocation(D->ColonLoc);
Douglas Gregor85f3f952015-07-07 03:57:15 +0000734
735 Code = serialization::DECL_OBJC_TYPE_PARAM;
736}
737
Sebastian Redl42a0f6a2010-08-18 23:56:27 +0000738void ASTDeclWriter::VisitObjCContainerDecl(ObjCContainerDecl *D) {
Chris Lattner7099dbc2009-04-27 06:16:06 +0000739 VisitNamedDecl(D);
Richard Smith69c82bf2016-04-01 22:52:03 +0000740 Record.AddSourceLocation(D->getAtStartLoc());
741 Record.AddSourceRange(D->getAtEndRange());
Sebastian Redl539c5062010-08-18 23:57:32 +0000742 // Abstract class (no need to define a stable serialization::DECL code).
Chris Lattner7099dbc2009-04-27 06:16:06 +0000743}
744
Sebastian Redl42a0f6a2010-08-18 23:56:27 +0000745void ASTDeclWriter::VisitObjCInterfaceDecl(ObjCInterfaceDecl *D) {
Douglas Gregor66b310c2011-12-15 18:03:09 +0000746 VisitRedeclarable(D);
Chris Lattner7099dbc2009-04-27 06:16:06 +0000747 VisitObjCContainerDecl(D);
Richard Smith69c82bf2016-04-01 22:52:03 +0000748 Record.AddTypeRef(QualType(D->getTypeForDecl(), 0));
Douglas Gregor85f3f952015-07-07 03:57:15 +0000749 AddObjCTypeParamList(D->TypeParamList);
Ted Kremenek0ef508d2010-09-01 01:21:15 +0000750
Douglas Gregor3a5ae562012-01-15 18:17:48 +0000751 Record.push_back(D->isThisDeclarationADefinition());
752 if (D->isThisDeclarationADefinition()) {
Douglas Gregorc0ac7d62011-12-15 05:27:12 +0000753 // Write the DefinitionData
754 ObjCInterfaceDecl::DefinitionData &Data = D->data();
Fangrui Song6907ce22018-07-30 19:24:48 +0000755
Richard Smith69c82bf2016-04-01 22:52:03 +0000756 Record.AddTypeSourceInfo(D->getSuperClassTInfo());
757 Record.AddSourceLocation(D->getEndOfDefinitionLoc());
Argyrios Kyrtzidis9ed9e5f2013-12-03 21:11:30 +0000758 Record.push_back(Data.HasDesignatedInitializers);
Douglas Gregor16408322011-12-15 22:34:59 +0000759
Douglas Gregorc0ac7d62011-12-15 05:27:12 +0000760 // Write out the protocols that are directly referenced by the @interface.
761 Record.push_back(Data.ReferencedProtocols.size());
Aaron Ballmana49c5062014-03-13 20:29:09 +0000762 for (const auto *P : D->protocols())
Richard Smith69c82bf2016-04-01 22:52:03 +0000763 Record.AddDeclRef(P);
Aaron Ballmane9378882014-03-13 20:34:24 +0000764 for (const auto &PL : D->protocol_locs())
Richard Smith69c82bf2016-04-01 22:52:03 +0000765 Record.AddSourceLocation(PL);
Fangrui Song6907ce22018-07-30 19:24:48 +0000766
Douglas Gregorc0ac7d62011-12-15 05:27:12 +0000767 // Write out the protocols that are transitively referenced.
768 Record.push_back(Data.AllReferencedProtocols.size());
769 for (ObjCList<ObjCProtocolDecl>::iterator
770 P = Data.AllReferencedProtocols.begin(),
771 PEnd = Data.AllReferencedProtocols.end();
772 P != PEnd; ++P)
Richard Smith69c82bf2016-04-01 22:52:03 +0000773 Record.AddDeclRef(*P);
Douglas Gregor048fbfa2013-01-16 23:00:23 +0000774
Fangrui Song6907ce22018-07-30 19:24:48 +0000775
Douglas Gregor048fbfa2013-01-16 23:00:23 +0000776 if (ObjCCategoryDecl *Cat = D->getCategoryListRaw()) {
Douglas Gregor404cdde2012-01-27 01:47:08 +0000777 // Ensure that we write out the set of categories for this class.
778 Writer.ObjCClassesWithCategories.insert(D);
Fangrui Song6907ce22018-07-30 19:24:48 +0000779
Douglas Gregor404cdde2012-01-27 01:47:08 +0000780 // Make sure that the categories get serialized.
Douglas Gregor048fbfa2013-01-16 23:00:23 +0000781 for (; Cat; Cat = Cat->getNextClassCategoryRaw())
Douglas Gregor404cdde2012-01-27 01:47:08 +0000782 (void)Writer.GetDeclRef(Cat);
783 }
Fangrui Song6907ce22018-07-30 19:24:48 +0000784 }
785
Sebastian Redl539c5062010-08-18 23:57:32 +0000786 Code = serialization::DECL_OBJC_INTERFACE;
Chris Lattner7099dbc2009-04-27 06:16:06 +0000787}
788
Sebastian Redl42a0f6a2010-08-18 23:56:27 +0000789void ASTDeclWriter::VisitObjCIvarDecl(ObjCIvarDecl *D) {
Chris Lattner7099dbc2009-04-27 06:16:06 +0000790 VisitFieldDecl(D);
791 // FIXME: stable encoding for @public/@private/@protected/@package
Mike Stump11289f42009-09-09 15:08:12 +0000792 Record.push_back(D->getAccessControl());
Fariborz Jahanianaea8e1e2010-07-17 18:35:47 +0000793 Record.push_back(D->getSynthesize());
Jonathan D. Turner205c7d52011-06-03 23:11:16 +0000794
Richard Smith8aed4222015-12-11 22:41:00 +0000795 if (D->getDeclContext() == D->getLexicalDeclContext() &&
796 !D->hasAttrs() &&
Jonathan D. Turner205c7d52011-06-03 23:11:16 +0000797 !D->isImplicit() &&
798 !D->isUsed(false) &&
799 !D->isInvalidDecl() &&
800 !D->isReferenced() &&
Douglas Gregor26701a42011-09-09 02:06:17 +0000801 !D->isModulePrivate() &&
Jonathan D. Turner205c7d52011-06-03 23:11:16 +0000802 !D->getBitWidth() &&
803 !D->hasExtInfo() &&
804 D->getDeclName())
805 AbbrevToUse = Writer.getDeclObjCIvarAbbrev();
806
Sebastian Redl539c5062010-08-18 23:57:32 +0000807 Code = serialization::DECL_OBJC_IVAR;
Chris Lattner7099dbc2009-04-27 06:16:06 +0000808}
809
Sebastian Redl42a0f6a2010-08-18 23:56:27 +0000810void ASTDeclWriter::VisitObjCProtocolDecl(ObjCProtocolDecl *D) {
Douglas Gregora715bff2012-01-01 19:51:50 +0000811 VisitRedeclarable(D);
Chris Lattner7099dbc2009-04-27 06:16:06 +0000812 VisitObjCContainerDecl(D);
Fangrui Song6907ce22018-07-30 19:24:48 +0000813
Douglas Gregor3a5ae562012-01-15 18:17:48 +0000814 Record.push_back(D->isThisDeclarationADefinition());
815 if (D->isThisDeclarationADefinition()) {
Douglas Gregore6e48b12012-01-01 19:29:29 +0000816 Record.push_back(D->protocol_size());
Aaron Ballman0f6e64d2014-03-13 22:58:06 +0000817 for (const auto *I : D->protocols())
Richard Smith69c82bf2016-04-01 22:52:03 +0000818 Record.AddDeclRef(I);
Aaron Ballmana964ec12014-03-14 12:38:50 +0000819 for (const auto &PL : D->protocol_locs())
Richard Smith69c82bf2016-04-01 22:52:03 +0000820 Record.AddSourceLocation(PL);
Douglas Gregore6e48b12012-01-01 19:29:29 +0000821 }
Fangrui Song6907ce22018-07-30 19:24:48 +0000822
Sebastian Redl539c5062010-08-18 23:57:32 +0000823 Code = serialization::DECL_OBJC_PROTOCOL;
Chris Lattner7099dbc2009-04-27 06:16:06 +0000824}
825
Sebastian Redl42a0f6a2010-08-18 23:56:27 +0000826void ASTDeclWriter::VisitObjCAtDefsFieldDecl(ObjCAtDefsFieldDecl *D) {
Chris Lattner7099dbc2009-04-27 06:16:06 +0000827 VisitFieldDecl(D);
Sebastian Redl539c5062010-08-18 23:57:32 +0000828 Code = serialization::DECL_OBJC_AT_DEFS_FIELD;
Chris Lattner7099dbc2009-04-27 06:16:06 +0000829}
830
Sebastian Redl42a0f6a2010-08-18 23:56:27 +0000831void ASTDeclWriter::VisitObjCCategoryDecl(ObjCCategoryDecl *D) {
Chris Lattner7099dbc2009-04-27 06:16:06 +0000832 VisitObjCContainerDecl(D);
Richard Smith69c82bf2016-04-01 22:52:03 +0000833 Record.AddSourceLocation(D->getCategoryNameLoc());
834 Record.AddSourceLocation(D->getIvarLBraceLoc());
835 Record.AddSourceLocation(D->getIvarRBraceLoc());
836 Record.AddDeclRef(D->getClassInterface());
Douglas Gregor85f3f952015-07-07 03:57:15 +0000837 AddObjCTypeParamList(D->TypeParamList);
Chris Lattner7099dbc2009-04-27 06:16:06 +0000838 Record.push_back(D->protocol_size());
Aaron Ballman19a41762014-03-14 12:55:57 +0000839 for (const auto *I : D->protocols())
Richard Smith69c82bf2016-04-01 22:52:03 +0000840 Record.AddDeclRef(I);
Aaron Ballmana73c8572014-03-14 13:03:32 +0000841 for (const auto &PL : D->protocol_locs())
Richard Smith69c82bf2016-04-01 22:52:03 +0000842 Record.AddSourceLocation(PL);
Sebastian Redl539c5062010-08-18 23:57:32 +0000843 Code = serialization::DECL_OBJC_CATEGORY;
Chris Lattner7099dbc2009-04-27 06:16:06 +0000844}
845
Sebastian Redl42a0f6a2010-08-18 23:56:27 +0000846void ASTDeclWriter::VisitObjCCompatibleAliasDecl(ObjCCompatibleAliasDecl *D) {
Chris Lattner7099dbc2009-04-27 06:16:06 +0000847 VisitNamedDecl(D);
Richard Smith69c82bf2016-04-01 22:52:03 +0000848 Record.AddDeclRef(D->getClassInterface());
Sebastian Redl539c5062010-08-18 23:57:32 +0000849 Code = serialization::DECL_OBJC_COMPATIBLE_ALIAS;
Chris Lattner7099dbc2009-04-27 06:16:06 +0000850}
851
Sebastian Redl42a0f6a2010-08-18 23:56:27 +0000852void ASTDeclWriter::VisitObjCPropertyDecl(ObjCPropertyDecl *D) {
Chris Lattner7099dbc2009-04-27 06:16:06 +0000853 VisitNamedDecl(D);
Richard Smith69c82bf2016-04-01 22:52:03 +0000854 Record.AddSourceLocation(D->getAtLoc());
855 Record.AddSourceLocation(D->getLParenLoc());
856 Record.AddTypeRef(D->getType());
857 Record.AddTypeSourceInfo(D->getTypeSourceInfo());
Chris Lattner7099dbc2009-04-27 06:16:06 +0000858 // FIXME: stable encoding
859 Record.push_back((unsigned)D->getPropertyAttributes());
Fariborz Jahanian3bf0ded2010-06-22 23:20:40 +0000860 Record.push_back((unsigned)D->getPropertyAttributesAsWritten());
Chris Lattner7099dbc2009-04-27 06:16:06 +0000861 // FIXME: stable encoding
862 Record.push_back((unsigned)D->getPropertyImplementation());
Richard Smith69c82bf2016-04-01 22:52:03 +0000863 Record.AddDeclarationName(D->getGetterName());
Argyrios Kyrtzidis194b28e2017-03-16 18:25:40 +0000864 Record.AddSourceLocation(D->getGetterNameLoc());
Richard Smith69c82bf2016-04-01 22:52:03 +0000865 Record.AddDeclarationName(D->getSetterName());
Argyrios Kyrtzidis194b28e2017-03-16 18:25:40 +0000866 Record.AddSourceLocation(D->getSetterNameLoc());
Richard Smith69c82bf2016-04-01 22:52:03 +0000867 Record.AddDeclRef(D->getGetterMethodDecl());
868 Record.AddDeclRef(D->getSetterMethodDecl());
869 Record.AddDeclRef(D->getPropertyIvarDecl());
Sebastian Redl539c5062010-08-18 23:57:32 +0000870 Code = serialization::DECL_OBJC_PROPERTY;
Chris Lattner7099dbc2009-04-27 06:16:06 +0000871}
872
Sebastian Redl42a0f6a2010-08-18 23:56:27 +0000873void ASTDeclWriter::VisitObjCImplDecl(ObjCImplDecl *D) {
Argyrios Kyrtzidis067c4072009-07-27 19:04:32 +0000874 VisitObjCContainerDecl(D);
Richard Smith69c82bf2016-04-01 22:52:03 +0000875 Record.AddDeclRef(D->getClassInterface());
Sebastian Redl539c5062010-08-18 23:57:32 +0000876 // Abstract class (no need to define a stable serialization::DECL code).
Chris Lattner7099dbc2009-04-27 06:16:06 +0000877}
878
Sebastian Redl42a0f6a2010-08-18 23:56:27 +0000879void ASTDeclWriter::VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D) {
Chris Lattner7099dbc2009-04-27 06:16:06 +0000880 VisitObjCImplDecl(D);
Richard Smith69c82bf2016-04-01 22:52:03 +0000881 Record.AddSourceLocation(D->getCategoryNameLoc());
Sebastian Redl539c5062010-08-18 23:57:32 +0000882 Code = serialization::DECL_OBJC_CATEGORY_IMPL;
Chris Lattner7099dbc2009-04-27 06:16:06 +0000883}
884
Sebastian Redl42a0f6a2010-08-18 23:56:27 +0000885void ASTDeclWriter::VisitObjCImplementationDecl(ObjCImplementationDecl *D) {
Chris Lattner7099dbc2009-04-27 06:16:06 +0000886 VisitObjCImplDecl(D);
Richard Smith69c82bf2016-04-01 22:52:03 +0000887 Record.AddDeclRef(D->getSuperClass());
888 Record.AddSourceLocation(D->getSuperClassLoc());
889 Record.AddSourceLocation(D->getIvarLBraceLoc());
890 Record.AddSourceLocation(D->getIvarRBraceLoc());
John McCall0d54a172012-10-17 04:53:31 +0000891 Record.push_back(D->hasNonZeroConstructors());
892 Record.push_back(D->hasDestructors());
Richard Smithc2bb8182015-03-24 06:36:48 +0000893 Record.push_back(D->NumIvarInitializers);
894 if (D->NumIvarInitializers)
Richard Smithaa165cf2016-04-13 21:57:08 +0000895 Record.AddCXXCtorInitializers(
Richard Smith69c82bf2016-04-01 22:52:03 +0000896 llvm::makeArrayRef(D->init_begin(), D->init_end()));
Sebastian Redl539c5062010-08-18 23:57:32 +0000897 Code = serialization::DECL_OBJC_IMPLEMENTATION;
Chris Lattner7099dbc2009-04-27 06:16:06 +0000898}
899
Sebastian Redl42a0f6a2010-08-18 23:56:27 +0000900void ASTDeclWriter::VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D) {
Chris Lattner7099dbc2009-04-27 06:16:06 +0000901 VisitDecl(D);
Stephen Kellyf2ceec42018-08-09 21:08:08 +0000902 Record.AddSourceLocation(D->getBeginLoc());
Richard Smith69c82bf2016-04-01 22:52:03 +0000903 Record.AddDeclRef(D->getPropertyDecl());
904 Record.AddDeclRef(D->getPropertyIvarDecl());
905 Record.AddSourceLocation(D->getPropertyIvarDeclLoc());
Adrian Prantl2073dd22019-11-04 14:28:14 -0800906 Record.AddDeclRef(D->getGetterMethodDecl());
907 Record.AddDeclRef(D->getSetterMethodDecl());
Richard Smith290d8012016-04-06 17:06:00 +0000908 Record.AddStmt(D->getGetterCXXConstructor());
909 Record.AddStmt(D->getSetterCXXAssignment());
Sebastian Redl539c5062010-08-18 23:57:32 +0000910 Code = serialization::DECL_OBJC_PROPERTY_IMPL;
Chris Lattner7099dbc2009-04-27 06:16:06 +0000911}
912
Sebastian Redl42a0f6a2010-08-18 23:56:27 +0000913void ASTDeclWriter::VisitFieldDecl(FieldDecl *D) {
Argyrios Kyrtzidis560ac972009-08-19 01:28:35 +0000914 VisitDeclaratorDecl(D);
Chris Lattner7099dbc2009-04-27 06:16:06 +0000915 Record.push_back(D->isMutable());
Richard Smith6b8e3c02017-08-28 00:28:14 +0000916
917 FieldDecl::InitStorageKind ISK = D->InitStorage.getInt();
918 Record.push_back(ISK);
919 if (ISK == FieldDecl::ISK_CapturedVLAType)
920 Record.AddTypeRef(QualType(D->getCapturedVLAType(), 0));
921 else if (ISK)
922 Record.AddStmt(D->getInClassInitializer());
923
924 Record.AddStmt(D->getBitWidth());
925
Argyrios Kyrtzidis6685e8a2010-07-04 21:44:35 +0000926 if (!D->getDeclName())
Richard Smith69c82bf2016-04-01 22:52:03 +0000927 Record.AddDeclRef(Context.getInstantiatedFromUnnamedFieldDecl(D));
Jonathan D. Turner205c7d52011-06-03 23:11:16 +0000928
Richard Smith8aed4222015-12-11 22:41:00 +0000929 if (D->getDeclContext() == D->getLexicalDeclContext() &&
930 !D->hasAttrs() &&
Jonathan D. Turner205c7d52011-06-03 23:11:16 +0000931 !D->isImplicit() &&
932 !D->isUsed(false) &&
933 !D->isInvalidDecl() &&
934 !D->isReferenced() &&
Argyrios Kyrtzidisa7245002011-11-23 21:11:23 +0000935 !D->isTopLevelDeclInObjCContainer() &&
Douglas Gregor26701a42011-09-09 02:06:17 +0000936 !D->isModulePrivate() &&
Jonathan D. Turner205c7d52011-06-03 23:11:16 +0000937 !D->getBitWidth() &&
Richard Smith938f40b2011-06-11 17:19:42 +0000938 !D->hasInClassInitializer() &&
Richard Smith6b8e3c02017-08-28 00:28:14 +0000939 !D->hasCapturedVLAType() &&
Jonathan D. Turner205c7d52011-06-03 23:11:16 +0000940 !D->hasExtInfo() &&
941 !ObjCIvarDecl::classofKind(D->getKind()) &&
942 !ObjCAtDefsFieldDecl::classofKind(D->getKind()) &&
943 D->getDeclName())
944 AbbrevToUse = Writer.getDeclFieldAbbrev();
945
Sebastian Redl539c5062010-08-18 23:57:32 +0000946 Code = serialization::DECL_FIELD;
Chris Lattner7099dbc2009-04-27 06:16:06 +0000947}
948
John McCall5e77d762013-04-16 07:28:30 +0000949void ASTDeclWriter::VisitMSPropertyDecl(MSPropertyDecl *D) {
950 VisitDeclaratorDecl(D);
Richard Smith69c82bf2016-04-01 22:52:03 +0000951 Record.AddIdentifierRef(D->getGetterId());
952 Record.AddIdentifierRef(D->getSetterId());
John McCall5e77d762013-04-16 07:28:30 +0000953 Code = serialization::DECL_MS_PROPERTY;
954}
955
Francois Pichet783dd6e2010-11-21 06:08:52 +0000956void ASTDeclWriter::VisitIndirectFieldDecl(IndirectFieldDecl *D) {
957 VisitValueDecl(D);
958 Record.push_back(D->getChainingSize());
959
Aaron Ballman29c94602014-03-07 18:36:15 +0000960 for (const auto *P : D->chain())
Richard Smith69c82bf2016-04-01 22:52:03 +0000961 Record.AddDeclRef(P);
Francois Pichet783dd6e2010-11-21 06:08:52 +0000962 Code = serialization::DECL_INDIRECTFIELD;
963}
964
Sebastian Redl42a0f6a2010-08-18 23:56:27 +0000965void ASTDeclWriter::VisitVarDecl(VarDecl *D) {
Argyrios Kyrtzidisf4bc0d82010-09-08 19:31:22 +0000966 VisitRedeclarable(D);
Douglas Gregor3e300102011-10-26 17:53:41 +0000967 VisitDeclaratorDecl(D);
Rafael Espindola6ae7e502013-04-03 19:27:57 +0000968 Record.push_back(D->getStorageClass());
Enea Zaffanellaacb8ecd2013-05-04 08:27:07 +0000969 Record.push_back(D->getTSCSpec());
Sebastian Redla9351792012-02-11 23:51:47 +0000970 Record.push_back(D->getInitStyle());
Erik Pilkington1e368822019-01-04 18:33:06 +0000971 Record.push_back(D->isARCPseudoStrong());
David Majnemerfa7bc782015-05-19 00:57:16 +0000972 if (!isa<ParmVarDecl>(D)) {
Richard Smithedbc6e92016-10-14 21:41:24 +0000973 Record.push_back(D->isThisDeclarationADemotedDefinition());
David Majnemerfa7bc782015-05-19 00:57:16 +0000974 Record.push_back(D->isExceptionVariable());
Taiju Tsuiki3be68e12018-06-19 05:35:30 +0000975 Record.push_back(D->isNRVOVariable());
David Majnemerfa7bc782015-05-19 00:57:16 +0000976 Record.push_back(D->isCXXForRangeDecl());
George Karpenkovec38cf72018-03-29 00:56:24 +0000977 Record.push_back(D->isObjCForDecl());
Richard Smith62f19e72016-06-25 00:15:56 +0000978 Record.push_back(D->isInline());
979 Record.push_back(D->isInlineSpecified());
David Majnemerfa7bc782015-05-19 00:57:16 +0000980 Record.push_back(D->isConstexpr());
981 Record.push_back(D->isInitCapture());
982 Record.push_back(D->isPreviousDeclInSameBlockScope());
Alexey Bataev56223232017-06-09 13:40:18 +0000983 if (const auto *IPD = dyn_cast<ImplicitParamDecl>(D))
984 Record.push_back(static_cast<unsigned>(IPD->getParameterKind()));
985 else
986 Record.push_back(0);
Akira Hatanaka8e57b072018-10-01 21:51:28 +0000987 Record.push_back(D->isEscapingByref());
David Majnemerfa7bc782015-05-19 00:57:16 +0000988 }
Rafael Espindola3ae00052013-05-13 00:12:11 +0000989 Record.push_back(D->getLinkageInternal());
Douglas Gregor12cda632012-09-20 23:43:29 +0000990
Richard Smithd0b4dd62011-12-19 06:19:21 +0000991 if (D->getInit()) {
Richard Smith2b4fa532019-09-29 05:08:46 +0000992 if (!D->isInitKnownICE())
993 Record.push_back(1);
994 else {
995 Record.push_back(
996 2 |
997 (D->isInitICE() ? 1 : 0) |
998 (D->ensureEvaluatedStmt()->HasConstantDestruction ? 4 : 0));
999 }
Richard Smith290d8012016-04-06 17:06:00 +00001000 Record.AddStmt(D->getInit());
Richard Smithd0b4dd62011-12-19 06:19:21 +00001001 } else {
1002 Record.push_back(0);
1003 }
Richard Smitha4653622017-09-06 20:01:14 +00001004
Akira Hatanaka9978da32018-08-10 15:09:24 +00001005 if (D->hasAttr<BlocksAttr>() && D->getType()->getAsCXXRecordDecl()) {
Reid Kleckner60573ae2019-11-15 17:31:55 -08001006 BlockVarCopyInit Init = Writer.Context->getBlockVarCopyInit(D);
Akira Hatanaka9978da32018-08-10 15:09:24 +00001007 Record.AddStmt(Init.getCopyExpr());
1008 if (Init.getCopyExpr())
1009 Record.push_back(Init.canThrow());
1010 }
1011
Richard Smitha4653622017-09-06 20:01:14 +00001012 if (D->getStorageDuration() == SD_Static) {
1013 bool ModulesCodegen = false;
Luboš Luňákcbc9d222019-11-03 21:15:03 +01001014 if (!D->getDescribedVarTemplate() && !D->getMemberSpecializationInfo() &&
Richard Smitha4653622017-09-06 20:01:14 +00001015 !isa<VarTemplateSpecializationDecl>(D)) {
1016 // When building a C++ Modules TS module interface unit, a strong
1017 // definition in the module interface is provided by the compilation of
1018 // that module interface unit, not by its users. (Inline variables are
1019 // still emitted in module users.)
1020 ModulesCodegen =
Luboš Luňákcbc9d222019-11-03 21:15:03 +01001021 (((Writer.WritingModule &&
1022 Writer.WritingModule->Kind == Module::ModuleInterfaceUnit) ||
1023 Writer.Context->getLangOpts().BuildingPCHWithObjectFile) &&
Richard Smitha4653622017-09-06 20:01:14 +00001024 Writer.Context->GetGVALinkageForVariable(D) == GVA_StrongExternal);
1025 }
1026 Record.push_back(ModulesCodegen);
1027 if (ModulesCodegen)
1028 Writer.ModularCodegenDecls.push_back(Writer.GetDeclRef(D));
1029 }
Fangrui Song6907ce22018-07-30 19:24:48 +00001030
Larisse Voufod8dd97c2013-08-14 03:09:19 +00001031 enum {
1032 VarNotTemplate = 0, VarTemplate, StaticDataMemberSpecialization
1033 };
1034 if (VarTemplateDecl *TemplD = D->getDescribedVarTemplate()) {
1035 Record.push_back(VarTemplate);
Richard Smith69c82bf2016-04-01 22:52:03 +00001036 Record.AddDeclRef(TemplD);
Larisse Voufod8dd97c2013-08-14 03:09:19 +00001037 } else if (MemberSpecializationInfo *SpecInfo
1038 = D->getMemberSpecializationInfo()) {
1039 Record.push_back(StaticDataMemberSpecialization);
Richard Smith69c82bf2016-04-01 22:52:03 +00001040 Record.AddDeclRef(SpecInfo->getInstantiatedFrom());
Argyrios Kyrtzidiscdb8b3f2010-07-04 21:44:00 +00001041 Record.push_back(SpecInfo->getTemplateSpecializationKind());
Richard Smith69c82bf2016-04-01 22:52:03 +00001042 Record.AddSourceLocation(SpecInfo->getPointOfInstantiation());
Larisse Voufod8dd97c2013-08-14 03:09:19 +00001043 } else {
1044 Record.push_back(VarNotTemplate);
Argyrios Kyrtzidiscdb8b3f2010-07-04 21:44:00 +00001045 }
1046
Richard Smith8aed4222015-12-11 22:41:00 +00001047 if (D->getDeclContext() == D->getLexicalDeclContext() &&
1048 !D->hasAttrs() &&
Jonathan D. Turner205c7d52011-06-03 23:11:16 +00001049 !D->isImplicit() &&
1050 !D->isUsed(false) &&
1051 !D->isInvalidDecl() &&
1052 !D->isReferenced() &&
Argyrios Kyrtzidisa7245002011-11-23 21:11:23 +00001053 !D->isTopLevelDeclInObjCContainer() &&
Jonathan D. Turner205c7d52011-06-03 23:11:16 +00001054 D->getAccess() == AS_none &&
Douglas Gregor26701a42011-09-09 02:06:17 +00001055 !D->isModulePrivate() &&
Richard Smithd08aeb62014-08-28 01:33:39 +00001056 !needsAnonymousDeclarationNumber(D) &&
Jonathan D. Turner205c7d52011-06-03 23:11:16 +00001057 D->getDeclName().getNameKind() == DeclarationName::Identifier &&
1058 !D->hasExtInfo() &&
Rafael Espindola8db352d2013-10-17 15:37:26 +00001059 D->getFirstDecl() == D->getMostRecentDecl() &&
Richard Smith7b76d812016-08-12 02:21:25 +00001060 D->getKind() == Decl::Var &&
Richard Smith62f19e72016-06-25 00:15:56 +00001061 !D->isInline() &&
Douglas Gregor12cda632012-09-20 23:43:29 +00001062 !D->isConstexpr() &&
Richard Smithbb13c9a2013-09-28 04:02:39 +00001063 !D->isInitCapture() &&
Richard Smith1c34fb72013-08-13 18:18:50 +00001064 !D->isPreviousDeclInSameBlockScope() &&
Akira Hatanaka9978da32018-08-10 15:09:24 +00001065 !(D->hasAttr<BlocksAttr>() && D->getType()->getAsCXXRecordDecl()) &&
Akira Hatanaka8e57b072018-10-01 21:51:28 +00001066 !D->isEscapingByref() &&
Richard Smitha4653622017-09-06 20:01:14 +00001067 D->getStorageDuration() != SD_Static &&
Larisse Voufod8dd97c2013-08-14 03:09:19 +00001068 !D->getMemberSpecializationInfo())
Jonathan D. Turner205c7d52011-06-03 23:11:16 +00001069 AbbrevToUse = Writer.getDeclVarAbbrev();
1070
Sebastian Redl539c5062010-08-18 23:57:32 +00001071 Code = serialization::DECL_VAR;
Chris Lattner7099dbc2009-04-27 06:16:06 +00001072}
1073
Sebastian Redl42a0f6a2010-08-18 23:56:27 +00001074void ASTDeclWriter::VisitImplicitParamDecl(ImplicitParamDecl *D) {
Chris Lattner7099dbc2009-04-27 06:16:06 +00001075 VisitVarDecl(D);
Sebastian Redl539c5062010-08-18 23:57:32 +00001076 Code = serialization::DECL_IMPLICIT_PARAM;
Chris Lattner7099dbc2009-04-27 06:16:06 +00001077}
1078
Sebastian Redl42a0f6a2010-08-18 23:56:27 +00001079void ASTDeclWriter::VisitParmVarDecl(ParmVarDecl *D) {
Chris Lattner7099dbc2009-04-27 06:16:06 +00001080 VisitVarDecl(D);
John McCall82490832011-05-02 00:30:12 +00001081 Record.push_back(D->isObjCMethodParameter());
John McCall8fb0d9d2011-05-01 22:35:37 +00001082 Record.push_back(D->getFunctionScopeDepth());
1083 Record.push_back(D->getFunctionScopeIndex());
Chris Lattner7099dbc2009-04-27 06:16:06 +00001084 Record.push_back(D->getObjCDeclQualifier()); // FIXME: stable encoding
John McCall6a014d52011-03-09 04:22:44 +00001085 Record.push_back(D->isKNRPromoted());
John McCallf3cd6652010-03-12 18:31:32 +00001086 Record.push_back(D->hasInheritedDefaultArg());
Argyrios Kyrtzidisccde6a02010-07-04 21:44:07 +00001087 Record.push_back(D->hasUninstantiatedDefaultArg());
1088 if (D->hasUninstantiatedDefaultArg())
Richard Smith290d8012016-04-06 17:06:00 +00001089 Record.AddStmt(D->getUninstantiatedDefaultArg());
Sebastian Redl539c5062010-08-18 23:57:32 +00001090 Code = serialization::DECL_PARM_VAR;
Mike Stump11289f42009-09-09 15:08:12 +00001091
John McCalld4631322011-06-17 06:42:21 +00001092 assert(!D->isARCPseudoStrong()); // can be true of ImplicitParamDecl
1093
Chris Lattner258172e2009-04-27 07:35:58 +00001094 // If the assumptions about the DECL_PARM_VAR abbrev are true, use it. Here
1095 // we dynamically check for the properties that we optimize for, but don't
1096 // know are true of all PARM_VAR_DECLs.
Richard Smith8aed4222015-12-11 22:41:00 +00001097 if (D->getDeclContext() == D->getLexicalDeclContext() &&
1098 !D->hasAttrs() &&
Jonathan D. Turner205c7d52011-06-03 23:11:16 +00001099 !D->hasExtInfo() &&
Chris Lattner258172e2009-04-27 07:35:58 +00001100 !D->isImplicit() &&
Douglas Gregorebada0772010-06-17 23:14:26 +00001101 !D->isUsed(false) &&
Argyrios Kyrtzidisb7d1ca22012-03-09 21:09:04 +00001102 !D->isInvalidDecl() &&
Eli Friedmanc09e0552012-01-13 23:41:25 +00001103 !D->isReferenced() &&
Chris Lattner258172e2009-04-27 07:35:58 +00001104 D->getAccess() == AS_none &&
Douglas Gregor26701a42011-09-09 02:06:17 +00001105 !D->isModulePrivate() &&
Chris Lattner258172e2009-04-27 07:35:58 +00001106 D->getStorageClass() == 0 &&
Sebastian Redla9351792012-02-11 23:51:47 +00001107 D->getInitStyle() == VarDecl::CInit && // Can params have anything else?
John McCall82490832011-05-02 00:30:12 +00001108 D->getFunctionScopeDepth() == 0 &&
John McCallf3cd6652010-03-12 18:31:32 +00001109 D->getObjCDeclQualifier() == 0 &&
John McCall6a014d52011-03-09 04:22:44 +00001110 !D->isKNRPromoted() &&
Chris Lattnere2437f42010-05-09 06:40:08 +00001111 !D->hasInheritedDefaultArg() &&
Craig Toppera13603a2014-05-22 05:54:18 +00001112 D->getInit() == nullptr &&
Argyrios Kyrtzidisccde6a02010-07-04 21:44:07 +00001113 !D->hasUninstantiatedDefaultArg()) // No default expr.
Jonathan D. Turner205c7d52011-06-03 23:11:16 +00001114 AbbrevToUse = Writer.getDeclParmVarAbbrev();
Chris Lattner258172e2009-04-27 07:35:58 +00001115
1116 // Check things we know are true of *every* PARM_VAR_DECL, which is more than
1117 // just us assuming it.
Enea Zaffanellaacb8ecd2013-05-04 08:27:07 +00001118 assert(!D->getTSCSpec() && "PARM_VAR_DECL can't use TLS");
Richard Smithedbc6e92016-10-14 21:41:24 +00001119 assert(!D->isThisDeclarationADemotedDefinition()
1120 && "PARM_VAR_DECL can't be demoted definition.");
Chris Lattner258172e2009-04-27 07:35:58 +00001121 assert(D->getAccess() == AS_none && "PARM_VAR_DECL can't be public/private");
Douglas Gregor3f324d562010-05-03 18:51:14 +00001122 assert(!D->isExceptionVariable() && "PARM_VAR_DECL can't be exception var");
Craig Toppera13603a2014-05-22 05:54:18 +00001123 assert(D->getPreviousDecl() == nullptr && "PARM_VAR_DECL can't be redecl");
Argyrios Kyrtzidiscdb8b3f2010-07-04 21:44:00 +00001124 assert(!D->isStaticDataMember() &&
1125 "PARM_VAR_DECL can't be static data member");
Chris Lattner7099dbc2009-04-27 06:16:06 +00001126}
1127
Richard Smith7b76d812016-08-12 02:21:25 +00001128void ASTDeclWriter::VisitDecompositionDecl(DecompositionDecl *D) {
1129 // Record the number of bindings first to simplify deserialization.
1130 Record.push_back(D->bindings().size());
1131
1132 VisitVarDecl(D);
1133 for (auto *B : D->bindings())
1134 Record.AddDeclRef(B);
1135 Code = serialization::DECL_DECOMPOSITION;
1136}
1137
1138void ASTDeclWriter::VisitBindingDecl(BindingDecl *D) {
1139 VisitValueDecl(D);
1140 Record.AddStmt(D->getBinding());
1141 Code = serialization::DECL_BINDING;
1142}
1143
Sebastian Redl42a0f6a2010-08-18 23:56:27 +00001144void ASTDeclWriter::VisitFileScopeAsmDecl(FileScopeAsmDecl *D) {
Chris Lattner7099dbc2009-04-27 06:16:06 +00001145 VisitDecl(D);
Richard Smith290d8012016-04-06 17:06:00 +00001146 Record.AddStmt(D->getAsmString());
Richard Smith69c82bf2016-04-01 22:52:03 +00001147 Record.AddSourceLocation(D->getRParenLoc());
Sebastian Redl539c5062010-08-18 23:57:32 +00001148 Code = serialization::DECL_FILE_SCOPE_ASM;
Chris Lattner7099dbc2009-04-27 06:16:06 +00001149}
1150
Michael Han84324352013-02-22 17:15:32 +00001151void ASTDeclWriter::VisitEmptyDecl(EmptyDecl *D) {
1152 VisitDecl(D);
1153 Code = serialization::DECL_EMPTY;
1154}
1155
Tykerb0561b32019-11-17 11:41:55 +01001156void ASTDeclWriter::VisitLifetimeExtendedTemporaryDecl(
1157 LifetimeExtendedTemporaryDecl *D) {
1158 VisitDecl(D);
1159 Record.AddDeclRef(D->getExtendingDecl());
1160 Record.AddStmt(D->getTemporaryExpr());
1161 Record.push_back(static_cast<bool>(D->getValue()));
1162 if (D->getValue())
1163 Record.AddAPValue(*D->getValue());
1164 Record.push_back(D->getManglingNumber());
1165 Code = serialization::DECL_LIFETIME_EXTENDED_TEMPORARY;
1166}
Sebastian Redl42a0f6a2010-08-18 23:56:27 +00001167void ASTDeclWriter::VisitBlockDecl(BlockDecl *D) {
Chris Lattner7099dbc2009-04-27 06:16:06 +00001168 VisitDecl(D);
Richard Smith290d8012016-04-06 17:06:00 +00001169 Record.AddStmt(D->getBody());
Richard Smith69c82bf2016-04-01 22:52:03 +00001170 Record.AddTypeSourceInfo(D->getSignatureAsWritten());
Chris Lattner7099dbc2009-04-27 06:16:06 +00001171 Record.push_back(D->param_size());
David Majnemera3debed2016-06-24 05:33:44 +00001172 for (ParmVarDecl *P : D->parameters())
1173 Record.AddDeclRef(P);
John McCallcf6ce282012-04-13 17:33:29 +00001174 Record.push_back(D->isVariadic());
1175 Record.push_back(D->blockMissingReturnType());
1176 Record.push_back(D->isConversionFromLambda());
Akira Hatanakadb49a1f2018-08-01 23:51:53 +00001177 Record.push_back(D->doesNotEscape());
Akira Hatanakac5792aa2019-02-27 18:17:16 +00001178 Record.push_back(D->canAvoidCopyToHeap());
John McCallc63de662011-02-02 13:00:07 +00001179 Record.push_back(D->capturesCXXThis());
John McCall351762c2011-02-07 10:33:21 +00001180 Record.push_back(D->getNumCaptures());
Aaron Ballman9371dd22014-03-14 18:34:04 +00001181 for (const auto &capture : D->captures()) {
Richard Smith69c82bf2016-04-01 22:52:03 +00001182 Record.AddDeclRef(capture.getVariable());
John McCall351762c2011-02-07 10:33:21 +00001183
1184 unsigned flags = 0;
1185 if (capture.isByRef()) flags |= 1;
1186 if (capture.isNested()) flags |= 2;
1187 if (capture.hasCopyExpr()) flags |= 4;
1188 Record.push_back(flags);
1189
Richard Smith290d8012016-04-06 17:06:00 +00001190 if (capture.hasCopyExpr()) Record.AddStmt(capture.getCopyExpr());
John McCall351762c2011-02-07 10:33:21 +00001191 }
John McCallc63de662011-02-02 13:00:07 +00001192
Sebastian Redl539c5062010-08-18 23:57:32 +00001193 Code = serialization::DECL_BLOCK;
Chris Lattner7099dbc2009-04-27 06:16:06 +00001194}
1195
Ben Langmuirce914fc2013-05-03 19:20:19 +00001196void ASTDeclWriter::VisitCapturedDecl(CapturedDecl *CD) {
1197 Record.push_back(CD->getNumParams());
1198 VisitDecl(CD);
Alexey Bataev9959db52014-05-06 10:08:46 +00001199 Record.push_back(CD->getContextParamPosition());
1200 Record.push_back(CD->isNothrow() ? 1 : 0);
Ben Langmuirce914fc2013-05-03 19:20:19 +00001201 // Body is stored by VisitCapturedStmt.
Alexey Bataev9959db52014-05-06 10:08:46 +00001202 for (unsigned I = 0; I < CD->getNumParams(); ++I)
Richard Smith69c82bf2016-04-01 22:52:03 +00001203 Record.AddDeclRef(CD->getParam(I));
Ben Langmuirce914fc2013-05-03 19:20:19 +00001204 Code = serialization::DECL_CAPTURED;
Tareq A. Siraj6dfa25a2013-04-16 19:37:38 +00001205}
1206
Sebastian Redl42a0f6a2010-08-18 23:56:27 +00001207void ASTDeclWriter::VisitLinkageSpecDecl(LinkageSpecDecl *D) {
Chris Lattnerca025db2010-05-07 21:43:38 +00001208 VisitDecl(D);
Chris Lattnerca025db2010-05-07 21:43:38 +00001209 Record.push_back(D->getLanguage());
Richard Smith69c82bf2016-04-01 22:52:03 +00001210 Record.AddSourceLocation(D->getExternLoc());
1211 Record.AddSourceLocation(D->getRBraceLoc());
Sebastian Redl539c5062010-08-18 23:57:32 +00001212 Code = serialization::DECL_LINKAGE_SPEC;
Chris Lattnerca025db2010-05-07 21:43:38 +00001213}
1214
Richard Smith8df390f2016-09-08 23:14:54 +00001215void ASTDeclWriter::VisitExportDecl(ExportDecl *D) {
1216 VisitDecl(D);
1217 Record.AddSourceLocation(D->getRBraceLoc());
1218 Code = serialization::DECL_EXPORT;
1219}
1220
Chris Lattnerc8e630e2011-02-17 07:39:24 +00001221void ASTDeclWriter::VisitLabelDecl(LabelDecl *D) {
1222 VisitNamedDecl(D);
Stephen Kellyf2ceec42018-08-09 21:08:08 +00001223 Record.AddSourceLocation(D->getBeginLoc());
Chris Lattnerc8e630e2011-02-17 07:39:24 +00001224 Code = serialization::DECL_LABEL;
1225}
1226
1227
Sebastian Redl42a0f6a2010-08-18 23:56:27 +00001228void ASTDeclWriter::VisitNamespaceDecl(NamespaceDecl *D) {
Douglas Gregore57e7522012-01-07 09:11:48 +00001229 VisitRedeclarable(D);
Chris Lattnerca025db2010-05-07 21:43:38 +00001230 VisitNamedDecl(D);
Douglas Gregor44e5c1f2010-10-05 20:41:58 +00001231 Record.push_back(D->isInline());
Stephen Kellyf2ceec42018-08-09 21:08:08 +00001232 Record.AddSourceLocation(D->getBeginLoc());
Richard Smith69c82bf2016-04-01 22:52:03 +00001233 Record.AddSourceLocation(D->getRBraceLoc());
Chris Lattnerca025db2010-05-07 21:43:38 +00001234
Chris Lattnerca025db2010-05-07 21:43:38 +00001235 if (D->isOriginalNamespace())
Richard Smith69c82bf2016-04-01 22:52:03 +00001236 Record.AddDeclRef(D->getAnonymousNamespace());
Sebastian Redl539c5062010-08-18 23:57:32 +00001237 Code = serialization::DECL_NAMESPACE;
Sebastian Redlf03cdc52010-08-05 21:22:19 +00001238
Fangrui Song6907ce22018-07-30 19:24:48 +00001239 if (Writer.hasChain() && D->isAnonymousNamespace() &&
Douglas Gregorec9fd132012-01-14 16:38:05 +00001240 D == D->getMostRecentDecl()) {
Sebastian Redl010288f2011-04-24 16:28:21 +00001241 // This is a most recent reopening of the anonymous namespace. If its parent
1242 // is in a previous PCH (or is the TU), mark that parent for update, because
1243 // the original namespace always points to the latest re-opening of its
1244 // anonymous namespace.
1245 Decl *Parent = cast<Decl>(
1246 D->getParent()->getRedeclContext()->getPrimaryContext());
Douglas Gregorb3722e22011-09-09 23:01:35 +00001247 if (Parent->isFromASTFile() || isa<TranslationUnitDecl>(Parent)) {
Richard Smith6ef42932014-03-20 21:02:00 +00001248 Writer.DeclUpdates[Parent].push_back(
Aaron Ballman4f45b712014-03-21 15:22:56 +00001249 ASTWriter::DeclUpdate(UPD_CXX_ADDED_ANONYMOUS_NAMESPACE, D));
Sebastian Redlfa1f3702011-04-24 16:28:13 +00001250 }
1251 }
Chris Lattnerca025db2010-05-07 21:43:38 +00001252}
1253
Sebastian Redl42a0f6a2010-08-18 23:56:27 +00001254void ASTDeclWriter::VisitNamespaceAliasDecl(NamespaceAliasDecl *D) {
Richard Smithf4634362014-09-03 23:11:22 +00001255 VisitRedeclarable(D);
Chris Lattnerca025db2010-05-07 21:43:38 +00001256 VisitNamedDecl(D);
Richard Smith69c82bf2016-04-01 22:52:03 +00001257 Record.AddSourceLocation(D->getNamespaceLoc());
1258 Record.AddSourceLocation(D->getTargetNameLoc());
1259 Record.AddNestedNameSpecifierLoc(D->getQualifierLoc());
1260 Record.AddDeclRef(D->getNamespace());
Sebastian Redl539c5062010-08-18 23:57:32 +00001261 Code = serialization::DECL_NAMESPACE_ALIAS;
Chris Lattnerca025db2010-05-07 21:43:38 +00001262}
1263
Sebastian Redl42a0f6a2010-08-18 23:56:27 +00001264void ASTDeclWriter::VisitUsingDecl(UsingDecl *D) {
Chris Lattnerca025db2010-05-07 21:43:38 +00001265 VisitNamedDecl(D);
Richard Smith69c82bf2016-04-01 22:52:03 +00001266 Record.AddSourceLocation(D->getUsingLoc());
1267 Record.AddNestedNameSpecifierLoc(D->getQualifierLoc());
1268 Record.AddDeclarationNameLoc(D->DNLoc, D->getDeclName());
1269 Record.AddDeclRef(D->FirstUsingShadow.getPointer());
Enea Zaffanellae05a3cf2013-07-22 10:54:09 +00001270 Record.push_back(D->hasTypename());
Richard Smith69c82bf2016-04-01 22:52:03 +00001271 Record.AddDeclRef(Context.getInstantiatedFromUsingDecl(D));
Sebastian Redl539c5062010-08-18 23:57:32 +00001272 Code = serialization::DECL_USING;
Chris Lattnerca025db2010-05-07 21:43:38 +00001273}
1274
Richard Smith151c4562016-12-20 21:35:28 +00001275void ASTDeclWriter::VisitUsingPackDecl(UsingPackDecl *D) {
1276 Record.push_back(D->NumExpansions);
1277 VisitNamedDecl(D);
1278 Record.AddDeclRef(D->getInstantiatedFromUsingDecl());
1279 for (auto *E : D->expansions())
1280 Record.AddDeclRef(E);
1281 Code = serialization::DECL_USING_PACK;
1282}
1283
Sebastian Redl42a0f6a2010-08-18 23:56:27 +00001284void ASTDeclWriter::VisitUsingShadowDecl(UsingShadowDecl *D) {
Richard Smithfd8634a2013-10-23 02:17:46 +00001285 VisitRedeclarable(D);
Chris Lattnerca025db2010-05-07 21:43:38 +00001286 VisitNamedDecl(D);
Richard Smith69c82bf2016-04-01 22:52:03 +00001287 Record.AddDeclRef(D->getTargetDecl());
Richard Smitha263c342018-01-06 01:07:05 +00001288 Record.push_back(D->getIdentifierNamespace());
Richard Smith69c82bf2016-04-01 22:52:03 +00001289 Record.AddDeclRef(D->UsingOrNextShadow);
1290 Record.AddDeclRef(Context.getInstantiatedFromUsingShadowDecl(D));
Sebastian Redl539c5062010-08-18 23:57:32 +00001291 Code = serialization::DECL_USING_SHADOW;
Chris Lattnerca025db2010-05-07 21:43:38 +00001292}
1293
Richard Smith5179eb72016-06-28 19:03:57 +00001294void ASTDeclWriter::VisitConstructorUsingShadowDecl(
1295 ConstructorUsingShadowDecl *D) {
1296 VisitUsingShadowDecl(D);
1297 Record.AddDeclRef(D->NominatedBaseClassShadowDecl);
1298 Record.AddDeclRef(D->ConstructedBaseClassShadowDecl);
1299 Record.push_back(D->IsVirtual);
1300 Code = serialization::DECL_CONSTRUCTOR_USING_SHADOW;
1301}
1302
Sebastian Redl42a0f6a2010-08-18 23:56:27 +00001303void ASTDeclWriter::VisitUsingDirectiveDecl(UsingDirectiveDecl *D) {
Chris Lattnerca025db2010-05-07 21:43:38 +00001304 VisitNamedDecl(D);
Richard Smith69c82bf2016-04-01 22:52:03 +00001305 Record.AddSourceLocation(D->getUsingLoc());
1306 Record.AddSourceLocation(D->getNamespaceKeyLocation());
1307 Record.AddNestedNameSpecifierLoc(D->getQualifierLoc());
1308 Record.AddDeclRef(D->getNominatedNamespace());
1309 Record.AddDeclRef(dyn_cast<Decl>(D->getCommonAncestor()));
Sebastian Redl539c5062010-08-18 23:57:32 +00001310 Code = serialization::DECL_USING_DIRECTIVE;
Chris Lattnerca025db2010-05-07 21:43:38 +00001311}
1312
Sebastian Redl42a0f6a2010-08-18 23:56:27 +00001313void ASTDeclWriter::VisitUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *D) {
Chris Lattnerca025db2010-05-07 21:43:38 +00001314 VisitValueDecl(D);
Richard Smith69c82bf2016-04-01 22:52:03 +00001315 Record.AddSourceLocation(D->getUsingLoc());
1316 Record.AddNestedNameSpecifierLoc(D->getQualifierLoc());
1317 Record.AddDeclarationNameLoc(D->DNLoc, D->getDeclName());
Richard Smith151c4562016-12-20 21:35:28 +00001318 Record.AddSourceLocation(D->getEllipsisLoc());
Sebastian Redl539c5062010-08-18 23:57:32 +00001319 Code = serialization::DECL_UNRESOLVED_USING_VALUE;
Chris Lattnerca025db2010-05-07 21:43:38 +00001320}
1321
Sebastian Redl42a0f6a2010-08-18 23:56:27 +00001322void ASTDeclWriter::VisitUnresolvedUsingTypenameDecl(
Chris Lattnerca025db2010-05-07 21:43:38 +00001323 UnresolvedUsingTypenameDecl *D) {
1324 VisitTypeDecl(D);
Richard Smith69c82bf2016-04-01 22:52:03 +00001325 Record.AddSourceLocation(D->getTypenameLoc());
1326 Record.AddNestedNameSpecifierLoc(D->getQualifierLoc());
Richard Smith151c4562016-12-20 21:35:28 +00001327 Record.AddSourceLocation(D->getEllipsisLoc());
Sebastian Redl539c5062010-08-18 23:57:32 +00001328 Code = serialization::DECL_UNRESOLVED_USING_TYPENAME;
Chris Lattnerca025db2010-05-07 21:43:38 +00001329}
1330
Sebastian Redl42a0f6a2010-08-18 23:56:27 +00001331void ASTDeclWriter::VisitCXXRecordDecl(CXXRecordDecl *D) {
Chris Lattnerca025db2010-05-07 21:43:38 +00001332 VisitRecordDecl(D);
Argyrios Kyrtzidis2c2167a2010-07-02 11:55:32 +00001333
Argyrios Kyrtzidis106caf922010-06-19 19:28:53 +00001334 enum {
1335 CXXRecNotTemplate = 0, CXXRecTemplate, CXXRecMemberSpecialization
1336 };
1337 if (ClassTemplateDecl *TemplD = D->getDescribedClassTemplate()) {
1338 Record.push_back(CXXRecTemplate);
Richard Smith69c82bf2016-04-01 22:52:03 +00001339 Record.AddDeclRef(TemplD);
Argyrios Kyrtzidis106caf922010-06-19 19:28:53 +00001340 } else if (MemberSpecializationInfo *MSInfo
1341 = D->getMemberSpecializationInfo()) {
1342 Record.push_back(CXXRecMemberSpecialization);
Richard Smith69c82bf2016-04-01 22:52:03 +00001343 Record.AddDeclRef(MSInfo->getInstantiatedFrom());
Argyrios Kyrtzidis106caf922010-06-19 19:28:53 +00001344 Record.push_back(MSInfo->getTemplateSpecializationKind());
Richard Smith69c82bf2016-04-01 22:52:03 +00001345 Record.AddSourceLocation(MSInfo->getPointOfInstantiation());
Argyrios Kyrtzidis106caf922010-06-19 19:28:53 +00001346 } else {
1347 Record.push_back(CXXRecNotTemplate);
1348 }
1349
Richard Smithcd45dbc2014-04-19 03:48:30 +00001350 Record.push_back(D->isThisDeclarationADefinition());
1351 if (D->isThisDeclarationADefinition())
Richard Smith69c82bf2016-04-01 22:52:03 +00001352 Record.AddCXXDefinitionData(D);
Richard Smithcd45dbc2014-04-19 03:48:30 +00001353
John McCall6bd2a892013-01-25 22:31:03 +00001354 // Store (what we currently believe to be) the key function to avoid
1355 // deserializing every method so we can compute it.
Erich Keanef92f31c2018-08-01 20:48:16 +00001356 if (D->isCompleteDefinition())
Richard Smith69c82bf2016-04-01 22:52:03 +00001357 Record.AddDeclRef(Context.getCurrentKeyFunction(D));
Argyrios Kyrtzidis68431412010-10-14 20:14:38 +00001358
Sebastian Redl539c5062010-08-18 23:57:32 +00001359 Code = serialization::DECL_CXX_RECORD;
Chris Lattnerca025db2010-05-07 21:43:38 +00001360}
1361
Sebastian Redl42a0f6a2010-08-18 23:56:27 +00001362void ASTDeclWriter::VisitCXXMethodDecl(CXXMethodDecl *D) {
Chris Lattnerca025db2010-05-07 21:43:38 +00001363 VisitFunctionDecl(D);
Argyrios Kyrtzidis3b1a7792012-10-12 05:31:40 +00001364 if (D->isCanonicalDecl()) {
1365 Record.push_back(D->size_overridden_methods());
Benjamin Krameracfa3392017-12-17 23:52:45 +00001366 for (const CXXMethodDecl *MD : D->overridden_methods())
1367 Record.AddDeclRef(MD);
Argyrios Kyrtzidis3b1a7792012-10-12 05:31:40 +00001368 } else {
1369 // We only need to record overridden methods once for the canonical decl.
1370 Record.push_back(0);
1371 }
Richard Smith01b2cb42014-07-26 06:37:51 +00001372
Richard Smith8aed4222015-12-11 22:41:00 +00001373 if (D->getDeclContext() == D->getLexicalDeclContext() &&
1374 D->getFirstDecl() == D->getMostRecentDecl() &&
Richard Smith01b2cb42014-07-26 06:37:51 +00001375 !D->isInvalidDecl() &&
1376 !D->hasAttrs() &&
1377 !D->isTopLevelDeclInObjCContainer() &&
1378 D->getDeclName().getNameKind() == DeclarationName::Identifier &&
1379 !D->hasExtInfo() &&
1380 !D->hasInheritedPrototype() &&
1381 D->hasWrittenPrototype())
1382 AbbrevToUse = Writer.getDeclCXXMethodAbbrev();
1383
Sebastian Redl539c5062010-08-18 23:57:32 +00001384 Code = serialization::DECL_CXX_METHOD;
Chris Lattnerca025db2010-05-07 21:43:38 +00001385}
1386
Sebastian Redl42a0f6a2010-08-18 23:56:27 +00001387void ASTDeclWriter::VisitCXXConstructorDecl(CXXConstructorDecl *D) {
Richard Smith76b90272019-05-09 03:59:21 +00001388 Record.push_back(D->getTraillingAllocKind());
1389 addExplicitSpecifier(D->getExplicitSpecifier(), Record);
Richard Smith5179eb72016-06-28 19:03:57 +00001390 if (auto Inherited = D->getInheritedConstructor()) {
1391 Record.AddDeclRef(Inherited.getShadowDecl());
1392 Record.AddDeclRef(Inherited.getConstructor());
Richard Smith5179eb72016-06-28 19:03:57 +00001393 }
1394
Chris Lattnerca025db2010-05-07 21:43:38 +00001395 VisitCXXMethodDecl(D);
Richard Smith76b90272019-05-09 03:59:21 +00001396 Code = serialization::DECL_CXX_CONSTRUCTOR;
Chris Lattnerca025db2010-05-07 21:43:38 +00001397}
1398
Sebastian Redl42a0f6a2010-08-18 23:56:27 +00001399void ASTDeclWriter::VisitCXXDestructorDecl(CXXDestructorDecl *D) {
Chris Lattnerca025db2010-05-07 21:43:38 +00001400 VisitCXXMethodDecl(D);
Argyrios Kyrtzidis33575162010-07-02 15:58:43 +00001401
Richard Smith69c82bf2016-04-01 22:52:03 +00001402 Record.AddDeclRef(D->getOperatorDelete());
Richard Smith5b349582017-10-13 01:55:36 +00001403 if (D->getOperatorDelete())
1404 Record.AddStmt(D->getOperatorDeleteThisArg());
Argyrios Kyrtzidis33575162010-07-02 15:58:43 +00001405
Sebastian Redl539c5062010-08-18 23:57:32 +00001406 Code = serialization::DECL_CXX_DESTRUCTOR;
Chris Lattnerca025db2010-05-07 21:43:38 +00001407}
1408
Sebastian Redl42a0f6a2010-08-18 23:56:27 +00001409void ASTDeclWriter::VisitCXXConversionDecl(CXXConversionDecl *D) {
Richard Smith76b90272019-05-09 03:59:21 +00001410 addExplicitSpecifier(D->getExplicitSpecifier(), Record);
Chris Lattnerca025db2010-05-07 21:43:38 +00001411 VisitCXXMethodDecl(D);
Sebastian Redl539c5062010-08-18 23:57:32 +00001412 Code = serialization::DECL_CXX_CONVERSION;
Chris Lattnerca025db2010-05-07 21:43:38 +00001413}
1414
Douglas Gregorba345522011-12-02 23:23:56 +00001415void ASTDeclWriter::VisitImportDecl(ImportDecl *D) {
1416 VisitDecl(D);
Argyrios Kyrtzidis7b8e5552012-10-03 01:58:45 +00001417 Record.push_back(Writer.getSubmoduleID(D->getImportedModule()));
Douglas Gregorba345522011-12-02 23:23:56 +00001418 ArrayRef<SourceLocation> IdentifierLocs = D->getIdentifierLocs();
1419 Record.push_back(!IdentifierLocs.empty());
1420 if (IdentifierLocs.empty()) {
Stephen Kelly1c301dc2018-08-09 21:09:38 +00001421 Record.AddSourceLocation(D->getEndLoc());
Douglas Gregorba345522011-12-02 23:23:56 +00001422 Record.push_back(1);
1423 } else {
1424 for (unsigned I = 0, N = IdentifierLocs.size(); I != N; ++I)
Richard Smith69c82bf2016-04-01 22:52:03 +00001425 Record.AddSourceLocation(IdentifierLocs[I]);
Douglas Gregorba345522011-12-02 23:23:56 +00001426 Record.push_back(IdentifierLocs.size());
1427 }
1428 // Note: the number of source locations must always be the last element in
1429 // the record.
1430 Code = serialization::DECL_IMPORT;
1431}
1432
Sebastian Redl42a0f6a2010-08-18 23:56:27 +00001433void ASTDeclWriter::VisitAccessSpecDecl(AccessSpecDecl *D) {
Abramo Bagnarad7340582010-06-05 05:09:32 +00001434 VisitDecl(D);
Richard Smith69c82bf2016-04-01 22:52:03 +00001435 Record.AddSourceLocation(D->getColonLoc());
Sebastian Redl539c5062010-08-18 23:57:32 +00001436 Code = serialization::DECL_ACCESS_SPEC;
Abramo Bagnarad7340582010-06-05 05:09:32 +00001437}
1438
Sebastian Redl42a0f6a2010-08-18 23:56:27 +00001439void ASTDeclWriter::VisitFriendDecl(FriendDecl *D) {
Enea Zaffanellaeb22c872013-01-31 09:54:08 +00001440 // Record the number of friend type template parameter lists here
1441 // so as to simplify memory allocation during deserialization.
1442 Record.push_back(D->NumTPLists);
Argyrios Kyrtzidisa95d0192010-07-05 10:38:01 +00001443 VisitDecl(D);
Enea Zaffanellaeb22c872013-01-31 09:54:08 +00001444 bool hasFriendDecl = D->Friend.is<NamedDecl*>();
1445 Record.push_back(hasFriendDecl);
1446 if (hasFriendDecl)
Richard Smith69c82bf2016-04-01 22:52:03 +00001447 Record.AddDeclRef(D->getFriendDecl());
Argyrios Kyrtzidis74d28bd2010-06-29 22:47:00 +00001448 else
Richard Smith69c82bf2016-04-01 22:52:03 +00001449 Record.AddTypeSourceInfo(D->getFriendType());
Enea Zaffanellaeb22c872013-01-31 09:54:08 +00001450 for (unsigned i = 0; i < D->NumTPLists; ++i)
Richard Smith69c82bf2016-04-01 22:52:03 +00001451 Record.AddTemplateParameterList(D->getFriendTypeTemplateParameterList(i));
1452 Record.AddDeclRef(D->getNextFriend());
John McCall2c2eb122010-10-16 06:59:13 +00001453 Record.push_back(D->UnsupportedFriend);
Richard Smith69c82bf2016-04-01 22:52:03 +00001454 Record.AddSourceLocation(D->FriendLoc);
Sebastian Redl539c5062010-08-18 23:57:32 +00001455 Code = serialization::DECL_FRIEND;
Argyrios Kyrtzidis74d28bd2010-06-29 22:47:00 +00001456}
1457
Sebastian Redl42a0f6a2010-08-18 23:56:27 +00001458void ASTDeclWriter::VisitFriendTemplateDecl(FriendTemplateDecl *D) {
Argyrios Kyrtzidis165b5812010-07-22 16:04:10 +00001459 VisitDecl(D);
1460 Record.push_back(D->getNumTemplateParameters());
1461 for (unsigned i = 0, e = D->getNumTemplateParameters(); i != e; ++i)
Richard Smith69c82bf2016-04-01 22:52:03 +00001462 Record.AddTemplateParameterList(D->getTemplateParameterList(i));
Craig Toppera13603a2014-05-22 05:54:18 +00001463 Record.push_back(D->getFriendDecl() != nullptr);
Argyrios Kyrtzidis165b5812010-07-22 16:04:10 +00001464 if (D->getFriendDecl())
Richard Smith69c82bf2016-04-01 22:52:03 +00001465 Record.AddDeclRef(D->getFriendDecl());
Argyrios Kyrtzidis165b5812010-07-22 16:04:10 +00001466 else
Richard Smith69c82bf2016-04-01 22:52:03 +00001467 Record.AddTypeSourceInfo(D->getFriendType());
1468 Record.AddSourceLocation(D->getFriendLoc());
Sebastian Redl539c5062010-08-18 23:57:32 +00001469 Code = serialization::DECL_FRIEND_TEMPLATE;
Chris Lattnerca025db2010-05-07 21:43:38 +00001470}
1471
Sebastian Redl42a0f6a2010-08-18 23:56:27 +00001472void ASTDeclWriter::VisitTemplateDecl(TemplateDecl *D) {
Argyrios Kyrtzidis106caf922010-06-19 19:28:53 +00001473 VisitNamedDecl(D);
1474
Richard Smith69c82bf2016-04-01 22:52:03 +00001475 Record.AddDeclRef(D->getTemplatedDecl());
1476 Record.AddTemplateParameterList(D->getTemplateParameters());
Chris Lattnerca025db2010-05-07 21:43:38 +00001477}
1478
Saar Razd7aae332019-07-10 21:25:49 +00001479void ASTDeclWriter::VisitConceptDecl(ConceptDecl *D) {
1480 VisitTemplateDecl(D);
1481 Record.AddStmt(D->getConstraintExpr());
1482 Code = serialization::DECL_CONCEPT;
1483}
1484
Saar Raza0f50d72020-01-18 09:11:43 +02001485void ASTDeclWriter::VisitRequiresExprBodyDecl(RequiresExprBodyDecl *D) {
1486 Code = serialization::DECL_REQUIRES_EXPR_BODY;
1487}
1488
Sebastian Redl42a0f6a2010-08-18 23:56:27 +00001489void ASTDeclWriter::VisitRedeclarableTemplateDecl(RedeclarableTemplateDecl *D) {
Douglas Gregor68444de2012-01-14 15:13:49 +00001490 VisitRedeclarable(D);
1491
Argyrios Kyrtzidisf4bc0d82010-09-08 19:31:22 +00001492 // Emit data to initialize CommonOrPrev before VisitTemplateDecl so that
1493 // getCommonPtr() can be used while this is still initializing.
Rafael Espindola8db352d2013-10-17 15:37:26 +00001494 if (D->isFirstDecl()) {
Douglas Gregor074a4092011-12-19 18:19:24 +00001495 // This declaration owns the 'common' pointer, so serialize that data now.
Richard Smith69c82bf2016-04-01 22:52:03 +00001496 Record.AddDeclRef(D->getInstantiatedFromMemberTemplate());
Peter Collingbourne91b25b72010-07-29 16:11:51 +00001497 if (D->getInstantiatedFromMemberTemplate())
1498 Record.push_back(D->isMemberSpecialization());
Douglas Gregor074a4092011-12-19 18:19:24 +00001499 }
Fangrui Song6907ce22018-07-30 19:24:48 +00001500
Argyrios Kyrtzidisf4bc0d82010-09-08 19:31:22 +00001501 VisitTemplateDecl(D);
1502 Record.push_back(D->getIdentifierNamespace());
Peter Collingbourne91b25b72010-07-29 16:11:51 +00001503}
1504
Sebastian Redl42a0f6a2010-08-18 23:56:27 +00001505void ASTDeclWriter::VisitClassTemplateDecl(ClassTemplateDecl *D) {
Peter Collingbourne91b25b72010-07-29 16:11:51 +00001506 VisitRedeclarableTemplateDecl(D);
1507
Richard Smith509fc852015-02-27 23:05:10 +00001508 if (D->isFirstDecl())
1509 AddTemplateSpecializations(D);
Sebastian Redl539c5062010-08-18 23:57:32 +00001510 Code = serialization::DECL_CLASS_TEMPLATE;
Chris Lattnerca025db2010-05-07 21:43:38 +00001511}
1512
Sebastian Redl42a0f6a2010-08-18 23:56:27 +00001513void ASTDeclWriter::VisitClassTemplateSpecializationDecl(
Chris Lattnerca025db2010-05-07 21:43:38 +00001514 ClassTemplateSpecializationDecl *D) {
Richard Smithd8a83712015-08-22 01:47:18 +00001515 RegisterTemplateSpecialization(D->getSpecializedTemplate(), D);
1516
Argyrios Kyrtzidis818c5db2010-06-23 13:48:30 +00001517 VisitCXXRecordDecl(D);
1518
1519 llvm::PointerUnion<ClassTemplateDecl *,
1520 ClassTemplatePartialSpecializationDecl *> InstFrom
1521 = D->getSpecializedTemplateOrPartial();
Argyrios Kyrtzidisd5553f12011-08-17 21:35:28 +00001522 if (Decl *InstFromD = InstFrom.dyn_cast<ClassTemplateDecl *>()) {
Richard Smith69c82bf2016-04-01 22:52:03 +00001523 Record.AddDeclRef(InstFromD);
Argyrios Kyrtzidis818c5db2010-06-23 13:48:30 +00001524 } else {
Richard Smith69c82bf2016-04-01 22:52:03 +00001525 Record.AddDeclRef(InstFrom.get<ClassTemplatePartialSpecializationDecl *>());
1526 Record.AddTemplateArgumentList(&D->getTemplateInstantiationArgs());
Argyrios Kyrtzidis818c5db2010-06-23 13:48:30 +00001527 }
1528
Richard Smith69c82bf2016-04-01 22:52:03 +00001529 Record.AddTemplateArgumentList(&D->getTemplateArgs());
1530 Record.AddSourceLocation(D->getPointOfInstantiation());
Argyrios Kyrtzidis818c5db2010-06-23 13:48:30 +00001531 Record.push_back(D->getSpecializationKind());
Axel Naumanna31dee22012-10-01 07:34:47 +00001532 Record.push_back(D->isCanonicalDecl());
Argyrios Kyrtzidis818c5db2010-06-23 13:48:30 +00001533
Argyrios Kyrtzidisc1624e92010-07-20 13:59:40 +00001534 if (D->isCanonicalDecl()) {
Fangrui Song6907ce22018-07-30 19:24:48 +00001535 // When reading, we'll add it to the folding set of the following template.
Richard Smith69c82bf2016-04-01 22:52:03 +00001536 Record.AddDeclRef(D->getSpecializedTemplate()->getCanonicalDecl());
Argyrios Kyrtzidis87040572010-07-09 21:11:43 +00001537 }
1538
Richard Smithd55889a2013-09-09 16:55:27 +00001539 // Explicit info.
Richard Smith69c82bf2016-04-01 22:52:03 +00001540 Record.AddTypeSourceInfo(D->getTypeAsWritten());
Richard Smithd55889a2013-09-09 16:55:27 +00001541 if (D->getTypeAsWritten()) {
Richard Smith69c82bf2016-04-01 22:52:03 +00001542 Record.AddSourceLocation(D->getExternLoc());
1543 Record.AddSourceLocation(D->getTemplateKeywordLoc());
Richard Smithd55889a2013-09-09 16:55:27 +00001544 }
1545
Sebastian Redl539c5062010-08-18 23:57:32 +00001546 Code = serialization::DECL_CLASS_TEMPLATE_SPECIALIZATION;
Chris Lattnerca025db2010-05-07 21:43:38 +00001547}
1548
Sebastian Redl42a0f6a2010-08-18 23:56:27 +00001549void ASTDeclWriter::VisitClassTemplatePartialSpecializationDecl(
Chris Lattnerca025db2010-05-07 21:43:38 +00001550 ClassTemplatePartialSpecializationDecl *D) {
Richard Smith69c82bf2016-04-01 22:52:03 +00001551 Record.AddTemplateParameterList(D->getTemplateParameters());
1552 Record.AddASTTemplateArgumentListInfo(D->getTemplateArgsAsWritten());
Argyrios Kyrtzidis818c5db2010-06-23 13:48:30 +00001553
Saar Razdf061c32019-12-23 08:37:35 +02001554 VisitClassTemplateSpecializationDecl(D);
1555
Argyrios Kyrtzidis818c5db2010-06-23 13:48:30 +00001556 // These are read/set from/to the first declaration.
Craig Toppera13603a2014-05-22 05:54:18 +00001557 if (D->getPreviousDecl() == nullptr) {
Richard Smith69c82bf2016-04-01 22:52:03 +00001558 Record.AddDeclRef(D->getInstantiatedFromMember());
Argyrios Kyrtzidis818c5db2010-06-23 13:48:30 +00001559 Record.push_back(D->isMemberSpecialization());
1560 }
1561
Sebastian Redl539c5062010-08-18 23:57:32 +00001562 Code = serialization::DECL_CLASS_TEMPLATE_PARTIAL_SPECIALIZATION;
Chris Lattnerca025db2010-05-07 21:43:38 +00001563}
1564
Larisse Voufo39a1e502013-08-06 01:03:05 +00001565void ASTDeclWriter::VisitVarTemplateDecl(VarTemplateDecl *D) {
1566 VisitRedeclarableTemplateDecl(D);
1567
Richard Smith509fc852015-02-27 23:05:10 +00001568 if (D->isFirstDecl())
1569 AddTemplateSpecializations(D);
Larisse Voufo39a1e502013-08-06 01:03:05 +00001570 Code = serialization::DECL_VAR_TEMPLATE;
1571}
1572
1573void ASTDeclWriter::VisitVarTemplateSpecializationDecl(
1574 VarTemplateSpecializationDecl *D) {
Richard Smithd8a83712015-08-22 01:47:18 +00001575 RegisterTemplateSpecialization(D->getSpecializedTemplate(), D);
1576
Larisse Voufo39a1e502013-08-06 01:03:05 +00001577 VisitVarDecl(D);
1578
1579 llvm::PointerUnion<VarTemplateDecl *, VarTemplatePartialSpecializationDecl *>
1580 InstFrom = D->getSpecializedTemplateOrPartial();
1581 if (Decl *InstFromD = InstFrom.dyn_cast<VarTemplateDecl *>()) {
Richard Smith69c82bf2016-04-01 22:52:03 +00001582 Record.AddDeclRef(InstFromD);
Larisse Voufo39a1e502013-08-06 01:03:05 +00001583 } else {
Richard Smith69c82bf2016-04-01 22:52:03 +00001584 Record.AddDeclRef(InstFrom.get<VarTemplatePartialSpecializationDecl *>());
1585 Record.AddTemplateArgumentList(&D->getTemplateInstantiationArgs());
Larisse Voufo39a1e502013-08-06 01:03:05 +00001586 }
1587
1588 // Explicit info.
Richard Smith69c82bf2016-04-01 22:52:03 +00001589 Record.AddTypeSourceInfo(D->getTypeAsWritten());
Larisse Voufo39a1e502013-08-06 01:03:05 +00001590 if (D->getTypeAsWritten()) {
Richard Smith69c82bf2016-04-01 22:52:03 +00001591 Record.AddSourceLocation(D->getExternLoc());
1592 Record.AddSourceLocation(D->getTemplateKeywordLoc());
Larisse Voufo39a1e502013-08-06 01:03:05 +00001593 }
1594
Richard Smith69c82bf2016-04-01 22:52:03 +00001595 Record.AddTemplateArgumentList(&D->getTemplateArgs());
1596 Record.AddSourceLocation(D->getPointOfInstantiation());
Larisse Voufo39a1e502013-08-06 01:03:05 +00001597 Record.push_back(D->getSpecializationKind());
Richard Smith435e6472017-12-02 02:48:42 +00001598 Record.push_back(D->IsCompleteDefinition);
Larisse Voufo39a1e502013-08-06 01:03:05 +00001599 Record.push_back(D->isCanonicalDecl());
1600
1601 if (D->isCanonicalDecl()) {
1602 // When reading, we'll add it to the folding set of the following template.
Richard Smith69c82bf2016-04-01 22:52:03 +00001603 Record.AddDeclRef(D->getSpecializedTemplate()->getCanonicalDecl());
Larisse Voufo39a1e502013-08-06 01:03:05 +00001604 }
1605
1606 Code = serialization::DECL_VAR_TEMPLATE_SPECIALIZATION;
1607}
1608
1609void ASTDeclWriter::VisitVarTemplatePartialSpecializationDecl(
1610 VarTemplatePartialSpecializationDecl *D) {
Richard Smith69c82bf2016-04-01 22:52:03 +00001611 Record.AddTemplateParameterList(D->getTemplateParameters());
1612 Record.AddASTTemplateArgumentListInfo(D->getTemplateArgsAsWritten());
Larisse Voufo39a1e502013-08-06 01:03:05 +00001613
Saar Razdf061c32019-12-23 08:37:35 +02001614 VisitVarTemplateSpecializationDecl(D);
1615
Larisse Voufo39a1e502013-08-06 01:03:05 +00001616 // These are read/set from/to the first declaration.
Craig Toppera13603a2014-05-22 05:54:18 +00001617 if (D->getPreviousDecl() == nullptr) {
Richard Smith69c82bf2016-04-01 22:52:03 +00001618 Record.AddDeclRef(D->getInstantiatedFromMember());
Larisse Voufo39a1e502013-08-06 01:03:05 +00001619 Record.push_back(D->isMemberSpecialization());
1620 }
1621
1622 Code = serialization::DECL_VAR_TEMPLATE_PARTIAL_SPECIALIZATION;
1623}
1624
Fariborz Jahanian3a039e32011-08-27 20:50:59 +00001625void ASTDeclWriter::VisitClassScopeFunctionSpecializationDecl(
1626 ClassScopeFunctionSpecializationDecl *D) {
Francois Pichet09af8c32011-08-17 01:06:54 +00001627 VisitDecl(D);
Richard Smith69c82bf2016-04-01 22:52:03 +00001628 Record.AddDeclRef(D->getSpecialization());
Richard Smithf19a8b02019-05-02 00:49:14 +00001629 Record.push_back(D->hasExplicitTemplateArgs());
1630 if (D->hasExplicitTemplateArgs())
1631 Record.AddASTTemplateArgumentListInfo(D->getTemplateArgsAsWritten());
Francois Pichet09af8c32011-08-17 01:06:54 +00001632 Code = serialization::DECL_CLASS_SCOPE_FUNCTION_SPECIALIZATION;
1633}
1634
1635
Sebastian Redl42a0f6a2010-08-18 23:56:27 +00001636void ASTDeclWriter::VisitFunctionTemplateDecl(FunctionTemplateDecl *D) {
Peter Collingbourne91b25b72010-07-29 16:11:51 +00001637 VisitRedeclarableTemplateDecl(D);
Argyrios Kyrtzidis69da4a82010-06-22 09:55:07 +00001638
Richard Smith509fc852015-02-27 23:05:10 +00001639 if (D->isFirstDecl())
1640 AddTemplateSpecializations(D);
Sebastian Redl539c5062010-08-18 23:57:32 +00001641 Code = serialization::DECL_FUNCTION_TEMPLATE;
Chris Lattnerca025db2010-05-07 21:43:38 +00001642}
1643
Sebastian Redl42a0f6a2010-08-18 23:56:27 +00001644void ASTDeclWriter::VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D) {
Saar Razff1e0fc2020-01-15 02:48:42 +02001645 Record.push_back(D->hasTypeConstraint());
Argyrios Kyrtzidis106caf922010-06-19 19:28:53 +00001646 VisitTypeDecl(D);
1647
1648 Record.push_back(D->wasDeclaredWithTypename());
Saar Razff1e0fc2020-01-15 02:48:42 +02001649
1650 const TypeConstraint *TC = D->getTypeConstraint();
1651 Record.push_back(TC != nullptr);
1652 if (TC) {
1653 Record.AddNestedNameSpecifierLoc(TC->getNestedNameSpecifierLoc());
1654 Record.AddDeclarationNameInfo(TC->getConceptNameInfo());
1655 Record.AddDeclRef(TC->getNamedConcept());
1656 Record.push_back(TC->getTemplateArgsAsWritten() != nullptr);
1657 if (TC->getTemplateArgsAsWritten())
1658 Record.AddASTTemplateArgumentListInfo(TC->getTemplateArgsAsWritten());
1659 Record.AddStmt(TC->getImmediatelyDeclaredConstraint());
1660 Record.push_back(D->isExpandedParameterPack());
1661 if (D->isExpandedParameterPack())
1662 Record.push_back(D->getNumExpansionParameters());
1663 }
1664
Richard Smith8346e522015-06-10 01:47:58 +00001665 bool OwnsDefaultArg = D->hasDefaultArgument() &&
1666 !D->defaultArgumentWasInherited();
1667 Record.push_back(OwnsDefaultArg);
1668 if (OwnsDefaultArg)
Richard Smith69c82bf2016-04-01 22:52:03 +00001669 Record.AddTypeSourceInfo(D->getDefaultArgumentInfo());
Argyrios Kyrtzidis106caf922010-06-19 19:28:53 +00001670
Sebastian Redl539c5062010-08-18 23:57:32 +00001671 Code = serialization::DECL_TEMPLATE_TYPE_PARM;
Chris Lattnerca025db2010-05-07 21:43:38 +00001672}
1673
Sebastian Redl42a0f6a2010-08-18 23:56:27 +00001674void ASTDeclWriter::VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D) {
Douglas Gregor0231d8d2011-01-19 20:10:05 +00001675 // For an expanded parameter pack, record the number of expansion types here
Richard Smith1fde8ec2012-09-07 02:06:42 +00001676 // so that it's easier for deserialization to allocate the right amount of
1677 // memory.
Saar Razb481f022020-01-22 02:03:05 +02001678 Expr *TypeConstraint = D->getPlaceholderTypeConstraint();
1679 Record.push_back(!!TypeConstraint);
Douglas Gregor0231d8d2011-01-19 20:10:05 +00001680 if (D->isExpandedParameterPack())
1681 Record.push_back(D->getNumExpansionTypes());
Fangrui Song6907ce22018-07-30 19:24:48 +00001682
John McCallf4cd4f92011-02-09 01:13:10 +00001683 VisitDeclaratorDecl(D);
Argyrios Kyrtzidisb1d38e32010-06-25 16:25:09 +00001684 // TemplateParmPosition.
1685 Record.push_back(D->getDepth());
1686 Record.push_back(D->getPosition());
Saar Razb481f022020-01-22 02:03:05 +02001687 if (TypeConstraint)
1688 Record.AddStmt(TypeConstraint);
Fangrui Song6907ce22018-07-30 19:24:48 +00001689
Douglas Gregor0231d8d2011-01-19 20:10:05 +00001690 if (D->isExpandedParameterPack()) {
1691 for (unsigned I = 0, N = D->getNumExpansionTypes(); I != N; ++I) {
Richard Smith69c82bf2016-04-01 22:52:03 +00001692 Record.AddTypeRef(D->getExpansionType(I));
1693 Record.AddTypeSourceInfo(D->getExpansionTypeSourceInfo(I));
Douglas Gregor0231d8d2011-01-19 20:10:05 +00001694 }
Fangrui Song6907ce22018-07-30 19:24:48 +00001695
Douglas Gregor0231d8d2011-01-19 20:10:05 +00001696 Code = serialization::DECL_EXPANDED_NON_TYPE_TEMPLATE_PARM_PACK;
1697 } else {
1698 // Rest of NonTypeTemplateParmDecl.
1699 Record.push_back(D->isParameterPack());
Richard Smith8346e522015-06-10 01:47:58 +00001700 bool OwnsDefaultArg = D->hasDefaultArgument() &&
1701 !D->defaultArgumentWasInherited();
1702 Record.push_back(OwnsDefaultArg);
1703 if (OwnsDefaultArg)
Richard Smith290d8012016-04-06 17:06:00 +00001704 Record.AddStmt(D->getDefaultArgument());
Douglas Gregor0231d8d2011-01-19 20:10:05 +00001705 Code = serialization::DECL_NON_TYPE_TEMPLATE_PARM;
Argyrios Kyrtzidisb1d38e32010-06-25 16:25:09 +00001706 }
Chris Lattnerca025db2010-05-07 21:43:38 +00001707}
1708
Sebastian Redl42a0f6a2010-08-18 23:56:27 +00001709void ASTDeclWriter::VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D) {
Richard Smith1fde8ec2012-09-07 02:06:42 +00001710 // For an expanded parameter pack, record the number of expansion types here
1711 // so that it's easier for deserialization to allocate the right amount of
1712 // memory.
1713 if (D->isExpandedParameterPack())
1714 Record.push_back(D->getNumExpansionTemplateParameters());
1715
Argyrios Kyrtzidis9f2d24a2010-07-08 17:12:57 +00001716 VisitTemplateDecl(D);
1717 // TemplateParmPosition.
1718 Record.push_back(D->getDepth());
1719 Record.push_back(D->getPosition());
Richard Smith1fde8ec2012-09-07 02:06:42 +00001720
1721 if (D->isExpandedParameterPack()) {
1722 for (unsigned I = 0, N = D->getNumExpansionTemplateParameters();
1723 I != N; ++I)
Richard Smith69c82bf2016-04-01 22:52:03 +00001724 Record.AddTemplateParameterList(D->getExpansionTemplateParameters(I));
Richard Smith1fde8ec2012-09-07 02:06:42 +00001725 Code = serialization::DECL_EXPANDED_TEMPLATE_TEMPLATE_PARM_PACK;
1726 } else {
1727 // Rest of TemplateTemplateParmDecl.
Richard Smith1fde8ec2012-09-07 02:06:42 +00001728 Record.push_back(D->isParameterPack());
Richard Smith8346e522015-06-10 01:47:58 +00001729 bool OwnsDefaultArg = D->hasDefaultArgument() &&
1730 !D->defaultArgumentWasInherited();
1731 Record.push_back(OwnsDefaultArg);
1732 if (OwnsDefaultArg)
Richard Smith69c82bf2016-04-01 22:52:03 +00001733 Record.AddTemplateArgumentLoc(D->getDefaultArgument());
Richard Smith1fde8ec2012-09-07 02:06:42 +00001734 Code = serialization::DECL_TEMPLATE_TEMPLATE_PARM;
1735 }
Chris Lattnerca025db2010-05-07 21:43:38 +00001736}
1737
Richard Smith3f1b5d02011-05-05 21:57:07 +00001738void ASTDeclWriter::VisitTypeAliasTemplateDecl(TypeAliasTemplateDecl *D) {
1739 VisitRedeclarableTemplateDecl(D);
1740 Code = serialization::DECL_TYPE_ALIAS_TEMPLATE;
1741}
1742
Sebastian Redl42a0f6a2010-08-18 23:56:27 +00001743void ASTDeclWriter::VisitStaticAssertDecl(StaticAssertDecl *D) {
Argyrios Kyrtzidis2d8891c2010-07-22 17:28:12 +00001744 VisitDecl(D);
Richard Smith290d8012016-04-06 17:06:00 +00001745 Record.AddStmt(D->getAssertExpr());
Richard Smithded9c2e2012-07-11 22:37:56 +00001746 Record.push_back(D->isFailed());
Richard Smith290d8012016-04-06 17:06:00 +00001747 Record.AddStmt(D->getMessage());
Richard Smith69c82bf2016-04-01 22:52:03 +00001748 Record.AddSourceLocation(D->getRParenLoc());
Sebastian Redl539c5062010-08-18 23:57:32 +00001749 Code = serialization::DECL_STATIC_ASSERT;
Chris Lattnerca025db2010-05-07 21:43:38 +00001750}
1751
Adrian Prantl9fc8faf2018-05-09 01:00:01 +00001752/// Emit the DeclContext part of a declaration context decl.
Richard Smithf1c23dc2016-04-13 02:12:03 +00001753void ASTDeclWriter::VisitDeclContext(DeclContext *DC) {
1754 Record.AddOffset(Writer.WriteDeclContextLexicalBlock(Context, DC));
1755 Record.AddOffset(Writer.WriteDeclContextVisibleBlock(Context, DC));
Chris Lattner7099dbc2009-04-27 06:16:06 +00001756}
1757
Richard Smithd8a83712015-08-22 01:47:18 +00001758const Decl *ASTWriter::getFirstLocalDecl(const Decl *D) {
Richard Smith3864be72015-09-11 02:22:03 +00001759 assert(IsLocalDecl(D) && "expected a local declaration");
Richard Smithd8a83712015-08-22 01:47:18 +00001760
1761 const Decl *Canon = D->getCanonicalDecl();
Richard Smith3864be72015-09-11 02:22:03 +00001762 if (IsLocalDecl(Canon))
Richard Smithd8a83712015-08-22 01:47:18 +00001763 return Canon;
1764
1765 const Decl *&CacheEntry = FirstLocalDeclCache[Canon];
1766 if (CacheEntry)
1767 return CacheEntry;
1768
1769 for (const Decl *Redecl = D; Redecl; Redecl = Redecl->getPreviousDecl())
Richard Smith3864be72015-09-11 02:22:03 +00001770 if (IsLocalDecl(Redecl))
Richard Smithd8a83712015-08-22 01:47:18 +00001771 D = Redecl;
1772 return CacheEntry = D;
Richard Smith5fc18a92015-07-12 23:43:21 +00001773}
1774
Argyrios Kyrtzidis839bbac2010-08-03 17:30:10 +00001775template <typename T>
Sebastian Redl42a0f6a2010-08-18 23:56:27 +00001776void ASTDeclWriter::VisitRedeclarable(Redeclarable<T> *D) {
Rafael Espindola8db352d2013-10-17 15:37:26 +00001777 T *First = D->getFirstDecl();
Richard Smith5a4737c2015-02-06 02:42:59 +00001778 T *MostRecent = First->getMostRecentDecl();
Richard Smithd8a83712015-08-22 01:47:18 +00001779 T *DAsT = static_cast<T *>(D);
Richard Smith5a4737c2015-02-06 02:42:59 +00001780 if (MostRecent != First) {
Richard Smithd8a83712015-08-22 01:47:18 +00001781 assert(isRedeclarableDeclKind(DAsT->getKind()) &&
Douglas Gregorfe732d52013-01-21 16:16:40 +00001782 "Not considered redeclarable?");
Richard Smith5a4737c2015-02-06 02:42:59 +00001783
Richard Smith69c82bf2016-04-01 22:52:03 +00001784 Record.AddDeclRef(First);
Richard Smithfe620d22015-03-05 23:24:12 +00001785
Richard Smithd8a83712015-08-22 01:47:18 +00001786 // Write out a list of local redeclarations of this declaration if it's the
1787 // first local declaration in the chain.
1788 const Decl *FirstLocal = Writer.getFirstLocalDecl(DAsT);
1789 if (DAsT == FirstLocal) {
Richard Smithd8a83712015-08-22 01:47:18 +00001790 // Emit a list of all imported first declarations so that we can be sure
1791 // that all redeclarations visible to this module are before D in the
1792 // redecl chain.
1793 unsigned I = Record.size();
1794 Record.push_back(0);
1795 if (Writer.Chain)
1796 AddFirstDeclFromEachModule(DAsT, /*IncludeLocal*/false);
1797 // This is the number of imported first declarations + 1.
1798 Record[I] = Record.size() - I;
Richard Smithd61d4ac2015-08-22 20:13:39 +00001799
1800 // Collect the set of local redeclarations of this declaration, from
1801 // newest to oldest.
Richard Smith69c82bf2016-04-01 22:52:03 +00001802 ASTWriter::RecordData LocalRedecls;
1803 ASTRecordWriter LocalRedeclWriter(Record, LocalRedecls);
Richard Smithd61d4ac2015-08-22 20:13:39 +00001804 for (const Decl *Prev = FirstLocal->getMostRecentDecl();
1805 Prev != FirstLocal; Prev = Prev->getPreviousDecl())
1806 if (!Prev->isFromASTFile())
Richard Smith69c82bf2016-04-01 22:52:03 +00001807 LocalRedeclWriter.AddDeclRef(Prev);
Richard Smithd61d4ac2015-08-22 20:13:39 +00001808
1809 // If we have any redecls, write them now as a separate record preceding
1810 // the declaration itself.
1811 if (LocalRedecls.empty())
1812 Record.push_back(0);
Richard Smithf1c23dc2016-04-13 02:12:03 +00001813 else
1814 Record.AddOffset(LocalRedeclWriter.Emit(LOCAL_REDECLARATIONS));
Richard Smithd8a83712015-08-22 01:47:18 +00001815 } else {
1816 Record.push_back(0);
Richard Smith69c82bf2016-04-01 22:52:03 +00001817 Record.AddDeclRef(FirstLocal);
Richard Smithfe620d22015-03-05 23:24:12 +00001818 }
Douglas Gregor358cd442012-01-15 16:58:34 +00001819
Fangrui Song6907ce22018-07-30 19:24:48 +00001820 // Make sure that we serialize both the previous and the most-recent
Douglas Gregor358cd442012-01-15 16:58:34 +00001821 // declarations, which (transitively) ensures that all declarations in the
1822 // chain get serialized.
Richard Smith5a4737c2015-02-06 02:42:59 +00001823 //
1824 // FIXME: This is not correct; when we reach an imported declaration we
1825 // won't emit its previous declaration.
Richard Smith5fc18a92015-07-12 23:43:21 +00001826 (void)Writer.GetDeclRef(D->getPreviousDecl());
Richard Smith5a4737c2015-02-06 02:42:59 +00001827 (void)Writer.GetDeclRef(MostRecent);
Douglas Gregor358cd442012-01-15 16:58:34 +00001828 } else {
1829 // We use the sentinel value 0 to indicate an only declaration.
1830 Record.push_back(0);
Douglas Gregor9f562c82011-12-19 15:27:36 +00001831 }
Argyrios Kyrtzidis839bbac2010-08-03 17:30:10 +00001832}
Chris Lattner7099dbc2009-04-27 06:16:06 +00001833
Alexey Bataeva769e072013-03-22 06:34:35 +00001834void ASTDeclWriter::VisitOMPThreadPrivateDecl(OMPThreadPrivateDecl *D) {
1835 Record.push_back(D->varlist_size());
1836 VisitDecl(D);
Aaron Ballman2205d2a2014-03-14 15:55:35 +00001837 for (auto *I : D->varlists())
Richard Smith290d8012016-04-06 17:06:00 +00001838 Record.AddStmt(I);
Alexey Bataeva769e072013-03-22 06:34:35 +00001839 Code = serialization::DECL_OMP_THREADPRIVATE;
1840}
1841
Alexey Bataev25ed0c02019-03-07 17:54:44 +00001842void ASTDeclWriter::VisitOMPAllocateDecl(OMPAllocateDecl *D) {
1843 Record.push_back(D->varlist_size());
Alexey Bataev9cc10fc2019-03-12 18:52:33 +00001844 Record.push_back(D->clauselist_size());
Alexey Bataev25ed0c02019-03-07 17:54:44 +00001845 VisitDecl(D);
1846 for (auto *I : D->varlists())
1847 Record.AddStmt(I);
Alexey Bataev9cc10fc2019-03-12 18:52:33 +00001848 for (OMPClause *C : D->clauselists())
John McCall2ac702a2019-12-14 03:17:03 -05001849 Record.writeOMPClause(C);
Alexey Bataev25ed0c02019-03-07 17:54:44 +00001850 Code = serialization::DECL_OMP_ALLOCATE;
1851}
1852
Kelvin Li1408f912018-09-26 04:28:39 +00001853void ASTDeclWriter::VisitOMPRequiresDecl(OMPRequiresDecl *D) {
1854 Record.push_back(D->clauselist_size());
1855 VisitDecl(D);
Kelvin Li1408f912018-09-26 04:28:39 +00001856 for (OMPClause *C : D->clauselists())
John McCall2ac702a2019-12-14 03:17:03 -05001857 Record.writeOMPClause(C);
Kelvin Li1408f912018-09-26 04:28:39 +00001858 Code = serialization::DECL_OMP_REQUIRES;
1859}
1860
Alexey Bataev94a4f0c2016-03-03 05:21:39 +00001861void ASTDeclWriter::VisitOMPDeclareReductionDecl(OMPDeclareReductionDecl *D) {
Alexey Bataevc5b1d322016-03-04 09:22:22 +00001862 VisitValueDecl(D);
Stephen Kellyf2ceec42018-08-09 21:08:08 +00001863 Record.AddSourceLocation(D->getBeginLoc());
Alexey Bataeve6aa4692018-09-13 16:54:05 +00001864 Record.AddStmt(D->getCombinerIn());
1865 Record.AddStmt(D->getCombinerOut());
Richard Smith290d8012016-04-06 17:06:00 +00001866 Record.AddStmt(D->getCombiner());
Alexey Bataeve6aa4692018-09-13 16:54:05 +00001867 Record.AddStmt(D->getInitOrig());
1868 Record.AddStmt(D->getInitPriv());
Richard Smith290d8012016-04-06 17:06:00 +00001869 Record.AddStmt(D->getInitializer());
Alexey Bataev070f43a2017-09-06 14:49:58 +00001870 Record.push_back(D->getInitializerKind());
Richard Smith69c82bf2016-04-01 22:52:03 +00001871 Record.AddDeclRef(D->getPrevDeclInScope());
Alexey Bataev94a4f0c2016-03-03 05:21:39 +00001872 Code = serialization::DECL_OMP_DECLARE_REDUCTION;
1873}
1874
Michael Kruse251e1482019-02-01 20:25:04 +00001875void ASTDeclWriter::VisitOMPDeclareMapperDecl(OMPDeclareMapperDecl *D) {
1876 Record.push_back(D->clauselist_size());
1877 VisitValueDecl(D);
1878 Record.AddSourceLocation(D->getBeginLoc());
1879 Record.AddStmt(D->getMapperVarRef());
1880 Record.AddDeclarationName(D->getVarName());
1881 Record.AddDeclRef(D->getPrevDeclInScope());
Michael Kruse251e1482019-02-01 20:25:04 +00001882 for (OMPClause *C : D->clauselists())
John McCall2ac702a2019-12-14 03:17:03 -05001883 Record.writeOMPClause(C);
Michael Kruse251e1482019-02-01 20:25:04 +00001884 Code = serialization::DECL_OMP_DECLARE_MAPPER;
1885}
1886
Alexey Bataev4244be22016-02-11 05:35:55 +00001887void ASTDeclWriter::VisitOMPCapturedExprDecl(OMPCapturedExprDecl *D) {
Alexey Bataev90c228f2016-02-08 09:29:13 +00001888 VisitVarDecl(D);
Alexey Bataev4244be22016-02-11 05:35:55 +00001889 Code = serialization::DECL_OMP_CAPTUREDEXPR;
Alexey Bataev90c228f2016-02-08 09:29:13 +00001890}
1891
Chris Lattner7099dbc2009-04-27 06:16:06 +00001892//===----------------------------------------------------------------------===//
Sebastian Redl55c0ad52010-08-18 23:56:21 +00001893// ASTWriter Implementation
Chris Lattner7099dbc2009-04-27 06:16:06 +00001894//===----------------------------------------------------------------------===//
1895
Richard Smith01b2cb42014-07-26 06:37:51 +00001896void ASTWriter::WriteDeclAbbrevs() {
Chris Lattner258172e2009-04-27 07:35:58 +00001897 using namespace llvm;
Chris Lattner258172e2009-04-27 07:35:58 +00001898
David Blaikieb44f0bf2017-01-04 22:36:43 +00001899 std::shared_ptr<BitCodeAbbrev> Abv;
Douglas Gregor03412ba2011-06-03 02:27:19 +00001900
Jonathan D. Turner205c7d52011-06-03 23:11:16 +00001901 // Abbreviation for DECL_FIELD
David Blaikieb44f0bf2017-01-04 22:36:43 +00001902 Abv = std::make_shared<BitCodeAbbrev>();
Jonathan D. Turner205c7d52011-06-03 23:11:16 +00001903 Abv->Add(BitCodeAbbrevOp(serialization::DECL_FIELD));
1904 // Decl
1905 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclContext
Richard Smith8aed4222015-12-11 22:41:00 +00001906 Abv->Add(BitCodeAbbrevOp(0)); // LexicalDeclContext
Argyrios Kyrtzidisb7d1ca22012-03-09 21:09:04 +00001907 Abv->Add(BitCodeAbbrevOp(0)); // isInvalidDecl
Jonathan D. Turner205c7d52011-06-03 23:11:16 +00001908 Abv->Add(BitCodeAbbrevOp(0)); // HasAttrs
1909 Abv->Add(BitCodeAbbrevOp(0)); // isImplicit
1910 Abv->Add(BitCodeAbbrevOp(0)); // isUsed
1911 Abv->Add(BitCodeAbbrevOp(0)); // isReferenced
Argyrios Kyrtzidis8ad3bab2011-11-23 20:27:36 +00001912 Abv->Add(BitCodeAbbrevOp(0)); // TopLevelDeclInObjCContainer
Jonathan D. Turner205c7d52011-06-03 23:11:16 +00001913 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2)); // AccessSpecifier
Douglas Gregor26701a42011-09-09 02:06:17 +00001914 Abv->Add(BitCodeAbbrevOp(0)); // ModulePrivate
Douglas Gregora28bcdd2011-12-01 02:07:58 +00001915 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SubmoduleID
Jonathan D. Turner205c7d52011-06-03 23:11:16 +00001916 // NamedDecl
1917 Abv->Add(BitCodeAbbrevOp(0)); // NameKind = Identifier
1918 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Name
Richard Smith2b560572015-02-07 03:11:11 +00001919 Abv->Add(BitCodeAbbrevOp(0)); // AnonDeclNumber
Jonathan D. Turner205c7d52011-06-03 23:11:16 +00001920 // ValueDecl
1921 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type
1922 // DeclaratorDecl
1923 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // InnerStartLoc
1924 Abv->Add(BitCodeAbbrevOp(0)); // hasExtInfo
Richard Smithc23d7342018-06-29 20:46:25 +00001925 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // TSIType
Jonathan D. Turner205c7d52011-06-03 23:11:16 +00001926 // FieldDecl
1927 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isMutable
Richard Smith6b8e3c02017-08-28 00:28:14 +00001928 Abv->Add(BitCodeAbbrevOp(0)); // InitStyle
Jonathan D. Turner205c7d52011-06-03 23:11:16 +00001929 // Type Source Info
Jonathan D. Turner205c7d52011-06-03 23:11:16 +00001930 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
1931 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // TypeLoc
David Blaikieb44f0bf2017-01-04 22:36:43 +00001932 DeclFieldAbbrev = Stream.EmitAbbrev(std::move(Abv));
Jonathan D. Turner205c7d52011-06-03 23:11:16 +00001933
1934 // Abbreviation for DECL_OBJC_IVAR
David Blaikieb44f0bf2017-01-04 22:36:43 +00001935 Abv = std::make_shared<BitCodeAbbrev>();
Jonathan D. Turner205c7d52011-06-03 23:11:16 +00001936 Abv->Add(BitCodeAbbrevOp(serialization::DECL_OBJC_IVAR));
1937 // Decl
1938 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclContext
Richard Smith8aed4222015-12-11 22:41:00 +00001939 Abv->Add(BitCodeAbbrevOp(0)); // LexicalDeclContext
Argyrios Kyrtzidisb7d1ca22012-03-09 21:09:04 +00001940 Abv->Add(BitCodeAbbrevOp(0)); // isInvalidDecl
Jonathan D. Turner205c7d52011-06-03 23:11:16 +00001941 Abv->Add(BitCodeAbbrevOp(0)); // HasAttrs
1942 Abv->Add(BitCodeAbbrevOp(0)); // isImplicit
1943 Abv->Add(BitCodeAbbrevOp(0)); // isUsed
1944 Abv->Add(BitCodeAbbrevOp(0)); // isReferenced
Argyrios Kyrtzidis8ad3bab2011-11-23 20:27:36 +00001945 Abv->Add(BitCodeAbbrevOp(0)); // TopLevelDeclInObjCContainer
Jonathan D. Turner205c7d52011-06-03 23:11:16 +00001946 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2)); // AccessSpecifier
Douglas Gregor26701a42011-09-09 02:06:17 +00001947 Abv->Add(BitCodeAbbrevOp(0)); // ModulePrivate
Douglas Gregora28bcdd2011-12-01 02:07:58 +00001948 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SubmoduleID
Jonathan D. Turner205c7d52011-06-03 23:11:16 +00001949 // NamedDecl
1950 Abv->Add(BitCodeAbbrevOp(0)); // NameKind = Identifier
1951 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Name
Richard Smith2b560572015-02-07 03:11:11 +00001952 Abv->Add(BitCodeAbbrevOp(0)); // AnonDeclNumber
Jonathan D. Turner205c7d52011-06-03 23:11:16 +00001953 // ValueDecl
1954 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type
1955 // DeclaratorDecl
1956 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // InnerStartLoc
1957 Abv->Add(BitCodeAbbrevOp(0)); // hasExtInfo
Richard Smithc23d7342018-06-29 20:46:25 +00001958 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // TSIType
Jonathan D. Turner205c7d52011-06-03 23:11:16 +00001959 // FieldDecl
1960 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isMutable
Richard Smith6b8e3c02017-08-28 00:28:14 +00001961 Abv->Add(BitCodeAbbrevOp(0)); // InitStyle
Jonathan D. Turner205c7d52011-06-03 23:11:16 +00001962 // ObjC Ivar
1963 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // getAccessControl
1964 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // getSynthesize
1965 // Type Source Info
Jonathan D. Turner205c7d52011-06-03 23:11:16 +00001966 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
1967 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // TypeLoc
David Blaikieb44f0bf2017-01-04 22:36:43 +00001968 DeclObjCIvarAbbrev = Stream.EmitAbbrev(std::move(Abv));
Jonathan D. Turner205c7d52011-06-03 23:11:16 +00001969
1970 // Abbreviation for DECL_ENUM
David Blaikieb44f0bf2017-01-04 22:36:43 +00001971 Abv = std::make_shared<BitCodeAbbrev>();
Jonathan D. Turner205c7d52011-06-03 23:11:16 +00001972 Abv->Add(BitCodeAbbrevOp(serialization::DECL_ENUM));
Douglas Gregor3e300102011-10-26 17:53:41 +00001973 // Redeclarable
Douglas Gregor9f562c82011-12-19 15:27:36 +00001974 Abv->Add(BitCodeAbbrevOp(0)); // No redeclaration
Chris Lattner258172e2009-04-27 07:35:58 +00001975 // Decl
1976 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclContext
Richard Smith8aed4222015-12-11 22:41:00 +00001977 Abv->Add(BitCodeAbbrevOp(0)); // LexicalDeclContext
Argyrios Kyrtzidisb7d1ca22012-03-09 21:09:04 +00001978 Abv->Add(BitCodeAbbrevOp(0)); // isInvalidDecl
Chris Lattner258172e2009-04-27 07:35:58 +00001979 Abv->Add(BitCodeAbbrevOp(0)); // HasAttrs
1980 Abv->Add(BitCodeAbbrevOp(0)); // isImplicit
Douglas Gregorc9c02ed2009-06-19 23:52:42 +00001981 Abv->Add(BitCodeAbbrevOp(0)); // isUsed
Argyrios Kyrtzidis16180232011-04-19 19:51:10 +00001982 Abv->Add(BitCodeAbbrevOp(0)); // isReferenced
Argyrios Kyrtzidis8ad3bab2011-11-23 20:27:36 +00001983 Abv->Add(BitCodeAbbrevOp(0)); // TopLevelDeclInObjCContainer
Chris Lattner258172e2009-04-27 07:35:58 +00001984 Abv->Add(BitCodeAbbrevOp(AS_none)); // C++ AccessSpecifier
Douglas Gregor26701a42011-09-09 02:06:17 +00001985 Abv->Add(BitCodeAbbrevOp(0)); // ModulePrivate
Douglas Gregora28bcdd2011-12-01 02:07:58 +00001986 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SubmoduleID
Douglas Gregor03412ba2011-06-03 02:27:19 +00001987 // NamedDecl
1988 Abv->Add(BitCodeAbbrevOp(0)); // NameKind = Identifier
1989 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Name
Richard Smith2b560572015-02-07 03:11:11 +00001990 Abv->Add(BitCodeAbbrevOp(0)); // AnonDeclNumber
Jonathan D. Turner205c7d52011-06-03 23:11:16 +00001991 // TypeDecl
1992 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Source Location
1993 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type Ref
Jonathan D. Turner205c7d52011-06-03 23:11:16 +00001994 // TagDecl
1995 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // IdentifierNamespace
1996 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // getTagKind
John McCallf937c022011-10-07 06:10:15 +00001997 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isCompleteDefinition
Jonathan D. Turner205c7d52011-06-03 23:11:16 +00001998 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // EmbeddedInDeclarator
Argyrios Kyrtzidis201d3772011-09-30 22:11:31 +00001999 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsFreeStanding
David Blaikiea8d23ce2013-07-14 01:07:41 +00002000 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsCompleteDefinitionRequired
Jonathan D. Turner205c7d52011-06-03 23:11:16 +00002001 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SourceLocation
Argyrios Kyrtzidisd798c052016-07-15 18:11:33 +00002002 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SourceLocation
Richard Smith70d58502014-08-30 00:04:23 +00002003 Abv->Add(BitCodeAbbrevOp(0)); // ExtInfoKind
Jonathan D. Turner205c7d52011-06-03 23:11:16 +00002004 // EnumDecl
2005 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // AddTypeRef
2006 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // IntegerType
2007 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // getPromotionType
2008 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // getNumPositiveBits
2009 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // getNumNegativeBits
2010 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isScoped
2011 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isScopedUsingClassTag
2012 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isFixed
Richard Trieuab4d7302018-07-25 22:52:05 +00002013 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));// ODRHash
Jonathan D. Turner205c7d52011-06-03 23:11:16 +00002014 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // InstantiatedMembEnum
2015 // DC
2016 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // LexicalOffset
2017 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // VisibleOffset
David Blaikieb44f0bf2017-01-04 22:36:43 +00002018 DeclEnumAbbrev = Stream.EmitAbbrev(std::move(Abv));
Mike Stump11289f42009-09-09 15:08:12 +00002019
Douglas Gregor03412ba2011-06-03 02:27:19 +00002020 // Abbreviation for DECL_RECORD
David Blaikieb44f0bf2017-01-04 22:36:43 +00002021 Abv = std::make_shared<BitCodeAbbrev>();
Douglas Gregor03412ba2011-06-03 02:27:19 +00002022 Abv->Add(BitCodeAbbrevOp(serialization::DECL_RECORD));
Douglas Gregor3e300102011-10-26 17:53:41 +00002023 // Redeclarable
Douglas Gregor9f562c82011-12-19 15:27:36 +00002024 Abv->Add(BitCodeAbbrevOp(0)); // No redeclaration
Douglas Gregor03412ba2011-06-03 02:27:19 +00002025 // Decl
2026 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclContext
Richard Smith8aed4222015-12-11 22:41:00 +00002027 Abv->Add(BitCodeAbbrevOp(0)); // LexicalDeclContext
Argyrios Kyrtzidisb7d1ca22012-03-09 21:09:04 +00002028 Abv->Add(BitCodeAbbrevOp(0)); // isInvalidDecl
Douglas Gregor03412ba2011-06-03 02:27:19 +00002029 Abv->Add(BitCodeAbbrevOp(0)); // HasAttrs
2030 Abv->Add(BitCodeAbbrevOp(0)); // isImplicit
2031 Abv->Add(BitCodeAbbrevOp(0)); // isUsed
2032 Abv->Add(BitCodeAbbrevOp(0)); // isReferenced
Argyrios Kyrtzidis8ad3bab2011-11-23 20:27:36 +00002033 Abv->Add(BitCodeAbbrevOp(0)); // TopLevelDeclInObjCContainer
Douglas Gregor03412ba2011-06-03 02:27:19 +00002034 Abv->Add(BitCodeAbbrevOp(AS_none)); // C++ AccessSpecifier
Douglas Gregor26701a42011-09-09 02:06:17 +00002035 Abv->Add(BitCodeAbbrevOp(0)); // ModulePrivate
Douglas Gregora28bcdd2011-12-01 02:07:58 +00002036 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SubmoduleID
Douglas Gregor03412ba2011-06-03 02:27:19 +00002037 // NamedDecl
2038 Abv->Add(BitCodeAbbrevOp(0)); // NameKind = Identifier
2039 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Name
Richard Smith2b560572015-02-07 03:11:11 +00002040 Abv->Add(BitCodeAbbrevOp(0)); // AnonDeclNumber
Douglas Gregor03412ba2011-06-03 02:27:19 +00002041 // TypeDecl
2042 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Source Location
2043 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type Ref
Douglas Gregor03412ba2011-06-03 02:27:19 +00002044 // TagDecl
2045 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // IdentifierNamespace
2046 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // getTagKind
John McCallf937c022011-10-07 06:10:15 +00002047 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isCompleteDefinition
Douglas Gregor03412ba2011-06-03 02:27:19 +00002048 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // EmbeddedInDeclarator
Argyrios Kyrtzidis201d3772011-09-30 22:11:31 +00002049 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsFreeStanding
David Blaikiea8d23ce2013-07-14 01:07:41 +00002050 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsCompleteDefinitionRequired
Douglas Gregor03412ba2011-06-03 02:27:19 +00002051 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SourceLocation
Argyrios Kyrtzidisd798c052016-07-15 18:11:33 +00002052 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SourceLocation
Richard Smith70d58502014-08-30 00:04:23 +00002053 Abv->Add(BitCodeAbbrevOp(0)); // ExtInfoKind
Douglas Gregor03412ba2011-06-03 02:27:19 +00002054 // RecordDecl
2055 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // FlexibleArrayMember
2056 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // AnonymousStructUnion
2057 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // hasObjectMember
Fariborz Jahanian78652202013-01-25 23:57:05 +00002058 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // hasVolatileMember
Akira Hatanaka34fb2642018-03-13 18:58:25 +00002059
2060 // isNonTrivialToPrimitiveDefaultInitialize
2061 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
2062 // isNonTrivialToPrimitiveCopy
2063 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
2064 // isNonTrivialToPrimitiveDestroy
2065 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
Akira Hatanaka09051062019-09-07 00:34:43 +00002066 // hasNonTrivialToPrimitiveDefaultInitializeCUnion
2067 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
2068 // hasNonTrivialToPrimitiveDestructCUnion
2069 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
2070 // hasNonTrivialToPrimitiveCopyCUnion
2071 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
Akira Hatanakafcbe17c2018-03-28 21:13:14 +00002072 // isParamDestroyedInCallee
2073 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
Akira Hatanakae6313ac2018-04-09 22:48:22 +00002074 // getArgPassingRestrictions
2075 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2));
Akira Hatanaka34fb2642018-03-13 18:58:25 +00002076
Douglas Gregor03412ba2011-06-03 02:27:19 +00002077 // DC
2078 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // LexicalOffset
2079 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // VisibleOffset
David Blaikieb44f0bf2017-01-04 22:36:43 +00002080 DeclRecordAbbrev = Stream.EmitAbbrev(std::move(Abv));
Douglas Gregor03412ba2011-06-03 02:27:19 +00002081
2082 // Abbreviation for DECL_PARM_VAR
David Blaikieb44f0bf2017-01-04 22:36:43 +00002083 Abv = std::make_shared<BitCodeAbbrev>();
Douglas Gregor03412ba2011-06-03 02:27:19 +00002084 Abv->Add(BitCodeAbbrevOp(serialization::DECL_PARM_VAR));
Douglas Gregor3e300102011-10-26 17:53:41 +00002085 // Redeclarable
Douglas Gregor9f562c82011-12-19 15:27:36 +00002086 Abv->Add(BitCodeAbbrevOp(0)); // No redeclaration
Douglas Gregor03412ba2011-06-03 02:27:19 +00002087 // Decl
2088 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclContext
Richard Smith8aed4222015-12-11 22:41:00 +00002089 Abv->Add(BitCodeAbbrevOp(0)); // LexicalDeclContext
Argyrios Kyrtzidisb7d1ca22012-03-09 21:09:04 +00002090 Abv->Add(BitCodeAbbrevOp(0)); // isInvalidDecl
Douglas Gregor03412ba2011-06-03 02:27:19 +00002091 Abv->Add(BitCodeAbbrevOp(0)); // HasAttrs
2092 Abv->Add(BitCodeAbbrevOp(0)); // isImplicit
2093 Abv->Add(BitCodeAbbrevOp(0)); // isUsed
2094 Abv->Add(BitCodeAbbrevOp(0)); // isReferenced
Argyrios Kyrtzidis8ad3bab2011-11-23 20:27:36 +00002095 Abv->Add(BitCodeAbbrevOp(0)); // TopLevelDeclInObjCContainer
Douglas Gregor03412ba2011-06-03 02:27:19 +00002096 Abv->Add(BitCodeAbbrevOp(AS_none)); // C++ AccessSpecifier
Douglas Gregor26701a42011-09-09 02:06:17 +00002097 Abv->Add(BitCodeAbbrevOp(0)); // ModulePrivate
Douglas Gregora28bcdd2011-12-01 02:07:58 +00002098 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SubmoduleID
Chris Lattner258172e2009-04-27 07:35:58 +00002099 // NamedDecl
2100 Abv->Add(BitCodeAbbrevOp(0)); // NameKind = Identifier
2101 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Name
Richard Smith2b560572015-02-07 03:11:11 +00002102 Abv->Add(BitCodeAbbrevOp(0)); // AnonDeclNumber
Chris Lattner258172e2009-04-27 07:35:58 +00002103 // ValueDecl
2104 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type
Argyrios Kyrtzidis560ac972009-08-19 01:28:35 +00002105 // DeclaratorDecl
Abramo Bagnaradff19302011-03-08 08:55:46 +00002106 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // InnerStartLoc
Argyrios Kyrtzidis434383d2010-10-15 18:21:24 +00002107 Abv->Add(BitCodeAbbrevOp(0)); // hasExtInfo
Richard Smithc23d7342018-06-29 20:46:25 +00002108 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // TSIType
Chris Lattner258172e2009-04-27 07:35:58 +00002109 // VarDecl
Vassil Vassilevd1a88132016-10-06 13:04:54 +00002110 Abv->Add(BitCodeAbbrevOp(0)); // SClass
2111 Abv->Add(BitCodeAbbrevOp(0)); // TSCSpec
2112 Abv->Add(BitCodeAbbrevOp(0)); // InitStyle
Erik Pilkington1e368822019-01-04 18:33:06 +00002113 Abv->Add(BitCodeAbbrevOp(0)); // ARCPseudoStrong
Richard Smith88581592013-02-12 05:48:23 +00002114 Abv->Add(BitCodeAbbrevOp(0)); // Linkage
Chris Lattner258172e2009-04-27 07:35:58 +00002115 Abv->Add(BitCodeAbbrevOp(0)); // HasInit
Argyrios Kyrtzidiscdb8b3f2010-07-04 21:44:00 +00002116 Abv->Add(BitCodeAbbrevOp(0)); // HasMemberSpecializationInfo
Chris Lattner258172e2009-04-27 07:35:58 +00002117 // ParmVarDecl
John McCall82490832011-05-02 00:30:12 +00002118 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsObjCMethodParameter
John McCall8fb0d9d2011-05-01 22:35:37 +00002119 Abv->Add(BitCodeAbbrevOp(0)); // ScopeDepth
2120 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // ScopeIndex
Chris Lattner258172e2009-04-27 07:35:58 +00002121 Abv->Add(BitCodeAbbrevOp(0)); // ObjCDeclQualifier
John McCall6a014d52011-03-09 04:22:44 +00002122 Abv->Add(BitCodeAbbrevOp(0)); // KNRPromoted
John McCallf3cd6652010-03-12 18:31:32 +00002123 Abv->Add(BitCodeAbbrevOp(0)); // HasInheritedDefaultArg
Argyrios Kyrtzidisccde6a02010-07-04 21:44:07 +00002124 Abv->Add(BitCodeAbbrevOp(0)); // HasUninstantiatedDefaultArg
Jonathan D. Turner205c7d52011-06-03 23:11:16 +00002125 // Type Source Info
Jonathan D. Turner205c7d52011-06-03 23:11:16 +00002126 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
2127 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // TypeLoc
David Blaikieb44f0bf2017-01-04 22:36:43 +00002128 DeclParmVarAbbrev = Stream.EmitAbbrev(std::move(Abv));
Sebastian Redl66c5eef2010-07-27 00:17:23 +00002129
Jonathan D. Turner780a6bf2011-06-06 16:22:39 +00002130 // Abbreviation for DECL_TYPEDEF
David Blaikieb44f0bf2017-01-04 22:36:43 +00002131 Abv = std::make_shared<BitCodeAbbrev>();
Jonathan D. Turner205c7d52011-06-03 23:11:16 +00002132 Abv->Add(BitCodeAbbrevOp(serialization::DECL_TYPEDEF));
Douglas Gregor05f10352011-12-17 23:38:30 +00002133 // Redeclarable
Douglas Gregor9f562c82011-12-19 15:27:36 +00002134 Abv->Add(BitCodeAbbrevOp(0)); // No redeclaration
Jonathan D. Turner205c7d52011-06-03 23:11:16 +00002135 // Decl
2136 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclContext
Richard Smith8aed4222015-12-11 22:41:00 +00002137 Abv->Add(BitCodeAbbrevOp(0)); // LexicalDeclContext
Argyrios Kyrtzidisb7d1ca22012-03-09 21:09:04 +00002138 Abv->Add(BitCodeAbbrevOp(0)); // isInvalidDecl
Jonathan D. Turner205c7d52011-06-03 23:11:16 +00002139 Abv->Add(BitCodeAbbrevOp(0)); // HasAttrs
2140 Abv->Add(BitCodeAbbrevOp(0)); // isImplicit
Richard Smith01b2cb42014-07-26 06:37:51 +00002141 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isUsed
2142 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isReferenced
Argyrios Kyrtzidis8ad3bab2011-11-23 20:27:36 +00002143 Abv->Add(BitCodeAbbrevOp(0)); // TopLevelDeclInObjCContainer
Richard Smith01b2cb42014-07-26 06:37:51 +00002144 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2)); // C++ AccessSpecifier
Douglas Gregor26701a42011-09-09 02:06:17 +00002145 Abv->Add(BitCodeAbbrevOp(0)); // ModulePrivate
Douglas Gregora28bcdd2011-12-01 02:07:58 +00002146 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SubmoduleID
Jonathan D. Turner205c7d52011-06-03 23:11:16 +00002147 // NamedDecl
2148 Abv->Add(BitCodeAbbrevOp(0)); // NameKind = Identifier
2149 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Name
Richard Smith2b560572015-02-07 03:11:11 +00002150 Abv->Add(BitCodeAbbrevOp(0)); // AnonDeclNumber
Jonathan D. Turner205c7d52011-06-03 23:11:16 +00002151 // TypeDecl
2152 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Source Location
2153 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type Ref
2154 // TypedefDecl
2155 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
2156 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // TypeLoc
David Blaikieb44f0bf2017-01-04 22:36:43 +00002157 DeclTypedefAbbrev = Stream.EmitAbbrev(std::move(Abv));
Jonathan D. Turner205c7d52011-06-03 23:11:16 +00002158
Jonathan D. Turner780a6bf2011-06-06 16:22:39 +00002159 // Abbreviation for DECL_VAR
David Blaikieb44f0bf2017-01-04 22:36:43 +00002160 Abv = std::make_shared<BitCodeAbbrev>();
Jonathan D. Turner205c7d52011-06-03 23:11:16 +00002161 Abv->Add(BitCodeAbbrevOp(serialization::DECL_VAR));
Douglas Gregor3e300102011-10-26 17:53:41 +00002162 // Redeclarable
Douglas Gregor9f562c82011-12-19 15:27:36 +00002163 Abv->Add(BitCodeAbbrevOp(0)); // No redeclaration
Jonathan D. Turner205c7d52011-06-03 23:11:16 +00002164 // Decl
2165 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclContext
Richard Smith8aed4222015-12-11 22:41:00 +00002166 Abv->Add(BitCodeAbbrevOp(0)); // LexicalDeclContext
Argyrios Kyrtzidisb7d1ca22012-03-09 21:09:04 +00002167 Abv->Add(BitCodeAbbrevOp(0)); // isInvalidDecl
Jonathan D. Turner205c7d52011-06-03 23:11:16 +00002168 Abv->Add(BitCodeAbbrevOp(0)); // HasAttrs
2169 Abv->Add(BitCodeAbbrevOp(0)); // isImplicit
2170 Abv->Add(BitCodeAbbrevOp(0)); // isUsed
2171 Abv->Add(BitCodeAbbrevOp(0)); // isReferenced
Argyrios Kyrtzidis8ad3bab2011-11-23 20:27:36 +00002172 Abv->Add(BitCodeAbbrevOp(0)); // TopLevelDeclInObjCContainer
Jonathan D. Turner205c7d52011-06-03 23:11:16 +00002173 Abv->Add(BitCodeAbbrevOp(AS_none)); // C++ AccessSpecifier
Douglas Gregor26701a42011-09-09 02:06:17 +00002174 Abv->Add(BitCodeAbbrevOp(0)); // ModulePrivate
Douglas Gregora28bcdd2011-12-01 02:07:58 +00002175 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SubmoduleID
Jonathan D. Turner205c7d52011-06-03 23:11:16 +00002176 // NamedDecl
2177 Abv->Add(BitCodeAbbrevOp(0)); // NameKind = Identifier
2178 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Name
Richard Smith2b560572015-02-07 03:11:11 +00002179 Abv->Add(BitCodeAbbrevOp(0)); // AnonDeclNumber
Jonathan D. Turner205c7d52011-06-03 23:11:16 +00002180 // ValueDecl
2181 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type
2182 // DeclaratorDecl
2183 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // InnerStartLoc
2184 Abv->Add(BitCodeAbbrevOp(0)); // hasExtInfo
Richard Smithc23d7342018-06-29 20:46:25 +00002185 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // TSIType
Jonathan D. Turner205c7d52011-06-03 23:11:16 +00002186 // VarDecl
Vassil Vassilevd1a88132016-10-06 13:04:54 +00002187 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); // SClass
2188 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2)); // TSCSpec
2189 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2)); // InitStyle
Erik Pilkington1e368822019-01-04 18:33:06 +00002190 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isARCPseudoStrong
Richard Smithedbc6e92016-10-14 21:41:24 +00002191 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsThisDeclarationADemotedDefinition
Jonathan D. Turner205c7d52011-06-03 23:11:16 +00002192 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isExceptionVariable
Taiju Tsuiki3be68e12018-06-19 05:35:30 +00002193 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isNRVOVariable
Jonathan D. Turner205c7d52011-06-03 23:11:16 +00002194 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isCXXForRangeDecl
George Karpenkovec38cf72018-03-29 00:56:24 +00002195 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isObjCForDecl
Richard Smith62f19e72016-06-25 00:15:56 +00002196 Abv->Add(BitCodeAbbrevOp(0)); // isInline
2197 Abv->Add(BitCodeAbbrevOp(0)); // isInlineSpecified
Douglas Gregor12cda632012-09-20 23:43:29 +00002198 Abv->Add(BitCodeAbbrevOp(0)); // isConstexpr
Richard Smithbb13c9a2013-09-28 04:02:39 +00002199 Abv->Add(BitCodeAbbrevOp(0)); // isInitCapture
Richard Smith1c34fb72013-08-13 18:18:50 +00002200 Abv->Add(BitCodeAbbrevOp(0)); // isPrevDeclInSameScope
Alexey Bataev56223232017-06-09 13:40:18 +00002201 Abv->Add(BitCodeAbbrevOp(0)); // ImplicitParamKind
Akira Hatanaka8e57b072018-10-01 21:51:28 +00002202 Abv->Add(BitCodeAbbrevOp(0)); // EscapingByref
Rafael Espindola50df3a02013-05-25 17:16:20 +00002203 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); // Linkage
Richard Smith2b4fa532019-09-29 05:08:46 +00002204 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); // IsInitICE (local)
Vassil Vassilevd1a88132016-10-06 13:04:54 +00002205 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2)); // VarKind (local enum)
Jonathan D. Turner205c7d52011-06-03 23:11:16 +00002206 // Type Source Info
Jonathan D. Turner205c7d52011-06-03 23:11:16 +00002207 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
2208 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // TypeLoc
David Blaikieb44f0bf2017-01-04 22:36:43 +00002209 DeclVarAbbrev = Stream.EmitAbbrev(std::move(Abv));
Jonathan D. Turner205c7d52011-06-03 23:11:16 +00002210
Richard Smith01b2cb42014-07-26 06:37:51 +00002211 // Abbreviation for DECL_CXX_METHOD
David Blaikieb44f0bf2017-01-04 22:36:43 +00002212 Abv = std::make_shared<BitCodeAbbrev>();
Richard Smith01b2cb42014-07-26 06:37:51 +00002213 Abv->Add(BitCodeAbbrevOp(serialization::DECL_CXX_METHOD));
2214 // RedeclarableDecl
2215 Abv->Add(BitCodeAbbrevOp(0)); // CanonicalDecl
2216 // Decl
2217 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclContext
Richard Smith8aed4222015-12-11 22:41:00 +00002218 Abv->Add(BitCodeAbbrevOp(0)); // LexicalDeclContext
Richard Smith01b2cb42014-07-26 06:37:51 +00002219 Abv->Add(BitCodeAbbrevOp(0)); // Invalid
2220 Abv->Add(BitCodeAbbrevOp(0)); // HasAttrs
2221 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Implicit
2222 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Used
2223 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Referenced
2224 Abv->Add(BitCodeAbbrevOp(0)); // InObjCContainer
2225 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2)); // Access
2226 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // ModulePrivate
2227 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SubmoduleID
2228 // NamedDecl
2229 Abv->Add(BitCodeAbbrevOp(DeclarationName::Identifier)); // NameKind
2230 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Identifier
Richard Smith2b560572015-02-07 03:11:11 +00002231 Abv->Add(BitCodeAbbrevOp(0)); // AnonDeclNumber
Richard Smith01b2cb42014-07-26 06:37:51 +00002232 // ValueDecl
2233 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type
2234 // DeclaratorDecl
2235 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // InnerLocStart
2236 Abv->Add(BitCodeAbbrevOp(0)); // HasExtInfo
Richard Smithc23d7342018-06-29 20:46:25 +00002237 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // TSIType
Richard Smith01b2cb42014-07-26 06:37:51 +00002238 // FunctionDecl
2239 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 11)); // IDNS
2240 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); // StorageClass
2241 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Inline
2242 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // InlineSpecified
2243 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // VirtualAsWritten
2244 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Pure
2245 Abv->Add(BitCodeAbbrevOp(0)); // HasInheritedProto
2246 Abv->Add(BitCodeAbbrevOp(1)); // HasWrittenProto
Richard Smith72625c22015-02-06 23:20:21 +00002247 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Deleted
Richard Smith01b2cb42014-07-26 06:37:51 +00002248 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Trivial
Akira Hatanaka02914dc2018-02-05 20:23:22 +00002249 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // TrivialForCall
Richard Smith01b2cb42014-07-26 06:37:51 +00002250 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Defaulted
2251 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // ExplicitlyDefaulted
2252 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // ImplicitReturnZero
2253 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Constexpr
Reid Kleckner0d157382017-01-10 21:27:03 +00002254 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // UsesSEHTry
Richard Smith01b2cb42014-07-26 06:37:51 +00002255 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // SkippedBody
Erich Keane281d20b2018-01-08 21:34:17 +00002256 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // MultiVersion
Richard Smith01b2cb42014-07-26 06:37:51 +00002257 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // LateParsed
2258 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); // Linkage
2259 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // LocEnd
Richard Trieue6caa262017-12-23 00:41:01 +00002260 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // ODRHash
Richard Smith01b2cb42014-07-26 06:37:51 +00002261 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); // TemplateKind
2262 // This Array slurps the rest of the record. Fortunately we want to encode
2263 // (nearly) all the remaining (variable number of) fields in the same way.
2264 //
2265 // This is the function template information if any, then
2266 // NumParams and Params[] from FunctionDecl, and
2267 // NumOverriddenMethods, OverriddenMethods[] from CXXMethodDecl.
2268 //
2269 // Add an AbbrevOp for 'size then elements' and use it here.
2270 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
2271 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));
David Blaikieb44f0bf2017-01-04 22:36:43 +00002272 DeclCXXMethodAbbrev = Stream.EmitAbbrev(std::move(Abv));
Richard Smith01b2cb42014-07-26 06:37:51 +00002273
Jonathan D. Turner780a6bf2011-06-06 16:22:39 +00002274 // Abbreviation for EXPR_DECL_REF
David Blaikieb44f0bf2017-01-04 22:36:43 +00002275 Abv = std::make_shared<BitCodeAbbrev>();
Douglas Gregor03412ba2011-06-03 02:27:19 +00002276 Abv->Add(BitCodeAbbrevOp(serialization::EXPR_DECL_REF));
2277 //Stmt
Roman Lebedevb5700602019-03-20 16:32:36 +00002278 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsOMPStructuredBlock
2279 // Expr
Douglas Gregor03412ba2011-06-03 02:27:19 +00002280 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type
Douglas Gregor678d76c2011-07-01 01:22:09 +00002281 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //TypeDependent
2282 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //ValueDependent
2283 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //InstantiationDependent
Douglas Gregor03412ba2011-06-03 02:27:19 +00002284 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //UnexpandedParamPack
2285 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); //GetValueKind
2286 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); //GetObjectKind
2287 //DeclRefExpr
2288 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //HasQualifier
2289 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //GetDeclFound
2290 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //ExplicitTemplateArgs
Abramo Bagnara635ed24e2011-10-05 07:56:41 +00002291 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //HadMultipleCandidates
Richard Smith715f7a12019-06-11 17:50:32 +00002292 Abv->Add(BitCodeAbbrevOp(0)); // RefersToEnclosingVariableOrCapture
2293 Abv->Add(BitCodeAbbrevOp(0)); // NonOdrUseReason
Douglas Gregor03412ba2011-06-03 02:27:19 +00002294 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclRef
2295 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Location
David Blaikieb44f0bf2017-01-04 22:36:43 +00002296 DeclRefExprAbbrev = Stream.EmitAbbrev(std::move(Abv));
Douglas Gregor03412ba2011-06-03 02:27:19 +00002297
2298 // Abbreviation for EXPR_INTEGER_LITERAL
David Blaikieb44f0bf2017-01-04 22:36:43 +00002299 Abv = std::make_shared<BitCodeAbbrev>();
Douglas Gregor03412ba2011-06-03 02:27:19 +00002300 Abv->Add(BitCodeAbbrevOp(serialization::EXPR_INTEGER_LITERAL));
2301 //Stmt
Roman Lebedevb5700602019-03-20 16:32:36 +00002302 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsOMPStructuredBlock
2303 // Expr
Douglas Gregor03412ba2011-06-03 02:27:19 +00002304 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type
Douglas Gregor678d76c2011-07-01 01:22:09 +00002305 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //TypeDependent
2306 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //ValueDependent
2307 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //InstantiationDependent
Douglas Gregor03412ba2011-06-03 02:27:19 +00002308 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //UnexpandedParamPack
2309 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); //GetValueKind
2310 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); //GetObjectKind
2311 //Integer Literal
2312 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Location
2313 Abv->Add(BitCodeAbbrevOp(32)); // Bit Width
2314 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Value
David Blaikieb44f0bf2017-01-04 22:36:43 +00002315 IntegerLiteralAbbrev = Stream.EmitAbbrev(std::move(Abv));
Douglas Gregor03412ba2011-06-03 02:27:19 +00002316
2317 // Abbreviation for EXPR_CHARACTER_LITERAL
David Blaikieb44f0bf2017-01-04 22:36:43 +00002318 Abv = std::make_shared<BitCodeAbbrev>();
Douglas Gregor03412ba2011-06-03 02:27:19 +00002319 Abv->Add(BitCodeAbbrevOp(serialization::EXPR_CHARACTER_LITERAL));
2320 //Stmt
Roman Lebedevb5700602019-03-20 16:32:36 +00002321 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsOMPStructuredBlock
2322 // Expr
Douglas Gregor03412ba2011-06-03 02:27:19 +00002323 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type
Douglas Gregor678d76c2011-07-01 01:22:09 +00002324 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //TypeDependent
2325 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //ValueDependent
2326 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //InstantiationDependent
Douglas Gregor03412ba2011-06-03 02:27:19 +00002327 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //UnexpandedParamPack
2328 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); //GetValueKind
2329 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); //GetObjectKind
Jonathan D. Turnerd09655f2011-06-03 21:46:44 +00002330 //Character Literal
Douglas Gregor03412ba2011-06-03 02:27:19 +00002331 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // getValue
2332 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Location
Aaron Ballman9a17c852016-01-07 20:59:26 +00002333 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); // getKind
David Blaikieb44f0bf2017-01-04 22:36:43 +00002334 CharacterLiteralAbbrev = Stream.EmitAbbrev(std::move(Abv));
Douglas Gregor03412ba2011-06-03 02:27:19 +00002335
Richard Smitha27c26e2014-07-27 04:19:32 +00002336 // Abbreviation for EXPR_IMPLICIT_CAST
David Blaikieb44f0bf2017-01-04 22:36:43 +00002337 Abv = std::make_shared<BitCodeAbbrev>();
Richard Smitha27c26e2014-07-27 04:19:32 +00002338 Abv->Add(BitCodeAbbrevOp(serialization::EXPR_IMPLICIT_CAST));
2339 // Stmt
Roman Lebedevb5700602019-03-20 16:32:36 +00002340 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsOMPStructuredBlock
Richard Smitha27c26e2014-07-27 04:19:32 +00002341 // Expr
2342 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type
2343 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //TypeDependent
2344 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //ValueDependent
2345 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //InstantiationDependent
2346 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //UnexpandedParamPack
2347 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); //GetValueKind
2348 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); //GetObjectKind
2349 // CastExpr
2350 Abv->Add(BitCodeAbbrevOp(0)); // PathSize
2351 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 6)); // CastKind
Roman Lebedevd55661d2018-07-24 08:16:50 +00002352 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // PartOfExplicitCast
Richard Smitha27c26e2014-07-27 04:19:32 +00002353 // ImplicitCastExpr
David Blaikieb44f0bf2017-01-04 22:36:43 +00002354 ExprImplicitCastAbbrev = Stream.EmitAbbrev(std::move(Abv));
Richard Smitha27c26e2014-07-27 04:19:32 +00002355
David Blaikieb44f0bf2017-01-04 22:36:43 +00002356 Abv = std::make_shared<BitCodeAbbrev>();
Sebastian Redl539c5062010-08-18 23:57:32 +00002357 Abv->Add(BitCodeAbbrevOp(serialization::DECL_CONTEXT_LEXICAL));
Sebastian Redl66c5eef2010-07-27 00:17:23 +00002358 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
David Blaikieb44f0bf2017-01-04 22:36:43 +00002359 DeclContextLexicalAbbrev = Stream.EmitAbbrev(std::move(Abv));
Argyrios Kyrtzidisba88bfa2010-08-20 16:04:35 +00002360
David Blaikieb44f0bf2017-01-04 22:36:43 +00002361 Abv = std::make_shared<BitCodeAbbrev>();
Argyrios Kyrtzidisba88bfa2010-08-20 16:04:35 +00002362 Abv->Add(BitCodeAbbrevOp(serialization::DECL_CONTEXT_VISIBLE));
Argyrios Kyrtzidisba88bfa2010-08-20 16:04:35 +00002363 Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
David Blaikieb44f0bf2017-01-04 22:36:43 +00002364 DeclContextVisibleLookupAbbrev = Stream.EmitAbbrev(std::move(Abv));
Chris Lattner258172e2009-04-27 07:35:58 +00002365}
2366
Daniel Dunbar5bb5ec52009-09-17 03:06:51 +00002367/// isRequiredDecl - Check if this is a "required" Decl, which must be seen by
2368/// consumers of the AST.
2369///
Sebastian Redl42a0f6a2010-08-18 23:56:27 +00002370/// Such decls will always be deserialized from the AST file, so we would like
Daniel Dunbar5bb5ec52009-09-17 03:06:51 +00002371/// this to be as restrictive as possible. Currently the predicate is driven by
2372/// code generation requirements, if other clients have a different notion of
2373/// what is "required" then we may have to consider an alternate scheme where
2374/// clients can iterate over the top-level decls and get information on them,
2375/// without necessary deserializing them. We could explicitly require such
2376/// clients to use a separate API call to "realize" the decl. This should be
2377/// relatively painless since they would presumably only do it for top-level
2378/// decls.
Richard Smithc52efa72015-08-19 02:30:28 +00002379static bool isRequiredDecl(const Decl *D, ASTContext &Context,
David Blaikiee6b7c282017-04-11 20:46:34 +00002380 bool WritingModule) {
Argyrios Kyrtzidisa98e8612011-09-13 21:35:00 +00002381 // An ObjCMethodDecl is never considered as "required" because its
2382 // implementation container always is.
2383
Dmitry Polukhin0b0da292016-04-06 11:38:59 +00002384 // File scoped assembly or obj-c or OMP declare target implementation must be
2385 // seen.
Alexey Bataevd01b7492018-08-15 19:45:12 +00002386 if (isa<FileScopeAsmDecl>(D) || isa<ObjCImplDecl>(D))
Richard Smithc52efa72015-08-19 02:30:28 +00002387 return true;
2388
Richard Smith520a37f2019-02-05 23:37:13 +00002389 if (WritingModule && isPartOfPerModuleInitializer(D)) {
Richard Smithdc1f0422016-07-20 19:10:16 +00002390 // These declarations are part of the module initializer, and are emitted
2391 // if and when the module is imported, rather than being emitted eagerly.
2392 return false;
2393 }
Daniel Dunbar5bb5ec52009-09-17 03:06:51 +00002394
David Blaikiee6b7c282017-04-11 20:46:34 +00002395 return Context.DeclMustBeEmitted(D);
Daniel Dunbar5bb5ec52009-09-17 03:06:51 +00002396}
2397
Sebastian Redl55c0ad52010-08-18 23:56:21 +00002398void ASTWriter::WriteDecl(ASTContext &Context, Decl *D) {
Jordan Rose1e879d82018-03-23 00:07:18 +00002399 PrettyDeclStackTraceEntry CrashInfo(Context, D, SourceLocation(),
2400 "serializing");
2401
Douglas Gregorb3163e52012-01-05 22:33:30 +00002402 // Determine the ID for this declaration.
2403 serialization::DeclID ID;
Douglas Gregor7dd37e52015-11-03 01:20:54 +00002404 assert(!D->isFromASTFile() && "should not be emitting imported decl");
2405 serialization::DeclID &IDR = DeclIDs[D];
2406 if (IDR == 0)
2407 IDR = NextDeclID++;
Fangrui Song6907ce22018-07-30 19:24:48 +00002408
Douglas Gregor7dd37e52015-11-03 01:20:54 +00002409 ID = IDR;
Argyrios Kyrtzidisbf6c3392012-03-22 16:08:04 +00002410
Richard Smith34da7512016-03-27 05:52:25 +00002411 assert(ID >= FirstDeclID && "invalid decl ID");
Fangrui Song6907ce22018-07-30 19:24:48 +00002412
Richard Smith69c82bf2016-04-01 22:52:03 +00002413 RecordData Record;
2414 ASTDeclWriter W(*this, Context, Record);
2415
Richard Smithd61d4ac2015-08-22 20:13:39 +00002416 // Build a record for this declaration
Richard Smithd61d4ac2015-08-22 20:13:39 +00002417 W.Visit(D);
Richard Smithd61d4ac2015-08-22 20:13:39 +00002418
Richard Smith69c82bf2016-04-01 22:52:03 +00002419 // Emit this declaration to the bitstream.
2420 uint64_t Offset = W.Emit(D);
Douglas Gregor12bfa382009-10-17 00:13:19 +00002421
Richard Smith34da7512016-03-27 05:52:25 +00002422 // Record the offset for this declaration
2423 SourceLocation Loc = D->getLocation();
Richard Smith69c82bf2016-04-01 22:52:03 +00002424 unsigned Index = ID - FirstDeclID;
Richard Smith34da7512016-03-27 05:52:25 +00002425 if (DeclOffsets.size() == Index)
Richard Smith69c82bf2016-04-01 22:52:03 +00002426 DeclOffsets.push_back(DeclOffset(Loc, Offset));
Richard Smith34da7512016-03-27 05:52:25 +00002427 else if (DeclOffsets.size() < Index) {
Richard Smith69c82bf2016-04-01 22:52:03 +00002428 // FIXME: Can/should this happen?
Richard Smith34da7512016-03-27 05:52:25 +00002429 DeclOffsets.resize(Index+1);
2430 DeclOffsets[Index].setLocation(Loc);
Richard Smith69c82bf2016-04-01 22:52:03 +00002431 DeclOffsets[Index].BitOffset = Offset;
2432 } else {
2433 llvm_unreachable("declarations should be emitted in ID order");
Douglas Gregor12bfa382009-10-17 00:13:19 +00002434 }
2435
Richard Smith34da7512016-03-27 05:52:25 +00002436 SourceManager &SM = Context.getSourceManager();
2437 if (Loc.isValid() && SM.isLocalSourceLocation(Loc))
2438 associateDeclWithFile(D, ID);
2439
Ben Langmuir332aafe2014-01-31 01:06:56 +00002440 // Note declarations that should be deserialized eagerly so that we can add
2441 // them to a record in the AST file later.
David Blaikiee6b7c282017-04-11 20:46:34 +00002442 if (isRequiredDecl(D, Context, WritingModule))
Ben Langmuir332aafe2014-01-31 01:06:56 +00002443 EagerlyDeserializedDecls.push_back(ID);
Chris Lattner7099dbc2009-04-27 06:16:06 +00002444}
Richard Smithd28ac5b2014-03-22 23:33:22 +00002445
Richard Smith290d8012016-04-06 17:06:00 +00002446void ASTRecordWriter::AddFunctionDefinition(const FunctionDecl *FD) {
2447 // Switch case IDs are per function body.
2448 Writer->ClearSwitchCaseIDs();
Richard Smithd28ac5b2014-03-22 23:33:22 +00002449
Richard Smith290d8012016-04-06 17:06:00 +00002450 assert(FD->doesThisDeclarationHaveABody());
Richard Smithb51cf112017-07-06 00:30:00 +00002451 bool ModulesCodegen = false;
Luboš Luňákcbc9d222019-11-03 21:15:03 +01002452 if (!FD->isDependentContext()) {
David Blaikie08267292017-11-02 21:55:40 +00002453 Optional<GVALinkage> Linkage;
Luboš Luňákcbc9d222019-11-03 21:15:03 +01002454 if ((Writer->WritingModule &&
2455 Writer->WritingModule->Kind == Module::ModuleInterfaceUnit) ||
2456 Writer->Context->getLangOpts().BuildingPCHWithObjectFile) {
David Blaikie08267292017-11-02 21:55:40 +00002457 // When building a C++ Modules TS module interface unit, a strong
2458 // definition in the module interface is provided by the compilation of
2459 // that module interface unit, not by its users. (Inline functions are
2460 // still emitted in module users.)
2461 Linkage = Writer->Context->GetGVALinkageForFunction(FD);
2462 ModulesCodegen = *Linkage == GVA_StrongExternal;
2463 }
2464 if (Writer->Context->getLangOpts().ModulesCodegen) {
2465 // Under -fmodules-codegen, codegen is performed for all non-internal,
Luboš Luňák729530f2019-11-03 20:47:40 +01002466 // non-always_inline functions, unless they are available elsewhere.
David Blaikie1524e672017-11-02 22:28:50 +00002467 if (!FD->hasAttr<AlwaysInlineAttr>()) {
2468 if (!Linkage)
2469 Linkage = Writer->Context->GetGVALinkageForFunction(FD);
Luboš Luňák729530f2019-11-03 20:47:40 +01002470 ModulesCodegen =
2471 *Linkage != GVA_Internal && *Linkage != GVA_AvailableExternally;
David Blaikie1524e672017-11-02 22:28:50 +00002472 }
David Blaikie08267292017-11-02 21:55:40 +00002473 }
Richard Smithb51cf112017-07-06 00:30:00 +00002474 }
David Blaikief63556d2017-04-12 20:58:33 +00002475 Record->push_back(ModulesCodegen);
2476 if (ModulesCodegen)
David Blaikiee6b7c282017-04-11 20:46:34 +00002477 Writer->ModularCodegenDecls.push_back(Writer->GetDeclRef(FD));
Richard Smith290d8012016-04-06 17:06:00 +00002478 if (auto *CD = dyn_cast<CXXConstructorDecl>(FD)) {
2479 Record->push_back(CD->getNumCtorInitializers());
2480 if (CD->getNumCtorInitializers())
Richard Smithaa165cf2016-04-13 21:57:08 +00002481 AddCXXCtorInitializers(
Richard Smith290d8012016-04-06 17:06:00 +00002482 llvm::makeArrayRef(CD->init_begin(), CD->init_end()));
2483 }
2484 AddStmt(FD->getBody());
Richard Smithd28ac5b2014-03-22 23:33:22 +00002485}