From 1ac2d518067f8341fb59c1c5ba1f5787fd78abe2 Mon Sep 17 00:00:00 2001 From: Chris Lattner Date: Mon, 23 Jan 2006 01:01:04 +0000 Subject: [PATCH] Speedup and simplify pass registration by the observation that there is exactly one PassInfo object per RegisterPass object and that their lifetimes are the same. As such, there is no reason for the RegisterPass object to dynamically allocate the PassInfo object at compiler startup time: just inline the object by-value. This should reduce codesize, heap size, and startup time. Yaay. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@25521 91177308-0d34-0410-b5e6-96231b3b80d8 --- include/llvm/PassSupport.h | 121 +++++++++++++++---------------------- lib/VMCore/Pass.cpp | 37 ++++++------ 2 files changed, 67 insertions(+), 91 deletions(-) diff --git a/include/llvm/PassSupport.h b/include/llvm/PassSupport.h index ad87d0fd4fb..8206e5f28e6 100644 --- a/include/llvm/PassSupport.h +++ b/include/llvm/PassSupport.h @@ -50,7 +50,7 @@ public: /// AnalysisGroup flag with others. /// enum { - Analysis = 1, Optimization = 2, LLC = 4, AnalysisGroup = 8 + Analysis = 1, Optimization = 2, AnalysisGroup = 4 }; /// PassInfo ctor - Do not call this directly, this should only be invoked @@ -149,17 +149,31 @@ public: struct RegisterPassBase { /// getPassInfo - Get the pass info for the registered class... /// - const PassInfo *getPassInfo() const { return PIObj; } + const PassInfo *getPassInfo() const { return &PIObj; } - RegisterPassBase() : PIObj(0) {} - ~RegisterPassBase() { // Intentionally non-virtual... - if (PIObj) unregisterPass(PIObj); + RegisterPassBase(const char *Name, const char *Arg, const std::type_info &TI, + unsigned char PT, Pass *(*Normal)() = 0, + Pass *(*TargetCtor)(TargetMachine &) = 0) + : PIObj(Name, Arg, TI, PT, Normal, TargetCtor) { + registerPass(); + } + RegisterPassBase(const std::type_info &TI, unsigned char PT) + : PIObj("", "", TI, PT, 0, 0) { + // This ctor may only be used for analysis groups: it does not auto-register + // the pass. + assert(PT == PassInfo::AnalysisGroup && "Not an AnalysisGroup!"); + } + + ~RegisterPassBase() { // Intentionally non-virtual. + // Analysis groups are registered/unregistered by their dtor. + if (PIObj.getPassType() != PassInfo::AnalysisGroup) + unregisterPass(); } protected: - PassInfo *PIObj; // The PassInfo object for this pass - void registerPass(PassInfo *); - void unregisterPass(PassInfo *); + PassInfo PIObj; // The PassInfo object for this pass + void registerPass(); + void unregisterPass(); /// setOnlyUsesCFG - Notice that this pass only depends on the CFG, so /// transformations that do not modify the CFG do not invalidate this pass. @@ -174,30 +188,26 @@ template struct RegisterPass : public RegisterPassBase { // Register Pass using default constructor... - RegisterPass(const char *PassArg, const char *Name, unsigned char PassTy = 0){ - registerPass(new PassInfo(Name, PassArg, typeid(PassName), PassTy, - callDefaultCtor)); - } + RegisterPass(const char *PassArg, const char *Name, unsigned char PassTy = 0) + : RegisterPassBase(Name, PassArg, typeid(PassName), PassTy, + callDefaultCtor) {} // Register Pass using default constructor explicitly... RegisterPass(const char *PassArg, const char *Name, unsigned char PassTy, - Pass *(*ctor)()) { - registerPass(new PassInfo(Name, PassArg, typeid(PassName), PassTy, ctor)); - } + Pass *(*ctor)()) + : RegisterPassBase(Name, PassArg, typeid(PassName), PassTy, ctor) {} // Register Pass using TargetMachine constructor... RegisterPass(const char *PassArg, const char *Name, unsigned char PassTy, - Pass *(*targetctor)(TargetMachine &)) { - registerPass(new PassInfo(Name, PassArg, typeid(PassName), PassTy, - 0, targetctor)); - } + Pass *(*targetctor)(TargetMachine &)) + : RegisterPassBase(Name, PassArg, typeid(PassName), PassTy, + 0, targetctor) {} // Generic constructor version that has an unknown ctor type... template RegisterPass(const char *PassArg, const char *Name, unsigned char PassTy, - CtorType *Fn) { - registerPass(new PassInfo(Name, PassArg, typeid(PassName), PassTy, 0)); - } + CtorType *Fn) + : RegisterPassBase(Name, PassArg, typeid(PassName), PassTy, 0) {} }; /// RegisterOpt - Register something that is to show up in Opt, this is just a @@ -205,38 +215,36 @@ struct RegisterPass : public RegisterPassBase { /// template struct RegisterOpt : public RegisterPassBase { - RegisterOpt(const char *PassArg, const char *Name, bool CFGOnly = false) { - registerPass(new PassInfo(Name, PassArg, typeid(PassName), - PassInfo::Optimization, - callDefaultCtor)); + RegisterOpt(const char *PassArg, const char *Name, bool CFGOnly = false) + : RegisterPassBase(Name, PassArg, typeid(PassName), PassInfo::Optimization, + callDefaultCtor) { if (CFGOnly) setOnlyUsesCFG(); } /// Register Pass using default constructor explicitly... /// RegisterOpt(const char *PassArg, const char *Name, Pass *(*ctor)(), - bool CFGOnly = false) { - registerPass(new PassInfo(Name, PassArg, typeid(PassName), - PassInfo::Optimization, ctor)); + bool CFGOnly = false) + : RegisterPassBase(Name, PassArg, typeid(PassName), + PassInfo::Optimization, ctor) { if (CFGOnly) setOnlyUsesCFG(); } /// Register FunctionPass using default constructor explicitly... /// RegisterOpt(const char *PassArg, const char *Name, FunctionPass *(*ctor)(), - bool CFGOnly = false) { - registerPass(new PassInfo(Name, PassArg, typeid(PassName), - PassInfo::Optimization, - static_cast(ctor))); + bool CFGOnly = false) + : RegisterPassBase(Name, PassArg, typeid(PassName), PassInfo::Optimization, + static_cast(ctor)) { if (CFGOnly) setOnlyUsesCFG(); } /// Register Pass using TargetMachine constructor... /// RegisterOpt(const char *PassArg, const char *Name, - Pass *(*targetctor)(TargetMachine &), bool CFGOnly = false) { - registerPass(new PassInfo(Name, PassArg, typeid(PassName), - PassInfo::Optimization, 0, targetctor)); + Pass *(*targetctor)(TargetMachine &), bool CFGOnly = false) + : RegisterPassBase(Name, PassArg, typeid(PassName), + PassInfo::Optimization, 0, targetctor) { if (CFGOnly) setOnlyUsesCFG(); } @@ -244,10 +252,9 @@ struct RegisterOpt : public RegisterPassBase { /// RegisterOpt(const char *PassArg, const char *Name, FunctionPass *(*targetctor)(TargetMachine &), - bool CFGOnly = false) { - registerPass(new PassInfo(Name, PassArg, typeid(PassName), - PassInfo::Optimization, 0, - static_cast(targetctor))); + bool CFGOnly = false) + : RegisterPassBase(Name, PassArg, typeid(PassName), PassInfo::Optimization, 0, + static_cast(targetctor)) { if (CFGOnly) setOnlyUsesCFG(); } }; @@ -261,41 +268,13 @@ struct RegisterOpt : public RegisterPassBase { template struct RegisterAnalysis : public RegisterPassBase { RegisterAnalysis(const char *PassArg, const char *Name, - bool CFGOnly = false) { - registerPass(new PassInfo(Name, PassArg, typeid(PassName), - PassInfo::Analysis, - callDefaultCtor)); + bool CFGOnly = false) + : RegisterPassBase(Name, PassArg, typeid(PassName), PassInfo::Analysis, + callDefaultCtor) { if (CFGOnly) setOnlyUsesCFG(); } }; -/// RegisterLLC - Register something that is to show up in LLC, this is just a -/// shortcut for specifying RegisterPass... -/// -template -struct RegisterLLC : public RegisterPassBase { - RegisterLLC(const char *PassArg, const char *Name) { - registerPass(new PassInfo(Name, PassArg, typeid(PassName), - PassInfo::LLC, - callDefaultCtor)); - } - - /// Register Pass using default constructor explicitly... - /// - RegisterLLC(const char *PassArg, const char *Name, Pass *(*ctor)()) { - registerPass(new PassInfo(Name, PassArg, typeid(PassName), - PassInfo::LLC, ctor)); - } - - /// Register Pass using TargetMachine constructor... - /// - RegisterLLC(const char *PassArg, const char *Name, - Pass *(*datactor)(TargetMachine &)) { - registerPass(new PassInfo(Name, PassArg, typeid(PassName), - PassInfo::LLC)); - } -}; - /// RegisterAnalysisGroup - Register a Pass as a member of an analysis _group_. /// Analysis groups are used to define an interface (which need not derive from diff --git a/lib/VMCore/Pass.cpp b/lib/VMCore/Pass.cpp index 94b1d4795e4..9fed6475439 100644 --- a/lib/VMCore/Pass.cpp +++ b/lib/VMCore/Pass.cpp @@ -38,7 +38,7 @@ static std::vector &getCFGOnlyAnalyses() { } void RegisterPassBase::setOnlyUsesCFG() { - getCFGOnlyAnalyses().push_back(PIObj); + getCFGOnlyAnalyses().push_back(&PIObj); } //===----------------------------------------------------------------------===// @@ -332,26 +332,25 @@ const PassInfo *Pass::lookupPassInfo(const std::type_info &TI) { return (I != PassInfoMap->end()) ? I->second : 0; } -void RegisterPassBase::registerPass(PassInfo *PI) { +void RegisterPassBase::registerPass() { if (PassInfoMap == 0) PassInfoMap = new std::map(); - assert(PassInfoMap->find(PI->getTypeInfo()) == PassInfoMap->end() && + assert(PassInfoMap->find(PIObj.getTypeInfo()) == PassInfoMap->end() && "Pass already registered!"); - PIObj = PI; - PassInfoMap->insert(std::make_pair(TypeInfo(PI->getTypeInfo()), PI)); + PassInfoMap->insert(std::make_pair(TypeInfo(PIObj.getTypeInfo()), &PIObj)); // Notify any listeners... if (Listeners) for (std::vector::iterator I = Listeners->begin(), E = Listeners->end(); I != E; ++I) - (*I)->passRegistered(PI); + (*I)->passRegistered(&PIObj); } -void RegisterPassBase::unregisterPass(PassInfo *PI) { +void RegisterPassBase::unregisterPass() { assert(PassInfoMap && "Pass registered but not in map!"); std::map::iterator I = - PassInfoMap->find(PI->getTypeInfo()); + PassInfoMap->find(PIObj.getTypeInfo()); assert(I != PassInfoMap->end() && "Pass registered but not in map!"); // Remove pass from the map... @@ -365,10 +364,7 @@ void RegisterPassBase::unregisterPass(PassInfo *PI) { if (Listeners) for (std::vector::iterator I = Listeners->begin(), E = Listeners->end(); I != E; ++I) - (*I)->passUnregistered(PI); - - // Delete the PassInfo object itself... - delete PI; + (*I)->passUnregistered(&PIObj); } //===----------------------------------------------------------------------===// @@ -387,14 +383,14 @@ static std::map *AnalysisGroupInfoMap = 0; // RegisterAGBase::RegisterAGBase(const std::type_info &Interface, const std::type_info *Pass, bool isDefault) - : ImplementationInfo(0), isDefaultImplementation(isDefault) { + : RegisterPassBase(Interface, PassInfo::AnalysisGroup), + ImplementationInfo(0), isDefaultImplementation(isDefault) { InterfaceInfo = const_cast(Pass::lookupPassInfo(Interface)); - if (InterfaceInfo == 0) { // First reference to Interface, add it now. - InterfaceInfo = // Create the new PassInfo for the interface... - new PassInfo("", "", Interface, PassInfo::AnalysisGroup, 0, 0); - registerPass(InterfaceInfo); - PIObj = 0; + if (InterfaceInfo == 0) { + // First reference to Interface, register it now. + registerPass(); + InterfaceInfo = &PIObj; } assert(InterfaceInfo->getPassType() == PassInfo::AnalysisGroup && "Trying to join an analysis group that is a normal pass!"); @@ -455,10 +451,11 @@ RegisterAGBase::~RegisterAGBase() { delete AnalysisGroupInfoMap; AnalysisGroupInfoMap = 0; } - - unregisterPass(InterfaceInfo); } } + + if (InterfaceInfo == &PIObj) + unregisterPass(); }