Sebastian Redl | 4ee2ad0 | 2010-08-18 23:56:31 +0000 | [diff] [blame] | 1 | //===--- ASTWriterDecl.cpp - Declaration Serialization --------------------===// |
Chris Lattner | 12b1c76 | 2009-04-27 06:16:06 +0000 | [diff] [blame] | 2 | // |
| 3 | // The LLVM Compiler Infrastructure |
| 4 | // |
| 5 | // This file is distributed under the University of Illinois Open Source |
| 6 | // License. See LICENSE.TXT for details. |
| 7 | // |
| 8 | //===----------------------------------------------------------------------===// |
| 9 | // |
| 10 | // This file implements serialization for Declarations. |
| 11 | // |
| 12 | //===----------------------------------------------------------------------===// |
| 13 | |
Sebastian Redl | 7faa2ec | 2010-08-18 23:56:37 +0000 | [diff] [blame] | 14 | #include "clang/Serialization/ASTWriter.h" |
Sebastian Redl | 7c0837f | 2011-04-24 16:28:13 +0000 | [diff] [blame] | 15 | #include "ASTCommon.h" |
Chris Lattner | 6ad9ac0 | 2010-05-07 21:43:38 +0000 | [diff] [blame] | 16 | #include "clang/AST/DeclCXX.h" |
Argyrios Kyrtzidis | 0ad6dc3 | 2010-10-20 16:22:56 +0000 | [diff] [blame] | 17 | #include "clang/AST/DeclContextInternals.h" |
Chandler Carruth | 55fc873 | 2012-12-04 09:13:33 +0000 | [diff] [blame] | 18 | #include "clang/AST/DeclTemplate.h" |
| 19 | #include "clang/AST/DeclVisitor.h" |
| 20 | #include "clang/AST/Expr.h" |
Argyrios Kyrtzidis | 10f3df5 | 2011-10-28 22:54:21 +0000 | [diff] [blame] | 21 | #include "clang/Basic/SourceManager.h" |
Chandler Carruth | 55fc873 | 2012-12-04 09:13:33 +0000 | [diff] [blame] | 22 | #include "clang/Serialization/ASTReader.h" |
Daniel Dunbar | 3367198 | 2009-12-03 09:13:36 +0000 | [diff] [blame] | 23 | #include "llvm/ADT/Twine.h" |
Chris Lattner | 12b1c76 | 2009-04-27 06:16:06 +0000 | [diff] [blame] | 24 | #include "llvm/Bitcode/BitstreamWriter.h" |
Daniel Dunbar | 3367198 | 2009-12-03 09:13:36 +0000 | [diff] [blame] | 25 | #include "llvm/Support/ErrorHandling.h" |
Chris Lattner | 12b1c76 | 2009-04-27 06:16:06 +0000 | [diff] [blame] | 26 | using namespace clang; |
Sebastian Redl | 7c0837f | 2011-04-24 16:28:13 +0000 | [diff] [blame] | 27 | using namespace serialization; |
Chris Lattner | 12b1c76 | 2009-04-27 06:16:06 +0000 | [diff] [blame] | 28 | |
| 29 | //===----------------------------------------------------------------------===// |
| 30 | // Declaration serialization |
| 31 | //===----------------------------------------------------------------------===// |
| 32 | |
Argyrios Kyrtzidis | 6764334 | 2010-06-29 22:47:00 +0000 | [diff] [blame] | 33 | namespace clang { |
Sebastian Redl | 3397c55 | 2010-08-18 23:56:27 +0000 | [diff] [blame] | 34 | class ASTDeclWriter : public DeclVisitor<ASTDeclWriter, void> { |
Chris Lattner | 12b1c76 | 2009-04-27 06:16:06 +0000 | [diff] [blame] | 35 | |
Sebastian Redl | a4232eb | 2010-08-18 23:56:21 +0000 | [diff] [blame] | 36 | ASTWriter &Writer; |
Chris Lattner | 12b1c76 | 2009-04-27 06:16:06 +0000 | [diff] [blame] | 37 | ASTContext &Context; |
Argyrios Kyrtzidis | c01dc6f | 2010-10-24 17:26:27 +0000 | [diff] [blame] | 38 | typedef ASTWriter::RecordData RecordData; |
| 39 | RecordData &Record; |
Chris Lattner | 12b1c76 | 2009-04-27 06:16:06 +0000 | [diff] [blame] | 40 | |
| 41 | public: |
Sebastian Redl | 8538e8d | 2010-08-18 23:57:32 +0000 | [diff] [blame] | 42 | serialization::DeclCode Code; |
Chris Lattner | ea5ce47 | 2009-04-27 07:35:58 +0000 | [diff] [blame] | 43 | unsigned AbbrevToUse; |
Chris Lattner | 12b1c76 | 2009-04-27 06:16:06 +0000 | [diff] [blame] | 44 | |
Argyrios Kyrtzidis | c01dc6f | 2010-10-24 17:26:27 +0000 | [diff] [blame] | 45 | ASTDeclWriter(ASTWriter &Writer, ASTContext &Context, RecordData &Record) |
Chris Lattner | ea5ce47 | 2009-04-27 07:35:58 +0000 | [diff] [blame] | 46 | : Writer(Writer), Context(Context), Record(Record) { |
| 47 | } |
Argyrios Kyrtzidis | c01dc6f | 2010-10-24 17:26:27 +0000 | [diff] [blame] | 48 | |
Argyrios Kyrtzidis | 9146832 | 2010-07-02 15:58:43 +0000 | [diff] [blame] | 49 | void Visit(Decl *D); |
Chris Lattner | 12b1c76 | 2009-04-27 06:16:06 +0000 | [diff] [blame] | 50 | |
| 51 | void VisitDecl(Decl *D); |
| 52 | void VisitTranslationUnitDecl(TranslationUnitDecl *D); |
| 53 | void VisitNamedDecl(NamedDecl *D); |
Chris Lattner | ad8dcf4 | 2011-02-17 07:39:24 +0000 | [diff] [blame] | 54 | void VisitLabelDecl(LabelDecl *LD); |
Douglas Gregor | 0cef483 | 2010-02-21 18:22:14 +0000 | [diff] [blame] | 55 | void VisitNamespaceDecl(NamespaceDecl *D); |
Chris Lattner | 6ad9ac0 | 2010-05-07 21:43:38 +0000 | [diff] [blame] | 56 | void VisitUsingDirectiveDecl(UsingDirectiveDecl *D); |
| 57 | void VisitNamespaceAliasDecl(NamespaceAliasDecl *D); |
Chris Lattner | 12b1c76 | 2009-04-27 06:16:06 +0000 | [diff] [blame] | 58 | void VisitTypeDecl(TypeDecl *D); |
Douglas Gregor | 0f45682 | 2011-12-19 14:40:25 +0000 | [diff] [blame] | 59 | void VisitTypedefNameDecl(TypedefNameDecl *D); |
Chris Lattner | 12b1c76 | 2009-04-27 06:16:06 +0000 | [diff] [blame] | 60 | void VisitTypedefDecl(TypedefDecl *D); |
Richard Smith | 162e1c1 | 2011-04-15 14:24:37 +0000 | [diff] [blame] | 61 | void VisitTypeAliasDecl(TypeAliasDecl *D); |
Argyrios Kyrtzidis | 8f4eae9 | 2010-06-30 08:49:30 +0000 | [diff] [blame] | 62 | void VisitUnresolvedUsingTypenameDecl(UnresolvedUsingTypenameDecl *D); |
Chris Lattner | 12b1c76 | 2009-04-27 06:16:06 +0000 | [diff] [blame] | 63 | void VisitTagDecl(TagDecl *D); |
| 64 | void VisitEnumDecl(EnumDecl *D); |
| 65 | void VisitRecordDecl(RecordDecl *D); |
Chris Lattner | 6ad9ac0 | 2010-05-07 21:43:38 +0000 | [diff] [blame] | 66 | void VisitCXXRecordDecl(CXXRecordDecl *D); |
| 67 | void VisitClassTemplateSpecializationDecl( |
| 68 | ClassTemplateSpecializationDecl *D); |
| 69 | void VisitClassTemplatePartialSpecializationDecl( |
| 70 | ClassTemplatePartialSpecializationDecl *D); |
Larisse Voufo | ef4579c | 2013-08-06 01:03:05 +0000 | [diff] [blame] | 71 | void VisitVarTemplateSpecializationDecl(VarTemplateSpecializationDecl *D); |
| 72 | void VisitVarTemplatePartialSpecializationDecl( |
| 73 | VarTemplatePartialSpecializationDecl *D); |
Fariborz Jahanian | 95ed778 | 2011-08-27 20:50:59 +0000 | [diff] [blame] | 74 | void VisitClassScopeFunctionSpecializationDecl( |
| 75 | ClassScopeFunctionSpecializationDecl *D); |
Chris Lattner | 6ad9ac0 | 2010-05-07 21:43:38 +0000 | [diff] [blame] | 76 | void VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D); |
Chris Lattner | 12b1c76 | 2009-04-27 06:16:06 +0000 | [diff] [blame] | 77 | void VisitValueDecl(ValueDecl *D); |
| 78 | void VisitEnumConstantDecl(EnumConstantDecl *D); |
Argyrios Kyrtzidis | 8f4eae9 | 2010-06-30 08:49:30 +0000 | [diff] [blame] | 79 | void VisitUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *D); |
Argyrios Kyrtzidis | d4a7e54 | 2009-08-19 01:28:35 +0000 | [diff] [blame] | 80 | void VisitDeclaratorDecl(DeclaratorDecl *D); |
Chris Lattner | 12b1c76 | 2009-04-27 06:16:06 +0000 | [diff] [blame] | 81 | void VisitFunctionDecl(FunctionDecl *D); |
Chris Lattner | 6ad9ac0 | 2010-05-07 21:43:38 +0000 | [diff] [blame] | 82 | void VisitCXXMethodDecl(CXXMethodDecl *D); |
| 83 | void VisitCXXConstructorDecl(CXXConstructorDecl *D); |
| 84 | void VisitCXXDestructorDecl(CXXDestructorDecl *D); |
| 85 | void VisitCXXConversionDecl(CXXConversionDecl *D); |
Chris Lattner | 12b1c76 | 2009-04-27 06:16:06 +0000 | [diff] [blame] | 86 | void VisitFieldDecl(FieldDecl *D); |
John McCall | 76da55d | 2013-04-16 07:28:30 +0000 | [diff] [blame] | 87 | void VisitMSPropertyDecl(MSPropertyDecl *D); |
Francois Pichet | 87c2e12 | 2010-11-21 06:08:52 +0000 | [diff] [blame] | 88 | void VisitIndirectFieldDecl(IndirectFieldDecl *D); |
Chris Lattner | 12b1c76 | 2009-04-27 06:16:06 +0000 | [diff] [blame] | 89 | void VisitVarDecl(VarDecl *D); |
| 90 | void VisitImplicitParamDecl(ImplicitParamDecl *D); |
| 91 | void VisitParmVarDecl(ParmVarDecl *D); |
Chris Lattner | 6ad9ac0 | 2010-05-07 21:43:38 +0000 | [diff] [blame] | 92 | void VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D); |
| 93 | void VisitTemplateDecl(TemplateDecl *D); |
Peter Collingbourne | 9eabeba | 2010-07-29 16:11:51 +0000 | [diff] [blame] | 94 | void VisitRedeclarableTemplateDecl(RedeclarableTemplateDecl *D); |
Chris Lattner | 6ad9ac0 | 2010-05-07 21:43:38 +0000 | [diff] [blame] | 95 | void VisitClassTemplateDecl(ClassTemplateDecl *D); |
Larisse Voufo | ef4579c | 2013-08-06 01:03:05 +0000 | [diff] [blame] | 96 | void VisitVarTemplateDecl(VarTemplateDecl *D); |
Argyrios Kyrtzidis | f511ba6 | 2010-06-22 09:55:07 +0000 | [diff] [blame] | 97 | void VisitFunctionTemplateDecl(FunctionTemplateDecl *D); |
Chris Lattner | 6ad9ac0 | 2010-05-07 21:43:38 +0000 | [diff] [blame] | 98 | void VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D); |
Richard Smith | 3e4c6c4 | 2011-05-05 21:57:07 +0000 | [diff] [blame] | 99 | void VisitTypeAliasTemplateDecl(TypeAliasTemplateDecl *D); |
Argyrios Kyrtzidis | b01a552 | 2010-06-20 14:40:59 +0000 | [diff] [blame] | 100 | void VisitUsingDecl(UsingDecl *D); |
| 101 | void VisitUsingShadowDecl(UsingShadowDecl *D); |
Chris Lattner | 6ad9ac0 | 2010-05-07 21:43:38 +0000 | [diff] [blame] | 102 | void VisitLinkageSpecDecl(LinkageSpecDecl *D); |
Chris Lattner | 12b1c76 | 2009-04-27 06:16:06 +0000 | [diff] [blame] | 103 | void VisitFileScopeAsmDecl(FileScopeAsmDecl *D); |
Douglas Gregor | 15de72c | 2011-12-02 23:23:56 +0000 | [diff] [blame] | 104 | void VisitImportDecl(ImportDecl *D); |
Abramo Bagnara | 6206d53 | 2010-06-05 05:09:32 +0000 | [diff] [blame] | 105 | void VisitAccessSpecDecl(AccessSpecDecl *D); |
Argyrios Kyrtzidis | 6764334 | 2010-06-29 22:47:00 +0000 | [diff] [blame] | 106 | void VisitFriendDecl(FriendDecl *D); |
Chris Lattner | 6ad9ac0 | 2010-05-07 21:43:38 +0000 | [diff] [blame] | 107 | void VisitFriendTemplateDecl(FriendTemplateDecl *D); |
| 108 | void VisitStaticAssertDecl(StaticAssertDecl *D); |
Chris Lattner | 12b1c76 | 2009-04-27 06:16:06 +0000 | [diff] [blame] | 109 | void VisitBlockDecl(BlockDecl *D); |
Tareq A. Siraj | 6afcf88 | 2013-04-16 19:37:38 +0000 | [diff] [blame] | 110 | void VisitCapturedDecl(CapturedDecl *D); |
Michael Han | 684aa73 | 2013-02-22 17:15:32 +0000 | [diff] [blame] | 111 | void VisitEmptyDecl(EmptyDecl *D); |
Chris Lattner | 6ad9ac0 | 2010-05-07 21:43:38 +0000 | [diff] [blame] | 112 | |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 113 | void VisitDeclContext(DeclContext *DC, uint64_t LexicalOffset, |
Chris Lattner | 12b1c76 | 2009-04-27 06:16:06 +0000 | [diff] [blame] | 114 | uint64_t VisibleOffset); |
Argyrios Kyrtzidis | a865005 | 2010-08-03 17:30:10 +0000 | [diff] [blame] | 115 | template <typename T> void VisitRedeclarable(Redeclarable<T> *D); |
Chris Lattner | 6ad9ac0 | 2010-05-07 21:43:38 +0000 | [diff] [blame] | 116 | |
| 117 | |
Sean Hunt | 9a55591 | 2010-05-30 07:21:58 +0000 | [diff] [blame] | 118 | // FIXME: Put in the same order is DeclNodes.td? |
Chris Lattner | 12b1c76 | 2009-04-27 06:16:06 +0000 | [diff] [blame] | 119 | void VisitObjCMethodDecl(ObjCMethodDecl *D); |
| 120 | void VisitObjCContainerDecl(ObjCContainerDecl *D); |
| 121 | void VisitObjCInterfaceDecl(ObjCInterfaceDecl *D); |
| 122 | void VisitObjCIvarDecl(ObjCIvarDecl *D); |
| 123 | void VisitObjCProtocolDecl(ObjCProtocolDecl *D); |
| 124 | void VisitObjCAtDefsFieldDecl(ObjCAtDefsFieldDecl *D); |
Chris Lattner | 12b1c76 | 2009-04-27 06:16:06 +0000 | [diff] [blame] | 125 | void VisitObjCCategoryDecl(ObjCCategoryDecl *D); |
| 126 | void VisitObjCImplDecl(ObjCImplDecl *D); |
| 127 | void VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D); |
| 128 | void VisitObjCImplementationDecl(ObjCImplementationDecl *D); |
| 129 | void VisitObjCCompatibleAliasDecl(ObjCCompatibleAliasDecl *D); |
| 130 | void VisitObjCPropertyDecl(ObjCPropertyDecl *D); |
| 131 | void VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D); |
Alexey Bataev | c640058 | 2013-03-22 06:34:35 +0000 | [diff] [blame] | 132 | void VisitOMPThreadPrivateDecl(OMPThreadPrivateDecl *D); |
Stephen Hines | 651f13c | 2014-04-23 16:59:28 -0700 | [diff] [blame] | 133 | |
| 134 | void AddFunctionDefinition(const FunctionDecl *FD) { |
| 135 | assert(FD->doesThisDeclarationHaveABody()); |
Pirama Arumuga Nainar | 3ea9e33 | 2015-04-08 08:57:32 -0700 | [diff] [blame] | 136 | if (auto *CD = dyn_cast<CXXConstructorDecl>(FD)) { |
| 137 | Record.push_back(CD->NumCtorInitializers); |
| 138 | if (CD->NumCtorInitializers) |
| 139 | Writer.AddCXXCtorInitializersRef( |
| 140 | llvm::makeArrayRef(CD->init_begin(), CD->init_end()), Record); |
| 141 | } |
Stephen Hines | 651f13c | 2014-04-23 16:59:28 -0700 | [diff] [blame] | 142 | Writer.AddStmt(FD->getBody()); |
| 143 | } |
Pirama Arumuga Nainar | 3ea9e33 | 2015-04-08 08:57:32 -0700 | [diff] [blame] | 144 | |
| 145 | /// Get the specialization decl from an entry in the specialization list. |
| 146 | template <typename EntryType> |
| 147 | typename RedeclarableTemplateDecl::SpecEntryTraits<EntryType>::DeclType * |
| 148 | getSpecializationDecl(EntryType &T) { |
| 149 | return RedeclarableTemplateDecl::SpecEntryTraits<EntryType>::getDecl(&T); |
| 150 | } |
| 151 | |
| 152 | /// Get the list of partial specializations from a template's common ptr. |
| 153 | template<typename T> |
| 154 | decltype(T::PartialSpecializations) &getPartialSpecializations(T *Common) { |
| 155 | return Common->PartialSpecializations; |
| 156 | } |
| 157 | ArrayRef<Decl> getPartialSpecializations(FunctionTemplateDecl::Common *) { |
| 158 | return None; |
| 159 | } |
| 160 | |
| 161 | template<typename Decl> |
| 162 | void AddTemplateSpecializations(Decl *D) { |
| 163 | auto *Common = D->getCommonPtr(); |
| 164 | |
| 165 | // If we have any lazy specializations, and the external AST source is |
| 166 | // our chained AST reader, we can just write out the DeclIDs. Otherwise, |
| 167 | // we need to resolve them to actual declarations. |
| 168 | if (Writer.Chain != Writer.Context->getExternalSource() && |
| 169 | Common->LazySpecializations) { |
| 170 | D->LoadLazySpecializations(); |
| 171 | assert(!Common->LazySpecializations); |
| 172 | } |
| 173 | |
| 174 | auto &Specializations = Common->Specializations; |
| 175 | auto &&PartialSpecializations = getPartialSpecializations(Common); |
| 176 | ArrayRef<DeclID> LazySpecializations; |
| 177 | if (auto *LS = Common->LazySpecializations) |
| 178 | LazySpecializations = ArrayRef<DeclID>(LS + 1, LS + 1 + LS[0]); |
| 179 | |
| 180 | Record.push_back(Specializations.size() + |
| 181 | PartialSpecializations.size() + |
| 182 | LazySpecializations.size()); |
| 183 | for (auto &Entry : Specializations) { |
| 184 | auto *D = getSpecializationDecl(Entry); |
| 185 | assert(D->isCanonicalDecl() && "non-canonical decl in set"); |
| 186 | Writer.AddDeclRef(D, Record); |
| 187 | } |
| 188 | for (auto &Entry : PartialSpecializations) { |
| 189 | auto *D = getSpecializationDecl(Entry); |
| 190 | assert(D->isCanonicalDecl() && "non-canonical decl in set"); |
| 191 | Writer.AddDeclRef(D, Record); |
| 192 | } |
| 193 | for (DeclID ID : LazySpecializations) |
| 194 | Record.push_back(ID); |
| 195 | } |
Chris Lattner | 12b1c76 | 2009-04-27 06:16:06 +0000 | [diff] [blame] | 196 | }; |
| 197 | } |
| 198 | |
Sebastian Redl | 3397c55 | 2010-08-18 23:56:27 +0000 | [diff] [blame] | 199 | void ASTDeclWriter::Visit(Decl *D) { |
| 200 | DeclVisitor<ASTDeclWriter>::Visit(D); |
Argyrios Kyrtzidis | 9146832 | 2010-07-02 15:58:43 +0000 | [diff] [blame] | 201 | |
Jonathan D. Turner | 953c564 | 2011-06-03 23:11:16 +0000 | [diff] [blame] | 202 | // Source locations require array (variable-length) abbreviations. The |
| 203 | // abbreviation infrastructure requires that arrays are encoded last, so |
| 204 | // we handle it here in the case of those classes derived from DeclaratorDecl |
| 205 | if (DeclaratorDecl *DD = dyn_cast<DeclaratorDecl>(D)){ |
| 206 | Writer.AddTypeSourceInfo(DD->getTypeSourceInfo(), Record); |
| 207 | } |
| 208 | |
Argyrios Kyrtzidis | 9146832 | 2010-07-02 15:58:43 +0000 | [diff] [blame] | 209 | // Handle FunctionDecl's body here and write it after all other Stmts/Exprs |
| 210 | // have been written. We want it last because we will not read it back when |
Sebastian Redl | 3397c55 | 2010-08-18 23:56:27 +0000 | [diff] [blame] | 211 | // retrieving it from the AST, we'll just lazily set the offset. |
Argyrios Kyrtzidis | 9146832 | 2010-07-02 15:58:43 +0000 | [diff] [blame] | 212 | if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) { |
Sean Hunt | 10620eb | 2011-05-06 20:44:56 +0000 | [diff] [blame] | 213 | Record.push_back(FD->doesThisDeclarationHaveABody()); |
| 214 | if (FD->doesThisDeclarationHaveABody()) |
Pirama Arumuga Nainar | 3ea9e33 | 2015-04-08 08:57:32 -0700 | [diff] [blame] | 215 | AddFunctionDefinition(FD); |
Argyrios Kyrtzidis | 9146832 | 2010-07-02 15:58:43 +0000 | [diff] [blame] | 216 | } |
| 217 | } |
| 218 | |
Sebastian Redl | 3397c55 | 2010-08-18 23:56:27 +0000 | [diff] [blame] | 219 | void ASTDeclWriter::VisitDecl(Decl *D) { |
Chris Lattner | 12b1c76 | 2009-04-27 06:16:06 +0000 | [diff] [blame] | 220 | Writer.AddDeclRef(cast_or_null<Decl>(D->getDeclContext()), Record); |
| 221 | Writer.AddDeclRef(cast_or_null<Decl>(D->getLexicalDeclContext()), Record); |
Chris Lattner | 12b1c76 | 2009-04-27 06:16:06 +0000 | [diff] [blame] | 222 | Record.push_back(D->isInvalidDecl()); |
| 223 | Record.push_back(D->hasAttrs()); |
Argyrios Kyrtzidis | 4eb9fc0 | 2010-10-18 19:20:11 +0000 | [diff] [blame] | 224 | if (D->hasAttrs()) |
Stephen Hines | 176edba | 2014-12-01 14:53:08 -0800 | [diff] [blame] | 225 | Writer.WriteAttributes(llvm::makeArrayRef(D->getAttrs().begin(), |
| 226 | D->getAttrs().size()), Record); |
Chris Lattner | 12b1c76 | 2009-04-27 06:16:06 +0000 | [diff] [blame] | 227 | Record.push_back(D->isImplicit()); |
Douglas Gregor | c070cc6 | 2010-06-17 23:14:26 +0000 | [diff] [blame] | 228 | Record.push_back(D->isUsed(false)); |
Argyrios Kyrtzidis | 6b6b42a | 2011-04-19 19:51:10 +0000 | [diff] [blame] | 229 | Record.push_back(D->isReferenced()); |
Douglas Gregor | 46cd218 | 2012-01-06 16:59:53 +0000 | [diff] [blame] | 230 | Record.push_back(D->isTopLevelDeclInObjCContainer()); |
Chris Lattner | 12b1c76 | 2009-04-27 06:16:06 +0000 | [diff] [blame] | 231 | Record.push_back(D->getAccess()); |
Douglas Gregor | 46cd218 | 2012-01-06 16:59:53 +0000 | [diff] [blame] | 232 | Record.push_back(D->isModulePrivate()); |
Douglas Gregor | 185dbd7 | 2011-12-01 02:07:58 +0000 | [diff] [blame] | 233 | Record.push_back(Writer.inferSubmoduleIDFromLocation(D->getLocation())); |
Stephen Hines | 651f13c | 2014-04-23 16:59:28 -0700 | [diff] [blame] | 234 | |
| 235 | // If this declaration injected a name into a context different from its |
| 236 | // lexical context, and that context is an imported namespace, we need to |
| 237 | // update its visible declarations to include this name. |
| 238 | // |
| 239 | // This happens when we instantiate a class with a friend declaration or a |
| 240 | // function with a local extern declaration, for instance. |
| 241 | if (D->isOutOfLine()) { |
| 242 | auto *DC = D->getDeclContext(); |
| 243 | while (auto *NS = dyn_cast<NamespaceDecl>(DC->getRedeclContext())) { |
| 244 | if (!NS->isFromASTFile()) |
| 245 | break; |
Pirama Arumuga Nainar | 3ea9e33 | 2015-04-08 08:57:32 -0700 | [diff] [blame] | 246 | Writer.UpdatedDeclContexts.insert(NS->getPrimaryContext()); |
Stephen Hines | 651f13c | 2014-04-23 16:59:28 -0700 | [diff] [blame] | 247 | if (!NS->isInlineNamespace()) |
| 248 | break; |
| 249 | DC = NS->getParent(); |
| 250 | } |
| 251 | } |
Chris Lattner | 12b1c76 | 2009-04-27 06:16:06 +0000 | [diff] [blame] | 252 | } |
| 253 | |
Sebastian Redl | 3397c55 | 2010-08-18 23:56:27 +0000 | [diff] [blame] | 254 | void ASTDeclWriter::VisitTranslationUnitDecl(TranslationUnitDecl *D) { |
Douglas Gregor | 6bf2b9f | 2011-08-12 00:15:20 +0000 | [diff] [blame] | 255 | llvm_unreachable("Translation units aren't directly serialized"); |
Chris Lattner | 12b1c76 | 2009-04-27 06:16:06 +0000 | [diff] [blame] | 256 | } |
| 257 | |
Sebastian Redl | 3397c55 | 2010-08-18 23:56:27 +0000 | [diff] [blame] | 258 | void ASTDeclWriter::VisitNamedDecl(NamedDecl *D) { |
Chris Lattner | 12b1c76 | 2009-04-27 06:16:06 +0000 | [diff] [blame] | 259 | VisitDecl(D); |
| 260 | Writer.AddDeclarationName(D->getDeclName(), Record); |
Stephen Hines | 0e2c34f | 2015-03-23 12:09:02 -0700 | [diff] [blame] | 261 | Record.push_back(needsAnonymousDeclarationNumber(D) |
| 262 | ? Writer.getAnonymousDeclarationNumber(D) |
| 263 | : 0); |
Chris Lattner | 12b1c76 | 2009-04-27 06:16:06 +0000 | [diff] [blame] | 264 | } |
| 265 | |
Sebastian Redl | 3397c55 | 2010-08-18 23:56:27 +0000 | [diff] [blame] | 266 | void ASTDeclWriter::VisitTypeDecl(TypeDecl *D) { |
Chris Lattner | 12b1c76 | 2009-04-27 06:16:06 +0000 | [diff] [blame] | 267 | VisitNamedDecl(D); |
Abramo Bagnara | 344577e | 2011-03-06 15:48:19 +0000 | [diff] [blame] | 268 | Writer.AddSourceLocation(D->getLocStart(), Record); |
Argyrios Kyrtzidis | d8a0c6f | 2010-07-02 11:55:01 +0000 | [diff] [blame] | 269 | Writer.AddTypeRef(QualType(D->getTypeForDecl(), 0), Record); |
Chris Lattner | 12b1c76 | 2009-04-27 06:16:06 +0000 | [diff] [blame] | 270 | } |
| 271 | |
Douglas Gregor | 0f45682 | 2011-12-19 14:40:25 +0000 | [diff] [blame] | 272 | void ASTDeclWriter::VisitTypedefNameDecl(TypedefNameDecl *D) { |
Douglas Gregor | a1be278 | 2011-12-17 23:38:30 +0000 | [diff] [blame] | 273 | VisitRedeclarable(D); |
Chris Lattner | 12b1c76 | 2009-04-27 06:16:06 +0000 | [diff] [blame] | 274 | VisitTypeDecl(D); |
Enea Zaffanella | c2fa6b6 | 2013-06-20 12:46:19 +0000 | [diff] [blame] | 275 | Writer.AddTypeSourceInfo(D->getTypeSourceInfo(), Record); |
| 276 | Record.push_back(D->isModed()); |
| 277 | if (D->isModed()) |
| 278 | Writer.AddTypeRef(D->getUnderlyingType(), Record); |
Douglas Gregor | 0f45682 | 2011-12-19 14:40:25 +0000 | [diff] [blame] | 279 | } |
Jonathan D. Turner | 953c564 | 2011-06-03 23:11:16 +0000 | [diff] [blame] | 280 | |
Douglas Gregor | 0f45682 | 2011-12-19 14:40:25 +0000 | [diff] [blame] | 281 | void ASTDeclWriter::VisitTypedefDecl(TypedefDecl *D) { |
| 282 | VisitTypedefNameDecl(D); |
Jonathan D. Turner | 953c564 | 2011-06-03 23:11:16 +0000 | [diff] [blame] | 283 | if (!D->hasAttrs() && |
| 284 | !D->isImplicit() && |
Rafael Espindola | bc65091 | 2013-10-17 15:37:26 +0000 | [diff] [blame] | 285 | D->getFirstDecl() == D->getMostRecentDecl() && |
Jonathan D. Turner | 953c564 | 2011-06-03 23:11:16 +0000 | [diff] [blame] | 286 | !D->isInvalidDecl() && |
Argyrios Kyrtzidis | bcf8df8 | 2011-11-23 21:11:23 +0000 | [diff] [blame] | 287 | !D->isTopLevelDeclInObjCContainer() && |
Douglas Gregor | 8d267c5 | 2011-09-09 02:06:17 +0000 | [diff] [blame] | 288 | !D->isModulePrivate() && |
Stephen Hines | 176edba | 2014-12-01 14:53:08 -0800 | [diff] [blame] | 289 | !needsAnonymousDeclarationNumber(D) && |
Jonathan D. Turner | 953c564 | 2011-06-03 23:11:16 +0000 | [diff] [blame] | 290 | D->getDeclName().getNameKind() == DeclarationName::Identifier) |
| 291 | AbbrevToUse = Writer.getDeclTypedefAbbrev(); |
| 292 | |
Sebastian Redl | 8538e8d | 2010-08-18 23:57:32 +0000 | [diff] [blame] | 293 | Code = serialization::DECL_TYPEDEF; |
Chris Lattner | 12b1c76 | 2009-04-27 06:16:06 +0000 | [diff] [blame] | 294 | } |
| 295 | |
Richard Smith | 162e1c1 | 2011-04-15 14:24:37 +0000 | [diff] [blame] | 296 | void ASTDeclWriter::VisitTypeAliasDecl(TypeAliasDecl *D) { |
Douglas Gregor | 0f45682 | 2011-12-19 14:40:25 +0000 | [diff] [blame] | 297 | VisitTypedefNameDecl(D); |
Stephen Hines | 176edba | 2014-12-01 14:53:08 -0800 | [diff] [blame] | 298 | Writer.AddDeclRef(D->getDescribedAliasTemplate(), Record); |
Richard Smith | 162e1c1 | 2011-04-15 14:24:37 +0000 | [diff] [blame] | 299 | Code = serialization::DECL_TYPEALIAS; |
| 300 | } |
| 301 | |
Sebastian Redl | 3397c55 | 2010-08-18 23:56:27 +0000 | [diff] [blame] | 302 | void ASTDeclWriter::VisitTagDecl(TagDecl *D) { |
Argyrios Kyrtzidis | a865005 | 2010-08-03 17:30:10 +0000 | [diff] [blame] | 303 | VisitRedeclarable(D); |
Douglas Gregor | d488b3a | 2011-10-26 17:53:41 +0000 | [diff] [blame] | 304 | VisitTypeDecl(D); |
Argyrios Kyrtzidis | 6b54151 | 2010-09-08 19:31:22 +0000 | [diff] [blame] | 305 | Record.push_back(D->getIdentifierNamespace()); |
Chris Lattner | 12b1c76 | 2009-04-27 06:16:06 +0000 | [diff] [blame] | 306 | Record.push_back((unsigned)D->getTagKind()); // FIXME: stable encoding |
Stephen Hines | 176edba | 2014-12-01 14:53:08 -0800 | [diff] [blame] | 307 | if (!isa<CXXRecordDecl>(D)) |
| 308 | Record.push_back(D->isCompleteDefinition()); |
Douglas Gregor | b37b648 | 2010-02-12 17:40:34 +0000 | [diff] [blame] | 309 | Record.push_back(D->isEmbeddedInDeclarator()); |
Argyrios Kyrtzidis | 717a20b | 2011-09-30 22:11:31 +0000 | [diff] [blame] | 310 | Record.push_back(D->isFreeStanding()); |
David Blaikie | e33a0a8 | 2013-07-14 01:07:41 +0000 | [diff] [blame] | 311 | Record.push_back(D->isCompleteDefinitionRequired()); |
Argyrios Kyrtzidis | ad93a74 | 2009-07-14 03:18:02 +0000 | [diff] [blame] | 312 | Writer.AddSourceLocation(D->getRBraceLoc(), Record); |
Stephen Hines | 176edba | 2014-12-01 14:53:08 -0800 | [diff] [blame] | 313 | |
| 314 | if (D->hasExtInfo()) { |
| 315 | Record.push_back(1); |
Argyrios Kyrtzidis | 4045107 | 2010-10-15 18:21:24 +0000 | [diff] [blame] | 316 | Writer.AddQualifierInfo(*D->getExtInfo(), Record); |
Stephen Hines | 176edba | 2014-12-01 14:53:08 -0800 | [diff] [blame] | 317 | } else if (auto *TD = D->getTypedefNameForAnonDecl()) { |
| 318 | Record.push_back(2); |
| 319 | Writer.AddDeclRef(TD, Record); |
| 320 | Writer.AddIdentifierRef(TD->getDeclName().getAsIdentifierInfo(), Record); |
| 321 | } else if (auto *DD = D->getDeclaratorForAnonDecl()) { |
| 322 | Record.push_back(3); |
| 323 | Writer.AddDeclRef(DD, Record); |
| 324 | } else { |
| 325 | Record.push_back(0); |
| 326 | } |
Chris Lattner | 12b1c76 | 2009-04-27 06:16:06 +0000 | [diff] [blame] | 327 | } |
| 328 | |
Sebastian Redl | 3397c55 | 2010-08-18 23:56:27 +0000 | [diff] [blame] | 329 | void ASTDeclWriter::VisitEnumDecl(EnumDecl *D) { |
Chris Lattner | 12b1c76 | 2009-04-27 06:16:06 +0000 | [diff] [blame] | 330 | VisitTagDecl(D); |
Douglas Gregor | 1274ccd | 2010-10-08 23:50:27 +0000 | [diff] [blame] | 331 | Writer.AddTypeSourceInfo(D->getIntegerTypeSourceInfo(), Record); |
| 332 | if (!D->getIntegerTypeSourceInfo()) |
| 333 | Writer.AddTypeRef(D->getIntegerType(), Record); |
John McCall | 842aef8 | 2009-12-09 09:09:27 +0000 | [diff] [blame] | 334 | Writer.AddTypeRef(D->getPromotionType(), Record); |
John McCall | 1b5a618 | 2010-05-06 08:49:23 +0000 | [diff] [blame] | 335 | Record.push_back(D->getNumPositiveBits()); |
| 336 | Record.push_back(D->getNumNegativeBits()); |
Douglas Gregor | 1274ccd | 2010-10-08 23:50:27 +0000 | [diff] [blame] | 337 | Record.push_back(D->isScoped()); |
Abramo Bagnara | a88cefd | 2010-12-03 18:54:17 +0000 | [diff] [blame] | 338 | Record.push_back(D->isScopedUsingClassTag()); |
Douglas Gregor | 1274ccd | 2010-10-08 23:50:27 +0000 | [diff] [blame] | 339 | Record.push_back(D->isFixed()); |
Richard Smith | f1c66b4 | 2012-03-14 23:13:10 +0000 | [diff] [blame] | 340 | if (MemberSpecializationInfo *MemberInfo = D->getMemberSpecializationInfo()) { |
| 341 | Writer.AddDeclRef(MemberInfo->getInstantiatedFrom(), Record); |
| 342 | Record.push_back(MemberInfo->getTemplateSpecializationKind()); |
| 343 | Writer.AddSourceLocation(MemberInfo->getPointOfInstantiation(), Record); |
| 344 | } else { |
Stephen Hines | 6bcf27b | 2014-05-29 04:14:42 -0700 | [diff] [blame] | 345 | Writer.AddDeclRef(nullptr, Record); |
Richard Smith | f1c66b4 | 2012-03-14 23:13:10 +0000 | [diff] [blame] | 346 | } |
Jonathan D. Turner | 953c564 | 2011-06-03 23:11:16 +0000 | [diff] [blame] | 347 | |
| 348 | if (!D->hasAttrs() && |
| 349 | !D->isImplicit() && |
| 350 | !D->isUsed(false) && |
Jonathan D. Turner | 953c564 | 2011-06-03 23:11:16 +0000 | [diff] [blame] | 351 | !D->hasExtInfo() && |
Stephen Hines | 176edba | 2014-12-01 14:53:08 -0800 | [diff] [blame] | 352 | !D->getTypedefNameForAnonDecl() && |
| 353 | !D->getDeclaratorForAnonDecl() && |
Rafael Espindola | bc65091 | 2013-10-17 15:37:26 +0000 | [diff] [blame] | 354 | D->getFirstDecl() == D->getMostRecentDecl() && |
Jonathan D. Turner | 953c564 | 2011-06-03 23:11:16 +0000 | [diff] [blame] | 355 | !D->isInvalidDecl() && |
| 356 | !D->isReferenced() && |
Argyrios Kyrtzidis | bcf8df8 | 2011-11-23 21:11:23 +0000 | [diff] [blame] | 357 | !D->isTopLevelDeclInObjCContainer() && |
Jonathan D. Turner | 953c564 | 2011-06-03 23:11:16 +0000 | [diff] [blame] | 358 | D->getAccess() == AS_none && |
Douglas Gregor | 8d267c5 | 2011-09-09 02:06:17 +0000 | [diff] [blame] | 359 | !D->isModulePrivate() && |
Jonathan D. Turner | 953c564 | 2011-06-03 23:11:16 +0000 | [diff] [blame] | 360 | !CXXRecordDecl::classofKind(D->getKind()) && |
| 361 | !D->getIntegerTypeSourceInfo() && |
Argyrios Kyrtzidis | 0378433 | 2013-03-18 22:23:49 +0000 | [diff] [blame] | 362 | !D->getMemberSpecializationInfo() && |
Stephen Hines | 176edba | 2014-12-01 14:53:08 -0800 | [diff] [blame] | 363 | !needsAnonymousDeclarationNumber(D) && |
Jonathan D. Turner | 953c564 | 2011-06-03 23:11:16 +0000 | [diff] [blame] | 364 | D->getDeclName().getNameKind() == DeclarationName::Identifier) |
| 365 | AbbrevToUse = Writer.getDeclEnumAbbrev(); |
| 366 | |
Sebastian Redl | 8538e8d | 2010-08-18 23:57:32 +0000 | [diff] [blame] | 367 | Code = serialization::DECL_ENUM; |
Chris Lattner | 12b1c76 | 2009-04-27 06:16:06 +0000 | [diff] [blame] | 368 | } |
| 369 | |
Sebastian Redl | 3397c55 | 2010-08-18 23:56:27 +0000 | [diff] [blame] | 370 | void ASTDeclWriter::VisitRecordDecl(RecordDecl *D) { |
Chris Lattner | 12b1c76 | 2009-04-27 06:16:06 +0000 | [diff] [blame] | 371 | VisitTagDecl(D); |
| 372 | Record.push_back(D->hasFlexibleArrayMember()); |
| 373 | Record.push_back(D->isAnonymousStructOrUnion()); |
Fariborz Jahanian | 643b7df | 2009-07-08 16:37:44 +0000 | [diff] [blame] | 374 | Record.push_back(D->hasObjectMember()); |
Fariborz Jahanian | 3ac83d6 | 2013-01-25 23:57:05 +0000 | [diff] [blame] | 375 | Record.push_back(D->hasVolatileMember()); |
Douglas Gregor | a72d8c4 | 2011-06-03 02:27:19 +0000 | [diff] [blame] | 376 | |
| 377 | if (!D->hasAttrs() && |
| 378 | !D->isImplicit() && |
| 379 | !D->isUsed(false) && |
Douglas Gregor | a72d8c4 | 2011-06-03 02:27:19 +0000 | [diff] [blame] | 380 | !D->hasExtInfo() && |
Stephen Hines | 176edba | 2014-12-01 14:53:08 -0800 | [diff] [blame] | 381 | !D->getTypedefNameForAnonDecl() && |
| 382 | !D->getDeclaratorForAnonDecl() && |
Rafael Espindola | bc65091 | 2013-10-17 15:37:26 +0000 | [diff] [blame] | 383 | D->getFirstDecl() == D->getMostRecentDecl() && |
Douglas Gregor | a72d8c4 | 2011-06-03 02:27:19 +0000 | [diff] [blame] | 384 | !D->isInvalidDecl() && |
| 385 | !D->isReferenced() && |
Argyrios Kyrtzidis | bcf8df8 | 2011-11-23 21:11:23 +0000 | [diff] [blame] | 386 | !D->isTopLevelDeclInObjCContainer() && |
Douglas Gregor | a72d8c4 | 2011-06-03 02:27:19 +0000 | [diff] [blame] | 387 | D->getAccess() == AS_none && |
Douglas Gregor | 8d267c5 | 2011-09-09 02:06:17 +0000 | [diff] [blame] | 388 | !D->isModulePrivate() && |
Douglas Gregor | a72d8c4 | 2011-06-03 02:27:19 +0000 | [diff] [blame] | 389 | !CXXRecordDecl::classofKind(D->getKind()) && |
Stephen Hines | 176edba | 2014-12-01 14:53:08 -0800 | [diff] [blame] | 390 | !needsAnonymousDeclarationNumber(D) && |
Douglas Gregor | a72d8c4 | 2011-06-03 02:27:19 +0000 | [diff] [blame] | 391 | D->getDeclName().getNameKind() == DeclarationName::Identifier) |
Douglas Gregor | a72d8c4 | 2011-06-03 02:27:19 +0000 | [diff] [blame] | 392 | AbbrevToUse = Writer.getDeclRecordAbbrev(); |
| 393 | |
Sebastian Redl | 8538e8d | 2010-08-18 23:57:32 +0000 | [diff] [blame] | 394 | Code = serialization::DECL_RECORD; |
Chris Lattner | 12b1c76 | 2009-04-27 06:16:06 +0000 | [diff] [blame] | 395 | } |
| 396 | |
Sebastian Redl | 3397c55 | 2010-08-18 23:56:27 +0000 | [diff] [blame] | 397 | void ASTDeclWriter::VisitValueDecl(ValueDecl *D) { |
Chris Lattner | 12b1c76 | 2009-04-27 06:16:06 +0000 | [diff] [blame] | 398 | VisitNamedDecl(D); |
| 399 | Writer.AddTypeRef(D->getType(), Record); |
| 400 | } |
| 401 | |
Sebastian Redl | 3397c55 | 2010-08-18 23:56:27 +0000 | [diff] [blame] | 402 | void ASTDeclWriter::VisitEnumConstantDecl(EnumConstantDecl *D) { |
Chris Lattner | 12b1c76 | 2009-04-27 06:16:06 +0000 | [diff] [blame] | 403 | VisitValueDecl(D); |
| 404 | Record.push_back(D->getInitExpr()? 1 : 0); |
| 405 | if (D->getInitExpr()) |
| 406 | Writer.AddStmt(D->getInitExpr()); |
| 407 | Writer.AddAPSInt(D->getInitVal(), Record); |
Douglas Gregor | a72d8c4 | 2011-06-03 02:27:19 +0000 | [diff] [blame] | 408 | |
Sebastian Redl | 8538e8d | 2010-08-18 23:57:32 +0000 | [diff] [blame] | 409 | Code = serialization::DECL_ENUM_CONSTANT; |
Chris Lattner | 12b1c76 | 2009-04-27 06:16:06 +0000 | [diff] [blame] | 410 | } |
Argyrios Kyrtzidis | d4a7e54 | 2009-08-19 01:28:35 +0000 | [diff] [blame] | 411 | |
Sebastian Redl | 3397c55 | 2010-08-18 23:56:27 +0000 | [diff] [blame] | 412 | void ASTDeclWriter::VisitDeclaratorDecl(DeclaratorDecl *D) { |
Argyrios Kyrtzidis | d4a7e54 | 2009-08-19 01:28:35 +0000 | [diff] [blame] | 413 | VisitValueDecl(D); |
Abramo Bagnara | ff676cb | 2011-03-08 08:55:46 +0000 | [diff] [blame] | 414 | Writer.AddSourceLocation(D->getInnerLocStart(), Record); |
Argyrios Kyrtzidis | 4045107 | 2010-10-15 18:21:24 +0000 | [diff] [blame] | 415 | Record.push_back(D->hasExtInfo()); |
| 416 | if (D->hasExtInfo()) |
| 417 | Writer.AddQualifierInfo(*D->getExtInfo(), Record); |
Argyrios Kyrtzidis | d4a7e54 | 2009-08-19 01:28:35 +0000 | [diff] [blame] | 418 | } |
Chris Lattner | 12b1c76 | 2009-04-27 06:16:06 +0000 | [diff] [blame] | 419 | |
Sebastian Redl | 3397c55 | 2010-08-18 23:56:27 +0000 | [diff] [blame] | 420 | void ASTDeclWriter::VisitFunctionDecl(FunctionDecl *D) { |
Argyrios Kyrtzidis | 6b54151 | 2010-09-08 19:31:22 +0000 | [diff] [blame] | 421 | VisitRedeclarable(D); |
Douglas Gregor | d488b3a | 2011-10-26 17:53:41 +0000 | [diff] [blame] | 422 | VisitDeclaratorDecl(D); |
Argyrios Kyrtzidis | 4045107 | 2010-10-15 18:21:24 +0000 | [diff] [blame] | 423 | Writer.AddDeclarationNameLoc(D->DNLoc, D->getDeclName(), Record); |
Argyrios Kyrtzidis | c8f9af2 | 2010-07-05 10:38:01 +0000 | [diff] [blame] | 424 | Record.push_back(D->getIdentifierNamespace()); |
Douglas Gregor | 7076281 | 2012-01-04 17:13:46 +0000 | [diff] [blame] | 425 | |
| 426 | // FunctionDecl's body is handled last at ASTWriterDecl::Visit, |
| 427 | // after everything else is written. |
| 428 | |
Stephen Hines | 0e2c34f | 2015-03-23 12:09:02 -0700 | [diff] [blame] | 429 | Record.push_back((int)D->SClass); // FIXME: stable encoding |
Douglas Gregor | 7076281 | 2012-01-04 17:13:46 +0000 | [diff] [blame] | 430 | Record.push_back(D->IsInline); |
Stephen Hines | 0e2c34f | 2015-03-23 12:09:02 -0700 | [diff] [blame] | 431 | Record.push_back(D->IsInlineSpecified); |
| 432 | Record.push_back(D->IsVirtualAsWritten); |
| 433 | Record.push_back(D->IsPure); |
| 434 | Record.push_back(D->HasInheritedPrototype); |
| 435 | Record.push_back(D->HasWrittenPrototype); |
| 436 | Record.push_back(D->IsDeleted); |
| 437 | Record.push_back(D->IsTrivial); |
| 438 | Record.push_back(D->IsDefaulted); |
| 439 | Record.push_back(D->IsExplicitlyDefaulted); |
| 440 | Record.push_back(D->HasImplicitReturnZero); |
| 441 | Record.push_back(D->IsConstexpr); |
Argyrios Kyrtzidis | 35f3f36 | 2012-12-06 18:59:10 +0000 | [diff] [blame] | 442 | Record.push_back(D->HasSkippedBody); |
Stephen Hines | 0e2c34f | 2015-03-23 12:09:02 -0700 | [diff] [blame] | 443 | Record.push_back(D->IsLateTemplateParsed); |
Rafael Espindola | 181e3ec | 2013-05-13 00:12:11 +0000 | [diff] [blame] | 444 | Record.push_back(D->getLinkageInternal()); |
Douglas Gregor | 7076281 | 2012-01-04 17:13:46 +0000 | [diff] [blame] | 445 | Writer.AddSourceLocation(D->getLocEnd(), Record); |
| 446 | |
Argyrios Kyrtzidis | f511ba6 | 2010-06-22 09:55:07 +0000 | [diff] [blame] | 447 | Record.push_back(D->getTemplatedKind()); |
| 448 | switch (D->getTemplatedKind()) { |
| 449 | case FunctionDecl::TK_NonTemplate: |
| 450 | break; |
| 451 | case FunctionDecl::TK_FunctionTemplate: |
| 452 | Writer.AddDeclRef(D->getDescribedFunctionTemplate(), Record); |
| 453 | break; |
| 454 | case FunctionDecl::TK_MemberSpecialization: { |
| 455 | MemberSpecializationInfo *MemberInfo = D->getMemberSpecializationInfo(); |
| 456 | Writer.AddDeclRef(MemberInfo->getInstantiatedFrom(), Record); |
| 457 | Record.push_back(MemberInfo->getTemplateSpecializationKind()); |
| 458 | Writer.AddSourceLocation(MemberInfo->getPointOfInstantiation(), Record); |
| 459 | break; |
| 460 | } |
| 461 | case FunctionDecl::TK_FunctionTemplateSpecialization: { |
| 462 | FunctionTemplateSpecializationInfo * |
| 463 | FTSInfo = D->getTemplateSpecializationInfo(); |
Argyrios Kyrtzidis | a626a3d | 2010-09-09 11:28:23 +0000 | [diff] [blame] | 464 | Writer.AddDeclRef(FTSInfo->getTemplate(), Record); |
Argyrios Kyrtzidis | f511ba6 | 2010-06-22 09:55:07 +0000 | [diff] [blame] | 465 | Record.push_back(FTSInfo->getTemplateSpecializationKind()); |
| 466 | |
| 467 | // Template arguments. |
Argyrios Kyrtzidis | dd41c14 | 2010-06-23 13:48:30 +0000 | [diff] [blame] | 468 | Writer.AddTemplateArgumentList(FTSInfo->TemplateArguments, Record); |
Argyrios Kyrtzidis | f511ba6 | 2010-06-22 09:55:07 +0000 | [diff] [blame] | 469 | |
| 470 | // Template args as written. |
Stephen Hines | 6bcf27b | 2014-05-29 04:14:42 -0700 | [diff] [blame] | 471 | Record.push_back(FTSInfo->TemplateArgumentsAsWritten != nullptr); |
Argyrios Kyrtzidis | f511ba6 | 2010-06-22 09:55:07 +0000 | [diff] [blame] | 472 | if (FTSInfo->TemplateArgumentsAsWritten) { |
Argyrios Kyrtzidis | 71a7605 | 2011-09-22 20:07:09 +0000 | [diff] [blame] | 473 | Record.push_back(FTSInfo->TemplateArgumentsAsWritten->NumTemplateArgs); |
| 474 | for (int i=0, e = FTSInfo->TemplateArgumentsAsWritten->NumTemplateArgs; |
| 475 | i!=e; ++i) |
Argyrios Kyrtzidis | f511ba6 | 2010-06-22 09:55:07 +0000 | [diff] [blame] | 476 | Writer.AddTemplateArgumentLoc((*FTSInfo->TemplateArgumentsAsWritten)[i], |
| 477 | Record); |
Argyrios Kyrtzidis | 71a7605 | 2011-09-22 20:07:09 +0000 | [diff] [blame] | 478 | Writer.AddSourceLocation(FTSInfo->TemplateArgumentsAsWritten->LAngleLoc, |
Argyrios Kyrtzidis | f511ba6 | 2010-06-22 09:55:07 +0000 | [diff] [blame] | 479 | Record); |
Argyrios Kyrtzidis | 71a7605 | 2011-09-22 20:07:09 +0000 | [diff] [blame] | 480 | Writer.AddSourceLocation(FTSInfo->TemplateArgumentsAsWritten->RAngleLoc, |
Argyrios Kyrtzidis | f511ba6 | 2010-06-22 09:55:07 +0000 | [diff] [blame] | 481 | Record); |
Argyrios Kyrtzidis | f511ba6 | 2010-06-22 09:55:07 +0000 | [diff] [blame] | 482 | } |
Argyrios Kyrtzidis | 7b081c8 | 2010-07-05 10:37:55 +0000 | [diff] [blame] | 483 | |
| 484 | Writer.AddSourceLocation(FTSInfo->getPointOfInstantiation(), Record); |
Argyrios Kyrtzidis | 99a8ca0 | 2010-09-13 11:45:48 +0000 | [diff] [blame] | 485 | |
| 486 | if (D->isCanonicalDecl()) { |
| 487 | // Write the template that contains the specializations set. We will |
| 488 | // add a FunctionTemplateSpecializationInfo to it when reading. |
| 489 | Writer.AddDeclRef(FTSInfo->getTemplate()->getCanonicalDecl(), Record); |
| 490 | } |
Argyrios Kyrtzidis | a56b049 | 2010-06-25 16:24:51 +0000 | [diff] [blame] | 491 | break; |
Argyrios Kyrtzidis | f511ba6 | 2010-06-22 09:55:07 +0000 | [diff] [blame] | 492 | } |
| 493 | case FunctionDecl::TK_DependentFunctionTemplateSpecialization: { |
| 494 | DependentFunctionTemplateSpecializationInfo * |
| 495 | DFTSInfo = D->getDependentSpecializationInfo(); |
| 496 | |
| 497 | // Templates. |
| 498 | Record.push_back(DFTSInfo->getNumTemplates()); |
| 499 | for (int i=0, e = DFTSInfo->getNumTemplates(); i != e; ++i) |
| 500 | Writer.AddDeclRef(DFTSInfo->getTemplate(i), Record); |
| 501 | |
| 502 | // Templates args. |
| 503 | Record.push_back(DFTSInfo->getNumTemplateArgs()); |
| 504 | for (int i=0, e = DFTSInfo->getNumTemplateArgs(); i != e; ++i) |
| 505 | Writer.AddTemplateArgumentLoc(DFTSInfo->getTemplateArg(i), Record); |
Argyrios Kyrtzidis | 7b081c8 | 2010-07-05 10:37:55 +0000 | [diff] [blame] | 506 | Writer.AddSourceLocation(DFTSInfo->getLAngleLoc(), Record); |
| 507 | Writer.AddSourceLocation(DFTSInfo->getRAngleLoc(), Record); |
Argyrios Kyrtzidis | a56b049 | 2010-06-25 16:24:51 +0000 | [diff] [blame] | 508 | break; |
Argyrios Kyrtzidis | f511ba6 | 2010-06-22 09:55:07 +0000 | [diff] [blame] | 509 | } |
| 510 | } |
Chris Lattner | 6ad9ac0 | 2010-05-07 21:43:38 +0000 | [diff] [blame] | 511 | |
Chris Lattner | 12b1c76 | 2009-04-27 06:16:06 +0000 | [diff] [blame] | 512 | Record.push_back(D->param_size()); |
Stephen Hines | 651f13c | 2014-04-23 16:59:28 -0700 | [diff] [blame] | 513 | for (auto P : D->params()) |
| 514 | Writer.AddDeclRef(P, Record); |
Sebastian Redl | 8538e8d | 2010-08-18 23:57:32 +0000 | [diff] [blame] | 515 | Code = serialization::DECL_FUNCTION; |
Chris Lattner | 12b1c76 | 2009-04-27 06:16:06 +0000 | [diff] [blame] | 516 | } |
| 517 | |
Sebastian Redl | 3397c55 | 2010-08-18 23:56:27 +0000 | [diff] [blame] | 518 | void ASTDeclWriter::VisitObjCMethodDecl(ObjCMethodDecl *D) { |
Chris Lattner | 12b1c76 | 2009-04-27 06:16:06 +0000 | [diff] [blame] | 519 | VisitNamedDecl(D); |
| 520 | // FIXME: convert to LazyStmtPtr? |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 521 | // Unlike C/C++, method bodies will never be in header files. |
Stephen Hines | 6bcf27b | 2014-05-29 04:14:42 -0700 | [diff] [blame] | 522 | bool HasBodyStuff = D->getBody() != nullptr || |
| 523 | D->getSelfDecl() != nullptr || D->getCmdDecl() != nullptr; |
Argyrios Kyrtzidis | 2f92230 | 2010-08-09 10:54:37 +0000 | [diff] [blame] | 524 | Record.push_back(HasBodyStuff); |
| 525 | if (HasBodyStuff) { |
Argyrios Kyrtzidis | 6fb0aee | 2009-06-30 02:35:26 +0000 | [diff] [blame] | 526 | Writer.AddStmt(D->getBody()); |
Chris Lattner | 12b1c76 | 2009-04-27 06:16:06 +0000 | [diff] [blame] | 527 | Writer.AddDeclRef(D->getSelfDecl(), Record); |
| 528 | Writer.AddDeclRef(D->getCmdDecl(), Record); |
| 529 | } |
| 530 | Record.push_back(D->isInstanceMethod()); |
| 531 | Record.push_back(D->isVariadic()); |
Jordan Rose | 1e4691b | 2012-10-10 16:42:25 +0000 | [diff] [blame] | 532 | Record.push_back(D->isPropertyAccessor()); |
Fariborz Jahanian | 3fe1041 | 2010-07-22 18:24:20 +0000 | [diff] [blame] | 533 | Record.push_back(D->isDefined()); |
Argyrios Kyrtzidis | e15db6f | 2012-05-09 16:12:57 +0000 | [diff] [blame] | 534 | Record.push_back(D->IsOverriding); |
Argyrios Kyrtzidis | 35f3f36 | 2012-12-06 18:59:10 +0000 | [diff] [blame] | 535 | Record.push_back(D->HasSkippedBody); |
Argyrios Kyrtzidis | 72b2625 | 2011-10-14 17:41:52 +0000 | [diff] [blame] | 536 | |
| 537 | Record.push_back(D->IsRedeclaration); |
| 538 | Record.push_back(D->HasRedeclaration); |
| 539 | if (D->HasRedeclaration) { |
| 540 | assert(Context.getObjCMethodRedeclaration(D)); |
| 541 | Writer.AddDeclRef(Context.getObjCMethodRedeclaration(D), Record); |
| 542 | } |
| 543 | |
Chris Lattner | 12b1c76 | 2009-04-27 06:16:06 +0000 | [diff] [blame] | 544 | // FIXME: stable encoding for @required/@optional |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 545 | Record.push_back(D->getImplementationControl()); |
Chris Lattner | 12b1c76 | 2009-04-27 06:16:06 +0000 | [diff] [blame] | 546 | // FIXME: stable encoding for in/out/inout/bycopy/byref/oneway |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 547 | Record.push_back(D->getObjCDeclQualifier()); |
Douglas Gregor | 926df6c | 2011-06-11 01:09:30 +0000 | [diff] [blame] | 548 | Record.push_back(D->hasRelatedResultType()); |
Stephen Hines | 651f13c | 2014-04-23 16:59:28 -0700 | [diff] [blame] | 549 | Writer.AddTypeRef(D->getReturnType(), Record); |
| 550 | Writer.AddTypeSourceInfo(D->getReturnTypeSourceInfo(), Record); |
Chris Lattner | 12b1c76 | 2009-04-27 06:16:06 +0000 | [diff] [blame] | 551 | Writer.AddSourceLocation(D->getLocEnd(), Record); |
| 552 | Record.push_back(D->param_size()); |
Stephen Hines | 651f13c | 2014-04-23 16:59:28 -0700 | [diff] [blame] | 553 | for (const auto *P : D->params()) |
| 554 | Writer.AddDeclRef(P, Record); |
Argyrios Kyrtzidis | 491306a | 2011-10-03 06:37:04 +0000 | [diff] [blame] | 555 | |
| 556 | Record.push_back(D->SelLocsKind); |
| 557 | unsigned NumStoredSelLocs = D->getNumStoredSelLocs(); |
| 558 | SourceLocation *SelLocs = D->getStoredSelLocs(); |
| 559 | Record.push_back(NumStoredSelLocs); |
| 560 | for (unsigned i = 0; i != NumStoredSelLocs; ++i) |
| 561 | Writer.AddSourceLocation(SelLocs[i], Record); |
| 562 | |
Sebastian Redl | 8538e8d | 2010-08-18 23:57:32 +0000 | [diff] [blame] | 563 | Code = serialization::DECL_OBJC_METHOD; |
Chris Lattner | 12b1c76 | 2009-04-27 06:16:06 +0000 | [diff] [blame] | 564 | } |
| 565 | |
Sebastian Redl | 3397c55 | 2010-08-18 23:56:27 +0000 | [diff] [blame] | 566 | void ASTDeclWriter::VisitObjCContainerDecl(ObjCContainerDecl *D) { |
Chris Lattner | 12b1c76 | 2009-04-27 06:16:06 +0000 | [diff] [blame] | 567 | VisitNamedDecl(D); |
Argyrios Kyrtzidis | 1711fc9 | 2011-10-04 04:48:02 +0000 | [diff] [blame] | 568 | Writer.AddSourceLocation(D->getAtStartLoc(), Record); |
Chris Lattner | 6ad9ac0 | 2010-05-07 21:43:38 +0000 | [diff] [blame] | 569 | Writer.AddSourceRange(D->getAtEndRange(), Record); |
Sebastian Redl | 8538e8d | 2010-08-18 23:57:32 +0000 | [diff] [blame] | 570 | // Abstract class (no need to define a stable serialization::DECL code). |
Chris Lattner | 12b1c76 | 2009-04-27 06:16:06 +0000 | [diff] [blame] | 571 | } |
| 572 | |
Sebastian Redl | 3397c55 | 2010-08-18 23:56:27 +0000 | [diff] [blame] | 573 | void ASTDeclWriter::VisitObjCInterfaceDecl(ObjCInterfaceDecl *D) { |
Douglas Gregor | 53df7a1 | 2011-12-15 18:03:09 +0000 | [diff] [blame] | 574 | VisitRedeclarable(D); |
Chris Lattner | 12b1c76 | 2009-04-27 06:16:06 +0000 | [diff] [blame] | 575 | VisitObjCContainerDecl(D); |
| 576 | Writer.AddTypeRef(QualType(D->getTypeForDecl(), 0), Record); |
Ted Kremenek | 53b9441 | 2010-09-01 01:21:15 +0000 | [diff] [blame] | 577 | |
Douglas Gregor | c23f857 | 2012-01-15 18:17:48 +0000 | [diff] [blame] | 578 | Record.push_back(D->isThisDeclarationADefinition()); |
| 579 | if (D->isThisDeclarationADefinition()) { |
Douglas Gregor | 2e5c15b | 2011-12-15 05:27:12 +0000 | [diff] [blame] | 580 | // Write the DefinitionData |
| 581 | ObjCInterfaceDecl::DefinitionData &Data = D->data(); |
| 582 | |
| 583 | Writer.AddDeclRef(D->getSuperClass(), Record); |
| 584 | Writer.AddSourceLocation(D->getSuperClassLoc(), Record); |
Douglas Gregor | 05c272f | 2011-12-15 22:34:59 +0000 | [diff] [blame] | 585 | Writer.AddSourceLocation(D->getEndOfDefinitionLoc(), Record); |
Stephen Hines | 651f13c | 2014-04-23 16:59:28 -0700 | [diff] [blame] | 586 | Record.push_back(Data.HasDesignatedInitializers); |
Douglas Gregor | 05c272f | 2011-12-15 22:34:59 +0000 | [diff] [blame] | 587 | |
Douglas Gregor | 2e5c15b | 2011-12-15 05:27:12 +0000 | [diff] [blame] | 588 | // Write out the protocols that are directly referenced by the @interface. |
| 589 | Record.push_back(Data.ReferencedProtocols.size()); |
Stephen Hines | 651f13c | 2014-04-23 16:59:28 -0700 | [diff] [blame] | 590 | for (const auto *P : D->protocols()) |
| 591 | Writer.AddDeclRef(P, Record); |
| 592 | for (const auto &PL : D->protocol_locs()) |
| 593 | Writer.AddSourceLocation(PL, Record); |
Douglas Gregor | 2e5c15b | 2011-12-15 05:27:12 +0000 | [diff] [blame] | 594 | |
| 595 | // Write out the protocols that are transitively referenced. |
| 596 | Record.push_back(Data.AllReferencedProtocols.size()); |
| 597 | for (ObjCList<ObjCProtocolDecl>::iterator |
| 598 | P = Data.AllReferencedProtocols.begin(), |
| 599 | PEnd = Data.AllReferencedProtocols.end(); |
| 600 | P != PEnd; ++P) |
| 601 | Writer.AddDeclRef(*P, Record); |
Douglas Gregor | d329724 | 2013-01-16 23:00:23 +0000 | [diff] [blame] | 602 | |
Douglas Gregor | 2e5c15b | 2011-12-15 05:27:12 +0000 | [diff] [blame] | 603 | |
Douglas Gregor | d329724 | 2013-01-16 23:00:23 +0000 | [diff] [blame] | 604 | if (ObjCCategoryDecl *Cat = D->getCategoryListRaw()) { |
Douglas Gregor | cff9f26 | 2012-01-27 01:47:08 +0000 | [diff] [blame] | 605 | // Ensure that we write out the set of categories for this class. |
| 606 | Writer.ObjCClassesWithCategories.insert(D); |
| 607 | |
| 608 | // Make sure that the categories get serialized. |
Douglas Gregor | d329724 | 2013-01-16 23:00:23 +0000 | [diff] [blame] | 609 | for (; Cat; Cat = Cat->getNextClassCategoryRaw()) |
Douglas Gregor | cff9f26 | 2012-01-27 01:47:08 +0000 | [diff] [blame] | 610 | (void)Writer.GetDeclRef(Cat); |
| 611 | } |
Douglas Gregor | 2e5c15b | 2011-12-15 05:27:12 +0000 | [diff] [blame] | 612 | } |
| 613 | |
Sebastian Redl | 8538e8d | 2010-08-18 23:57:32 +0000 | [diff] [blame] | 614 | Code = serialization::DECL_OBJC_INTERFACE; |
Chris Lattner | 12b1c76 | 2009-04-27 06:16:06 +0000 | [diff] [blame] | 615 | } |
| 616 | |
Sebastian Redl | 3397c55 | 2010-08-18 23:56:27 +0000 | [diff] [blame] | 617 | void ASTDeclWriter::VisitObjCIvarDecl(ObjCIvarDecl *D) { |
Chris Lattner | 12b1c76 | 2009-04-27 06:16:06 +0000 | [diff] [blame] | 618 | VisitFieldDecl(D); |
| 619 | // FIXME: stable encoding for @public/@private/@protected/@package |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 620 | Record.push_back(D->getAccessControl()); |
Fariborz Jahanian | ac0021b | 2010-07-17 18:35:47 +0000 | [diff] [blame] | 621 | Record.push_back(D->getSynthesize()); |
Jonathan D. Turner | 953c564 | 2011-06-03 23:11:16 +0000 | [diff] [blame] | 622 | |
| 623 | if (!D->hasAttrs() && |
| 624 | !D->isImplicit() && |
| 625 | !D->isUsed(false) && |
| 626 | !D->isInvalidDecl() && |
| 627 | !D->isReferenced() && |
Douglas Gregor | 8d267c5 | 2011-09-09 02:06:17 +0000 | [diff] [blame] | 628 | !D->isModulePrivate() && |
Jonathan D. Turner | 953c564 | 2011-06-03 23:11:16 +0000 | [diff] [blame] | 629 | !D->getBitWidth() && |
| 630 | !D->hasExtInfo() && |
| 631 | D->getDeclName()) |
| 632 | AbbrevToUse = Writer.getDeclObjCIvarAbbrev(); |
| 633 | |
Sebastian Redl | 8538e8d | 2010-08-18 23:57:32 +0000 | [diff] [blame] | 634 | Code = serialization::DECL_OBJC_IVAR; |
Chris Lattner | 12b1c76 | 2009-04-27 06:16:06 +0000 | [diff] [blame] | 635 | } |
| 636 | |
Sebastian Redl | 3397c55 | 2010-08-18 23:56:27 +0000 | [diff] [blame] | 637 | void ASTDeclWriter::VisitObjCProtocolDecl(ObjCProtocolDecl *D) { |
Douglas Gregor | 1d784b2 | 2012-01-01 19:51:50 +0000 | [diff] [blame] | 638 | VisitRedeclarable(D); |
Chris Lattner | 12b1c76 | 2009-04-27 06:16:06 +0000 | [diff] [blame] | 639 | VisitObjCContainerDecl(D); |
Douglas Gregor | 5e2a1ff | 2012-01-01 19:29:29 +0000 | [diff] [blame] | 640 | |
Douglas Gregor | c23f857 | 2012-01-15 18:17:48 +0000 | [diff] [blame] | 641 | Record.push_back(D->isThisDeclarationADefinition()); |
| 642 | if (D->isThisDeclarationADefinition()) { |
Douglas Gregor | 5e2a1ff | 2012-01-01 19:29:29 +0000 | [diff] [blame] | 643 | Record.push_back(D->protocol_size()); |
Stephen Hines | 651f13c | 2014-04-23 16:59:28 -0700 | [diff] [blame] | 644 | for (const auto *I : D->protocols()) |
| 645 | Writer.AddDeclRef(I, Record); |
| 646 | for (const auto &PL : D->protocol_locs()) |
| 647 | Writer.AddSourceLocation(PL, Record); |
Douglas Gregor | 5e2a1ff | 2012-01-01 19:29:29 +0000 | [diff] [blame] | 648 | } |
| 649 | |
Sebastian Redl | 8538e8d | 2010-08-18 23:57:32 +0000 | [diff] [blame] | 650 | Code = serialization::DECL_OBJC_PROTOCOL; |
Chris Lattner | 12b1c76 | 2009-04-27 06:16:06 +0000 | [diff] [blame] | 651 | } |
| 652 | |
Sebastian Redl | 3397c55 | 2010-08-18 23:56:27 +0000 | [diff] [blame] | 653 | void ASTDeclWriter::VisitObjCAtDefsFieldDecl(ObjCAtDefsFieldDecl *D) { |
Chris Lattner | 12b1c76 | 2009-04-27 06:16:06 +0000 | [diff] [blame] | 654 | VisitFieldDecl(D); |
Sebastian Redl | 8538e8d | 2010-08-18 23:57:32 +0000 | [diff] [blame] | 655 | Code = serialization::DECL_OBJC_AT_DEFS_FIELD; |
Chris Lattner | 12b1c76 | 2009-04-27 06:16:06 +0000 | [diff] [blame] | 656 | } |
| 657 | |
Sebastian Redl | 3397c55 | 2010-08-18 23:56:27 +0000 | [diff] [blame] | 658 | void ASTDeclWriter::VisitObjCCategoryDecl(ObjCCategoryDecl *D) { |
Chris Lattner | 12b1c76 | 2009-04-27 06:16:06 +0000 | [diff] [blame] | 659 | VisitObjCContainerDecl(D); |
Douglas Gregor | cff9f26 | 2012-01-27 01:47:08 +0000 | [diff] [blame] | 660 | Writer.AddSourceLocation(D->getCategoryNameLoc(), Record); |
Fariborz Jahanian | af30029 | 2012-02-20 20:09:20 +0000 | [diff] [blame] | 661 | Writer.AddSourceLocation(D->getIvarLBraceLoc(), Record); |
| 662 | Writer.AddSourceLocation(D->getIvarRBraceLoc(), Record); |
Chris Lattner | 12b1c76 | 2009-04-27 06:16:06 +0000 | [diff] [blame] | 663 | Writer.AddDeclRef(D->getClassInterface(), Record); |
| 664 | Record.push_back(D->protocol_size()); |
Stephen Hines | 651f13c | 2014-04-23 16:59:28 -0700 | [diff] [blame] | 665 | for (const auto *I : D->protocols()) |
| 666 | Writer.AddDeclRef(I, Record); |
| 667 | for (const auto &PL : D->protocol_locs()) |
| 668 | Writer.AddSourceLocation(PL, Record); |
Sebastian Redl | 8538e8d | 2010-08-18 23:57:32 +0000 | [diff] [blame] | 669 | Code = serialization::DECL_OBJC_CATEGORY; |
Chris Lattner | 12b1c76 | 2009-04-27 06:16:06 +0000 | [diff] [blame] | 670 | } |
| 671 | |
Sebastian Redl | 3397c55 | 2010-08-18 23:56:27 +0000 | [diff] [blame] | 672 | void ASTDeclWriter::VisitObjCCompatibleAliasDecl(ObjCCompatibleAliasDecl *D) { |
Chris Lattner | 12b1c76 | 2009-04-27 06:16:06 +0000 | [diff] [blame] | 673 | VisitNamedDecl(D); |
| 674 | Writer.AddDeclRef(D->getClassInterface(), Record); |
Sebastian Redl | 8538e8d | 2010-08-18 23:57:32 +0000 | [diff] [blame] | 675 | Code = serialization::DECL_OBJC_COMPATIBLE_ALIAS; |
Chris Lattner | 12b1c76 | 2009-04-27 06:16:06 +0000 | [diff] [blame] | 676 | } |
| 677 | |
Sebastian Redl | 3397c55 | 2010-08-18 23:56:27 +0000 | [diff] [blame] | 678 | void ASTDeclWriter::VisitObjCPropertyDecl(ObjCPropertyDecl *D) { |
Chris Lattner | 12b1c76 | 2009-04-27 06:16:06 +0000 | [diff] [blame] | 679 | VisitNamedDecl(D); |
Fariborz Jahanian | d050240 | 2010-01-21 17:36:00 +0000 | [diff] [blame] | 680 | Writer.AddSourceLocation(D->getAtLoc(), Record); |
Fariborz Jahanian | 77bfb8b | 2012-02-29 22:18:55 +0000 | [diff] [blame] | 681 | Writer.AddSourceLocation(D->getLParenLoc(), Record); |
John McCall | 83a230c | 2010-06-04 20:50:08 +0000 | [diff] [blame] | 682 | Writer.AddTypeSourceInfo(D->getTypeSourceInfo(), Record); |
Chris Lattner | 12b1c76 | 2009-04-27 06:16:06 +0000 | [diff] [blame] | 683 | // FIXME: stable encoding |
| 684 | Record.push_back((unsigned)D->getPropertyAttributes()); |
Fariborz Jahanian | 80aa1cd | 2010-06-22 23:20:40 +0000 | [diff] [blame] | 685 | Record.push_back((unsigned)D->getPropertyAttributesAsWritten()); |
Chris Lattner | 12b1c76 | 2009-04-27 06:16:06 +0000 | [diff] [blame] | 686 | // FIXME: stable encoding |
| 687 | Record.push_back((unsigned)D->getPropertyImplementation()); |
| 688 | Writer.AddDeclarationName(D->getGetterName(), Record); |
| 689 | Writer.AddDeclarationName(D->getSetterName(), Record); |
| 690 | Writer.AddDeclRef(D->getGetterMethodDecl(), Record); |
| 691 | Writer.AddDeclRef(D->getSetterMethodDecl(), Record); |
| 692 | Writer.AddDeclRef(D->getPropertyIvarDecl(), Record); |
Sebastian Redl | 8538e8d | 2010-08-18 23:57:32 +0000 | [diff] [blame] | 693 | Code = serialization::DECL_OBJC_PROPERTY; |
Chris Lattner | 12b1c76 | 2009-04-27 06:16:06 +0000 | [diff] [blame] | 694 | } |
| 695 | |
Sebastian Redl | 3397c55 | 2010-08-18 23:56:27 +0000 | [diff] [blame] | 696 | void ASTDeclWriter::VisitObjCImplDecl(ObjCImplDecl *D) { |
Argyrios Kyrtzidis | aecae62 | 2009-07-27 19:04:32 +0000 | [diff] [blame] | 697 | VisitObjCContainerDecl(D); |
Chris Lattner | 12b1c76 | 2009-04-27 06:16:06 +0000 | [diff] [blame] | 698 | Writer.AddDeclRef(D->getClassInterface(), Record); |
Sebastian Redl | 8538e8d | 2010-08-18 23:57:32 +0000 | [diff] [blame] | 699 | // Abstract class (no need to define a stable serialization::DECL code). |
Chris Lattner | 12b1c76 | 2009-04-27 06:16:06 +0000 | [diff] [blame] | 700 | } |
| 701 | |
Sebastian Redl | 3397c55 | 2010-08-18 23:56:27 +0000 | [diff] [blame] | 702 | void ASTDeclWriter::VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D) { |
Chris Lattner | 12b1c76 | 2009-04-27 06:16:06 +0000 | [diff] [blame] | 703 | VisitObjCImplDecl(D); |
| 704 | Writer.AddIdentifierRef(D->getIdentifier(), Record); |
Argyrios Kyrtzidis | c699400 | 2011-12-09 00:31:40 +0000 | [diff] [blame] | 705 | Writer.AddSourceLocation(D->getCategoryNameLoc(), Record); |
Sebastian Redl | 8538e8d | 2010-08-18 23:57:32 +0000 | [diff] [blame] | 706 | Code = serialization::DECL_OBJC_CATEGORY_IMPL; |
Chris Lattner | 12b1c76 | 2009-04-27 06:16:06 +0000 | [diff] [blame] | 707 | } |
| 708 | |
Sebastian Redl | 3397c55 | 2010-08-18 23:56:27 +0000 | [diff] [blame] | 709 | void ASTDeclWriter::VisitObjCImplementationDecl(ObjCImplementationDecl *D) { |
Chris Lattner | 12b1c76 | 2009-04-27 06:16:06 +0000 | [diff] [blame] | 710 | VisitObjCImplDecl(D); |
| 711 | Writer.AddDeclRef(D->getSuperClass(), Record); |
Argyrios Kyrtzidis | 2f72900 | 2013-05-03 22:31:26 +0000 | [diff] [blame] | 712 | Writer.AddSourceLocation(D->getSuperClassLoc(), Record); |
Fariborz Jahanian | af30029 | 2012-02-20 20:09:20 +0000 | [diff] [blame] | 713 | Writer.AddSourceLocation(D->getIvarLBraceLoc(), Record); |
| 714 | Writer.AddSourceLocation(D->getIvarRBraceLoc(), Record); |
John McCall | b03527a | 2012-10-17 04:53:31 +0000 | [diff] [blame] | 715 | Record.push_back(D->hasNonZeroConstructors()); |
| 716 | Record.push_back(D->hasDestructors()); |
Pirama Arumuga Nainar | 3ea9e33 | 2015-04-08 08:57:32 -0700 | [diff] [blame] | 717 | Record.push_back(D->NumIvarInitializers); |
| 718 | if (D->NumIvarInitializers) |
| 719 | Writer.AddCXXCtorInitializersRef( |
| 720 | llvm::makeArrayRef(D->init_begin(), D->init_end()), Record); |
Sebastian Redl | 8538e8d | 2010-08-18 23:57:32 +0000 | [diff] [blame] | 721 | Code = serialization::DECL_OBJC_IMPLEMENTATION; |
Chris Lattner | 12b1c76 | 2009-04-27 06:16:06 +0000 | [diff] [blame] | 722 | } |
| 723 | |
Sebastian Redl | 3397c55 | 2010-08-18 23:56:27 +0000 | [diff] [blame] | 724 | void ASTDeclWriter::VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D) { |
Chris Lattner | 12b1c76 | 2009-04-27 06:16:06 +0000 | [diff] [blame] | 725 | VisitDecl(D); |
| 726 | Writer.AddSourceLocation(D->getLocStart(), Record); |
| 727 | Writer.AddDeclRef(D->getPropertyDecl(), Record); |
| 728 | Writer.AddDeclRef(D->getPropertyIvarDecl(), Record); |
Douglas Gregor | a4ffd85 | 2010-11-17 01:03:52 +0000 | [diff] [blame] | 729 | Writer.AddSourceLocation(D->getPropertyIvarDeclLoc(), Record); |
Argyrios Kyrtzidis | 2f92230 | 2010-08-09 10:54:37 +0000 | [diff] [blame] | 730 | Writer.AddStmt(D->getGetterCXXConstructor()); |
| 731 | Writer.AddStmt(D->getSetterCXXAssignment()); |
Sebastian Redl | 8538e8d | 2010-08-18 23:57:32 +0000 | [diff] [blame] | 732 | Code = serialization::DECL_OBJC_PROPERTY_IMPL; |
Chris Lattner | 12b1c76 | 2009-04-27 06:16:06 +0000 | [diff] [blame] | 733 | } |
| 734 | |
Sebastian Redl | 3397c55 | 2010-08-18 23:56:27 +0000 | [diff] [blame] | 735 | void ASTDeclWriter::VisitFieldDecl(FieldDecl *D) { |
Argyrios Kyrtzidis | d4a7e54 | 2009-08-19 01:28:35 +0000 | [diff] [blame] | 736 | VisitDeclaratorDecl(D); |
Chris Lattner | 12b1c76 | 2009-04-27 06:16:06 +0000 | [diff] [blame] | 737 | Record.push_back(D->isMutable()); |
Stephen Hines | 176edba | 2014-12-01 14:53:08 -0800 | [diff] [blame] | 738 | if (D->InitStorage.getInt() == FieldDecl::ISK_BitWidthOrNothing && |
| 739 | D->InitStorage.getPointer() == nullptr) { |
Richard Smith | ca52330 | 2012-06-10 03:12:00 +0000 | [diff] [blame] | 740 | Record.push_back(0); |
Stephen Hines | 176edba | 2014-12-01 14:53:08 -0800 | [diff] [blame] | 741 | } else if (D->InitStorage.getInt() == FieldDecl::ISK_CapturedVLAType) { |
| 742 | Record.push_back(D->InitStorage.getInt() + 1); |
| 743 | Writer.AddTypeRef( |
| 744 | QualType(static_cast<Type *>(D->InitStorage.getPointer()), 0), |
| 745 | Record); |
| 746 | } else { |
| 747 | Record.push_back(D->InitStorage.getInt() + 1); |
| 748 | Writer.AddStmt(static_cast<Expr *>(D->InitStorage.getPointer())); |
Richard Smith | ca52330 | 2012-06-10 03:12:00 +0000 | [diff] [blame] | 749 | } |
Argyrios Kyrtzidis | c91e9f4 | 2010-07-04 21:44:35 +0000 | [diff] [blame] | 750 | if (!D->getDeclName()) |
| 751 | Writer.AddDeclRef(Context.getInstantiatedFromUnnamedFieldDecl(D), Record); |
Jonathan D. Turner | 953c564 | 2011-06-03 23:11:16 +0000 | [diff] [blame] | 752 | |
| 753 | if (!D->hasAttrs() && |
| 754 | !D->isImplicit() && |
| 755 | !D->isUsed(false) && |
| 756 | !D->isInvalidDecl() && |
| 757 | !D->isReferenced() && |
Argyrios Kyrtzidis | bcf8df8 | 2011-11-23 21:11:23 +0000 | [diff] [blame] | 758 | !D->isTopLevelDeclInObjCContainer() && |
Douglas Gregor | 8d267c5 | 2011-09-09 02:06:17 +0000 | [diff] [blame] | 759 | !D->isModulePrivate() && |
Jonathan D. Turner | 953c564 | 2011-06-03 23:11:16 +0000 | [diff] [blame] | 760 | !D->getBitWidth() && |
Richard Smith | 7a614d8 | 2011-06-11 17:19:42 +0000 | [diff] [blame] | 761 | !D->hasInClassInitializer() && |
Jonathan D. Turner | 953c564 | 2011-06-03 23:11:16 +0000 | [diff] [blame] | 762 | !D->hasExtInfo() && |
| 763 | !ObjCIvarDecl::classofKind(D->getKind()) && |
| 764 | !ObjCAtDefsFieldDecl::classofKind(D->getKind()) && |
| 765 | D->getDeclName()) |
| 766 | AbbrevToUse = Writer.getDeclFieldAbbrev(); |
| 767 | |
Sebastian Redl | 8538e8d | 2010-08-18 23:57:32 +0000 | [diff] [blame] | 768 | Code = serialization::DECL_FIELD; |
Chris Lattner | 12b1c76 | 2009-04-27 06:16:06 +0000 | [diff] [blame] | 769 | } |
| 770 | |
John McCall | 76da55d | 2013-04-16 07:28:30 +0000 | [diff] [blame] | 771 | void ASTDeclWriter::VisitMSPropertyDecl(MSPropertyDecl *D) { |
| 772 | VisitDeclaratorDecl(D); |
| 773 | Writer.AddIdentifierRef(D->getGetterId(), Record); |
| 774 | Writer.AddIdentifierRef(D->getSetterId(), Record); |
| 775 | Code = serialization::DECL_MS_PROPERTY; |
| 776 | } |
| 777 | |
Francois Pichet | 87c2e12 | 2010-11-21 06:08:52 +0000 | [diff] [blame] | 778 | void ASTDeclWriter::VisitIndirectFieldDecl(IndirectFieldDecl *D) { |
| 779 | VisitValueDecl(D); |
| 780 | Record.push_back(D->getChainingSize()); |
| 781 | |
Stephen Hines | 651f13c | 2014-04-23 16:59:28 -0700 | [diff] [blame] | 782 | for (const auto *P : D->chain()) |
| 783 | Writer.AddDeclRef(P, Record); |
Francois Pichet | 87c2e12 | 2010-11-21 06:08:52 +0000 | [diff] [blame] | 784 | Code = serialization::DECL_INDIRECTFIELD; |
| 785 | } |
| 786 | |
Sebastian Redl | 3397c55 | 2010-08-18 23:56:27 +0000 | [diff] [blame] | 787 | void ASTDeclWriter::VisitVarDecl(VarDecl *D) { |
Argyrios Kyrtzidis | 6b54151 | 2010-09-08 19:31:22 +0000 | [diff] [blame] | 788 | VisitRedeclarable(D); |
Douglas Gregor | d488b3a | 2011-10-26 17:53:41 +0000 | [diff] [blame] | 789 | VisitDeclaratorDecl(D); |
Rafael Espindola | d2615cc | 2013-04-03 19:27:57 +0000 | [diff] [blame] | 790 | Record.push_back(D->getStorageClass()); |
Enea Zaffanella | dc17384 | 2013-05-04 08:27:07 +0000 | [diff] [blame] | 791 | Record.push_back(D->getTSCSpec()); |
Sebastian Redl | 5b9cc5d | 2012-02-11 23:51:47 +0000 | [diff] [blame] | 792 | Record.push_back(D->getInitStyle()); |
Douglas Gregor | 324b54d | 2010-05-03 18:51:14 +0000 | [diff] [blame] | 793 | Record.push_back(D->isExceptionVariable()); |
Douglas Gregor | 5077c38 | 2010-05-15 06:01:05 +0000 | [diff] [blame] | 794 | Record.push_back(D->isNRVOVariable()); |
Richard Smith | ad762fc | 2011-04-14 22:09:26 +0000 | [diff] [blame] | 795 | Record.push_back(D->isCXXForRangeDecl()); |
John McCall | 7acddac | 2011-06-17 06:42:21 +0000 | [diff] [blame] | 796 | Record.push_back(D->isARCPseudoStrong()); |
Douglas Gregor | 67d45ec | 2012-09-20 23:43:29 +0000 | [diff] [blame] | 797 | Record.push_back(D->isConstexpr()); |
Richard Smith | 04fa7a3 | 2013-09-28 04:02:39 +0000 | [diff] [blame] | 798 | Record.push_back(D->isInitCapture()); |
Richard Smith | dd9459f | 2013-08-13 18:18:50 +0000 | [diff] [blame] | 799 | Record.push_back(D->isPreviousDeclInSameBlockScope()); |
Rafael Espindola | 181e3ec | 2013-05-13 00:12:11 +0000 | [diff] [blame] | 800 | Record.push_back(D->getLinkageInternal()); |
Douglas Gregor | 67d45ec | 2012-09-20 23:43:29 +0000 | [diff] [blame] | 801 | |
Richard Smith | 099e7f6 | 2011-12-19 06:19:21 +0000 | [diff] [blame] | 802 | if (D->getInit()) { |
| 803 | Record.push_back(!D->isInitKnownICE() ? 1 : (D->isInitICE() ? 3 : 2)); |
Chris Lattner | 12b1c76 | 2009-04-27 06:16:06 +0000 | [diff] [blame] | 804 | Writer.AddStmt(D->getInit()); |
Richard Smith | 099e7f6 | 2011-12-19 06:19:21 +0000 | [diff] [blame] | 805 | } else { |
| 806 | Record.push_back(0); |
| 807 | } |
Larisse Voufo | 4a91989 | 2013-08-14 03:09:19 +0000 | [diff] [blame] | 808 | |
| 809 | enum { |
| 810 | VarNotTemplate = 0, VarTemplate, StaticDataMemberSpecialization |
| 811 | }; |
| 812 | if (VarTemplateDecl *TemplD = D->getDescribedVarTemplate()) { |
| 813 | Record.push_back(VarTemplate); |
| 814 | Writer.AddDeclRef(TemplD, Record); |
| 815 | } else if (MemberSpecializationInfo *SpecInfo |
| 816 | = D->getMemberSpecializationInfo()) { |
| 817 | Record.push_back(StaticDataMemberSpecialization); |
Argyrios Kyrtzidis | 9421adc | 2010-07-04 21:44:00 +0000 | [diff] [blame] | 818 | Writer.AddDeclRef(SpecInfo->getInstantiatedFrom(), Record); |
| 819 | Record.push_back(SpecInfo->getTemplateSpecializationKind()); |
| 820 | Writer.AddSourceLocation(SpecInfo->getPointOfInstantiation(), Record); |
Larisse Voufo | 4a91989 | 2013-08-14 03:09:19 +0000 | [diff] [blame] | 821 | } else { |
| 822 | Record.push_back(VarNotTemplate); |
Argyrios Kyrtzidis | 9421adc | 2010-07-04 21:44:00 +0000 | [diff] [blame] | 823 | } |
| 824 | |
Jonathan D. Turner | 953c564 | 2011-06-03 23:11:16 +0000 | [diff] [blame] | 825 | if (!D->hasAttrs() && |
| 826 | !D->isImplicit() && |
| 827 | !D->isUsed(false) && |
| 828 | !D->isInvalidDecl() && |
| 829 | !D->isReferenced() && |
Argyrios Kyrtzidis | bcf8df8 | 2011-11-23 21:11:23 +0000 | [diff] [blame] | 830 | !D->isTopLevelDeclInObjCContainer() && |
Jonathan D. Turner | 953c564 | 2011-06-03 23:11:16 +0000 | [diff] [blame] | 831 | D->getAccess() == AS_none && |
Douglas Gregor | 8d267c5 | 2011-09-09 02:06:17 +0000 | [diff] [blame] | 832 | !D->isModulePrivate() && |
Stephen Hines | 176edba | 2014-12-01 14:53:08 -0800 | [diff] [blame] | 833 | !needsAnonymousDeclarationNumber(D) && |
Jonathan D. Turner | 953c564 | 2011-06-03 23:11:16 +0000 | [diff] [blame] | 834 | D->getDeclName().getNameKind() == DeclarationName::Identifier && |
| 835 | !D->hasExtInfo() && |
Rafael Espindola | bc65091 | 2013-10-17 15:37:26 +0000 | [diff] [blame] | 836 | D->getFirstDecl() == D->getMostRecentDecl() && |
Sebastian Redl | 5b9cc5d | 2012-02-11 23:51:47 +0000 | [diff] [blame] | 837 | D->getInitStyle() == VarDecl::CInit && |
Stephen Hines | 6bcf27b | 2014-05-29 04:14:42 -0700 | [diff] [blame] | 838 | D->getInit() == nullptr && |
John McCall | 7acddac | 2011-06-17 06:42:21 +0000 | [diff] [blame] | 839 | !isa<ParmVarDecl>(D) && |
Larisse Voufo | 439d665 | 2013-08-13 02:02:26 +0000 | [diff] [blame] | 840 | !isa<VarTemplateSpecializationDecl>(D) && |
Douglas Gregor | 67d45ec | 2012-09-20 23:43:29 +0000 | [diff] [blame] | 841 | !D->isConstexpr() && |
Richard Smith | 04fa7a3 | 2013-09-28 04:02:39 +0000 | [diff] [blame] | 842 | !D->isInitCapture() && |
Richard Smith | dd9459f | 2013-08-13 18:18:50 +0000 | [diff] [blame] | 843 | !D->isPreviousDeclInSameBlockScope() && |
Larisse Voufo | 4a91989 | 2013-08-14 03:09:19 +0000 | [diff] [blame] | 844 | !D->getMemberSpecializationInfo()) |
Jonathan D. Turner | 953c564 | 2011-06-03 23:11:16 +0000 | [diff] [blame] | 845 | AbbrevToUse = Writer.getDeclVarAbbrev(); |
| 846 | |
Sebastian Redl | 8538e8d | 2010-08-18 23:57:32 +0000 | [diff] [blame] | 847 | Code = serialization::DECL_VAR; |
Chris Lattner | 12b1c76 | 2009-04-27 06:16:06 +0000 | [diff] [blame] | 848 | } |
| 849 | |
Sebastian Redl | 3397c55 | 2010-08-18 23:56:27 +0000 | [diff] [blame] | 850 | void ASTDeclWriter::VisitImplicitParamDecl(ImplicitParamDecl *D) { |
Chris Lattner | 12b1c76 | 2009-04-27 06:16:06 +0000 | [diff] [blame] | 851 | VisitVarDecl(D); |
Sebastian Redl | 8538e8d | 2010-08-18 23:57:32 +0000 | [diff] [blame] | 852 | Code = serialization::DECL_IMPLICIT_PARAM; |
Chris Lattner | 12b1c76 | 2009-04-27 06:16:06 +0000 | [diff] [blame] | 853 | } |
| 854 | |
Sebastian Redl | 3397c55 | 2010-08-18 23:56:27 +0000 | [diff] [blame] | 855 | void ASTDeclWriter::VisitParmVarDecl(ParmVarDecl *D) { |
Chris Lattner | 12b1c76 | 2009-04-27 06:16:06 +0000 | [diff] [blame] | 856 | VisitVarDecl(D); |
John McCall | 7079886 | 2011-05-02 00:30:12 +0000 | [diff] [blame] | 857 | Record.push_back(D->isObjCMethodParameter()); |
John McCall | fb44de9 | 2011-05-01 22:35:37 +0000 | [diff] [blame] | 858 | Record.push_back(D->getFunctionScopeDepth()); |
| 859 | Record.push_back(D->getFunctionScopeIndex()); |
Chris Lattner | 12b1c76 | 2009-04-27 06:16:06 +0000 | [diff] [blame] | 860 | Record.push_back(D->getObjCDeclQualifier()); // FIXME: stable encoding |
John McCall | eecf5fa | 2011-03-09 04:22:44 +0000 | [diff] [blame] | 861 | Record.push_back(D->isKNRPromoted()); |
John McCall | bf73b35 | 2010-03-12 18:31:32 +0000 | [diff] [blame] | 862 | Record.push_back(D->hasInheritedDefaultArg()); |
Argyrios Kyrtzidis | 691d77f | 2010-07-04 21:44:07 +0000 | [diff] [blame] | 863 | Record.push_back(D->hasUninstantiatedDefaultArg()); |
| 864 | if (D->hasUninstantiatedDefaultArg()) |
| 865 | Writer.AddStmt(D->getUninstantiatedDefaultArg()); |
Sebastian Redl | 8538e8d | 2010-08-18 23:57:32 +0000 | [diff] [blame] | 866 | Code = serialization::DECL_PARM_VAR; |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 867 | |
John McCall | 7acddac | 2011-06-17 06:42:21 +0000 | [diff] [blame] | 868 | assert(!D->isARCPseudoStrong()); // can be true of ImplicitParamDecl |
| 869 | |
Chris Lattner | ea5ce47 | 2009-04-27 07:35:58 +0000 | [diff] [blame] | 870 | // If the assumptions about the DECL_PARM_VAR abbrev are true, use it. Here |
| 871 | // we dynamically check for the properties that we optimize for, but don't |
| 872 | // know are true of all PARM_VAR_DECLs. |
Jonathan D. Turner | 953c564 | 2011-06-03 23:11:16 +0000 | [diff] [blame] | 873 | if (!D->hasAttrs() && |
| 874 | !D->hasExtInfo() && |
Chris Lattner | ea5ce47 | 2009-04-27 07:35:58 +0000 | [diff] [blame] | 875 | !D->isImplicit() && |
Douglas Gregor | c070cc6 | 2010-06-17 23:14:26 +0000 | [diff] [blame] | 876 | !D->isUsed(false) && |
Argyrios Kyrtzidis | ba50b3e | 2012-03-09 21:09:04 +0000 | [diff] [blame] | 877 | !D->isInvalidDecl() && |
Eli Friedman | dd9d645 | 2012-01-13 23:41:25 +0000 | [diff] [blame] | 878 | !D->isReferenced() && |
Chris Lattner | ea5ce47 | 2009-04-27 07:35:58 +0000 | [diff] [blame] | 879 | D->getAccess() == AS_none && |
Douglas Gregor | 8d267c5 | 2011-09-09 02:06:17 +0000 | [diff] [blame] | 880 | !D->isModulePrivate() && |
Chris Lattner | ea5ce47 | 2009-04-27 07:35:58 +0000 | [diff] [blame] | 881 | D->getStorageClass() == 0 && |
Sebastian Redl | 5b9cc5d | 2012-02-11 23:51:47 +0000 | [diff] [blame] | 882 | D->getInitStyle() == VarDecl::CInit && // Can params have anything else? |
John McCall | 7079886 | 2011-05-02 00:30:12 +0000 | [diff] [blame] | 883 | D->getFunctionScopeDepth() == 0 && |
John McCall | bf73b35 | 2010-03-12 18:31:32 +0000 | [diff] [blame] | 884 | D->getObjCDeclQualifier() == 0 && |
John McCall | eecf5fa | 2011-03-09 04:22:44 +0000 | [diff] [blame] | 885 | !D->isKNRPromoted() && |
Chris Lattner | 030854b | 2010-05-09 06:40:08 +0000 | [diff] [blame] | 886 | !D->hasInheritedDefaultArg() && |
Stephen Hines | 6bcf27b | 2014-05-29 04:14:42 -0700 | [diff] [blame] | 887 | D->getInit() == nullptr && |
Argyrios Kyrtzidis | 691d77f | 2010-07-04 21:44:07 +0000 | [diff] [blame] | 888 | !D->hasUninstantiatedDefaultArg()) // No default expr. |
Jonathan D. Turner | 953c564 | 2011-06-03 23:11:16 +0000 | [diff] [blame] | 889 | AbbrevToUse = Writer.getDeclParmVarAbbrev(); |
Chris Lattner | ea5ce47 | 2009-04-27 07:35:58 +0000 | [diff] [blame] | 890 | |
| 891 | // Check things we know are true of *every* PARM_VAR_DECL, which is more than |
| 892 | // just us assuming it. |
Enea Zaffanella | dc17384 | 2013-05-04 08:27:07 +0000 | [diff] [blame] | 893 | assert(!D->getTSCSpec() && "PARM_VAR_DECL can't use TLS"); |
Chris Lattner | ea5ce47 | 2009-04-27 07:35:58 +0000 | [diff] [blame] | 894 | assert(D->getAccess() == AS_none && "PARM_VAR_DECL can't be public/private"); |
Douglas Gregor | 324b54d | 2010-05-03 18:51:14 +0000 | [diff] [blame] | 895 | assert(!D->isExceptionVariable() && "PARM_VAR_DECL can't be exception var"); |
Stephen Hines | 6bcf27b | 2014-05-29 04:14:42 -0700 | [diff] [blame] | 896 | assert(D->getPreviousDecl() == nullptr && "PARM_VAR_DECL can't be redecl"); |
Argyrios Kyrtzidis | 9421adc | 2010-07-04 21:44:00 +0000 | [diff] [blame] | 897 | assert(!D->isStaticDataMember() && |
| 898 | "PARM_VAR_DECL can't be static data member"); |
Chris Lattner | 12b1c76 | 2009-04-27 06:16:06 +0000 | [diff] [blame] | 899 | } |
| 900 | |
Sebastian Redl | 3397c55 | 2010-08-18 23:56:27 +0000 | [diff] [blame] | 901 | void ASTDeclWriter::VisitFileScopeAsmDecl(FileScopeAsmDecl *D) { |
Chris Lattner | 12b1c76 | 2009-04-27 06:16:06 +0000 | [diff] [blame] | 902 | VisitDecl(D); |
| 903 | Writer.AddStmt(D->getAsmString()); |
Abramo Bagnara | 21e006e | 2011-03-03 14:20:18 +0000 | [diff] [blame] | 904 | Writer.AddSourceLocation(D->getRParenLoc(), Record); |
Sebastian Redl | 8538e8d | 2010-08-18 23:57:32 +0000 | [diff] [blame] | 905 | Code = serialization::DECL_FILE_SCOPE_ASM; |
Chris Lattner | 12b1c76 | 2009-04-27 06:16:06 +0000 | [diff] [blame] | 906 | } |
| 907 | |
Michael Han | 684aa73 | 2013-02-22 17:15:32 +0000 | [diff] [blame] | 908 | void ASTDeclWriter::VisitEmptyDecl(EmptyDecl *D) { |
| 909 | VisitDecl(D); |
| 910 | Code = serialization::DECL_EMPTY; |
| 911 | } |
| 912 | |
Sebastian Redl | 3397c55 | 2010-08-18 23:56:27 +0000 | [diff] [blame] | 913 | void ASTDeclWriter::VisitBlockDecl(BlockDecl *D) { |
Chris Lattner | 12b1c76 | 2009-04-27 06:16:06 +0000 | [diff] [blame] | 914 | VisitDecl(D); |
| 915 | Writer.AddStmt(D->getBody()); |
John McCall | 82dc009 | 2010-06-04 11:21:44 +0000 | [diff] [blame] | 916 | Writer.AddTypeSourceInfo(D->getSignatureAsWritten(), Record); |
Chris Lattner | 12b1c76 | 2009-04-27 06:16:06 +0000 | [diff] [blame] | 917 | Record.push_back(D->param_size()); |
| 918 | for (FunctionDecl::param_iterator P = D->param_begin(), PEnd = D->param_end(); |
| 919 | P != PEnd; ++P) |
| 920 | Writer.AddDeclRef(*P, Record); |
John McCall | b889614 | 2012-04-13 17:33:29 +0000 | [diff] [blame] | 921 | Record.push_back(D->isVariadic()); |
| 922 | Record.push_back(D->blockMissingReturnType()); |
| 923 | Record.push_back(D->isConversionFromLambda()); |
John McCall | 469a1eb | 2011-02-02 13:00:07 +0000 | [diff] [blame] | 924 | Record.push_back(D->capturesCXXThis()); |
John McCall | 6b5a61b | 2011-02-07 10:33:21 +0000 | [diff] [blame] | 925 | Record.push_back(D->getNumCaptures()); |
Stephen Hines | 651f13c | 2014-04-23 16:59:28 -0700 | [diff] [blame] | 926 | for (const auto &capture : D->captures()) { |
John McCall | 6b5a61b | 2011-02-07 10:33:21 +0000 | [diff] [blame] | 927 | Writer.AddDeclRef(capture.getVariable(), Record); |
| 928 | |
| 929 | unsigned flags = 0; |
| 930 | if (capture.isByRef()) flags |= 1; |
| 931 | if (capture.isNested()) flags |= 2; |
| 932 | if (capture.hasCopyExpr()) flags |= 4; |
| 933 | Record.push_back(flags); |
| 934 | |
| 935 | if (capture.hasCopyExpr()) Writer.AddStmt(capture.getCopyExpr()); |
| 936 | } |
John McCall | 469a1eb | 2011-02-02 13:00:07 +0000 | [diff] [blame] | 937 | |
Sebastian Redl | 8538e8d | 2010-08-18 23:57:32 +0000 | [diff] [blame] | 938 | Code = serialization::DECL_BLOCK; |
Chris Lattner | 12b1c76 | 2009-04-27 06:16:06 +0000 | [diff] [blame] | 939 | } |
| 940 | |
Ben Langmuir | dc5be4f | 2013-05-03 19:20:19 +0000 | [diff] [blame] | 941 | void ASTDeclWriter::VisitCapturedDecl(CapturedDecl *CD) { |
| 942 | Record.push_back(CD->getNumParams()); |
| 943 | VisitDecl(CD); |
Stephen Hines | 6bcf27b | 2014-05-29 04:14:42 -0700 | [diff] [blame] | 944 | Record.push_back(CD->getContextParamPosition()); |
| 945 | Record.push_back(CD->isNothrow() ? 1 : 0); |
Ben Langmuir | dc5be4f | 2013-05-03 19:20:19 +0000 | [diff] [blame] | 946 | // Body is stored by VisitCapturedStmt. |
Stephen Hines | 6bcf27b | 2014-05-29 04:14:42 -0700 | [diff] [blame] | 947 | for (unsigned I = 0; I < CD->getNumParams(); ++I) |
| 948 | Writer.AddDeclRef(CD->getParam(I), Record); |
Ben Langmuir | dc5be4f | 2013-05-03 19:20:19 +0000 | [diff] [blame] | 949 | Code = serialization::DECL_CAPTURED; |
Tareq A. Siraj | 6afcf88 | 2013-04-16 19:37:38 +0000 | [diff] [blame] | 950 | } |
| 951 | |
Sebastian Redl | 3397c55 | 2010-08-18 23:56:27 +0000 | [diff] [blame] | 952 | void ASTDeclWriter::VisitLinkageSpecDecl(LinkageSpecDecl *D) { |
Chris Lattner | 6ad9ac0 | 2010-05-07 21:43:38 +0000 | [diff] [blame] | 953 | VisitDecl(D); |
Chris Lattner | 6ad9ac0 | 2010-05-07 21:43:38 +0000 | [diff] [blame] | 954 | Record.push_back(D->getLanguage()); |
Abramo Bagnara | a2026c9 | 2011-03-08 16:41:52 +0000 | [diff] [blame] | 955 | Writer.AddSourceLocation(D->getExternLoc(), Record); |
Abramo Bagnara | 5f6bcbe | 2011-03-03 14:52:38 +0000 | [diff] [blame] | 956 | Writer.AddSourceLocation(D->getRBraceLoc(), Record); |
Sebastian Redl | 8538e8d | 2010-08-18 23:57:32 +0000 | [diff] [blame] | 957 | Code = serialization::DECL_LINKAGE_SPEC; |
Chris Lattner | 6ad9ac0 | 2010-05-07 21:43:38 +0000 | [diff] [blame] | 958 | } |
| 959 | |
Chris Lattner | ad8dcf4 | 2011-02-17 07:39:24 +0000 | [diff] [blame] | 960 | void ASTDeclWriter::VisitLabelDecl(LabelDecl *D) { |
| 961 | VisitNamedDecl(D); |
Abramo Bagnara | 6784304 | 2011-03-05 18:21:20 +0000 | [diff] [blame] | 962 | Writer.AddSourceLocation(D->getLocStart(), Record); |
Chris Lattner | ad8dcf4 | 2011-02-17 07:39:24 +0000 | [diff] [blame] | 963 | Code = serialization::DECL_LABEL; |
| 964 | } |
| 965 | |
| 966 | |
Sebastian Redl | 3397c55 | 2010-08-18 23:56:27 +0000 | [diff] [blame] | 967 | void ASTDeclWriter::VisitNamespaceDecl(NamespaceDecl *D) { |
Douglas Gregor | f5c9f9f | 2012-01-07 09:11:48 +0000 | [diff] [blame] | 968 | VisitRedeclarable(D); |
Chris Lattner | 6ad9ac0 | 2010-05-07 21:43:38 +0000 | [diff] [blame] | 969 | VisitNamedDecl(D); |
Douglas Gregor | 0a0c3e7 | 2010-10-05 20:41:58 +0000 | [diff] [blame] | 970 | Record.push_back(D->isInline()); |
Abramo Bagnara | acba90f | 2011-03-08 12:38:20 +0000 | [diff] [blame] | 971 | Writer.AddSourceLocation(D->getLocStart(), Record); |
| 972 | Writer.AddSourceLocation(D->getRBraceLoc(), Record); |
Chris Lattner | 6ad9ac0 | 2010-05-07 21:43:38 +0000 | [diff] [blame] | 973 | |
Chris Lattner | 6ad9ac0 | 2010-05-07 21:43:38 +0000 | [diff] [blame] | 974 | if (D->isOriginalNamespace()) |
| 975 | Writer.AddDeclRef(D->getAnonymousNamespace(), Record); |
Sebastian Redl | 8538e8d | 2010-08-18 23:57:32 +0000 | [diff] [blame] | 976 | Code = serialization::DECL_NAMESPACE; |
Sebastian Redl | a7be506 | 2010-08-05 21:22:19 +0000 | [diff] [blame] | 977 | |
| 978 | if (Writer.hasChain() && !D->isOriginalNamespace() && |
Douglas Gregor | 919814d | 2011-09-09 23:01:35 +0000 | [diff] [blame] | 979 | D->getOriginalNamespace()->isFromASTFile()) { |
Argyrios Kyrtzidis | 0ad6dc3 | 2010-10-20 16:22:56 +0000 | [diff] [blame] | 980 | NamespaceDecl *NS = D->getOriginalNamespace(); |
Pirama Arumuga Nainar | 3ea9e33 | 2015-04-08 08:57:32 -0700 | [diff] [blame] | 981 | Writer.UpdatedDeclContexts.insert(NS); |
Argyrios Kyrtzidis | 0ad6dc3 | 2010-10-20 16:22:56 +0000 | [diff] [blame] | 982 | |
Pirama Arumuga Nainar | 3ea9e33 | 2015-04-08 08:57:32 -0700 | [diff] [blame] | 983 | // Make sure all visible decls are written. They will be recorded later. We |
| 984 | // do this using a side data structure so we can sort the names into |
| 985 | // a deterministic order. |
| 986 | StoredDeclsMap *Map = NS->buildLookup(); |
| 987 | SmallVector<std::pair<DeclarationName, DeclContext::lookup_result>, 16> |
| 988 | LookupResults; |
| 989 | LookupResults.reserve(Map->size()); |
| 990 | for (auto &Entry : *Map) |
| 991 | LookupResults.push_back( |
| 992 | std::make_pair(Entry.first, Entry.second.getLookupResult())); |
| 993 | |
| 994 | std::sort(LookupResults.begin(), LookupResults.end(), llvm::less_first()); |
| 995 | for (auto &NameAndResult : LookupResults) { |
| 996 | DeclarationName Name = NameAndResult.first; |
Pirama Arumuga Nainar | 3ea9e33 | 2015-04-08 08:57:32 -0700 | [diff] [blame] | 997 | DeclContext::lookup_result Result = NameAndResult.second; |
Pirama Arumuga Nainar | 33337ca | 2015-05-06 11:48:57 -0700 | [diff] [blame] | 998 | if (Name.getNameKind() == DeclarationName::CXXConstructorName || |
| 999 | Name.getNameKind() == DeclarationName::CXXConversionFunctionName) { |
| 1000 | // We have to work around a name lookup bug here where negative lookup |
| 1001 | // results for these names get cached in namespace lookup tables. |
| 1002 | assert(Result.empty() && "Cannot have a constructor or conversion " |
| 1003 | "function name in a namespace!"); |
| 1004 | continue; |
| 1005 | } |
| 1006 | |
Pirama Arumuga Nainar | 3ea9e33 | 2015-04-08 08:57:32 -0700 | [diff] [blame] | 1007 | for (NamedDecl *ND : Result) |
| 1008 | Writer.GetDeclRef(ND); |
Argyrios Kyrtzidis | 0ad6dc3 | 2010-10-20 16:22:56 +0000 | [diff] [blame] | 1009 | } |
Sebastian Redl | a7be506 | 2010-08-05 21:22:19 +0000 | [diff] [blame] | 1010 | } |
Sebastian Redl | 7c0837f | 2011-04-24 16:28:13 +0000 | [diff] [blame] | 1011 | |
Douglas Gregor | f5c9f9f | 2012-01-07 09:11:48 +0000 | [diff] [blame] | 1012 | if (Writer.hasChain() && D->isAnonymousNamespace() && |
Douglas Gregor | ef96ee0 | 2012-01-14 16:38:05 +0000 | [diff] [blame] | 1013 | D == D->getMostRecentDecl()) { |
Sebastian Redl | 74b485a | 2011-04-24 16:28:21 +0000 | [diff] [blame] | 1014 | // This is a most recent reopening of the anonymous namespace. If its parent |
| 1015 | // is in a previous PCH (or is the TU), mark that parent for update, because |
| 1016 | // the original namespace always points to the latest re-opening of its |
| 1017 | // anonymous namespace. |
| 1018 | Decl *Parent = cast<Decl>( |
| 1019 | D->getParent()->getRedeclContext()->getPrimaryContext()); |
Douglas Gregor | 919814d | 2011-09-09 23:01:35 +0000 | [diff] [blame] | 1020 | if (Parent->isFromASTFile() || isa<TranslationUnitDecl>(Parent)) { |
Stephen Hines | 651f13c | 2014-04-23 16:59:28 -0700 | [diff] [blame] | 1021 | Writer.DeclUpdates[Parent].push_back( |
| 1022 | ASTWriter::DeclUpdate(UPD_CXX_ADDED_ANONYMOUS_NAMESPACE, D)); |
Sebastian Redl | 7c0837f | 2011-04-24 16:28:13 +0000 | [diff] [blame] | 1023 | } |
| 1024 | } |
Chris Lattner | 6ad9ac0 | 2010-05-07 21:43:38 +0000 | [diff] [blame] | 1025 | } |
| 1026 | |
Sebastian Redl | 3397c55 | 2010-08-18 23:56:27 +0000 | [diff] [blame] | 1027 | void ASTDeclWriter::VisitNamespaceAliasDecl(NamespaceAliasDecl *D) { |
Stephen Hines | 176edba | 2014-12-01 14:53:08 -0800 | [diff] [blame] | 1028 | VisitRedeclarable(D); |
Chris Lattner | 6ad9ac0 | 2010-05-07 21:43:38 +0000 | [diff] [blame] | 1029 | VisitNamedDecl(D); |
Douglas Gregor | 8ea5b9d | 2010-09-01 00:08:19 +0000 | [diff] [blame] | 1030 | Writer.AddSourceLocation(D->getNamespaceLoc(), Record); |
Chris Lattner | 6ad9ac0 | 2010-05-07 21:43:38 +0000 | [diff] [blame] | 1031 | Writer.AddSourceLocation(D->getTargetNameLoc(), Record); |
Douglas Gregor | 0cfaf6a | 2011-02-25 17:08:07 +0000 | [diff] [blame] | 1032 | Writer.AddNestedNameSpecifierLoc(D->getQualifierLoc(), Record); |
Chris Lattner | 6ad9ac0 | 2010-05-07 21:43:38 +0000 | [diff] [blame] | 1033 | Writer.AddDeclRef(D->getNamespace(), Record); |
Sebastian Redl | 8538e8d | 2010-08-18 23:57:32 +0000 | [diff] [blame] | 1034 | Code = serialization::DECL_NAMESPACE_ALIAS; |
Chris Lattner | 6ad9ac0 | 2010-05-07 21:43:38 +0000 | [diff] [blame] | 1035 | } |
| 1036 | |
Sebastian Redl | 3397c55 | 2010-08-18 23:56:27 +0000 | [diff] [blame] | 1037 | void ASTDeclWriter::VisitUsingDecl(UsingDecl *D) { |
Chris Lattner | 6ad9ac0 | 2010-05-07 21:43:38 +0000 | [diff] [blame] | 1038 | VisitNamedDecl(D); |
Enea Zaffanella | 8d030c7 | 2013-07-22 10:54:09 +0000 | [diff] [blame] | 1039 | Writer.AddSourceLocation(D->getUsingLoc(), Record); |
Douglas Gregor | dc35571 | 2011-02-25 00:36:19 +0000 | [diff] [blame] | 1040 | Writer.AddNestedNameSpecifierLoc(D->getQualifierLoc(), Record); |
Argyrios Kyrtzidis | 4045107 | 2010-10-15 18:21:24 +0000 | [diff] [blame] | 1041 | Writer.AddDeclarationNameLoc(D->DNLoc, D->getDeclName(), Record); |
Benjamin Kramer | 9bc6fb6 | 2012-01-07 19:09:05 +0000 | [diff] [blame] | 1042 | Writer.AddDeclRef(D->FirstUsingShadow.getPointer(), Record); |
Enea Zaffanella | 8d030c7 | 2013-07-22 10:54:09 +0000 | [diff] [blame] | 1043 | Record.push_back(D->hasTypename()); |
Argyrios Kyrtzidis | c91e9f4 | 2010-07-04 21:44:35 +0000 | [diff] [blame] | 1044 | Writer.AddDeclRef(Context.getInstantiatedFromUsingDecl(D), Record); |
Sebastian Redl | 8538e8d | 2010-08-18 23:57:32 +0000 | [diff] [blame] | 1045 | Code = serialization::DECL_USING; |
Chris Lattner | 6ad9ac0 | 2010-05-07 21:43:38 +0000 | [diff] [blame] | 1046 | } |
| 1047 | |
Sebastian Redl | 3397c55 | 2010-08-18 23:56:27 +0000 | [diff] [blame] | 1048 | void ASTDeclWriter::VisitUsingShadowDecl(UsingShadowDecl *D) { |
Richard Smith | f06a2893 | 2013-10-23 02:17:46 +0000 | [diff] [blame] | 1049 | VisitRedeclarable(D); |
Chris Lattner | 6ad9ac0 | 2010-05-07 21:43:38 +0000 | [diff] [blame] | 1050 | VisitNamedDecl(D); |
| 1051 | Writer.AddDeclRef(D->getTargetDecl(), Record); |
Argyrios Kyrtzidis | 826faa2 | 2010-11-10 05:40:41 +0000 | [diff] [blame] | 1052 | Writer.AddDeclRef(D->UsingOrNextShadow, Record); |
Argyrios Kyrtzidis | c91e9f4 | 2010-07-04 21:44:35 +0000 | [diff] [blame] | 1053 | Writer.AddDeclRef(Context.getInstantiatedFromUsingShadowDecl(D), Record); |
Sebastian Redl | 8538e8d | 2010-08-18 23:57:32 +0000 | [diff] [blame] | 1054 | Code = serialization::DECL_USING_SHADOW; |
Chris Lattner | 6ad9ac0 | 2010-05-07 21:43:38 +0000 | [diff] [blame] | 1055 | } |
| 1056 | |
Sebastian Redl | 3397c55 | 2010-08-18 23:56:27 +0000 | [diff] [blame] | 1057 | void ASTDeclWriter::VisitUsingDirectiveDecl(UsingDirectiveDecl *D) { |
Chris Lattner | 6ad9ac0 | 2010-05-07 21:43:38 +0000 | [diff] [blame] | 1058 | VisitNamedDecl(D); |
Douglas Gregor | 0a35bce | 2010-09-01 03:07:18 +0000 | [diff] [blame] | 1059 | Writer.AddSourceLocation(D->getUsingLoc(), Record); |
Chris Lattner | 6ad9ac0 | 2010-05-07 21:43:38 +0000 | [diff] [blame] | 1060 | Writer.AddSourceLocation(D->getNamespaceKeyLocation(), Record); |
Douglas Gregor | db99241 | 2011-02-25 16:33:46 +0000 | [diff] [blame] | 1061 | Writer.AddNestedNameSpecifierLoc(D->getQualifierLoc(), Record); |
Chris Lattner | 6ad9ac0 | 2010-05-07 21:43:38 +0000 | [diff] [blame] | 1062 | Writer.AddDeclRef(D->getNominatedNamespace(), Record); |
| 1063 | Writer.AddDeclRef(dyn_cast<Decl>(D->getCommonAncestor()), Record); |
Sebastian Redl | 8538e8d | 2010-08-18 23:57:32 +0000 | [diff] [blame] | 1064 | Code = serialization::DECL_USING_DIRECTIVE; |
Chris Lattner | 6ad9ac0 | 2010-05-07 21:43:38 +0000 | [diff] [blame] | 1065 | } |
| 1066 | |
Sebastian Redl | 3397c55 | 2010-08-18 23:56:27 +0000 | [diff] [blame] | 1067 | void ASTDeclWriter::VisitUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *D) { |
Chris Lattner | 6ad9ac0 | 2010-05-07 21:43:38 +0000 | [diff] [blame] | 1068 | VisitValueDecl(D); |
Chris Lattner | 6ad9ac0 | 2010-05-07 21:43:38 +0000 | [diff] [blame] | 1069 | Writer.AddSourceLocation(D->getUsingLoc(), Record); |
Douglas Gregor | dc35571 | 2011-02-25 00:36:19 +0000 | [diff] [blame] | 1070 | Writer.AddNestedNameSpecifierLoc(D->getQualifierLoc(), Record); |
Argyrios Kyrtzidis | 4045107 | 2010-10-15 18:21:24 +0000 | [diff] [blame] | 1071 | Writer.AddDeclarationNameLoc(D->DNLoc, D->getDeclName(), Record); |
Sebastian Redl | 8538e8d | 2010-08-18 23:57:32 +0000 | [diff] [blame] | 1072 | Code = serialization::DECL_UNRESOLVED_USING_VALUE; |
Chris Lattner | 6ad9ac0 | 2010-05-07 21:43:38 +0000 | [diff] [blame] | 1073 | } |
| 1074 | |
Sebastian Redl | 3397c55 | 2010-08-18 23:56:27 +0000 | [diff] [blame] | 1075 | void ASTDeclWriter::VisitUnresolvedUsingTypenameDecl( |
Chris Lattner | 6ad9ac0 | 2010-05-07 21:43:38 +0000 | [diff] [blame] | 1076 | UnresolvedUsingTypenameDecl *D) { |
| 1077 | VisitTypeDecl(D); |
Chris Lattner | 6ad9ac0 | 2010-05-07 21:43:38 +0000 | [diff] [blame] | 1078 | Writer.AddSourceLocation(D->getTypenameLoc(), Record); |
Douglas Gregor | dc35571 | 2011-02-25 00:36:19 +0000 | [diff] [blame] | 1079 | Writer.AddNestedNameSpecifierLoc(D->getQualifierLoc(), Record); |
Sebastian Redl | 8538e8d | 2010-08-18 23:57:32 +0000 | [diff] [blame] | 1080 | Code = serialization::DECL_UNRESOLVED_USING_TYPENAME; |
Chris Lattner | 6ad9ac0 | 2010-05-07 21:43:38 +0000 | [diff] [blame] | 1081 | } |
| 1082 | |
Sebastian Redl | 3397c55 | 2010-08-18 23:56:27 +0000 | [diff] [blame] | 1083 | void ASTDeclWriter::VisitCXXRecordDecl(CXXRecordDecl *D) { |
Chris Lattner | 6ad9ac0 | 2010-05-07 21:43:38 +0000 | [diff] [blame] | 1084 | VisitRecordDecl(D); |
Argyrios Kyrtzidis | 37ffed3 | 2010-07-02 11:55:32 +0000 | [diff] [blame] | 1085 | |
Argyrios Kyrtzidis | 90b715e | 2010-06-19 19:28:53 +0000 | [diff] [blame] | 1086 | enum { |
| 1087 | CXXRecNotTemplate = 0, CXXRecTemplate, CXXRecMemberSpecialization |
| 1088 | }; |
| 1089 | if (ClassTemplateDecl *TemplD = D->getDescribedClassTemplate()) { |
| 1090 | Record.push_back(CXXRecTemplate); |
| 1091 | Writer.AddDeclRef(TemplD, Record); |
| 1092 | } else if (MemberSpecializationInfo *MSInfo |
| 1093 | = D->getMemberSpecializationInfo()) { |
| 1094 | Record.push_back(CXXRecMemberSpecialization); |
| 1095 | Writer.AddDeclRef(MSInfo->getInstantiatedFrom(), Record); |
| 1096 | Record.push_back(MSInfo->getTemplateSpecializationKind()); |
| 1097 | Writer.AddSourceLocation(MSInfo->getPointOfInstantiation(), Record); |
| 1098 | } else { |
| 1099 | Record.push_back(CXXRecNotTemplate); |
| 1100 | } |
| 1101 | |
Stephen Hines | 6bcf27b | 2014-05-29 04:14:42 -0700 | [diff] [blame] | 1102 | Record.push_back(D->isThisDeclarationADefinition()); |
| 1103 | if (D->isThisDeclarationADefinition()) |
| 1104 | Writer.AddCXXDefinitionData(D, Record); |
| 1105 | |
John McCall | d5617ee | 2013-01-25 22:31:03 +0000 | [diff] [blame] | 1106 | // Store (what we currently believe to be) the key function to avoid |
| 1107 | // deserializing every method so we can compute it. |
John McCall | 5e1cdac | 2011-10-07 06:10:15 +0000 | [diff] [blame] | 1108 | if (D->IsCompleteDefinition) |
John McCall | d5617ee | 2013-01-25 22:31:03 +0000 | [diff] [blame] | 1109 | Writer.AddDeclRef(Context.getCurrentKeyFunction(D), Record); |
Argyrios Kyrtzidis | 36d2fd4 | 2010-10-14 20:14:38 +0000 | [diff] [blame] | 1110 | |
Sebastian Redl | 8538e8d | 2010-08-18 23:57:32 +0000 | [diff] [blame] | 1111 | Code = serialization::DECL_CXX_RECORD; |
Chris Lattner | 6ad9ac0 | 2010-05-07 21:43:38 +0000 | [diff] [blame] | 1112 | } |
| 1113 | |
Sebastian Redl | 3397c55 | 2010-08-18 23:56:27 +0000 | [diff] [blame] | 1114 | void ASTDeclWriter::VisitCXXMethodDecl(CXXMethodDecl *D) { |
Chris Lattner | 6ad9ac0 | 2010-05-07 21:43:38 +0000 | [diff] [blame] | 1115 | VisitFunctionDecl(D); |
Argyrios Kyrtzidis | 716c8df | 2012-10-12 05:31:40 +0000 | [diff] [blame] | 1116 | if (D->isCanonicalDecl()) { |
| 1117 | Record.push_back(D->size_overridden_methods()); |
| 1118 | for (CXXMethodDecl::method_iterator |
| 1119 | I = D->begin_overridden_methods(), E = D->end_overridden_methods(); |
| 1120 | I != E; ++I) |
| 1121 | Writer.AddDeclRef(*I, Record); |
| 1122 | } else { |
| 1123 | // We only need to record overridden methods once for the canonical decl. |
| 1124 | Record.push_back(0); |
| 1125 | } |
Stephen Hines | 176edba | 2014-12-01 14:53:08 -0800 | [diff] [blame] | 1126 | |
| 1127 | if (D->getFirstDecl() == D->getMostRecentDecl() && |
| 1128 | !D->isInvalidDecl() && |
| 1129 | !D->hasAttrs() && |
| 1130 | !D->isTopLevelDeclInObjCContainer() && |
| 1131 | D->getDeclName().getNameKind() == DeclarationName::Identifier && |
| 1132 | !D->hasExtInfo() && |
| 1133 | !D->hasInheritedPrototype() && |
| 1134 | D->hasWrittenPrototype()) |
| 1135 | AbbrevToUse = Writer.getDeclCXXMethodAbbrev(); |
| 1136 | |
Sebastian Redl | 8538e8d | 2010-08-18 23:57:32 +0000 | [diff] [blame] | 1137 | Code = serialization::DECL_CXX_METHOD; |
Chris Lattner | 6ad9ac0 | 2010-05-07 21:43:38 +0000 | [diff] [blame] | 1138 | } |
| 1139 | |
Sebastian Redl | 3397c55 | 2010-08-18 23:56:27 +0000 | [diff] [blame] | 1140 | void ASTDeclWriter::VisitCXXConstructorDecl(CXXConstructorDecl *D) { |
Chris Lattner | 6ad9ac0 | 2010-05-07 21:43:38 +0000 | [diff] [blame] | 1141 | VisitCXXMethodDecl(D); |
Argyrios Kyrtzidis | 9146832 | 2010-07-02 15:58:43 +0000 | [diff] [blame] | 1142 | |
Stephen Hines | 651f13c | 2014-04-23 16:59:28 -0700 | [diff] [blame] | 1143 | Writer.AddDeclRef(D->getInheritedConstructor(), Record); |
Argyrios Kyrtzidis | 9146832 | 2010-07-02 15:58:43 +0000 | [diff] [blame] | 1144 | Record.push_back(D->IsExplicitSpecified); |
Argyrios Kyrtzidis | 9146832 | 2010-07-02 15:58:43 +0000 | [diff] [blame] | 1145 | |
Sebastian Redl | 8538e8d | 2010-08-18 23:57:32 +0000 | [diff] [blame] | 1146 | Code = serialization::DECL_CXX_CONSTRUCTOR; |
Chris Lattner | 6ad9ac0 | 2010-05-07 21:43:38 +0000 | [diff] [blame] | 1147 | } |
| 1148 | |
Sebastian Redl | 3397c55 | 2010-08-18 23:56:27 +0000 | [diff] [blame] | 1149 | void ASTDeclWriter::VisitCXXDestructorDecl(CXXDestructorDecl *D) { |
Chris Lattner | 6ad9ac0 | 2010-05-07 21:43:38 +0000 | [diff] [blame] | 1150 | VisitCXXMethodDecl(D); |
Argyrios Kyrtzidis | 9146832 | 2010-07-02 15:58:43 +0000 | [diff] [blame] | 1151 | |
Pirama Arumuga Nainar | 3ea9e33 | 2015-04-08 08:57:32 -0700 | [diff] [blame] | 1152 | Writer.AddDeclRef(D->getOperatorDelete(), Record); |
Argyrios Kyrtzidis | 9146832 | 2010-07-02 15:58:43 +0000 | [diff] [blame] | 1153 | |
Sebastian Redl | 8538e8d | 2010-08-18 23:57:32 +0000 | [diff] [blame] | 1154 | Code = serialization::DECL_CXX_DESTRUCTOR; |
Chris Lattner | 6ad9ac0 | 2010-05-07 21:43:38 +0000 | [diff] [blame] | 1155 | } |
| 1156 | |
Sebastian Redl | 3397c55 | 2010-08-18 23:56:27 +0000 | [diff] [blame] | 1157 | void ASTDeclWriter::VisitCXXConversionDecl(CXXConversionDecl *D) { |
Chris Lattner | 6ad9ac0 | 2010-05-07 21:43:38 +0000 | [diff] [blame] | 1158 | VisitCXXMethodDecl(D); |
Argyrios Kyrtzidis | 9146832 | 2010-07-02 15:58:43 +0000 | [diff] [blame] | 1159 | Record.push_back(D->IsExplicitSpecified); |
Sebastian Redl | 8538e8d | 2010-08-18 23:57:32 +0000 | [diff] [blame] | 1160 | Code = serialization::DECL_CXX_CONVERSION; |
Chris Lattner | 6ad9ac0 | 2010-05-07 21:43:38 +0000 | [diff] [blame] | 1161 | } |
| 1162 | |
Douglas Gregor | 15de72c | 2011-12-02 23:23:56 +0000 | [diff] [blame] | 1163 | void ASTDeclWriter::VisitImportDecl(ImportDecl *D) { |
| 1164 | VisitDecl(D); |
Argyrios Kyrtzidis | bebae7c | 2012-10-03 01:58:45 +0000 | [diff] [blame] | 1165 | Record.push_back(Writer.getSubmoduleID(D->getImportedModule())); |
Douglas Gregor | 15de72c | 2011-12-02 23:23:56 +0000 | [diff] [blame] | 1166 | ArrayRef<SourceLocation> IdentifierLocs = D->getIdentifierLocs(); |
| 1167 | Record.push_back(!IdentifierLocs.empty()); |
| 1168 | if (IdentifierLocs.empty()) { |
| 1169 | Writer.AddSourceLocation(D->getLocEnd(), Record); |
| 1170 | Record.push_back(1); |
| 1171 | } else { |
| 1172 | for (unsigned I = 0, N = IdentifierLocs.size(); I != N; ++I) |
| 1173 | Writer.AddSourceLocation(IdentifierLocs[I], Record); |
| 1174 | Record.push_back(IdentifierLocs.size()); |
| 1175 | } |
| 1176 | // Note: the number of source locations must always be the last element in |
| 1177 | // the record. |
| 1178 | Code = serialization::DECL_IMPORT; |
| 1179 | } |
| 1180 | |
Sebastian Redl | 3397c55 | 2010-08-18 23:56:27 +0000 | [diff] [blame] | 1181 | void ASTDeclWriter::VisitAccessSpecDecl(AccessSpecDecl *D) { |
Abramo Bagnara | 6206d53 | 2010-06-05 05:09:32 +0000 | [diff] [blame] | 1182 | VisitDecl(D); |
| 1183 | Writer.AddSourceLocation(D->getColonLoc(), Record); |
Sebastian Redl | 8538e8d | 2010-08-18 23:57:32 +0000 | [diff] [blame] | 1184 | Code = serialization::DECL_ACCESS_SPEC; |
Abramo Bagnara | 6206d53 | 2010-06-05 05:09:32 +0000 | [diff] [blame] | 1185 | } |
| 1186 | |
Sebastian Redl | 3397c55 | 2010-08-18 23:56:27 +0000 | [diff] [blame] | 1187 | void ASTDeclWriter::VisitFriendDecl(FriendDecl *D) { |
Enea Zaffanella | 8c84028 | 2013-01-31 09:54:08 +0000 | [diff] [blame] | 1188 | // Record the number of friend type template parameter lists here |
| 1189 | // so as to simplify memory allocation during deserialization. |
| 1190 | Record.push_back(D->NumTPLists); |
Argyrios Kyrtzidis | c8f9af2 | 2010-07-05 10:38:01 +0000 | [diff] [blame] | 1191 | VisitDecl(D); |
Enea Zaffanella | 8c84028 | 2013-01-31 09:54:08 +0000 | [diff] [blame] | 1192 | bool hasFriendDecl = D->Friend.is<NamedDecl*>(); |
| 1193 | Record.push_back(hasFriendDecl); |
| 1194 | if (hasFriendDecl) |
| 1195 | Writer.AddDeclRef(D->getFriendDecl(), Record); |
Argyrios Kyrtzidis | 6764334 | 2010-06-29 22:47:00 +0000 | [diff] [blame] | 1196 | else |
Enea Zaffanella | 8c84028 | 2013-01-31 09:54:08 +0000 | [diff] [blame] | 1197 | Writer.AddTypeSourceInfo(D->getFriendType(), Record); |
| 1198 | for (unsigned i = 0; i < D->NumTPLists; ++i) |
| 1199 | Writer.AddTemplateParameterList(D->getFriendTypeTemplateParameterList(i), |
| 1200 | Record); |
Douglas Gregor | 69aecc6 | 2010-10-27 20:23:41 +0000 | [diff] [blame] | 1201 | Writer.AddDeclRef(D->getNextFriend(), Record); |
John McCall | 6102ca1 | 2010-10-16 06:59:13 +0000 | [diff] [blame] | 1202 | Record.push_back(D->UnsupportedFriend); |
Argyrios Kyrtzidis | 6764334 | 2010-06-29 22:47:00 +0000 | [diff] [blame] | 1203 | Writer.AddSourceLocation(D->FriendLoc, Record); |
Sebastian Redl | 8538e8d | 2010-08-18 23:57:32 +0000 | [diff] [blame] | 1204 | Code = serialization::DECL_FRIEND; |
Argyrios Kyrtzidis | 6764334 | 2010-06-29 22:47:00 +0000 | [diff] [blame] | 1205 | } |
| 1206 | |
Sebastian Redl | 3397c55 | 2010-08-18 23:56:27 +0000 | [diff] [blame] | 1207 | void ASTDeclWriter::VisitFriendTemplateDecl(FriendTemplateDecl *D) { |
Argyrios Kyrtzidis | 554e6aa | 2010-07-22 16:04:10 +0000 | [diff] [blame] | 1208 | VisitDecl(D); |
| 1209 | Record.push_back(D->getNumTemplateParameters()); |
| 1210 | for (unsigned i = 0, e = D->getNumTemplateParameters(); i != e; ++i) |
| 1211 | Writer.AddTemplateParameterList(D->getTemplateParameterList(i), Record); |
Stephen Hines | 6bcf27b | 2014-05-29 04:14:42 -0700 | [diff] [blame] | 1212 | Record.push_back(D->getFriendDecl() != nullptr); |
Argyrios Kyrtzidis | 554e6aa | 2010-07-22 16:04:10 +0000 | [diff] [blame] | 1213 | if (D->getFriendDecl()) |
| 1214 | Writer.AddDeclRef(D->getFriendDecl(), Record); |
| 1215 | else |
| 1216 | Writer.AddTypeSourceInfo(D->getFriendType(), Record); |
| 1217 | Writer.AddSourceLocation(D->getFriendLoc(), Record); |
Sebastian Redl | 8538e8d | 2010-08-18 23:57:32 +0000 | [diff] [blame] | 1218 | Code = serialization::DECL_FRIEND_TEMPLATE; |
Chris Lattner | 6ad9ac0 | 2010-05-07 21:43:38 +0000 | [diff] [blame] | 1219 | } |
| 1220 | |
Sebastian Redl | 3397c55 | 2010-08-18 23:56:27 +0000 | [diff] [blame] | 1221 | void ASTDeclWriter::VisitTemplateDecl(TemplateDecl *D) { |
Argyrios Kyrtzidis | 90b715e | 2010-06-19 19:28:53 +0000 | [diff] [blame] | 1222 | VisitNamedDecl(D); |
| 1223 | |
| 1224 | Writer.AddDeclRef(D->getTemplatedDecl(), Record); |
Argyrios Kyrtzidis | dd41c14 | 2010-06-23 13:48:30 +0000 | [diff] [blame] | 1225 | Writer.AddTemplateParameterList(D->getTemplateParameters(), Record); |
Chris Lattner | 6ad9ac0 | 2010-05-07 21:43:38 +0000 | [diff] [blame] | 1226 | } |
| 1227 | |
Sebastian Redl | 3397c55 | 2010-08-18 23:56:27 +0000 | [diff] [blame] | 1228 | void ASTDeclWriter::VisitRedeclarableTemplateDecl(RedeclarableTemplateDecl *D) { |
Douglas Gregor | 7c99bb5c | 2012-01-14 15:13:49 +0000 | [diff] [blame] | 1229 | VisitRedeclarable(D); |
| 1230 | |
Argyrios Kyrtzidis | 6b54151 | 2010-09-08 19:31:22 +0000 | [diff] [blame] | 1231 | // Emit data to initialize CommonOrPrev before VisitTemplateDecl so that |
| 1232 | // getCommonPtr() can be used while this is still initializing. |
Rafael Espindola | bc65091 | 2013-10-17 15:37:26 +0000 | [diff] [blame] | 1233 | if (D->isFirstDecl()) { |
Douglas Gregor | f63b0a5 | 2011-12-19 18:19:24 +0000 | [diff] [blame] | 1234 | // This declaration owns the 'common' pointer, so serialize that data now. |
Peter Collingbourne | 9eabeba | 2010-07-29 16:11:51 +0000 | [diff] [blame] | 1235 | Writer.AddDeclRef(D->getInstantiatedFromMemberTemplate(), Record); |
| 1236 | if (D->getInstantiatedFromMemberTemplate()) |
| 1237 | Record.push_back(D->isMemberSpecialization()); |
Douglas Gregor | f63b0a5 | 2011-12-19 18:19:24 +0000 | [diff] [blame] | 1238 | } |
| 1239 | |
Argyrios Kyrtzidis | 6b54151 | 2010-09-08 19:31:22 +0000 | [diff] [blame] | 1240 | VisitTemplateDecl(D); |
| 1241 | Record.push_back(D->getIdentifierNamespace()); |
Peter Collingbourne | 9eabeba | 2010-07-29 16:11:51 +0000 | [diff] [blame] | 1242 | } |
| 1243 | |
Sebastian Redl | 3397c55 | 2010-08-18 23:56:27 +0000 | [diff] [blame] | 1244 | void ASTDeclWriter::VisitClassTemplateDecl(ClassTemplateDecl *D) { |
Peter Collingbourne | 9eabeba | 2010-07-29 16:11:51 +0000 | [diff] [blame] | 1245 | VisitRedeclarableTemplateDecl(D); |
| 1246 | |
Pirama Arumuga Nainar | 3ea9e33 | 2015-04-08 08:57:32 -0700 | [diff] [blame] | 1247 | if (D->isFirstDecl()) |
| 1248 | AddTemplateSpecializations(D); |
Sebastian Redl | 8538e8d | 2010-08-18 23:57:32 +0000 | [diff] [blame] | 1249 | Code = serialization::DECL_CLASS_TEMPLATE; |
Chris Lattner | 6ad9ac0 | 2010-05-07 21:43:38 +0000 | [diff] [blame] | 1250 | } |
| 1251 | |
Sebastian Redl | 3397c55 | 2010-08-18 23:56:27 +0000 | [diff] [blame] | 1252 | void ASTDeclWriter::VisitClassTemplateSpecializationDecl( |
Chris Lattner | 6ad9ac0 | 2010-05-07 21:43:38 +0000 | [diff] [blame] | 1253 | ClassTemplateSpecializationDecl *D) { |
Argyrios Kyrtzidis | dd41c14 | 2010-06-23 13:48:30 +0000 | [diff] [blame] | 1254 | VisitCXXRecordDecl(D); |
| 1255 | |
| 1256 | llvm::PointerUnion<ClassTemplateDecl *, |
| 1257 | ClassTemplatePartialSpecializationDecl *> InstFrom |
| 1258 | = D->getSpecializedTemplateOrPartial(); |
Argyrios Kyrtzidis | 28fc50c | 2011-08-17 21:35:28 +0000 | [diff] [blame] | 1259 | if (Decl *InstFromD = InstFrom.dyn_cast<ClassTemplateDecl *>()) { |
Sebastian Redl | 4153a06 | 2010-08-24 22:50:24 +0000 | [diff] [blame] | 1260 | Writer.AddDeclRef(InstFromD, Record); |
Argyrios Kyrtzidis | dd41c14 | 2010-06-23 13:48:30 +0000 | [diff] [blame] | 1261 | } else { |
Argyrios Kyrtzidis | 28fc50c | 2011-08-17 21:35:28 +0000 | [diff] [blame] | 1262 | Writer.AddDeclRef(InstFrom.get<ClassTemplatePartialSpecializationDecl *>(), |
| 1263 | Record); |
Argyrios Kyrtzidis | dd41c14 | 2010-06-23 13:48:30 +0000 | [diff] [blame] | 1264 | Writer.AddTemplateArgumentList(&D->getTemplateInstantiationArgs(), Record); |
| 1265 | } |
| 1266 | |
Argyrios Kyrtzidis | dd41c14 | 2010-06-23 13:48:30 +0000 | [diff] [blame] | 1267 | Writer.AddTemplateArgumentList(&D->getTemplateArgs(), Record); |
| 1268 | Writer.AddSourceLocation(D->getPointOfInstantiation(), Record); |
| 1269 | Record.push_back(D->getSpecializationKind()); |
Axel Naumann | 7b3b95a | 2012-10-01 07:34:47 +0000 | [diff] [blame] | 1270 | Record.push_back(D->isCanonicalDecl()); |
Argyrios Kyrtzidis | dd41c14 | 2010-06-23 13:48:30 +0000 | [diff] [blame] | 1271 | |
Argyrios Kyrtzidis | bc5ab7c | 2010-07-20 13:59:40 +0000 | [diff] [blame] | 1272 | if (D->isCanonicalDecl()) { |
| 1273 | // When reading, we'll add it to the folding set of the following template. |
Argyrios Kyrtzidis | ecf966e | 2010-07-09 21:11:43 +0000 | [diff] [blame] | 1274 | Writer.AddDeclRef(D->getSpecializedTemplate()->getCanonicalDecl(), Record); |
| 1275 | } |
| 1276 | |
Richard Smith | b60fae5 | 2013-09-09 16:55:27 +0000 | [diff] [blame] | 1277 | // Explicit info. |
| 1278 | Writer.AddTypeSourceInfo(D->getTypeAsWritten(), Record); |
| 1279 | if (D->getTypeAsWritten()) { |
| 1280 | Writer.AddSourceLocation(D->getExternLoc(), Record); |
| 1281 | Writer.AddSourceLocation(D->getTemplateKeywordLoc(), Record); |
| 1282 | } |
| 1283 | |
Sebastian Redl | 8538e8d | 2010-08-18 23:57:32 +0000 | [diff] [blame] | 1284 | Code = serialization::DECL_CLASS_TEMPLATE_SPECIALIZATION; |
Chris Lattner | 6ad9ac0 | 2010-05-07 21:43:38 +0000 | [diff] [blame] | 1285 | } |
| 1286 | |
Sebastian Redl | 3397c55 | 2010-08-18 23:56:27 +0000 | [diff] [blame] | 1287 | void ASTDeclWriter::VisitClassTemplatePartialSpecializationDecl( |
Chris Lattner | 6ad9ac0 | 2010-05-07 21:43:38 +0000 | [diff] [blame] | 1288 | ClassTemplatePartialSpecializationDecl *D) { |
Argyrios Kyrtzidis | dd41c14 | 2010-06-23 13:48:30 +0000 | [diff] [blame] | 1289 | VisitClassTemplateSpecializationDecl(D); |
| 1290 | |
| 1291 | Writer.AddTemplateParameterList(D->getTemplateParameters(), Record); |
Enea Zaffanella | c1cef08 | 2013-08-10 07:24:53 +0000 | [diff] [blame] | 1292 | Writer.AddASTTemplateArgumentListInfo(D->getTemplateArgsAsWritten(), Record); |
Argyrios Kyrtzidis | dd41c14 | 2010-06-23 13:48:30 +0000 | [diff] [blame] | 1293 | |
Argyrios Kyrtzidis | dd41c14 | 2010-06-23 13:48:30 +0000 | [diff] [blame] | 1294 | // These are read/set from/to the first declaration. |
Stephen Hines | 6bcf27b | 2014-05-29 04:14:42 -0700 | [diff] [blame] | 1295 | if (D->getPreviousDecl() == nullptr) { |
Argyrios Kyrtzidis | dd41c14 | 2010-06-23 13:48:30 +0000 | [diff] [blame] | 1296 | Writer.AddDeclRef(D->getInstantiatedFromMember(), Record); |
| 1297 | Record.push_back(D->isMemberSpecialization()); |
| 1298 | } |
| 1299 | |
Sebastian Redl | 8538e8d | 2010-08-18 23:57:32 +0000 | [diff] [blame] | 1300 | Code = serialization::DECL_CLASS_TEMPLATE_PARTIAL_SPECIALIZATION; |
Chris Lattner | 6ad9ac0 | 2010-05-07 21:43:38 +0000 | [diff] [blame] | 1301 | } |
| 1302 | |
Larisse Voufo | ef4579c | 2013-08-06 01:03:05 +0000 | [diff] [blame] | 1303 | void ASTDeclWriter::VisitVarTemplateDecl(VarTemplateDecl *D) { |
| 1304 | VisitRedeclarableTemplateDecl(D); |
| 1305 | |
Pirama Arumuga Nainar | 3ea9e33 | 2015-04-08 08:57:32 -0700 | [diff] [blame] | 1306 | if (D->isFirstDecl()) |
| 1307 | AddTemplateSpecializations(D); |
Larisse Voufo | ef4579c | 2013-08-06 01:03:05 +0000 | [diff] [blame] | 1308 | Code = serialization::DECL_VAR_TEMPLATE; |
| 1309 | } |
| 1310 | |
| 1311 | void ASTDeclWriter::VisitVarTemplateSpecializationDecl( |
| 1312 | VarTemplateSpecializationDecl *D) { |
| 1313 | VisitVarDecl(D); |
| 1314 | |
| 1315 | llvm::PointerUnion<VarTemplateDecl *, VarTemplatePartialSpecializationDecl *> |
| 1316 | InstFrom = D->getSpecializedTemplateOrPartial(); |
| 1317 | if (Decl *InstFromD = InstFrom.dyn_cast<VarTemplateDecl *>()) { |
| 1318 | Writer.AddDeclRef(InstFromD, Record); |
| 1319 | } else { |
| 1320 | Writer.AddDeclRef(InstFrom.get<VarTemplatePartialSpecializationDecl *>(), |
| 1321 | Record); |
| 1322 | Writer.AddTemplateArgumentList(&D->getTemplateInstantiationArgs(), Record); |
| 1323 | } |
| 1324 | |
| 1325 | // Explicit info. |
| 1326 | Writer.AddTypeSourceInfo(D->getTypeAsWritten(), Record); |
| 1327 | if (D->getTypeAsWritten()) { |
| 1328 | Writer.AddSourceLocation(D->getExternLoc(), Record); |
| 1329 | Writer.AddSourceLocation(D->getTemplateKeywordLoc(), Record); |
| 1330 | } |
| 1331 | |
| 1332 | Writer.AddTemplateArgumentList(&D->getTemplateArgs(), Record); |
| 1333 | Writer.AddSourceLocation(D->getPointOfInstantiation(), Record); |
| 1334 | Record.push_back(D->getSpecializationKind()); |
| 1335 | Record.push_back(D->isCanonicalDecl()); |
| 1336 | |
| 1337 | if (D->isCanonicalDecl()) { |
| 1338 | // When reading, we'll add it to the folding set of the following template. |
| 1339 | Writer.AddDeclRef(D->getSpecializedTemplate()->getCanonicalDecl(), Record); |
| 1340 | } |
| 1341 | |
| 1342 | Code = serialization::DECL_VAR_TEMPLATE_SPECIALIZATION; |
| 1343 | } |
| 1344 | |
| 1345 | void ASTDeclWriter::VisitVarTemplatePartialSpecializationDecl( |
| 1346 | VarTemplatePartialSpecializationDecl *D) { |
| 1347 | VisitVarTemplateSpecializationDecl(D); |
| 1348 | |
| 1349 | Writer.AddTemplateParameterList(D->getTemplateParameters(), Record); |
Enea Zaffanella | c1cef08 | 2013-08-10 07:24:53 +0000 | [diff] [blame] | 1350 | Writer.AddASTTemplateArgumentListInfo(D->getTemplateArgsAsWritten(), Record); |
Larisse Voufo | ef4579c | 2013-08-06 01:03:05 +0000 | [diff] [blame] | 1351 | |
| 1352 | // These are read/set from/to the first declaration. |
Stephen Hines | 6bcf27b | 2014-05-29 04:14:42 -0700 | [diff] [blame] | 1353 | if (D->getPreviousDecl() == nullptr) { |
Larisse Voufo | ef4579c | 2013-08-06 01:03:05 +0000 | [diff] [blame] | 1354 | Writer.AddDeclRef(D->getInstantiatedFromMember(), Record); |
| 1355 | Record.push_back(D->isMemberSpecialization()); |
| 1356 | } |
| 1357 | |
| 1358 | Code = serialization::DECL_VAR_TEMPLATE_PARTIAL_SPECIALIZATION; |
| 1359 | } |
| 1360 | |
Fariborz Jahanian | 95ed778 | 2011-08-27 20:50:59 +0000 | [diff] [blame] | 1361 | void ASTDeclWriter::VisitClassScopeFunctionSpecializationDecl( |
| 1362 | ClassScopeFunctionSpecializationDecl *D) { |
Francois Pichet | bc84532 | 2011-08-17 01:06:54 +0000 | [diff] [blame] | 1363 | VisitDecl(D); |
| 1364 | Writer.AddDeclRef(D->getSpecialization(), Record); |
| 1365 | Code = serialization::DECL_CLASS_SCOPE_FUNCTION_SPECIALIZATION; |
| 1366 | } |
| 1367 | |
| 1368 | |
Sebastian Redl | 3397c55 | 2010-08-18 23:56:27 +0000 | [diff] [blame] | 1369 | void ASTDeclWriter::VisitFunctionTemplateDecl(FunctionTemplateDecl *D) { |
Peter Collingbourne | 9eabeba | 2010-07-29 16:11:51 +0000 | [diff] [blame] | 1370 | VisitRedeclarableTemplateDecl(D); |
Argyrios Kyrtzidis | f511ba6 | 2010-06-22 09:55:07 +0000 | [diff] [blame] | 1371 | |
Pirama Arumuga Nainar | 3ea9e33 | 2015-04-08 08:57:32 -0700 | [diff] [blame] | 1372 | if (D->isFirstDecl()) |
| 1373 | AddTemplateSpecializations(D); |
Sebastian Redl | 8538e8d | 2010-08-18 23:57:32 +0000 | [diff] [blame] | 1374 | Code = serialization::DECL_FUNCTION_TEMPLATE; |
Chris Lattner | 6ad9ac0 | 2010-05-07 21:43:38 +0000 | [diff] [blame] | 1375 | } |
| 1376 | |
Sebastian Redl | 3397c55 | 2010-08-18 23:56:27 +0000 | [diff] [blame] | 1377 | void ASTDeclWriter::VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D) { |
Argyrios Kyrtzidis | 90b715e | 2010-06-19 19:28:53 +0000 | [diff] [blame] | 1378 | VisitTypeDecl(D); |
| 1379 | |
| 1380 | Record.push_back(D->wasDeclaredWithTypename()); |
Argyrios Kyrtzidis | 90b715e | 2010-06-19 19:28:53 +0000 | [diff] [blame] | 1381 | Record.push_back(D->defaultArgumentWasInherited()); |
| 1382 | Writer.AddTypeSourceInfo(D->getDefaultArgumentInfo(), Record); |
| 1383 | |
Sebastian Redl | 8538e8d | 2010-08-18 23:57:32 +0000 | [diff] [blame] | 1384 | Code = serialization::DECL_TEMPLATE_TYPE_PARM; |
Chris Lattner | 6ad9ac0 | 2010-05-07 21:43:38 +0000 | [diff] [blame] | 1385 | } |
| 1386 | |
Sebastian Redl | 3397c55 | 2010-08-18 23:56:27 +0000 | [diff] [blame] | 1387 | void ASTDeclWriter::VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D) { |
Douglas Gregor | 6952f1e | 2011-01-19 20:10:05 +0000 | [diff] [blame] | 1388 | // For an expanded parameter pack, record the number of expansion types here |
Richard Smith | 6964b3f | 2012-09-07 02:06:42 +0000 | [diff] [blame] | 1389 | // so that it's easier for deserialization to allocate the right amount of |
| 1390 | // memory. |
Douglas Gregor | 6952f1e | 2011-01-19 20:10:05 +0000 | [diff] [blame] | 1391 | if (D->isExpandedParameterPack()) |
| 1392 | Record.push_back(D->getNumExpansionTypes()); |
| 1393 | |
John McCall | 76a4021 | 2011-02-09 01:13:10 +0000 | [diff] [blame] | 1394 | VisitDeclaratorDecl(D); |
Argyrios Kyrtzidis | b24e199 | 2010-06-25 16:25:09 +0000 | [diff] [blame] | 1395 | // TemplateParmPosition. |
| 1396 | Record.push_back(D->getDepth()); |
| 1397 | Record.push_back(D->getPosition()); |
Douglas Gregor | 6952f1e | 2011-01-19 20:10:05 +0000 | [diff] [blame] | 1398 | |
| 1399 | if (D->isExpandedParameterPack()) { |
| 1400 | for (unsigned I = 0, N = D->getNumExpansionTypes(); I != N; ++I) { |
| 1401 | Writer.AddTypeRef(D->getExpansionType(I), Record); |
| 1402 | Writer.AddTypeSourceInfo(D->getExpansionTypeSourceInfo(I), Record); |
| 1403 | } |
| 1404 | |
| 1405 | Code = serialization::DECL_EXPANDED_NON_TYPE_TEMPLATE_PARM_PACK; |
| 1406 | } else { |
| 1407 | // Rest of NonTypeTemplateParmDecl. |
| 1408 | Record.push_back(D->isParameterPack()); |
Stephen Hines | 6bcf27b | 2014-05-29 04:14:42 -0700 | [diff] [blame] | 1409 | Record.push_back(D->getDefaultArgument() != nullptr); |
Douglas Gregor | 6952f1e | 2011-01-19 20:10:05 +0000 | [diff] [blame] | 1410 | if (D->getDefaultArgument()) { |
| 1411 | Writer.AddStmt(D->getDefaultArgument()); |
| 1412 | Record.push_back(D->defaultArgumentWasInherited()); |
| 1413 | } |
| 1414 | Code = serialization::DECL_NON_TYPE_TEMPLATE_PARM; |
Argyrios Kyrtzidis | b24e199 | 2010-06-25 16:25:09 +0000 | [diff] [blame] | 1415 | } |
Chris Lattner | 6ad9ac0 | 2010-05-07 21:43:38 +0000 | [diff] [blame] | 1416 | } |
| 1417 | |
Sebastian Redl | 3397c55 | 2010-08-18 23:56:27 +0000 | [diff] [blame] | 1418 | void ASTDeclWriter::VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D) { |
Richard Smith | 6964b3f | 2012-09-07 02:06:42 +0000 | [diff] [blame] | 1419 | // For an expanded parameter pack, record the number of expansion types here |
| 1420 | // so that it's easier for deserialization to allocate the right amount of |
| 1421 | // memory. |
| 1422 | if (D->isExpandedParameterPack()) |
| 1423 | Record.push_back(D->getNumExpansionTemplateParameters()); |
| 1424 | |
Argyrios Kyrtzidis | bfcc92c | 2010-07-08 17:12:57 +0000 | [diff] [blame] | 1425 | VisitTemplateDecl(D); |
| 1426 | // TemplateParmPosition. |
| 1427 | Record.push_back(D->getDepth()); |
| 1428 | Record.push_back(D->getPosition()); |
Richard Smith | 6964b3f | 2012-09-07 02:06:42 +0000 | [diff] [blame] | 1429 | |
| 1430 | if (D->isExpandedParameterPack()) { |
| 1431 | for (unsigned I = 0, N = D->getNumExpansionTemplateParameters(); |
| 1432 | I != N; ++I) |
| 1433 | Writer.AddTemplateParameterList(D->getExpansionTemplateParameters(I), |
| 1434 | Record); |
| 1435 | Code = serialization::DECL_EXPANDED_TEMPLATE_TEMPLATE_PARM_PACK; |
| 1436 | } else { |
| 1437 | // Rest of TemplateTemplateParmDecl. |
| 1438 | Writer.AddTemplateArgumentLoc(D->getDefaultArgument(), Record); |
| 1439 | Record.push_back(D->defaultArgumentWasInherited()); |
| 1440 | Record.push_back(D->isParameterPack()); |
| 1441 | Code = serialization::DECL_TEMPLATE_TEMPLATE_PARM; |
| 1442 | } |
Chris Lattner | 6ad9ac0 | 2010-05-07 21:43:38 +0000 | [diff] [blame] | 1443 | } |
| 1444 | |
Richard Smith | 3e4c6c4 | 2011-05-05 21:57:07 +0000 | [diff] [blame] | 1445 | void ASTDeclWriter::VisitTypeAliasTemplateDecl(TypeAliasTemplateDecl *D) { |
| 1446 | VisitRedeclarableTemplateDecl(D); |
| 1447 | Code = serialization::DECL_TYPE_ALIAS_TEMPLATE; |
| 1448 | } |
| 1449 | |
Sebastian Redl | 3397c55 | 2010-08-18 23:56:27 +0000 | [diff] [blame] | 1450 | void ASTDeclWriter::VisitStaticAssertDecl(StaticAssertDecl *D) { |
Argyrios Kyrtzidis | 0d39689 | 2010-07-22 17:28:12 +0000 | [diff] [blame] | 1451 | VisitDecl(D); |
| 1452 | Writer.AddStmt(D->getAssertExpr()); |
Richard Smith | e3f470a | 2012-07-11 22:37:56 +0000 | [diff] [blame] | 1453 | Record.push_back(D->isFailed()); |
Argyrios Kyrtzidis | 0d39689 | 2010-07-22 17:28:12 +0000 | [diff] [blame] | 1454 | Writer.AddStmt(D->getMessage()); |
Abramo Bagnara | a2026c9 | 2011-03-08 16:41:52 +0000 | [diff] [blame] | 1455 | Writer.AddSourceLocation(D->getRParenLoc(), Record); |
Sebastian Redl | 8538e8d | 2010-08-18 23:57:32 +0000 | [diff] [blame] | 1456 | Code = serialization::DECL_STATIC_ASSERT; |
Chris Lattner | 6ad9ac0 | 2010-05-07 21:43:38 +0000 | [diff] [blame] | 1457 | } |
| 1458 | |
Chris Lattner | 12b1c76 | 2009-04-27 06:16:06 +0000 | [diff] [blame] | 1459 | /// \brief Emit the DeclContext part of a declaration context decl. |
| 1460 | /// |
| 1461 | /// \param LexicalOffset the offset at which the DECL_CONTEXT_LEXICAL |
| 1462 | /// block for this declaration context is stored. May be 0 to indicate |
| 1463 | /// that there are no declarations stored within this context. |
| 1464 | /// |
| 1465 | /// \param VisibleOffset the offset at which the DECL_CONTEXT_VISIBLE |
| 1466 | /// block for this declaration context is stored. May be 0 to indicate |
| 1467 | /// that there are no declarations visible from this context. Note |
| 1468 | /// that this value will not be emitted for non-primary declaration |
| 1469 | /// contexts. |
Sebastian Redl | 3397c55 | 2010-08-18 23:56:27 +0000 | [diff] [blame] | 1470 | void ASTDeclWriter::VisitDeclContext(DeclContext *DC, uint64_t LexicalOffset, |
Chris Lattner | 12b1c76 | 2009-04-27 06:16:06 +0000 | [diff] [blame] | 1471 | uint64_t VisibleOffset) { |
| 1472 | Record.push_back(LexicalOffset); |
| 1473 | Record.push_back(VisibleOffset); |
| 1474 | } |
| 1475 | |
Argyrios Kyrtzidis | a865005 | 2010-08-03 17:30:10 +0000 | [diff] [blame] | 1476 | template <typename T> |
Sebastian Redl | 3397c55 | 2010-08-18 23:56:27 +0000 | [diff] [blame] | 1477 | void ASTDeclWriter::VisitRedeclarable(Redeclarable<T> *D) { |
Rafael Espindola | bc65091 | 2013-10-17 15:37:26 +0000 | [diff] [blame] | 1478 | T *First = D->getFirstDecl(); |
Stephen Hines | 0e2c34f | 2015-03-23 12:09:02 -0700 | [diff] [blame] | 1479 | T *MostRecent = First->getMostRecentDecl(); |
| 1480 | if (MostRecent != First) { |
Douglas Gregor | 9cfdc03 | 2013-01-21 16:16:40 +0000 | [diff] [blame] | 1481 | assert(isRedeclarableDeclKind(static_cast<T *>(D)->getKind()) && |
| 1482 | "Not considered redeclarable?"); |
Stephen Hines | 0e2c34f | 2015-03-23 12:09:02 -0700 | [diff] [blame] | 1483 | |
Pirama Arumuga Nainar | 3ea9e33 | 2015-04-08 08:57:32 -0700 | [diff] [blame] | 1484 | // There is more than one declaration of this entity, so we will need to |
| 1485 | // write a redeclaration chain. |
| 1486 | Writer.AddDeclRef(First, Record); |
| 1487 | Writer.Redeclarations.insert(First); |
| 1488 | |
Stephen Hines | 0e2c34f | 2015-03-23 12:09:02 -0700 | [diff] [blame] | 1489 | auto *Previous = D->getPreviousDecl(); |
Pirama Arumuga Nainar | 3ea9e33 | 2015-04-08 08:57:32 -0700 | [diff] [blame] | 1490 | |
| 1491 | // In a modules build, we can have imported declarations after a local |
| 1492 | // canonical declaration. If this is the first local declaration, emit |
| 1493 | // a list of all such imported declarations so that we can ensure they |
| 1494 | // are loaded before we are. This allows us to rebuild the redecl chain |
| 1495 | // in the right order on reload (all declarations imported by a module |
| 1496 | // should be before all declarations provided by that module). |
| 1497 | bool EmitImportedMergedCanonicalDecls = false; |
| 1498 | if (Context.getLangOpts().Modules && Writer.Chain) { |
| 1499 | auto *PreviousLocal = Previous; |
| 1500 | while (PreviousLocal && PreviousLocal->isFromASTFile()) |
| 1501 | PreviousLocal = PreviousLocal->getPreviousDecl(); |
| 1502 | if (!PreviousLocal) |
| 1503 | EmitImportedMergedCanonicalDecls = true; |
| 1504 | } |
| 1505 | if (EmitImportedMergedCanonicalDecls) { |
| 1506 | llvm::SmallMapVector<ModuleFile*, Decl*, 16> FirstInModule; |
Stephen Hines | 0e2c34f | 2015-03-23 12:09:02 -0700 | [diff] [blame] | 1507 | for (auto *Redecl = MostRecent; Redecl; |
| 1508 | Redecl = Redecl->getPreviousDecl()) |
| 1509 | if (Redecl->isFromASTFile()) |
Pirama Arumuga Nainar | 3ea9e33 | 2015-04-08 08:57:32 -0700 | [diff] [blame] | 1510 | FirstInModule[Writer.Chain->getOwningModuleFile(Redecl)] = Redecl; |
| 1511 | // FIXME: If FirstInModule has entries for modules A and B, and B imports |
| 1512 | // A (directly or indirectly), we don't need to write the entry for A. |
| 1513 | Record.push_back(FirstInModule.size()); |
| 1514 | for (auto I = FirstInModule.rbegin(), E = FirstInModule.rend(); |
| 1515 | I != E; ++I) |
| 1516 | Writer.AddDeclRef(I->second, Record); |
| 1517 | } else |
| 1518 | Record.push_back(0); |
Douglas Gregor | 2171bf1 | 2012-01-15 16:58:34 +0000 | [diff] [blame] | 1519 | |
| 1520 | // Make sure that we serialize both the previous and the most-recent |
| 1521 | // declarations, which (transitively) ensures that all declarations in the |
| 1522 | // chain get serialized. |
Stephen Hines | 0e2c34f | 2015-03-23 12:09:02 -0700 | [diff] [blame] | 1523 | // |
| 1524 | // FIXME: This is not correct; when we reach an imported declaration we |
| 1525 | // won't emit its previous declaration. |
| 1526 | (void)Writer.GetDeclRef(Previous); |
| 1527 | (void)Writer.GetDeclRef(MostRecent); |
Douglas Gregor | 2171bf1 | 2012-01-15 16:58:34 +0000 | [diff] [blame] | 1528 | } else { |
| 1529 | // We use the sentinel value 0 to indicate an only declaration. |
| 1530 | Record.push_back(0); |
Douglas Gregor | ecb1938 | 2011-12-19 15:27:36 +0000 | [diff] [blame] | 1531 | } |
Argyrios Kyrtzidis | a865005 | 2010-08-03 17:30:10 +0000 | [diff] [blame] | 1532 | } |
Chris Lattner | 12b1c76 | 2009-04-27 06:16:06 +0000 | [diff] [blame] | 1533 | |
Alexey Bataev | c640058 | 2013-03-22 06:34:35 +0000 | [diff] [blame] | 1534 | void ASTDeclWriter::VisitOMPThreadPrivateDecl(OMPThreadPrivateDecl *D) { |
| 1535 | Record.push_back(D->varlist_size()); |
| 1536 | VisitDecl(D); |
Stephen Hines | 651f13c | 2014-04-23 16:59:28 -0700 | [diff] [blame] | 1537 | for (auto *I : D->varlists()) |
| 1538 | Writer.AddStmt(I); |
Alexey Bataev | c640058 | 2013-03-22 06:34:35 +0000 | [diff] [blame] | 1539 | Code = serialization::DECL_OMP_THREADPRIVATE; |
| 1540 | } |
| 1541 | |
Chris Lattner | 12b1c76 | 2009-04-27 06:16:06 +0000 | [diff] [blame] | 1542 | //===----------------------------------------------------------------------===// |
Sebastian Redl | a4232eb | 2010-08-18 23:56:21 +0000 | [diff] [blame] | 1543 | // ASTWriter Implementation |
Chris Lattner | 12b1c76 | 2009-04-27 06:16:06 +0000 | [diff] [blame] | 1544 | //===----------------------------------------------------------------------===// |
| 1545 | |
Stephen Hines | 176edba | 2014-12-01 14:53:08 -0800 | [diff] [blame] | 1546 | void ASTWriter::WriteDeclAbbrevs() { |
Chris Lattner | ea5ce47 | 2009-04-27 07:35:58 +0000 | [diff] [blame] | 1547 | using namespace llvm; |
Chris Lattner | ea5ce47 | 2009-04-27 07:35:58 +0000 | [diff] [blame] | 1548 | |
Douglas Gregor | a72d8c4 | 2011-06-03 02:27:19 +0000 | [diff] [blame] | 1549 | BitCodeAbbrev *Abv; |
| 1550 | |
Jonathan D. Turner | 953c564 | 2011-06-03 23:11:16 +0000 | [diff] [blame] | 1551 | // Abbreviation for DECL_FIELD |
| 1552 | Abv = new BitCodeAbbrev(); |
| 1553 | Abv->Add(BitCodeAbbrevOp(serialization::DECL_FIELD)); |
| 1554 | // Decl |
| 1555 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclContext |
| 1556 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // LexicalDeclContext |
Argyrios Kyrtzidis | ba50b3e | 2012-03-09 21:09:04 +0000 | [diff] [blame] | 1557 | Abv->Add(BitCodeAbbrevOp(0)); // isInvalidDecl |
Jonathan D. Turner | 953c564 | 2011-06-03 23:11:16 +0000 | [diff] [blame] | 1558 | Abv->Add(BitCodeAbbrevOp(0)); // HasAttrs |
| 1559 | Abv->Add(BitCodeAbbrevOp(0)); // isImplicit |
| 1560 | Abv->Add(BitCodeAbbrevOp(0)); // isUsed |
| 1561 | Abv->Add(BitCodeAbbrevOp(0)); // isReferenced |
Argyrios Kyrtzidis | c14a03d | 2011-11-23 20:27:36 +0000 | [diff] [blame] | 1562 | Abv->Add(BitCodeAbbrevOp(0)); // TopLevelDeclInObjCContainer |
Jonathan D. Turner | 953c564 | 2011-06-03 23:11:16 +0000 | [diff] [blame] | 1563 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2)); // AccessSpecifier |
Douglas Gregor | 8d267c5 | 2011-09-09 02:06:17 +0000 | [diff] [blame] | 1564 | Abv->Add(BitCodeAbbrevOp(0)); // ModulePrivate |
Douglas Gregor | 185dbd7 | 2011-12-01 02:07:58 +0000 | [diff] [blame] | 1565 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SubmoduleID |
Jonathan D. Turner | 953c564 | 2011-06-03 23:11:16 +0000 | [diff] [blame] | 1566 | // NamedDecl |
| 1567 | Abv->Add(BitCodeAbbrevOp(0)); // NameKind = Identifier |
| 1568 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Name |
Stephen Hines | 0e2c34f | 2015-03-23 12:09:02 -0700 | [diff] [blame] | 1569 | Abv->Add(BitCodeAbbrevOp(0)); // AnonDeclNumber |
Jonathan D. Turner | 953c564 | 2011-06-03 23:11:16 +0000 | [diff] [blame] | 1570 | // ValueDecl |
| 1571 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type |
| 1572 | // DeclaratorDecl |
| 1573 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // InnerStartLoc |
| 1574 | Abv->Add(BitCodeAbbrevOp(0)); // hasExtInfo |
| 1575 | // FieldDecl |
| 1576 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isMutable |
| 1577 | Abv->Add(BitCodeAbbrevOp(0)); //getBitWidth |
| 1578 | // Type Source Info |
| 1579 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); |
| 1580 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array)); |
| 1581 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // TypeLoc |
| 1582 | DeclFieldAbbrev = Stream.EmitAbbrev(Abv); |
| 1583 | |
| 1584 | // Abbreviation for DECL_OBJC_IVAR |
| 1585 | Abv = new BitCodeAbbrev(); |
| 1586 | Abv->Add(BitCodeAbbrevOp(serialization::DECL_OBJC_IVAR)); |
| 1587 | // Decl |
| 1588 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclContext |
| 1589 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // LexicalDeclContext |
Argyrios Kyrtzidis | ba50b3e | 2012-03-09 21:09:04 +0000 | [diff] [blame] | 1590 | Abv->Add(BitCodeAbbrevOp(0)); // isInvalidDecl |
Jonathan D. Turner | 953c564 | 2011-06-03 23:11:16 +0000 | [diff] [blame] | 1591 | Abv->Add(BitCodeAbbrevOp(0)); // HasAttrs |
| 1592 | Abv->Add(BitCodeAbbrevOp(0)); // isImplicit |
| 1593 | Abv->Add(BitCodeAbbrevOp(0)); // isUsed |
| 1594 | Abv->Add(BitCodeAbbrevOp(0)); // isReferenced |
Argyrios Kyrtzidis | c14a03d | 2011-11-23 20:27:36 +0000 | [diff] [blame] | 1595 | Abv->Add(BitCodeAbbrevOp(0)); // TopLevelDeclInObjCContainer |
Jonathan D. Turner | 953c564 | 2011-06-03 23:11:16 +0000 | [diff] [blame] | 1596 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2)); // AccessSpecifier |
Douglas Gregor | 8d267c5 | 2011-09-09 02:06:17 +0000 | [diff] [blame] | 1597 | Abv->Add(BitCodeAbbrevOp(0)); // ModulePrivate |
Douglas Gregor | 185dbd7 | 2011-12-01 02:07:58 +0000 | [diff] [blame] | 1598 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SubmoduleID |
Jonathan D. Turner | 953c564 | 2011-06-03 23:11:16 +0000 | [diff] [blame] | 1599 | // NamedDecl |
| 1600 | Abv->Add(BitCodeAbbrevOp(0)); // NameKind = Identifier |
| 1601 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Name |
Stephen Hines | 0e2c34f | 2015-03-23 12:09:02 -0700 | [diff] [blame] | 1602 | Abv->Add(BitCodeAbbrevOp(0)); // AnonDeclNumber |
Jonathan D. Turner | 953c564 | 2011-06-03 23:11:16 +0000 | [diff] [blame] | 1603 | // ValueDecl |
| 1604 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type |
| 1605 | // DeclaratorDecl |
| 1606 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // InnerStartLoc |
| 1607 | Abv->Add(BitCodeAbbrevOp(0)); // hasExtInfo |
| 1608 | // FieldDecl |
| 1609 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isMutable |
| 1610 | Abv->Add(BitCodeAbbrevOp(0)); //getBitWidth |
| 1611 | // ObjC Ivar |
| 1612 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // getAccessControl |
| 1613 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // getSynthesize |
| 1614 | // Type Source Info |
| 1615 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); |
| 1616 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array)); |
| 1617 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // TypeLoc |
| 1618 | DeclObjCIvarAbbrev = Stream.EmitAbbrev(Abv); |
| 1619 | |
| 1620 | // Abbreviation for DECL_ENUM |
| 1621 | Abv = new BitCodeAbbrev(); |
| 1622 | Abv->Add(BitCodeAbbrevOp(serialization::DECL_ENUM)); |
Douglas Gregor | d488b3a | 2011-10-26 17:53:41 +0000 | [diff] [blame] | 1623 | // Redeclarable |
Douglas Gregor | ecb1938 | 2011-12-19 15:27:36 +0000 | [diff] [blame] | 1624 | Abv->Add(BitCodeAbbrevOp(0)); // No redeclaration |
Chris Lattner | ea5ce47 | 2009-04-27 07:35:58 +0000 | [diff] [blame] | 1625 | // Decl |
| 1626 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclContext |
| 1627 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // LexicalDeclContext |
Argyrios Kyrtzidis | ba50b3e | 2012-03-09 21:09:04 +0000 | [diff] [blame] | 1628 | Abv->Add(BitCodeAbbrevOp(0)); // isInvalidDecl |
Chris Lattner | ea5ce47 | 2009-04-27 07:35:58 +0000 | [diff] [blame] | 1629 | Abv->Add(BitCodeAbbrevOp(0)); // HasAttrs |
| 1630 | Abv->Add(BitCodeAbbrevOp(0)); // isImplicit |
Douglas Gregor | e0762c9 | 2009-06-19 23:52:42 +0000 | [diff] [blame] | 1631 | Abv->Add(BitCodeAbbrevOp(0)); // isUsed |
Argyrios Kyrtzidis | 6b6b42a | 2011-04-19 19:51:10 +0000 | [diff] [blame] | 1632 | Abv->Add(BitCodeAbbrevOp(0)); // isReferenced |
Argyrios Kyrtzidis | c14a03d | 2011-11-23 20:27:36 +0000 | [diff] [blame] | 1633 | Abv->Add(BitCodeAbbrevOp(0)); // TopLevelDeclInObjCContainer |
Chris Lattner | ea5ce47 | 2009-04-27 07:35:58 +0000 | [diff] [blame] | 1634 | Abv->Add(BitCodeAbbrevOp(AS_none)); // C++ AccessSpecifier |
Douglas Gregor | 8d267c5 | 2011-09-09 02:06:17 +0000 | [diff] [blame] | 1635 | Abv->Add(BitCodeAbbrevOp(0)); // ModulePrivate |
Douglas Gregor | 185dbd7 | 2011-12-01 02:07:58 +0000 | [diff] [blame] | 1636 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SubmoduleID |
Douglas Gregor | a72d8c4 | 2011-06-03 02:27:19 +0000 | [diff] [blame] | 1637 | // NamedDecl |
| 1638 | Abv->Add(BitCodeAbbrevOp(0)); // NameKind = Identifier |
| 1639 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Name |
Stephen Hines | 0e2c34f | 2015-03-23 12:09:02 -0700 | [diff] [blame] | 1640 | Abv->Add(BitCodeAbbrevOp(0)); // AnonDeclNumber |
Jonathan D. Turner | 953c564 | 2011-06-03 23:11:16 +0000 | [diff] [blame] | 1641 | // TypeDecl |
| 1642 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Source Location |
| 1643 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type Ref |
Jonathan D. Turner | 953c564 | 2011-06-03 23:11:16 +0000 | [diff] [blame] | 1644 | // TagDecl |
| 1645 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // IdentifierNamespace |
| 1646 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // getTagKind |
John McCall | 5e1cdac | 2011-10-07 06:10:15 +0000 | [diff] [blame] | 1647 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isCompleteDefinition |
Jonathan D. Turner | 953c564 | 2011-06-03 23:11:16 +0000 | [diff] [blame] | 1648 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // EmbeddedInDeclarator |
Argyrios Kyrtzidis | 717a20b | 2011-09-30 22:11:31 +0000 | [diff] [blame] | 1649 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsFreeStanding |
David Blaikie | e33a0a8 | 2013-07-14 01:07:41 +0000 | [diff] [blame] | 1650 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsCompleteDefinitionRequired |
Jonathan D. Turner | 953c564 | 2011-06-03 23:11:16 +0000 | [diff] [blame] | 1651 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SourceLocation |
Stephen Hines | 176edba | 2014-12-01 14:53:08 -0800 | [diff] [blame] | 1652 | Abv->Add(BitCodeAbbrevOp(0)); // ExtInfoKind |
Jonathan D. Turner | 953c564 | 2011-06-03 23:11:16 +0000 | [diff] [blame] | 1653 | // EnumDecl |
| 1654 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // AddTypeRef |
| 1655 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // IntegerType |
| 1656 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // getPromotionType |
| 1657 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // getNumPositiveBits |
| 1658 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // getNumNegativeBits |
| 1659 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isScoped |
| 1660 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isScopedUsingClassTag |
| 1661 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isFixed |
| 1662 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // InstantiatedMembEnum |
| 1663 | // DC |
| 1664 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // LexicalOffset |
| 1665 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // VisibleOffset |
| 1666 | DeclEnumAbbrev = Stream.EmitAbbrev(Abv); |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 1667 | |
Douglas Gregor | a72d8c4 | 2011-06-03 02:27:19 +0000 | [diff] [blame] | 1668 | // Abbreviation for DECL_RECORD |
| 1669 | Abv = new BitCodeAbbrev(); |
| 1670 | Abv->Add(BitCodeAbbrevOp(serialization::DECL_RECORD)); |
Douglas Gregor | d488b3a | 2011-10-26 17:53:41 +0000 | [diff] [blame] | 1671 | // Redeclarable |
Douglas Gregor | ecb1938 | 2011-12-19 15:27:36 +0000 | [diff] [blame] | 1672 | Abv->Add(BitCodeAbbrevOp(0)); // No redeclaration |
Douglas Gregor | a72d8c4 | 2011-06-03 02:27:19 +0000 | [diff] [blame] | 1673 | // Decl |
| 1674 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclContext |
| 1675 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // LexicalDeclContext |
Argyrios Kyrtzidis | ba50b3e | 2012-03-09 21:09:04 +0000 | [diff] [blame] | 1676 | Abv->Add(BitCodeAbbrevOp(0)); // isInvalidDecl |
Douglas Gregor | a72d8c4 | 2011-06-03 02:27:19 +0000 | [diff] [blame] | 1677 | Abv->Add(BitCodeAbbrevOp(0)); // HasAttrs |
| 1678 | Abv->Add(BitCodeAbbrevOp(0)); // isImplicit |
| 1679 | Abv->Add(BitCodeAbbrevOp(0)); // isUsed |
| 1680 | Abv->Add(BitCodeAbbrevOp(0)); // isReferenced |
Argyrios Kyrtzidis | c14a03d | 2011-11-23 20:27:36 +0000 | [diff] [blame] | 1681 | Abv->Add(BitCodeAbbrevOp(0)); // TopLevelDeclInObjCContainer |
Douglas Gregor | a72d8c4 | 2011-06-03 02:27:19 +0000 | [diff] [blame] | 1682 | Abv->Add(BitCodeAbbrevOp(AS_none)); // C++ AccessSpecifier |
Douglas Gregor | 8d267c5 | 2011-09-09 02:06:17 +0000 | [diff] [blame] | 1683 | Abv->Add(BitCodeAbbrevOp(0)); // ModulePrivate |
Douglas Gregor | 185dbd7 | 2011-12-01 02:07:58 +0000 | [diff] [blame] | 1684 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SubmoduleID |
Douglas Gregor | a72d8c4 | 2011-06-03 02:27:19 +0000 | [diff] [blame] | 1685 | // NamedDecl |
| 1686 | Abv->Add(BitCodeAbbrevOp(0)); // NameKind = Identifier |
| 1687 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Name |
Stephen Hines | 0e2c34f | 2015-03-23 12:09:02 -0700 | [diff] [blame] | 1688 | Abv->Add(BitCodeAbbrevOp(0)); // AnonDeclNumber |
Douglas Gregor | a72d8c4 | 2011-06-03 02:27:19 +0000 | [diff] [blame] | 1689 | // TypeDecl |
| 1690 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Source Location |
| 1691 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type Ref |
Douglas Gregor | a72d8c4 | 2011-06-03 02:27:19 +0000 | [diff] [blame] | 1692 | // TagDecl |
| 1693 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // IdentifierNamespace |
| 1694 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // getTagKind |
John McCall | 5e1cdac | 2011-10-07 06:10:15 +0000 | [diff] [blame] | 1695 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isCompleteDefinition |
Douglas Gregor | a72d8c4 | 2011-06-03 02:27:19 +0000 | [diff] [blame] | 1696 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // EmbeddedInDeclarator |
Argyrios Kyrtzidis | 717a20b | 2011-09-30 22:11:31 +0000 | [diff] [blame] | 1697 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsFreeStanding |
David Blaikie | e33a0a8 | 2013-07-14 01:07:41 +0000 | [diff] [blame] | 1698 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsCompleteDefinitionRequired |
Douglas Gregor | a72d8c4 | 2011-06-03 02:27:19 +0000 | [diff] [blame] | 1699 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SourceLocation |
Stephen Hines | 176edba | 2014-12-01 14:53:08 -0800 | [diff] [blame] | 1700 | Abv->Add(BitCodeAbbrevOp(0)); // ExtInfoKind |
Douglas Gregor | a72d8c4 | 2011-06-03 02:27:19 +0000 | [diff] [blame] | 1701 | // RecordDecl |
| 1702 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // FlexibleArrayMember |
| 1703 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // AnonymousStructUnion |
| 1704 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // hasObjectMember |
Fariborz Jahanian | 3ac83d6 | 2013-01-25 23:57:05 +0000 | [diff] [blame] | 1705 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // hasVolatileMember |
Douglas Gregor | a72d8c4 | 2011-06-03 02:27:19 +0000 | [diff] [blame] | 1706 | // DC |
| 1707 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // LexicalOffset |
| 1708 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // VisibleOffset |
| 1709 | DeclRecordAbbrev = Stream.EmitAbbrev(Abv); |
| 1710 | |
| 1711 | // Abbreviation for DECL_PARM_VAR |
| 1712 | Abv = new BitCodeAbbrev(); |
| 1713 | Abv->Add(BitCodeAbbrevOp(serialization::DECL_PARM_VAR)); |
Douglas Gregor | d488b3a | 2011-10-26 17:53:41 +0000 | [diff] [blame] | 1714 | // Redeclarable |
Douglas Gregor | ecb1938 | 2011-12-19 15:27:36 +0000 | [diff] [blame] | 1715 | Abv->Add(BitCodeAbbrevOp(0)); // No redeclaration |
Douglas Gregor | a72d8c4 | 2011-06-03 02:27:19 +0000 | [diff] [blame] | 1716 | // Decl |
| 1717 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclContext |
| 1718 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // LexicalDeclContext |
Argyrios Kyrtzidis | ba50b3e | 2012-03-09 21:09:04 +0000 | [diff] [blame] | 1719 | Abv->Add(BitCodeAbbrevOp(0)); // isInvalidDecl |
Douglas Gregor | a72d8c4 | 2011-06-03 02:27:19 +0000 | [diff] [blame] | 1720 | Abv->Add(BitCodeAbbrevOp(0)); // HasAttrs |
| 1721 | Abv->Add(BitCodeAbbrevOp(0)); // isImplicit |
| 1722 | Abv->Add(BitCodeAbbrevOp(0)); // isUsed |
| 1723 | Abv->Add(BitCodeAbbrevOp(0)); // isReferenced |
Argyrios Kyrtzidis | c14a03d | 2011-11-23 20:27:36 +0000 | [diff] [blame] | 1724 | Abv->Add(BitCodeAbbrevOp(0)); // TopLevelDeclInObjCContainer |
Douglas Gregor | a72d8c4 | 2011-06-03 02:27:19 +0000 | [diff] [blame] | 1725 | Abv->Add(BitCodeAbbrevOp(AS_none)); // C++ AccessSpecifier |
Douglas Gregor | 8d267c5 | 2011-09-09 02:06:17 +0000 | [diff] [blame] | 1726 | Abv->Add(BitCodeAbbrevOp(0)); // ModulePrivate |
Douglas Gregor | 185dbd7 | 2011-12-01 02:07:58 +0000 | [diff] [blame] | 1727 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SubmoduleID |
Chris Lattner | ea5ce47 | 2009-04-27 07:35:58 +0000 | [diff] [blame] | 1728 | // NamedDecl |
| 1729 | Abv->Add(BitCodeAbbrevOp(0)); // NameKind = Identifier |
| 1730 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Name |
Stephen Hines | 0e2c34f | 2015-03-23 12:09:02 -0700 | [diff] [blame] | 1731 | Abv->Add(BitCodeAbbrevOp(0)); // AnonDeclNumber |
Chris Lattner | ea5ce47 | 2009-04-27 07:35:58 +0000 | [diff] [blame] | 1732 | // ValueDecl |
| 1733 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type |
Argyrios Kyrtzidis | d4a7e54 | 2009-08-19 01:28:35 +0000 | [diff] [blame] | 1734 | // DeclaratorDecl |
Abramo Bagnara | ff676cb | 2011-03-08 08:55:46 +0000 | [diff] [blame] | 1735 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // InnerStartLoc |
Argyrios Kyrtzidis | 4045107 | 2010-10-15 18:21:24 +0000 | [diff] [blame] | 1736 | Abv->Add(BitCodeAbbrevOp(0)); // hasExtInfo |
Chris Lattner | ea5ce47 | 2009-04-27 07:35:58 +0000 | [diff] [blame] | 1737 | // VarDecl |
| 1738 | Abv->Add(BitCodeAbbrevOp(0)); // StorageClass |
Enea Zaffanella | dc17384 | 2013-05-04 08:27:07 +0000 | [diff] [blame] | 1739 | Abv->Add(BitCodeAbbrevOp(0)); // getTSCSpec |
Chris Lattner | ea5ce47 | 2009-04-27 07:35:58 +0000 | [diff] [blame] | 1740 | Abv->Add(BitCodeAbbrevOp(0)); // hasCXXDirectInitializer |
Douglas Gregor | 324b54d | 2010-05-03 18:51:14 +0000 | [diff] [blame] | 1741 | Abv->Add(BitCodeAbbrevOp(0)); // isExceptionVariable |
Douglas Gregor | 5077c38 | 2010-05-15 06:01:05 +0000 | [diff] [blame] | 1742 | Abv->Add(BitCodeAbbrevOp(0)); // isNRVOVariable |
Richard Smith | ad762fc | 2011-04-14 22:09:26 +0000 | [diff] [blame] | 1743 | Abv->Add(BitCodeAbbrevOp(0)); // isCXXForRangeDecl |
John McCall | 7acddac | 2011-06-17 06:42:21 +0000 | [diff] [blame] | 1744 | Abv->Add(BitCodeAbbrevOp(0)); // isARCPseudoStrong |
Douglas Gregor | 67d45ec | 2012-09-20 23:43:29 +0000 | [diff] [blame] | 1745 | Abv->Add(BitCodeAbbrevOp(0)); // isConstexpr |
Richard Smith | 04fa7a3 | 2013-09-28 04:02:39 +0000 | [diff] [blame] | 1746 | Abv->Add(BitCodeAbbrevOp(0)); // isInitCapture |
Richard Smith | dd9459f | 2013-08-13 18:18:50 +0000 | [diff] [blame] | 1747 | Abv->Add(BitCodeAbbrevOp(0)); // isPrevDeclInSameScope |
Richard Smith | ad0e27b | 2013-02-12 05:48:23 +0000 | [diff] [blame] | 1748 | Abv->Add(BitCodeAbbrevOp(0)); // Linkage |
Chris Lattner | ea5ce47 | 2009-04-27 07:35:58 +0000 | [diff] [blame] | 1749 | Abv->Add(BitCodeAbbrevOp(0)); // HasInit |
Argyrios Kyrtzidis | 9421adc | 2010-07-04 21:44:00 +0000 | [diff] [blame] | 1750 | Abv->Add(BitCodeAbbrevOp(0)); // HasMemberSpecializationInfo |
Chris Lattner | ea5ce47 | 2009-04-27 07:35:58 +0000 | [diff] [blame] | 1751 | // ParmVarDecl |
John McCall | 7079886 | 2011-05-02 00:30:12 +0000 | [diff] [blame] | 1752 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsObjCMethodParameter |
John McCall | fb44de9 | 2011-05-01 22:35:37 +0000 | [diff] [blame] | 1753 | Abv->Add(BitCodeAbbrevOp(0)); // ScopeDepth |
| 1754 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // ScopeIndex |
Chris Lattner | ea5ce47 | 2009-04-27 07:35:58 +0000 | [diff] [blame] | 1755 | Abv->Add(BitCodeAbbrevOp(0)); // ObjCDeclQualifier |
John McCall | eecf5fa | 2011-03-09 04:22:44 +0000 | [diff] [blame] | 1756 | Abv->Add(BitCodeAbbrevOp(0)); // KNRPromoted |
John McCall | bf73b35 | 2010-03-12 18:31:32 +0000 | [diff] [blame] | 1757 | Abv->Add(BitCodeAbbrevOp(0)); // HasInheritedDefaultArg |
Argyrios Kyrtzidis | 691d77f | 2010-07-04 21:44:07 +0000 | [diff] [blame] | 1758 | Abv->Add(BitCodeAbbrevOp(0)); // HasUninstantiatedDefaultArg |
Jonathan D. Turner | 953c564 | 2011-06-03 23:11:16 +0000 | [diff] [blame] | 1759 | // Type Source Info |
| 1760 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); |
| 1761 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array)); |
| 1762 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // TypeLoc |
| 1763 | DeclParmVarAbbrev = Stream.EmitAbbrev(Abv); |
Sebastian Redl | 681d723 | 2010-07-27 00:17:23 +0000 | [diff] [blame] | 1764 | |
Jonathan D. Turner | 8e1b80c | 2011-06-06 16:22:39 +0000 | [diff] [blame] | 1765 | // Abbreviation for DECL_TYPEDEF |
Douglas Gregor | a72d8c4 | 2011-06-03 02:27:19 +0000 | [diff] [blame] | 1766 | Abv = new BitCodeAbbrev(); |
Jonathan D. Turner | 953c564 | 2011-06-03 23:11:16 +0000 | [diff] [blame] | 1767 | Abv->Add(BitCodeAbbrevOp(serialization::DECL_TYPEDEF)); |
Douglas Gregor | a1be278 | 2011-12-17 23:38:30 +0000 | [diff] [blame] | 1768 | // Redeclarable |
Douglas Gregor | ecb1938 | 2011-12-19 15:27:36 +0000 | [diff] [blame] | 1769 | Abv->Add(BitCodeAbbrevOp(0)); // No redeclaration |
Jonathan D. Turner | 953c564 | 2011-06-03 23:11:16 +0000 | [diff] [blame] | 1770 | // Decl |
| 1771 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclContext |
| 1772 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // LexicalDeclContext |
Argyrios Kyrtzidis | ba50b3e | 2012-03-09 21:09:04 +0000 | [diff] [blame] | 1773 | Abv->Add(BitCodeAbbrevOp(0)); // isInvalidDecl |
Jonathan D. Turner | 953c564 | 2011-06-03 23:11:16 +0000 | [diff] [blame] | 1774 | Abv->Add(BitCodeAbbrevOp(0)); // HasAttrs |
| 1775 | Abv->Add(BitCodeAbbrevOp(0)); // isImplicit |
Stephen Hines | 176edba | 2014-12-01 14:53:08 -0800 | [diff] [blame] | 1776 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isUsed |
| 1777 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isReferenced |
Argyrios Kyrtzidis | c14a03d | 2011-11-23 20:27:36 +0000 | [diff] [blame] | 1778 | Abv->Add(BitCodeAbbrevOp(0)); // TopLevelDeclInObjCContainer |
Stephen Hines | 176edba | 2014-12-01 14:53:08 -0800 | [diff] [blame] | 1779 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2)); // C++ AccessSpecifier |
Douglas Gregor | 8d267c5 | 2011-09-09 02:06:17 +0000 | [diff] [blame] | 1780 | Abv->Add(BitCodeAbbrevOp(0)); // ModulePrivate |
Douglas Gregor | 185dbd7 | 2011-12-01 02:07:58 +0000 | [diff] [blame] | 1781 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SubmoduleID |
Jonathan D. Turner | 953c564 | 2011-06-03 23:11:16 +0000 | [diff] [blame] | 1782 | // NamedDecl |
| 1783 | Abv->Add(BitCodeAbbrevOp(0)); // NameKind = Identifier |
| 1784 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Name |
Stephen Hines | 0e2c34f | 2015-03-23 12:09:02 -0700 | [diff] [blame] | 1785 | Abv->Add(BitCodeAbbrevOp(0)); // AnonDeclNumber |
Jonathan D. Turner | 953c564 | 2011-06-03 23:11:16 +0000 | [diff] [blame] | 1786 | // TypeDecl |
| 1787 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Source Location |
| 1788 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type Ref |
| 1789 | // TypedefDecl |
| 1790 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array)); |
| 1791 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // TypeLoc |
| 1792 | DeclTypedefAbbrev = Stream.EmitAbbrev(Abv); |
| 1793 | |
Jonathan D. Turner | 8e1b80c | 2011-06-06 16:22:39 +0000 | [diff] [blame] | 1794 | // Abbreviation for DECL_VAR |
Jonathan D. Turner | 953c564 | 2011-06-03 23:11:16 +0000 | [diff] [blame] | 1795 | Abv = new BitCodeAbbrev(); |
| 1796 | Abv->Add(BitCodeAbbrevOp(serialization::DECL_VAR)); |
Douglas Gregor | d488b3a | 2011-10-26 17:53:41 +0000 | [diff] [blame] | 1797 | // Redeclarable |
Douglas Gregor | ecb1938 | 2011-12-19 15:27:36 +0000 | [diff] [blame] | 1798 | Abv->Add(BitCodeAbbrevOp(0)); // No redeclaration |
Jonathan D. Turner | 953c564 | 2011-06-03 23:11:16 +0000 | [diff] [blame] | 1799 | // Decl |
| 1800 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclContext |
| 1801 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // LexicalDeclContext |
Argyrios Kyrtzidis | ba50b3e | 2012-03-09 21:09:04 +0000 | [diff] [blame] | 1802 | Abv->Add(BitCodeAbbrevOp(0)); // isInvalidDecl |
Jonathan D. Turner | 953c564 | 2011-06-03 23:11:16 +0000 | [diff] [blame] | 1803 | Abv->Add(BitCodeAbbrevOp(0)); // HasAttrs |
| 1804 | Abv->Add(BitCodeAbbrevOp(0)); // isImplicit |
| 1805 | Abv->Add(BitCodeAbbrevOp(0)); // isUsed |
| 1806 | Abv->Add(BitCodeAbbrevOp(0)); // isReferenced |
Argyrios Kyrtzidis | c14a03d | 2011-11-23 20:27:36 +0000 | [diff] [blame] | 1807 | Abv->Add(BitCodeAbbrevOp(0)); // TopLevelDeclInObjCContainer |
Jonathan D. Turner | 953c564 | 2011-06-03 23:11:16 +0000 | [diff] [blame] | 1808 | Abv->Add(BitCodeAbbrevOp(AS_none)); // C++ AccessSpecifier |
Douglas Gregor | 8d267c5 | 2011-09-09 02:06:17 +0000 | [diff] [blame] | 1809 | Abv->Add(BitCodeAbbrevOp(0)); // ModulePrivate |
Douglas Gregor | 185dbd7 | 2011-12-01 02:07:58 +0000 | [diff] [blame] | 1810 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SubmoduleID |
Jonathan D. Turner | 953c564 | 2011-06-03 23:11:16 +0000 | [diff] [blame] | 1811 | // NamedDecl |
| 1812 | Abv->Add(BitCodeAbbrevOp(0)); // NameKind = Identifier |
| 1813 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Name |
Stephen Hines | 0e2c34f | 2015-03-23 12:09:02 -0700 | [diff] [blame] | 1814 | Abv->Add(BitCodeAbbrevOp(0)); // AnonDeclNumber |
Jonathan D. Turner | 953c564 | 2011-06-03 23:11:16 +0000 | [diff] [blame] | 1815 | // ValueDecl |
| 1816 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type |
| 1817 | // DeclaratorDecl |
| 1818 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // InnerStartLoc |
| 1819 | Abv->Add(BitCodeAbbrevOp(0)); // hasExtInfo |
| 1820 | // VarDecl |
Jonathan D. Turner | 953c564 | 2011-06-03 23:11:16 +0000 | [diff] [blame] | 1821 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // StorageClass |
Enea Zaffanella | dc17384 | 2013-05-04 08:27:07 +0000 | [diff] [blame] | 1822 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2)); // getTSCSpec |
Jonathan D. Turner | 953c564 | 2011-06-03 23:11:16 +0000 | [diff] [blame] | 1823 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // CXXDirectInitializer |
| 1824 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isExceptionVariable |
| 1825 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isNRVOVariable |
| 1826 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isCXXForRangeDecl |
John McCall | 7acddac | 2011-06-17 06:42:21 +0000 | [diff] [blame] | 1827 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isARCPseudoStrong |
Douglas Gregor | 67d45ec | 2012-09-20 23:43:29 +0000 | [diff] [blame] | 1828 | Abv->Add(BitCodeAbbrevOp(0)); // isConstexpr |
Richard Smith | 04fa7a3 | 2013-09-28 04:02:39 +0000 | [diff] [blame] | 1829 | Abv->Add(BitCodeAbbrevOp(0)); // isInitCapture |
Richard Smith | dd9459f | 2013-08-13 18:18:50 +0000 | [diff] [blame] | 1830 | Abv->Add(BitCodeAbbrevOp(0)); // isPrevDeclInSameScope |
Rafael Espindola | a99ecbc | 2013-05-25 17:16:20 +0000 | [diff] [blame] | 1831 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); // Linkage |
Jonathan D. Turner | 953c564 | 2011-06-03 23:11:16 +0000 | [diff] [blame] | 1832 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // HasInit |
| 1833 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // HasMemberSpecInfo |
| 1834 | // Type Source Info |
| 1835 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); |
| 1836 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array)); |
| 1837 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // TypeLoc |
| 1838 | DeclVarAbbrev = Stream.EmitAbbrev(Abv); |
| 1839 | |
Stephen Hines | 176edba | 2014-12-01 14:53:08 -0800 | [diff] [blame] | 1840 | // Abbreviation for DECL_CXX_METHOD |
| 1841 | Abv = new BitCodeAbbrev(); |
| 1842 | Abv->Add(BitCodeAbbrevOp(serialization::DECL_CXX_METHOD)); |
| 1843 | // RedeclarableDecl |
| 1844 | Abv->Add(BitCodeAbbrevOp(0)); // CanonicalDecl |
| 1845 | // Decl |
| 1846 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclContext |
| 1847 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // LexicalDeclContext |
| 1848 | Abv->Add(BitCodeAbbrevOp(0)); // Invalid |
| 1849 | Abv->Add(BitCodeAbbrevOp(0)); // HasAttrs |
| 1850 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Implicit |
| 1851 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Used |
| 1852 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Referenced |
| 1853 | Abv->Add(BitCodeAbbrevOp(0)); // InObjCContainer |
| 1854 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2)); // Access |
| 1855 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // ModulePrivate |
| 1856 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SubmoduleID |
| 1857 | // NamedDecl |
| 1858 | Abv->Add(BitCodeAbbrevOp(DeclarationName::Identifier)); // NameKind |
| 1859 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Identifier |
Stephen Hines | 0e2c34f | 2015-03-23 12:09:02 -0700 | [diff] [blame] | 1860 | Abv->Add(BitCodeAbbrevOp(0)); // AnonDeclNumber |
Stephen Hines | 176edba | 2014-12-01 14:53:08 -0800 | [diff] [blame] | 1861 | // ValueDecl |
| 1862 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type |
| 1863 | // DeclaratorDecl |
| 1864 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // InnerLocStart |
| 1865 | Abv->Add(BitCodeAbbrevOp(0)); // HasExtInfo |
| 1866 | // FunctionDecl |
| 1867 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 11)); // IDNS |
| 1868 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); // StorageClass |
| 1869 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Inline |
| 1870 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // InlineSpecified |
| 1871 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // VirtualAsWritten |
| 1872 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Pure |
| 1873 | Abv->Add(BitCodeAbbrevOp(0)); // HasInheritedProto |
| 1874 | Abv->Add(BitCodeAbbrevOp(1)); // HasWrittenProto |
Stephen Hines | 0e2c34f | 2015-03-23 12:09:02 -0700 | [diff] [blame] | 1875 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Deleted |
Stephen Hines | 176edba | 2014-12-01 14:53:08 -0800 | [diff] [blame] | 1876 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Trivial |
| 1877 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Defaulted |
| 1878 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // ExplicitlyDefaulted |
| 1879 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // ImplicitReturnZero |
| 1880 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Constexpr |
| 1881 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // SkippedBody |
| 1882 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // LateParsed |
| 1883 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); // Linkage |
| 1884 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // LocEnd |
| 1885 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); // TemplateKind |
| 1886 | // This Array slurps the rest of the record. Fortunately we want to encode |
| 1887 | // (nearly) all the remaining (variable number of) fields in the same way. |
| 1888 | // |
| 1889 | // This is the function template information if any, then |
| 1890 | // NumParams and Params[] from FunctionDecl, and |
| 1891 | // NumOverriddenMethods, OverriddenMethods[] from CXXMethodDecl. |
| 1892 | // |
| 1893 | // Add an AbbrevOp for 'size then elements' and use it here. |
| 1894 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array)); |
| 1895 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); |
| 1896 | DeclCXXMethodAbbrev = Stream.EmitAbbrev(Abv); |
| 1897 | |
Jonathan D. Turner | 8e1b80c | 2011-06-06 16:22:39 +0000 | [diff] [blame] | 1898 | // Abbreviation for EXPR_DECL_REF |
Jonathan D. Turner | 953c564 | 2011-06-03 23:11:16 +0000 | [diff] [blame] | 1899 | Abv = new BitCodeAbbrev(); |
Douglas Gregor | a72d8c4 | 2011-06-03 02:27:19 +0000 | [diff] [blame] | 1900 | Abv->Add(BitCodeAbbrevOp(serialization::EXPR_DECL_REF)); |
| 1901 | //Stmt |
| 1902 | //Expr |
| 1903 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type |
Douglas Gregor | 561f812 | 2011-07-01 01:22:09 +0000 | [diff] [blame] | 1904 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //TypeDependent |
| 1905 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //ValueDependent |
| 1906 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //InstantiationDependent |
Douglas Gregor | a72d8c4 | 2011-06-03 02:27:19 +0000 | [diff] [blame] | 1907 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //UnexpandedParamPack |
| 1908 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); //GetValueKind |
| 1909 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); //GetObjectKind |
| 1910 | //DeclRefExpr |
| 1911 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //HasQualifier |
| 1912 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //GetDeclFound |
| 1913 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //ExplicitTemplateArgs |
Abramo Bagnara | 7cc58b4 | 2011-10-05 07:56:41 +0000 | [diff] [blame] | 1914 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //HadMultipleCandidates |
Stephen Hines | 0e2c34f | 2015-03-23 12:09:02 -0700 | [diff] [blame] | 1915 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, |
| 1916 | 1)); // RefersToEnclosingVariableOrCapture |
Douglas Gregor | a72d8c4 | 2011-06-03 02:27:19 +0000 | [diff] [blame] | 1917 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclRef |
| 1918 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Location |
| 1919 | DeclRefExprAbbrev = Stream.EmitAbbrev(Abv); |
| 1920 | |
| 1921 | // Abbreviation for EXPR_INTEGER_LITERAL |
| 1922 | Abv = new BitCodeAbbrev(); |
| 1923 | Abv->Add(BitCodeAbbrevOp(serialization::EXPR_INTEGER_LITERAL)); |
| 1924 | //Stmt |
| 1925 | //Expr |
| 1926 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type |
Douglas Gregor | 561f812 | 2011-07-01 01:22:09 +0000 | [diff] [blame] | 1927 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //TypeDependent |
| 1928 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //ValueDependent |
| 1929 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //InstantiationDependent |
Douglas Gregor | a72d8c4 | 2011-06-03 02:27:19 +0000 | [diff] [blame] | 1930 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //UnexpandedParamPack |
| 1931 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); //GetValueKind |
| 1932 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); //GetObjectKind |
| 1933 | //Integer Literal |
| 1934 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Location |
| 1935 | Abv->Add(BitCodeAbbrevOp(32)); // Bit Width |
| 1936 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Value |
| 1937 | IntegerLiteralAbbrev = Stream.EmitAbbrev(Abv); |
| 1938 | |
| 1939 | // Abbreviation for EXPR_CHARACTER_LITERAL |
| 1940 | Abv = new BitCodeAbbrev(); |
| 1941 | Abv->Add(BitCodeAbbrevOp(serialization::EXPR_CHARACTER_LITERAL)); |
| 1942 | //Stmt |
| 1943 | //Expr |
| 1944 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type |
Douglas Gregor | 561f812 | 2011-07-01 01:22:09 +0000 | [diff] [blame] | 1945 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //TypeDependent |
| 1946 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //ValueDependent |
| 1947 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //InstantiationDependent |
Douglas Gregor | a72d8c4 | 2011-06-03 02:27:19 +0000 | [diff] [blame] | 1948 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //UnexpandedParamPack |
| 1949 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); //GetValueKind |
| 1950 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); //GetObjectKind |
Jonathan D. Turner | 2808757 | 2011-06-03 21:46:44 +0000 | [diff] [blame] | 1951 | //Character Literal |
Douglas Gregor | a72d8c4 | 2011-06-03 02:27:19 +0000 | [diff] [blame] | 1952 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // getValue |
| 1953 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Location |
Eli Friedman | b3b6c22 | 2012-09-14 00:51:36 +0000 | [diff] [blame] | 1954 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2)); // getKind |
Douglas Gregor | a72d8c4 | 2011-06-03 02:27:19 +0000 | [diff] [blame] | 1955 | CharacterLiteralAbbrev = Stream.EmitAbbrev(Abv); |
| 1956 | |
Stephen Hines | 176edba | 2014-12-01 14:53:08 -0800 | [diff] [blame] | 1957 | // Abbreviation for EXPR_IMPLICIT_CAST |
| 1958 | Abv = new BitCodeAbbrev(); |
| 1959 | Abv->Add(BitCodeAbbrevOp(serialization::EXPR_IMPLICIT_CAST)); |
| 1960 | // Stmt |
| 1961 | // Expr |
| 1962 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type |
| 1963 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //TypeDependent |
| 1964 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //ValueDependent |
| 1965 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //InstantiationDependent |
| 1966 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //UnexpandedParamPack |
| 1967 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); //GetValueKind |
| 1968 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); //GetObjectKind |
| 1969 | // CastExpr |
| 1970 | Abv->Add(BitCodeAbbrevOp(0)); // PathSize |
| 1971 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 6)); // CastKind |
| 1972 | // ImplicitCastExpr |
| 1973 | ExprImplicitCastAbbrev = Stream.EmitAbbrev(Abv); |
| 1974 | |
Sebastian Redl | 681d723 | 2010-07-27 00:17:23 +0000 | [diff] [blame] | 1975 | Abv = new BitCodeAbbrev(); |
Sebastian Redl | 8538e8d | 2010-08-18 23:57:32 +0000 | [diff] [blame] | 1976 | Abv->Add(BitCodeAbbrevOp(serialization::DECL_CONTEXT_LEXICAL)); |
Sebastian Redl | 681d723 | 2010-07-27 00:17:23 +0000 | [diff] [blame] | 1977 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); |
| 1978 | DeclContextLexicalAbbrev = Stream.EmitAbbrev(Abv); |
Argyrios Kyrtzidis | 074dcc8 | 2010-08-20 16:04:35 +0000 | [diff] [blame] | 1979 | |
| 1980 | Abv = new BitCodeAbbrev(); |
| 1981 | Abv->Add(BitCodeAbbrevOp(serialization::DECL_CONTEXT_VISIBLE)); |
| 1982 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); |
| 1983 | Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); |
| 1984 | DeclContextVisibleLookupAbbrev = Stream.EmitAbbrev(Abv); |
Chris Lattner | ea5ce47 | 2009-04-27 07:35:58 +0000 | [diff] [blame] | 1985 | } |
| 1986 | |
Daniel Dunbar | e24d38f | 2009-09-17 03:06:51 +0000 | [diff] [blame] | 1987 | /// isRequiredDecl - Check if this is a "required" Decl, which must be seen by |
| 1988 | /// consumers of the AST. |
| 1989 | /// |
Sebastian Redl | 3397c55 | 2010-08-18 23:56:27 +0000 | [diff] [blame] | 1990 | /// Such decls will always be deserialized from the AST file, so we would like |
Daniel Dunbar | e24d38f | 2009-09-17 03:06:51 +0000 | [diff] [blame] | 1991 | /// this to be as restrictive as possible. Currently the predicate is driven by |
| 1992 | /// code generation requirements, if other clients have a different notion of |
| 1993 | /// what is "required" then we may have to consider an alternate scheme where |
| 1994 | /// clients can iterate over the top-level decls and get information on them, |
| 1995 | /// without necessary deserializing them. We could explicitly require such |
| 1996 | /// clients to use a separate API call to "realize" the decl. This should be |
| 1997 | /// relatively painless since they would presumably only do it for top-level |
| 1998 | /// decls. |
Daniel Dunbar | e24d38f | 2009-09-17 03:06:51 +0000 | [diff] [blame] | 1999 | static bool isRequiredDecl(const Decl *D, ASTContext &Context) { |
Argyrios Kyrtzidis | 144b38a | 2011-09-13 21:35:00 +0000 | [diff] [blame] | 2000 | // An ObjCMethodDecl is never considered as "required" because its |
| 2001 | // implementation container always is. |
| 2002 | |
Stephen Hines | 651f13c | 2014-04-23 16:59:28 -0700 | [diff] [blame] | 2003 | // File scoped assembly or obj-c implementation must be seen. ImportDecl is |
| 2004 | // used by codegen to determine the set of imported modules to search for |
| 2005 | // inputs for automatic linking. |
| 2006 | if (isa<FileScopeAsmDecl>(D) || isa<ObjCImplDecl>(D) || isa<ImportDecl>(D)) |
Daniel Dunbar | e24d38f | 2009-09-17 03:06:51 +0000 | [diff] [blame] | 2007 | return true; |
| 2008 | |
Argyrios Kyrtzidis | 4ac7c0b | 2010-07-29 20:08:05 +0000 | [diff] [blame] | 2009 | return Context.DeclMustBeEmitted(D); |
Daniel Dunbar | e24d38f | 2009-09-17 03:06:51 +0000 | [diff] [blame] | 2010 | } |
| 2011 | |
Sebastian Redl | a4232eb | 2010-08-18 23:56:21 +0000 | [diff] [blame] | 2012 | void ASTWriter::WriteDecl(ASTContext &Context, Decl *D) { |
Argyrios Kyrtzidis | e09a275 | 2010-10-28 09:29:32 +0000 | [diff] [blame] | 2013 | // Switch case IDs are per Decl. |
| 2014 | ClearSwitchCaseIDs(); |
| 2015 | |
Chris Lattner | 12b1c76 | 2009-04-27 06:16:06 +0000 | [diff] [blame] | 2016 | RecordData Record; |
Sebastian Redl | 3397c55 | 2010-08-18 23:56:27 +0000 | [diff] [blame] | 2017 | ASTDeclWriter W(*this, Context, Record); |
Chris Lattner | 12b1c76 | 2009-04-27 06:16:06 +0000 | [diff] [blame] | 2018 | |
Douglas Gregor | 1c7946a | 2012-01-05 22:33:30 +0000 | [diff] [blame] | 2019 | // Determine the ID for this declaration. |
| 2020 | serialization::DeclID ID; |
Stephen Hines | 0e2c34f | 2015-03-23 12:09:02 -0700 | [diff] [blame] | 2021 | if (D->isFromASTFile()) { |
| 2022 | assert(isRewritten(D) && "should not be emitting imported decl"); |
Douglas Gregor | 1c7946a | 2012-01-05 22:33:30 +0000 | [diff] [blame] | 2023 | ID = getDeclID(D); |
Stephen Hines | 0e2c34f | 2015-03-23 12:09:02 -0700 | [diff] [blame] | 2024 | } else { |
Douglas Gregor | 1c7946a | 2012-01-05 22:33:30 +0000 | [diff] [blame] | 2025 | serialization::DeclID &IDR = DeclIDs[D]; |
| 2026 | if (IDR == 0) |
| 2027 | IDR = NextDeclID++; |
| 2028 | |
| 2029 | ID= IDR; |
| 2030 | } |
Argyrios Kyrtzidis | 643586f | 2012-03-22 16:08:04 +0000 | [diff] [blame] | 2031 | |
| 2032 | bool isReplacingADecl = ID < FirstDeclID; |
| 2033 | |
| 2034 | // If this declaration is also a DeclContext, write blocks for the |
| 2035 | // declarations that lexically stored inside its context and those |
| 2036 | // declarations that are visible from its context. These blocks |
| 2037 | // are written before the declaration itself so that we can put |
| 2038 | // their offsets into the record for the declaration. |
| 2039 | uint64_t LexicalOffset = 0; |
| 2040 | uint64_t VisibleOffset = 0; |
| 2041 | DeclContext *DC = dyn_cast<DeclContext>(D); |
| 2042 | if (DC) { |
| 2043 | if (isReplacingADecl) { |
| 2044 | // It is replacing a decl from a chained PCH; make sure that the |
| 2045 | // DeclContext is fully loaded. |
| 2046 | if (DC->hasExternalLexicalStorage()) |
| 2047 | DC->LoadLexicalDeclsFromExternalStorage(); |
| 2048 | if (DC->hasExternalVisibleStorage()) |
| 2049 | Chain->completeVisibleDeclsMap(DC); |
| 2050 | } |
| 2051 | LexicalOffset = WriteDeclContextLexicalBlock(Context, DC); |
| 2052 | VisibleOffset = WriteDeclContextVisibleBlock(Context, DC); |
| 2053 | } |
Douglas Gregor | 1c7946a | 2012-01-05 22:33:30 +0000 | [diff] [blame] | 2054 | |
Argyrios Kyrtzidis | 643586f | 2012-03-22 16:08:04 +0000 | [diff] [blame] | 2055 | if (isReplacingADecl) { |
Sebastian Redl | 0b17c61 | 2010-08-13 00:28:03 +0000 | [diff] [blame] | 2056 | // We're replacing a decl in a previous file. |
Argyrios Kyrtzidis | ef23b60 | 2011-10-31 07:20:15 +0000 | [diff] [blame] | 2057 | ReplacedDecls.push_back(ReplacedDeclInfo(ID, Stream.GetCurrentBitNo(), |
| 2058 | D->getLocation())); |
Sebastian Redl | 0b17c61 | 2010-08-13 00:28:03 +0000 | [diff] [blame] | 2059 | } else { |
| 2060 | unsigned Index = ID - FirstDeclID; |
Douglas Gregor | 61d60ee | 2009-10-17 00:13:19 +0000 | [diff] [blame] | 2061 | |
Sebastian Redl | 0b17c61 | 2010-08-13 00:28:03 +0000 | [diff] [blame] | 2062 | // Record the offset for this declaration |
Argyrios Kyrtzidis | 10f3df5 | 2011-10-28 22:54:21 +0000 | [diff] [blame] | 2063 | SourceLocation Loc = D->getLocation(); |
Sebastian Redl | 0b17c61 | 2010-08-13 00:28:03 +0000 | [diff] [blame] | 2064 | if (DeclOffsets.size() == Index) |
Argyrios Kyrtzidis | 10f3df5 | 2011-10-28 22:54:21 +0000 | [diff] [blame] | 2065 | DeclOffsets.push_back(DeclOffset(Loc, Stream.GetCurrentBitNo())); |
Sebastian Redl | 0b17c61 | 2010-08-13 00:28:03 +0000 | [diff] [blame] | 2066 | else if (DeclOffsets.size() < Index) { |
| 2067 | DeclOffsets.resize(Index+1); |
Argyrios Kyrtzidis | 10f3df5 | 2011-10-28 22:54:21 +0000 | [diff] [blame] | 2068 | DeclOffsets[Index].setLocation(Loc); |
Argyrios Kyrtzidis | 9d31fa7 | 2011-10-27 18:47:35 +0000 | [diff] [blame] | 2069 | DeclOffsets[Index].BitOffset = Stream.GetCurrentBitNo(); |
Sebastian Redl | 0b17c61 | 2010-08-13 00:28:03 +0000 | [diff] [blame] | 2070 | } |
Argyrios Kyrtzidis | 10f3df5 | 2011-10-28 22:54:21 +0000 | [diff] [blame] | 2071 | |
| 2072 | SourceManager &SM = Context.getSourceManager(); |
Argyrios Kyrtzidis | 19645d2 | 2011-10-28 23:57:43 +0000 | [diff] [blame] | 2073 | if (Loc.isValid() && SM.isLocalSourceLocation(Loc)) |
| 2074 | associateDeclWithFile(D, ID); |
Douglas Gregor | 61d60ee | 2009-10-17 00:13:19 +0000 | [diff] [blame] | 2075 | } |
| 2076 | |
| 2077 | // Build and emit a record for this declaration |
| 2078 | Record.clear(); |
Sebastian Redl | 8538e8d | 2010-08-18 23:57:32 +0000 | [diff] [blame] | 2079 | W.Code = (serialization::DeclCode)0; |
Douglas Gregor | 61d60ee | 2009-10-17 00:13:19 +0000 | [diff] [blame] | 2080 | W.AbbrevToUse = 0; |
| 2081 | W.Visit(D); |
| 2082 | if (DC) W.VisitDeclContext(DC, LexicalOffset, VisibleOffset); |
| 2083 | |
Daniel Dunbar | 3367198 | 2009-12-03 09:13:36 +0000 | [diff] [blame] | 2084 | if (!W.Code) |
Chris Lattner | 5f9e272 | 2011-07-23 10:55:15 +0000 | [diff] [blame] | 2085 | llvm::report_fatal_error(StringRef("unexpected declaration kind '") + |
Daniel Dunbar | 3367198 | 2009-12-03 09:13:36 +0000 | [diff] [blame] | 2086 | D->getDeclKindName() + "'"); |
Douglas Gregor | 61d60ee | 2009-10-17 00:13:19 +0000 | [diff] [blame] | 2087 | Stream.EmitRecord(W.Code, Record, W.AbbrevToUse); |
| 2088 | |
Pirama Arumuga Nainar | 3ea9e33 | 2015-04-08 08:57:32 -0700 | [diff] [blame] | 2089 | // Flush any expressions, base specifiers, and ctor initializers that |
| 2090 | // were written as part of this declaration. |
| 2091 | FlushPendingAfterDecl(); |
| 2092 | |
Stephen Hines | 651f13c | 2014-04-23 16:59:28 -0700 | [diff] [blame] | 2093 | // Note declarations that should be deserialized eagerly so that we can add |
| 2094 | // them to a record in the AST file later. |
Douglas Gregor | 61d60ee | 2009-10-17 00:13:19 +0000 | [diff] [blame] | 2095 | if (isRequiredDecl(D, Context)) |
Stephen Hines | 651f13c | 2014-04-23 16:59:28 -0700 | [diff] [blame] | 2096 | EagerlyDeserializedDecls.push_back(ID); |
| 2097 | } |
| 2098 | |
| 2099 | void ASTWriter::AddFunctionDefinition(const FunctionDecl *FD, |
| 2100 | RecordData &Record) { |
| 2101 | ClearSwitchCaseIDs(); |
| 2102 | |
| 2103 | ASTDeclWriter W(*this, FD->getASTContext(), Record); |
| 2104 | W.AddFunctionDefinition(FD); |
Chris Lattner | 12b1c76 | 2009-04-27 06:16:06 +0000 | [diff] [blame] | 2105 | } |