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