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