From 422cfcdcb3c33b50878fd66dca3fa4091e95ac9b Mon Sep 17 00:00:00 2001 From: Chris Lattner Date: Tue, 17 Apr 2007 04:04:14 +0000 Subject: [PATCH] The (negative) offset from a SymbolTableListTraits-using ilist to its container object is always constant. As such, evaluate it at compile time instead of storing it as an ivar in SymbolTableListTraits. This shrinks every SymbolTableListTraits ilist by a word, shrinking BasicBlock from 44->40 bytes, Function from 96->88 bytes, and Module from 60->52 bytes. llvm-svn: 36189 --- llvm/include/llvm/BasicBlock.h | 12 +++++++++++ llvm/include/llvm/Function.h | 22 +++++++++++++++++++++ llvm/include/llvm/Module.h | 20 +++++++++++++++++++ llvm/include/llvm/SymbolTableListTraits.h | 10 +++++++--- llvm/lib/VMCore/BasicBlock.cpp | 2 -- llvm/lib/VMCore/Function.cpp | 2 -- llvm/lib/VMCore/Module.cpp | 2 -- llvm/lib/VMCore/SymbolTableListTraitsImpl.h | 17 ++++++++-------- 8 files changed, 70 insertions(+), 17 deletions(-) diff --git a/llvm/include/llvm/BasicBlock.h b/llvm/include/llvm/BasicBlock.h index 8cc450c127d1..0a22f44b985b 100644 --- a/llvm/include/llvm/BasicBlock.h +++ b/llvm/include/llvm/BasicBlock.h @@ -31,6 +31,7 @@ template<> struct ilist_traits static void destroySentinel(Instruction *I) { delete I; } static iplist &getList(BasicBlock *BB); static ValueSymbolTable *getSymTab(BasicBlock *ItemParent); + static int getListOffset(); }; /// This represents a single basic block in LLVM. A basic block is simply a @@ -194,8 +195,19 @@ public: /// the basic block). /// BasicBlock *splitBasicBlock(iterator I, const std::string &BBName = ""); + + + static unsigned getInstListOffset() { + BasicBlock *Obj = 0; + return reinterpret_cast(&Obj->InstList); + } }; +inline int +ilist_traits::getListOffset() { + return BasicBlock::getInstListOffset(); +} + } // End llvm namespace #endif diff --git a/llvm/include/llvm/Function.h b/llvm/include/llvm/Function.h index d42c8d8aa2b5..3fdbd0250081 100644 --- a/llvm/include/llvm/Function.h +++ b/llvm/include/llvm/Function.h @@ -37,6 +37,7 @@ template<> struct ilist_traits static void destroySentinel(BasicBlock *BB) { delete BB; } static iplist &getList(Function *F); static ValueSymbolTable *getSymTab(Function *ItemParent); + static int getListOffset(); }; template<> struct ilist_traits @@ -47,6 +48,7 @@ template<> struct ilist_traits static void destroySentinel(Argument *A) { delete A; } static iplist &getList(Function *F); static ValueSymbolTable *getSymTab(Function *ItemParent); + static int getListOffset(); }; class Function : public GlobalValue, public Annotable { @@ -238,6 +240,15 @@ public: /// including any contained basic blocks. /// void dropAllReferences(); + + static unsigned getBasicBlockListOffset() { + Function *Obj = 0; + return reinterpret_cast(&Obj->BasicBlocks); + } + static unsigned getArgumentListOffset() { + Function *Obj = 0; + return reinterpret_cast(&Obj->ArgumentList); + } }; inline ValueSymbolTable * @@ -250,6 +261,17 @@ ilist_traits::getSymTab(Function *F) { return F ? &F->getValueSymbolTable() : 0; } +inline int +ilist_traits::getListOffset() { + return Function::getBasicBlockListOffset(); +} + +inline int +ilist_traits::getListOffset() { + return Function::getArgumentListOffset(); +} + + } // End llvm namespace #endif diff --git a/llvm/include/llvm/Module.h b/llvm/include/llvm/Module.h index e645f51c1c3a..1d82e2aad3d5 100644 --- a/llvm/include/llvm/Module.h +++ b/llvm/include/llvm/Module.h @@ -32,6 +32,7 @@ template<> struct ilist_traits static void destroySentinel(Function *F) { delete F; } static iplist &getList(Module *M); static inline ValueSymbolTable *getSymTab(Module *M); + static int getListOffset(); }; template<> struct ilist_traits : public SymbolTableListTraits { @@ -40,6 +41,7 @@ template<> struct ilist_traits static void destroySentinel(GlobalVariable *GV) { delete GV; } static iplist &getList(Module *M); static inline ValueSymbolTable *getSymTab(Module *M); + static int getListOffset(); }; /// A Module instance is used to store all the information related to an @@ -313,6 +315,15 @@ public: /// that has "dropped all references", except operator delete. void dropAllReferences(); /// @} + + static unsigned getFunctionListOffset() { + Module *Obj = 0; + return reinterpret_cast(&Obj->FunctionList); + } + static unsigned getGlobalVariableListOffset() { + Module *Obj = 0; + return reinterpret_cast(&Obj->GlobalList); + } }; /// An iostream inserter for modules. @@ -331,6 +342,15 @@ ilist_traits::getSymTab(Module *M) { return M ? &M->getValueSymbolTable() : 0; } +inline int +ilist_traits::getListOffset() { + return Module::getFunctionListOffset(); +} + +inline int +ilist_traits::getListOffset() { + return Module::getGlobalVariableListOffset(); +} } // End llvm namespace diff --git a/llvm/include/llvm/SymbolTableListTraits.h b/llvm/include/llvm/SymbolTableListTraits.h index 099cfe0ca7fe..205b409e8eb2 100644 --- a/llvm/include/llvm/SymbolTableListTraits.h +++ b/llvm/include/llvm/SymbolTableListTraits.h @@ -39,10 +39,15 @@ template struct ilist_traits; template class SymbolTableListTraits { typedef ilist_traits TraitsClass; - ItemParentClass *ItemParent; public: - SymbolTableListTraits() : ItemParent(0) {} + SymbolTableListTraits() {} + /// getListOwner - Return the object that owns this list. If this is a list + /// of instructions, it returns the BasicBlock that owns them. + ItemParentClass *getListOwner() { + return reinterpret_cast((char*)this- + TraitsClass::getListOffset()); + } static ValueSubClass *getPrev(ValueSubClass *V) { return V->getPrev(); } static ValueSubClass *getNext(ValueSubClass *V) { return V->getNext(); } static const ValueSubClass *getPrev(const ValueSubClass *V) { @@ -62,7 +67,6 @@ public: ilist_iterator first, ilist_iterator last); //private: - void setItemParent(ItemParentClass *IP) { ItemParent = IP; } template void setSymTabObject(TPtr *, TPtr); }; diff --git a/llvm/lib/VMCore/BasicBlock.cpp b/llvm/lib/VMCore/BasicBlock.cpp index e10948e2ad31..431bb5090a76 100644 --- a/llvm/lib/VMCore/BasicBlock.cpp +++ b/llvm/lib/VMCore/BasicBlock.cpp @@ -72,8 +72,6 @@ template class SymbolTableListTraits; BasicBlock::BasicBlock(const std::string &Name, Function *NewParent, BasicBlock *InsertBefore) : Value(Type::LabelTy, Value::BasicBlockVal), Parent(0) { - // Initialize the instlist. - InstList.setItemParent(this); // Make sure that we get added to a function LeakDetector::addGarbageObject(this); diff --git a/llvm/lib/VMCore/Function.cpp b/llvm/lib/VMCore/Function.cpp index 7949e39f84d0..e47798e12cd2 100644 --- a/llvm/lib/VMCore/Function.cpp +++ b/llvm/lib/VMCore/Function.cpp @@ -143,8 +143,6 @@ Function::Function(const FunctionType *Ty, LinkageTypes Linkage, : GlobalValue(PointerType::get(Ty), Value::FunctionVal, 0, 0, Linkage, name) { ParamAttrs = 0; CallingConvention = 0; - BasicBlocks.setItemParent(this); - ArgumentList.setItemParent(this); SymTab = new ValueSymbolTable(); assert((getReturnType()->isFirstClassType() ||getReturnType() == Type::VoidTy) diff --git a/llvm/lib/VMCore/Module.cpp b/llvm/lib/VMCore/Module.cpp index 465cb6944586..ddd503dea1c9 100644 --- a/llvm/lib/VMCore/Module.cpp +++ b/llvm/lib/VMCore/Module.cpp @@ -64,8 +64,6 @@ template class SymbolTableListTraits; Module::Module(const std::string &MID) : ModuleID(MID), DataLayout("") { - FunctionList.setItemParent(this); - GlobalList.setItemParent(this); ValSymTab = new ValueSymbolTable(); TypeSymTab = new TypeSymbolTable(); } diff --git a/llvm/lib/VMCore/SymbolTableListTraitsImpl.h b/llvm/lib/VMCore/SymbolTableListTraitsImpl.h index ce2c0c0cc79e..b2b6a3fa346d 100644 --- a/llvm/lib/VMCore/SymbolTableListTraitsImpl.h +++ b/llvm/lib/VMCore/SymbolTableListTraitsImpl.h @@ -29,19 +29,19 @@ template void SymbolTableListTraits ::setSymTabObject(TPtr *Dest, TPtr Src) { // Get the old symtab and value list before doing the assignment. - ValueSymbolTable *OldST = TraitsClass::getSymTab(ItemParent); + ValueSymbolTable *OldST = TraitsClass::getSymTab(getListOwner()); // Do it. *Dest = Src; // Get the new SymTab object. - ValueSymbolTable *NewST = TraitsClass::getSymTab(ItemParent); + ValueSymbolTable *NewST = TraitsClass::getSymTab(getListOwner()); // If there is nothing to do, quick exit. if (OldST == NewST) return; // Move all the elements from the old symtab to the new one. - iplist &ItemList = TraitsClass::getList(ItemParent); + iplist &ItemList = TraitsClass::getList(getListOwner()); if (ItemList.empty()) return; if (OldST) { @@ -66,9 +66,10 @@ template void SymbolTableListTraits ::addNodeToList(ValueSubClass *V) { assert(V->getParent() == 0 && "Value already in a container!!"); - V->setParent(ItemParent); + ItemParentClass *Owner = getListOwner(); + V->setParent(Owner); if (V->hasName()) - if (ValueSymbolTable *ST = TraitsClass::getSymTab(ItemParent)) + if (ValueSymbolTable *ST = TraitsClass::getSymTab(Owner)) ST->reinsertValue(V); } @@ -77,7 +78,7 @@ void SymbolTableListTraits ::removeNodeFromList(ValueSubClass *V) { V->setParent(0); if (V->hasName()) - if (ValueSymbolTable *ST = TraitsClass::getSymTab(ItemParent)) + if (ValueSymbolTable *ST = TraitsClass::getSymTab(getListOwner())) ST->removeValueName(V->getValueName()); } @@ -87,12 +88,12 @@ void SymbolTableListTraits ilist_iterator first, ilist_iterator last) { // We only have to do work here if transferring instructions between BBs - ItemParentClass *NewIP = ItemParent, *OldIP = L2.ItemParent; + ItemParentClass *NewIP = getListOwner(), *OldIP = L2.getListOwner(); if (NewIP == OldIP) return; // No work to do at all... // We only have to update symbol table entries if we are transferring the // instructions to a different symtab object... - ValueSymbolTable *NewST = TraitsClass::getSymTab(ItemParent); + ValueSymbolTable *NewST = TraitsClass::getSymTab(NewIP); ValueSymbolTable *OldST = TraitsClass::getSymTab(OldIP); if (NewST != OldST) { for (; first != last; ++first) {