// RegisterAGBase implementation // RegisterAGBase::RegisterAGBase(const char *Name, intptr_t InterfaceID, intptr_t PassID, bool isDefault) : PassInfo(Name, InterfaceID), ImplementationInfo(0), isDefaultImplementation(isDefault) { InterfaceInfo = const_cast<PassInfo*>(Pass::lookupPassInfo(InterfaceID)); if (InterfaceInfo == 0) { // First reference to Interface, register it now. registerPass(); InterfaceInfo = this; } assert(isAnalysisGroup() && "Trying to join an analysis group that is a normal pass!"); if (PassID) { ImplementationInfo = Pass::lookupPassInfo(PassID); assert(ImplementationInfo && "Must register pass before adding to AnalysisGroup!"); // Make sure we keep track of the fact that the implementation implements // the interface. PassInfo *IIPI = const_cast<PassInfo*>(ImplementationInfo); IIPI->addInterfaceImplemented(InterfaceInfo); getPassRegistrar()->RegisterAnalysisGroup(InterfaceInfo, IIPI, isDefault); } }
void PassRegistry::unregisterPass(const PassInfo &PI) { sys::SmartScopedLock<true> Guard(Lock); MapType::iterator I = PassInfoMap.find(PI.getTypeInfo()); assert(I != PassInfoMap.end() && "Pass registered but not in map!"); // Remove pass from the map. PassInfoMap.erase(I); PassInfoStringMap.erase(PI.getPassArgument()); }
void PassRegistry::unregisterPass(const PassInfo &PI) { sys::SmartScopedWriter<true> Guard(*Lock); PassRegistryImpl *Impl = static_cast<PassRegistryImpl*>(getImpl()); PassRegistryImpl::MapType::iterator I = Impl->PassInfoMap.find(PI.getTypeInfo()); assert(I != Impl->PassInfoMap.end() && "Pass registered but not in map!"); // Remove pass from the map. Impl->PassInfoMap.erase(I); Impl->PassInfoStringMap.erase(PI.getPassArgument()); }
void PassRegistry::registerPass(const PassInfo &PI) { sys::SmartScopedLock<true> Guard(Lock); bool Inserted = PassInfoMap.insert(std::make_pair(PI.getTypeInfo(),&PI)).second; assert(Inserted && "Pass registered multiple times!"); Inserted=Inserted; PassInfoStringMap[PI.getPassArgument()] = &PI; // Notify any listeners. for (std::vector<PassRegistrationListener*>::iterator I = Listeners.begin(), E = Listeners.end(); I != E; ++I) (*I)->passRegistered(&PI); }
void PassRegistry::registerPass(const PassInfo &PI, bool ShouldFree) { sys::SmartScopedWriter<true> Guard(Lock); bool Inserted = PassInfoMap.insert(std::make_pair(PI.getTypeInfo(), &PI)).second; assert(Inserted && "Pass registered multiple times!"); (void)Inserted; PassInfoStringMap[PI.getPassArgument()] = &PI; // Notify any listeners. for (auto *Listener : Listeners) Listener->passRegistered(&PI); if (ShouldFree) ToFree.push_back(std::unique_ptr<const PassInfo>(&PI)); }
void PassRegistry::registerPass(const PassInfo &PI, bool ShouldFree) { sys::SmartScopedWriter<true> Guard(*Lock); PassRegistryImpl *Impl = static_cast<PassRegistryImpl*>(getImpl()); bool Inserted = Impl->PassInfoMap.insert(std::make_pair(PI.getTypeInfo(),&PI)).second; assert(Inserted && "Pass registered multiple times!"); (void)Inserted; Impl->PassInfoStringMap[PI.getPassArgument()] = &PI; // Notify any listeners. for (std::vector<PassRegistrationListener*>::iterator I = Impl->Listeners.begin(), E = Impl->Listeners.end(); I != E; ++I) (*I)->passRegistered(&PI); if (ShouldFree) Impl->ToFree.push_back(&PI); }
virtual bool run(Module &M) { std::cout << "Printing analysis '" << PassToPrint->getPassName() << "':\n"; getAnalysisID<Pass>(PassToPrint).print(std::cout, &M); // Get and print pass... return false; }
virtual bool runOnBasicBlock(BasicBlock &BB) { std::cout << "Printing Analysis info for BasicBlock '" << BB.getName() << "': Pass " << PassToPrint->getPassName() << ":\n"; getAnalysisID<Pass>(PassToPrint).print(std::cout, BB.getParent()->getParent()); // Get and print pass... return false; }
virtual bool runOnFunction(Function &F) { std::cout << "Printing analysis '" << PassToPrint->getPassName() << "' for function '" << F.getName() << "':\n"; getAnalysisID<Pass>(PassToPrint).print(std::cout, F.getParent()); // Get and print pass... return false; }
/// Analysis Group Mechanisms. void PassRegistry::registerAnalysisGroup(const void *InterfaceID, const void *PassID, PassInfo& Registeree, bool isDefault, bool ShouldFree) { PassInfo *InterfaceInfo = const_cast<PassInfo*>(getPassInfo(InterfaceID)); if (InterfaceInfo == 0) { // First reference to Interface, register it now. registerPass(Registeree); InterfaceInfo = &Registeree; } assert(Registeree.isAnalysisGroup() && "Trying to join an analysis group that is a normal pass!"); if (PassID) { PassInfo *ImplementationInfo = const_cast<PassInfo*>(getPassInfo(PassID)); assert(ImplementationInfo && "Must register pass before adding to AnalysisGroup!"); sys::SmartScopedWriter<true> Guard(*Lock); // Make sure we keep track of the fact that the implementation implements // the interface. ImplementationInfo->addInterfaceImplemented(InterfaceInfo); PassRegistryImpl *Impl = static_cast<PassRegistryImpl*>(getImpl()); PassRegistryImpl::AnalysisGroupInfo &AGI = Impl->AnalysisGroupInfoMap[InterfaceInfo]; assert(AGI.Implementations.count(ImplementationInfo) == 0 && "Cannot add a pass to the same analysis group more than once!"); AGI.Implementations.insert(ImplementationInfo); if (isDefault) { assert(InterfaceInfo->getNormalCtor() == 0 && "Default implementation for analysis group already specified!"); assert(ImplementationInfo->getNormalCtor() && "Cannot specify pass as default if it does not have a default ctor"); InterfaceInfo->setNormalCtor(ImplementationInfo->getNormalCtor()); InterfaceInfo->setTargetMachineCtor( ImplementationInfo->getTargetMachineCtor()); } } PassRegistryImpl *Impl = static_cast<PassRegistryImpl*>(getImpl()); if (ShouldFree) Impl->ToFree.push_back(&Registeree); }
/// Analysis Group Mechanisms. void PassRegistry::registerAnalysisGroup(const void *InterfaceID, const void *PassID, PassInfo &Registeree, bool isDefault, bool ShouldFree) { PassInfo *InterfaceInfo = const_cast<PassInfo *>(getPassInfo(InterfaceID)); if (!InterfaceInfo) { // First reference to Interface, register it now. registerPass(Registeree); InterfaceInfo = &Registeree; } assert(Registeree.isAnalysisGroup() && "Trying to join an analysis group that is a normal pass!"); if (PassID) { PassInfo *ImplementationInfo = const_cast<PassInfo *>(getPassInfo(PassID)); assert(ImplementationInfo && "Must register pass before adding to AnalysisGroup!"); sys::SmartScopedWriter<true> Guard(Lock); // Make sure we keep track of the fact that the implementation implements // the interface. ImplementationInfo->addInterfaceImplemented(InterfaceInfo); if (isDefault) { assert(InterfaceInfo->getNormalCtor() == nullptr && "Default implementation for analysis group already specified!"); assert( ImplementationInfo->getNormalCtor() && "Cannot specify pass as default if it does not have a default ctor"); InterfaceInfo->setNormalCtor(ImplementationInfo->getNormalCtor()); } } if (ShouldFree) ToFree.push_back(std::unique_ptr<const PassInfo>(&Registeree)); }