MultiplexConsumer.cpp revision 1.1.1.1
1//===- MultiplexConsumer.cpp - AST Consumer for PCH Generation --*- C++ -*-===// 2// 3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4// See https://llvm.org/LICENSE.txt for license information. 5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6// 7//===----------------------------------------------------------------------===// 8// 9// This file defines the MultiplexConsumer class. It also declares and defines 10// MultiplexASTDeserializationListener and MultiplexASTMutationListener, which 11// are implementation details of MultiplexConsumer. 12// 13//===----------------------------------------------------------------------===// 14 15#include "clang/Frontend/MultiplexConsumer.h" 16#include "clang/AST/ASTMutationListener.h" 17#include "clang/AST/DeclGroup.h" 18 19using namespace clang; 20 21namespace clang { 22 23MultiplexASTDeserializationListener::MultiplexASTDeserializationListener( 24 const std::vector<ASTDeserializationListener*>& L) 25 : Listeners(L) { 26} 27 28void MultiplexASTDeserializationListener::ReaderInitialized( 29 ASTReader *Reader) { 30 for (size_t i = 0, e = Listeners.size(); i != e; ++i) 31 Listeners[i]->ReaderInitialized(Reader); 32} 33 34void MultiplexASTDeserializationListener::IdentifierRead( 35 serialization::IdentID ID, IdentifierInfo *II) { 36 for (size_t i = 0, e = Listeners.size(); i != e; ++i) 37 Listeners[i]->IdentifierRead(ID, II); 38} 39 40void MultiplexASTDeserializationListener::MacroRead( 41 serialization::MacroID ID, MacroInfo *MI) { 42 for (auto &Listener : Listeners) 43 Listener->MacroRead(ID, MI); 44} 45 46void MultiplexASTDeserializationListener::TypeRead( 47 serialization::TypeIdx Idx, QualType T) { 48 for (size_t i = 0, e = Listeners.size(); i != e; ++i) 49 Listeners[i]->TypeRead(Idx, T); 50} 51 52void MultiplexASTDeserializationListener::DeclRead( 53 serialization::DeclID ID, const Decl *D) { 54 for (size_t i = 0, e = Listeners.size(); i != e; ++i) 55 Listeners[i]->DeclRead(ID, D); 56} 57 58void MultiplexASTDeserializationListener::SelectorRead( 59 serialization::SelectorID ID, Selector Sel) { 60 for (size_t i = 0, e = Listeners.size(); i != e; ++i) 61 Listeners[i]->SelectorRead(ID, Sel); 62} 63 64void MultiplexASTDeserializationListener::MacroDefinitionRead( 65 serialization::PreprocessedEntityID ID, MacroDefinitionRecord *MD) { 66 for (size_t i = 0, e = Listeners.size(); i != e; ++i) 67 Listeners[i]->MacroDefinitionRead(ID, MD); 68} 69 70void MultiplexASTDeserializationListener::ModuleRead( 71 serialization::SubmoduleID ID, Module *Mod) { 72 for (auto &Listener : Listeners) 73 Listener->ModuleRead(ID, Mod); 74} 75 76// This ASTMutationListener forwards its notifications to a set of 77// child listeners. 78class MultiplexASTMutationListener : public ASTMutationListener { 79public: 80 // Does NOT take ownership of the elements in L. 81 MultiplexASTMutationListener(ArrayRef<ASTMutationListener*> L); 82 void CompletedTagDefinition(const TagDecl *D) override; 83 void AddedVisibleDecl(const DeclContext *DC, const Decl *D) override; 84 void AddedCXXImplicitMember(const CXXRecordDecl *RD, const Decl *D) override; 85 void AddedCXXTemplateSpecialization(const ClassTemplateDecl *TD, 86 const ClassTemplateSpecializationDecl *D) override; 87 void AddedCXXTemplateSpecialization(const VarTemplateDecl *TD, 88 const VarTemplateSpecializationDecl *D) override; 89 void AddedCXXTemplateSpecialization(const FunctionTemplateDecl *TD, 90 const FunctionDecl *D) override; 91 void ResolvedExceptionSpec(const FunctionDecl *FD) override; 92 void DeducedReturnType(const FunctionDecl *FD, QualType ReturnType) override; 93 void ResolvedOperatorDelete(const CXXDestructorDecl *DD, 94 const FunctionDecl *Delete, 95 Expr *ThisArg) override; 96 void CompletedImplicitDefinition(const FunctionDecl *D) override; 97 void InstantiationRequested(const ValueDecl *D) override; 98 void VariableDefinitionInstantiated(const VarDecl *D) override; 99 void FunctionDefinitionInstantiated(const FunctionDecl *D) override; 100 void DefaultArgumentInstantiated(const ParmVarDecl *D) override; 101 void DefaultMemberInitializerInstantiated(const FieldDecl *D) override; 102 void AddedObjCCategoryToInterface(const ObjCCategoryDecl *CatD, 103 const ObjCInterfaceDecl *IFD) override; 104 void DeclarationMarkedUsed(const Decl *D) override; 105 void DeclarationMarkedOpenMPThreadPrivate(const Decl *D) override; 106 void DeclarationMarkedOpenMPAllocate(const Decl *D, const Attr *A) override; 107 void DeclarationMarkedOpenMPDeclareTarget(const Decl *D, 108 const Attr *Attr) override; 109 void RedefinedHiddenDefinition(const NamedDecl *D, Module *M) override; 110 void AddedAttributeToRecord(const Attr *Attr, 111 const RecordDecl *Record) override; 112 113private: 114 std::vector<ASTMutationListener*> Listeners; 115}; 116 117MultiplexASTMutationListener::MultiplexASTMutationListener( 118 ArrayRef<ASTMutationListener*> L) 119 : Listeners(L.begin(), L.end()) { 120} 121 122void MultiplexASTMutationListener::CompletedTagDefinition(const TagDecl *D) { 123 for (size_t i = 0, e = Listeners.size(); i != e; ++i) 124 Listeners[i]->CompletedTagDefinition(D); 125} 126 127void MultiplexASTMutationListener::AddedVisibleDecl( 128 const DeclContext *DC, const Decl *D) { 129 for (size_t i = 0, e = Listeners.size(); i != e; ++i) 130 Listeners[i]->AddedVisibleDecl(DC, D); 131} 132 133void MultiplexASTMutationListener::AddedCXXImplicitMember( 134 const CXXRecordDecl *RD, const Decl *D) { 135 for (size_t i = 0, e = Listeners.size(); i != e; ++i) 136 Listeners[i]->AddedCXXImplicitMember(RD, D); 137} 138void MultiplexASTMutationListener::AddedCXXTemplateSpecialization( 139 const ClassTemplateDecl *TD, const ClassTemplateSpecializationDecl *D) { 140 for (size_t i = 0, e = Listeners.size(); i != e; ++i) 141 Listeners[i]->AddedCXXTemplateSpecialization(TD, D); 142} 143void MultiplexASTMutationListener::AddedCXXTemplateSpecialization( 144 const VarTemplateDecl *TD, const VarTemplateSpecializationDecl *D) { 145 for (size_t i = 0, e = Listeners.size(); i != e; ++i) 146 Listeners[i]->AddedCXXTemplateSpecialization(TD, D); 147} 148void MultiplexASTMutationListener::AddedCXXTemplateSpecialization( 149 const FunctionTemplateDecl *TD, const FunctionDecl *D) { 150 for (size_t i = 0, e = Listeners.size(); i != e; ++i) 151 Listeners[i]->AddedCXXTemplateSpecialization(TD, D); 152} 153void MultiplexASTMutationListener::ResolvedExceptionSpec( 154 const FunctionDecl *FD) { 155 for (auto &Listener : Listeners) 156 Listener->ResolvedExceptionSpec(FD); 157} 158void MultiplexASTMutationListener::DeducedReturnType(const FunctionDecl *FD, 159 QualType ReturnType) { 160 for (size_t i = 0, e = Listeners.size(); i != e; ++i) 161 Listeners[i]->DeducedReturnType(FD, ReturnType); 162} 163void MultiplexASTMutationListener::ResolvedOperatorDelete( 164 const CXXDestructorDecl *DD, const FunctionDecl *Delete, Expr *ThisArg) { 165 for (auto *L : Listeners) 166 L->ResolvedOperatorDelete(DD, Delete, ThisArg); 167} 168void MultiplexASTMutationListener::CompletedImplicitDefinition( 169 const FunctionDecl *D) { 170 for (size_t i = 0, e = Listeners.size(); i != e; ++i) 171 Listeners[i]->CompletedImplicitDefinition(D); 172} 173void MultiplexASTMutationListener::InstantiationRequested(const ValueDecl *D) { 174 for (size_t i = 0, e = Listeners.size(); i != e; ++i) 175 Listeners[i]->InstantiationRequested(D); 176} 177void MultiplexASTMutationListener::VariableDefinitionInstantiated( 178 const VarDecl *D) { 179 for (size_t i = 0, e = Listeners.size(); i != e; ++i) 180 Listeners[i]->VariableDefinitionInstantiated(D); 181} 182void MultiplexASTMutationListener::FunctionDefinitionInstantiated( 183 const FunctionDecl *D) { 184 for (auto &Listener : Listeners) 185 Listener->FunctionDefinitionInstantiated(D); 186} 187void MultiplexASTMutationListener::DefaultArgumentInstantiated( 188 const ParmVarDecl *D) { 189 for (size_t i = 0, e = Listeners.size(); i != e; ++i) 190 Listeners[i]->DefaultArgumentInstantiated(D); 191} 192void MultiplexASTMutationListener::DefaultMemberInitializerInstantiated( 193 const FieldDecl *D) { 194 for (size_t i = 0, e = Listeners.size(); i != e; ++i) 195 Listeners[i]->DefaultMemberInitializerInstantiated(D); 196} 197void MultiplexASTMutationListener::AddedObjCCategoryToInterface( 198 const ObjCCategoryDecl *CatD, 199 const ObjCInterfaceDecl *IFD) { 200 for (size_t i = 0, e = Listeners.size(); i != e; ++i) 201 Listeners[i]->AddedObjCCategoryToInterface(CatD, IFD); 202} 203void MultiplexASTMutationListener::DeclarationMarkedUsed(const Decl *D) { 204 for (size_t i = 0, e = Listeners.size(); i != e; ++i) 205 Listeners[i]->DeclarationMarkedUsed(D); 206} 207void MultiplexASTMutationListener::DeclarationMarkedOpenMPThreadPrivate( 208 const Decl *D) { 209 for (size_t i = 0, e = Listeners.size(); i != e; ++i) 210 Listeners[i]->DeclarationMarkedOpenMPThreadPrivate(D); 211} 212void MultiplexASTMutationListener::DeclarationMarkedOpenMPAllocate( 213 const Decl *D, const Attr *A) { 214 for (ASTMutationListener *L : Listeners) 215 L->DeclarationMarkedOpenMPAllocate(D, A); 216} 217void MultiplexASTMutationListener::DeclarationMarkedOpenMPDeclareTarget( 218 const Decl *D, const Attr *Attr) { 219 for (auto *L : Listeners) 220 L->DeclarationMarkedOpenMPDeclareTarget(D, Attr); 221} 222void MultiplexASTMutationListener::RedefinedHiddenDefinition(const NamedDecl *D, 223 Module *M) { 224 for (auto *L : Listeners) 225 L->RedefinedHiddenDefinition(D, M); 226} 227 228void MultiplexASTMutationListener::AddedAttributeToRecord( 229 const Attr *Attr, 230 const RecordDecl *Record) { 231 for (auto *L : Listeners) 232 L->AddedAttributeToRecord(Attr, Record); 233} 234 235} // end namespace clang 236 237MultiplexConsumer::MultiplexConsumer( 238 std::vector<std::unique_ptr<ASTConsumer>> C) 239 : Consumers(std::move(C)), MutationListener(), DeserializationListener() { 240 // Collect the mutation listeners and deserialization listeners of all 241 // children, and create a multiplex listener each if so. 242 std::vector<ASTMutationListener*> mutationListeners; 243 std::vector<ASTDeserializationListener*> serializationListeners; 244 for (auto &Consumer : Consumers) { 245 if (auto *mutationListener = Consumer->GetASTMutationListener()) 246 mutationListeners.push_back(mutationListener); 247 if (auto *serializationListener = Consumer->GetASTDeserializationListener()) 248 serializationListeners.push_back(serializationListener); 249 } 250 if (!mutationListeners.empty()) { 251 MutationListener = 252 std::make_unique<MultiplexASTMutationListener>(mutationListeners); 253 } 254 if (!serializationListeners.empty()) { 255 DeserializationListener = 256 std::make_unique<MultiplexASTDeserializationListener>( 257 serializationListeners); 258 } 259} 260 261MultiplexConsumer::~MultiplexConsumer() {} 262 263void MultiplexConsumer::Initialize(ASTContext &Context) { 264 for (auto &Consumer : Consumers) 265 Consumer->Initialize(Context); 266} 267 268bool MultiplexConsumer::HandleTopLevelDecl(DeclGroupRef D) { 269 bool Continue = true; 270 for (auto &Consumer : Consumers) 271 Continue = Continue && Consumer->HandleTopLevelDecl(D); 272 return Continue; 273} 274 275void MultiplexConsumer::HandleInlineFunctionDefinition(FunctionDecl *D) { 276 for (auto &Consumer : Consumers) 277 Consumer->HandleInlineFunctionDefinition(D); 278} 279 280void MultiplexConsumer::HandleCXXStaticMemberVarInstantiation(VarDecl *VD) { 281 for (auto &Consumer : Consumers) 282 Consumer->HandleCXXStaticMemberVarInstantiation(VD); 283} 284 285void MultiplexConsumer::HandleInterestingDecl(DeclGroupRef D) { 286 for (auto &Consumer : Consumers) 287 Consumer->HandleInterestingDecl(D); 288} 289 290void MultiplexConsumer::HandleTranslationUnit(ASTContext &Ctx) { 291 for (auto &Consumer : Consumers) 292 Consumer->HandleTranslationUnit(Ctx); 293} 294 295void MultiplexConsumer::HandleTagDeclDefinition(TagDecl *D) { 296 for (auto &Consumer : Consumers) 297 Consumer->HandleTagDeclDefinition(D); 298} 299 300void MultiplexConsumer::HandleTagDeclRequiredDefinition(const TagDecl *D) { 301 for (auto &Consumer : Consumers) 302 Consumer->HandleTagDeclRequiredDefinition(D); 303} 304 305void MultiplexConsumer::HandleCXXImplicitFunctionInstantiation(FunctionDecl *D){ 306 for (auto &Consumer : Consumers) 307 Consumer->HandleCXXImplicitFunctionInstantiation(D); 308} 309 310void MultiplexConsumer::HandleTopLevelDeclInObjCContainer(DeclGroupRef D) { 311 for (auto &Consumer : Consumers) 312 Consumer->HandleTopLevelDeclInObjCContainer(D); 313} 314 315void MultiplexConsumer::HandleImplicitImportDecl(ImportDecl *D) { 316 for (auto &Consumer : Consumers) 317 Consumer->HandleImplicitImportDecl(D); 318} 319 320void MultiplexConsumer::CompleteTentativeDefinition(VarDecl *D) { 321 for (auto &Consumer : Consumers) 322 Consumer->CompleteTentativeDefinition(D); 323} 324 325void MultiplexConsumer::AssignInheritanceModel(CXXRecordDecl *RD) { 326 for (auto &Consumer : Consumers) 327 Consumer->AssignInheritanceModel(RD); 328} 329 330void MultiplexConsumer::HandleVTable(CXXRecordDecl *RD) { 331 for (auto &Consumer : Consumers) 332 Consumer->HandleVTable(RD); 333} 334 335ASTMutationListener *MultiplexConsumer::GetASTMutationListener() { 336 return MutationListener.get(); 337} 338 339ASTDeserializationListener *MultiplexConsumer::GetASTDeserializationListener() { 340 return DeserializationListener.get(); 341} 342 343void MultiplexConsumer::PrintStats() { 344 for (auto &Consumer : Consumers) 345 Consumer->PrintStats(); 346} 347 348bool MultiplexConsumer::shouldSkipFunctionBody(Decl *D) { 349 bool Skip = true; 350 for (auto &Consumer : Consumers) 351 Skip = Skip && Consumer->shouldSkipFunctionBody(D); 352 return Skip; 353} 354 355void MultiplexConsumer::InitializeSema(Sema &S) { 356 for (auto &Consumer : Consumers) 357 if (SemaConsumer *SC = dyn_cast<SemaConsumer>(Consumer.get())) 358 SC->InitializeSema(S); 359} 360 361void MultiplexConsumer::ForgetSema() { 362 for (auto &Consumer : Consumers) 363 if (SemaConsumer *SC = dyn_cast<SemaConsumer>(Consumer.get())) 364 SC->ForgetSema(); 365} 366