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