replica
/
hanchenye-llvm-project
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Refactor SymbolTableListTraits to only have a single pointer in it, instead 

of two.  This shrinkifies Function by 8 bytes (104->96) and Module by 8
bytes (68->60).  On a testcase of mine, this reduces the memory used to
read a module header from 565680b to 561024, a little over 4K.

llvm-svn: 36188
This commit is contained in:
Chris Lattner 2007-04-17 03:26:42 +00:00
parent 0ed36f4078
commit b47aa543bb
13 changed files with 138 additions and 113 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
llvm/include/llvm/Argument.h
View File

@ -18,9 +18,8 @@
namespace llvm {
template<typename SC> struct ilist_traits;
template<typename ValueSubClass, typename ItemParentClass, typename SymTabClass,
typename SubClass> class SymbolTableListTraits;
template<typename ValueSubClass, typename ItemParentClass>
class SymbolTableListTraits;
/// A class to represent an incoming formal argument to a Function. An argument
/// is a very simple Value. It is essentially a named (optional) type. When used
@ -33,8 +32,7 @@ class Argument : public Value { // Defined in the Function.cpp file
Argument *Prev, *Next; // Next and Prev links for our intrusive linked list
void setNext(Argument *N) { Next = N; }
void setPrev(Argument *N) { Prev = N; }
friend class SymbolTableListTraits<Argument, Function, Function,
ilist_traits<Argument> >;
friend class SymbolTableListTraits<Argument, Function>;
void setParent(Function *parent);
public:

10
llvm/include/llvm/BasicBlock.h
View File

@ -25,11 +25,12 @@ template <class Term, class BB> class SuccIterator; // Successor Iterator
template <class Ptr, class USE_iterator> class PredIterator;
template<> struct ilist_traits<Instruction>
: public SymbolTableListTraits<Instruction, BasicBlock, Function> {
: public SymbolTableListTraits<Instruction, BasicBlock> {
// createSentinel is used to create a node that marks the end of the list...
static Instruction *createSentinel();
static void destroySentinel(Instruction *I) { delete I; }
static iplist<Instruction> &getList(BasicBlock *BB);
static ValueSymbolTable *getSymTab(BasicBlock *ItemParent);
};
/// This represents a single basic block in LLVM. A basic block is simply a
@ -52,11 +53,12 @@ public:
private :
InstListType InstList;
BasicBlock *Prev, *Next; // Next and Prev links for our intrusive linked list
Function *Parent;
void setParent(Function *parent);
void setNext(BasicBlock *N) { Next = N; }
void setPrev(BasicBlock *N) { Prev = N; }
friend class SymbolTableListTraits<BasicBlock, Function, Function>;
friend class SymbolTableListTraits<BasicBlock, Function>;
BasicBlock(const BasicBlock &); // Do not implement
void operator=(const BasicBlock &); // Do not implement
@ -76,8 +78,8 @@ public:
/// getParent - Return the enclosing method, or null if none
///
const Function *getParent() const { return InstList.getParent(); }
Function *getParent() { return InstList.getParent(); }
const Function *getParent() const { return Parent; }
Function *getParent() { return Parent; }
// getNext/Prev - Return the next or previous basic block in the list.
BasicBlock *getNext() { return Next; }

18
llvm/include/llvm/Function.h
View File

@ -30,21 +30,23 @@ class ParamAttrsList;
// Traits for intrusive list of instructions...
template<> struct ilist_traits<BasicBlock>
: public SymbolTableListTraits<BasicBlock, Function, Function> {
: public SymbolTableListTraits<BasicBlock, Function> {
// createSentinel is used to create a node that marks the end of the list...
static BasicBlock *createSentinel();
static void destroySentinel(BasicBlock *BB) { delete BB; }
static iplist<BasicBlock> &getList(Function *F);
static ValueSymbolTable *getSymTab(Function *ItemParent);
};
template<> struct ilist_traits<Argument>
: public SymbolTableListTraits<Argument, Function, Function> {
: public SymbolTableListTraits<Argument, Function> {
// createSentinel is used to create a node that marks the end of the list...
static Argument *createSentinel();
static void destroySentinel(Argument *A) { delete A; }
static iplist<Argument> &getList(Function *F);
static ValueSymbolTable *getSymTab(Function *ItemParent);
};
class Function : public GlobalValue, public Annotable {
@ -67,7 +69,7 @@ private:
ParamAttrsList *ParamAttrs; ///< Parameter attributes
unsigned CallingConvention; ///< Calling convention to use
friend class SymbolTableListTraits<Function, Module, Module>;
friend class SymbolTableListTraits<Function, Module>;
void setParent(Module *parent);
Function *Prev, *Next;
@ -238,6 +240,16 @@ public:
void dropAllReferences();
};
inline ValueSymbolTable *
ilist_traits<BasicBlock>::getSymTab(Function *F) {
return F ? &F->getValueSymbolTable() : 0;
}
inline ValueSymbolTable *
ilist_traits<Argument>::getSymTab(Function *F) {
return F ? &F->getValueSymbolTable() : 0;
}
} // End llvm namespace
#endif

8
llvm/include/llvm/GlobalVariable.h
View File

@ -27,13 +27,11 @@ namespace llvm {
class Module;
class Constant;
class PointerType;
template<typename SC> struct ilist_traits;
template<typename ValueSubClass, typename ItemParentClass, typename SymTabClass,
typename SubClass> class SymbolTableListTraits;
template<typename ValueSubClass, typename ItemParentClass>
class SymbolTableListTraits;
class GlobalVariable : public GlobalValue {
friend class SymbolTableListTraits<GlobalVariable, Module, Module,
ilist_traits<GlobalVariable> >;
friend class SymbolTableListTraits<GlobalVariable, Module>;
void operator=(const GlobalVariable &); // Do not implement
GlobalVariable(const GlobalVariable &); // Do not implement

8
llvm/include/llvm/Instruction.h
View File

@ -22,9 +22,8 @@ namespace llvm {
struct AssemblyAnnotationWriter;
class BinaryOperator;
template<typename SC> struct ilist_traits;
template<typename ValueSubClass, typename ItemParentClass, typename SymTabClass,
typename SubClass> class SymbolTableListTraits;
template<typename ValueSubClass, typename ItemParentClass>
class SymbolTableListTraits;
class Instruction : public User {
void operator=(const Instruction &); // Do not implement
@ -36,8 +35,7 @@ class Instruction : public User {
void setNext(Instruction *N) { Next = N; }
void setPrev(Instruction *N) { Prev = N; }
friend class SymbolTableListTraits<Instruction, BasicBlock, Function,
ilist_traits<Instruction> >;
friend class SymbolTableListTraits<Instruction, BasicBlock>;
void setParent(BasicBlock *P);
protected:
Instruction(const Type *Ty, unsigned iType, Use *Ops, unsigned NumOps,

17
llvm/include/llvm/Module.h
View File

@ -26,18 +26,20 @@ class GlobalValueRefMap; // Used by ConstantVals.cpp
class FunctionType;
template<> struct ilist_traits<Function>
: public SymbolTableListTraits<Function, Module, Module> {
: public SymbolTableListTraits<Function, Module> {
// createSentinel is used to create a node that marks the end of the list.
static Function *createSentinel();
static void destroySentinel(Function *F) { delete F; }
static iplist<Function> &getList(Module *M);
static inline ValueSymbolTable *getSymTab(Module *M);
};
template<> struct ilist_traits<GlobalVariable>
: public SymbolTableListTraits<GlobalVariable, Module, Module> {
: public SymbolTableListTraits<GlobalVariable, Module> {
// createSentinel is used to create a node that marks the end of the list.
static GlobalVariable *createSentinel();
static void destroySentinel(GlobalVariable *GV) { delete GV; }
static iplist<GlobalVariable> &getList(Module *M);
static inline ValueSymbolTable *getSymTab(Module *M);
};
/// A Module instance is used to store all the information related to an
@ -319,6 +321,17 @@ inline std::ostream &operator<<(std::ostream &O, const Module &M) {
return O;
}
inline ValueSymbolTable *
ilist_traits<Function>::getSymTab(Module *M) {
return M ? &M->getValueSymbolTable() : 0;
}
inline ValueSymbolTable *
ilist_traits<GlobalVariable>::getSymTab(Module *M) {
return M ? &M->getValueSymbolTable() : 0;
}
} // End llvm namespace
#endif

27
llvm/include/llvm/SymbolTableListTraits.h
View File

@ -31,24 +31,17 @@ template<typename NodeTy> class ilist_iterator;
template<typename NodeTy, typename Traits> class iplist;
template<typename Ty> struct ilist_traits;
// ValueSubClass - The type of objects that I hold
// ItemParentType - I call setParent() on all of my "ValueSubclass" items, and
// this is the value that I pass in.
// SymTabType - This is the class type, whose symtab I insert my
// ValueSubClass items into. Most of the time it is
// ItemParentType, but Instructions have item parents of BB's
// but symtabtype's of a Function
// ValueSubClass - The type of objects that I hold, e.g. Instruction.
// ItemParentType - The type of object that owns the list, e.g. BasicBlock.
// TraitBaseClass - The class this trait should inherit from, it should
// inherit from ilist_traits<ValueSubClass>
//
template<typename ValueSubClass, typename ItemParentClass, typename SymTabClass,
typename SubClass=ilist_traits<ValueSubClass> >
template<typename ValueSubClass, typename ItemParentClass>
class SymbolTableListTraits {
SymTabClass *SymTabObject;
typedef ilist_traits<ValueSubClass> TraitsClass;
ItemParentClass *ItemParent;
public:
SymbolTableListTraits() : SymTabObject(0), ItemParent(0) {}
SymTabClass *getParent() { return SymTabObject; }
const SymTabClass *getParent() const { return SymTabObject; }
SymbolTableListTraits() : ItemParent(0) {}
static ValueSubClass *getPrev(ValueSubClass *V) { return V->getPrev(); }
static ValueSubClass *getNext(ValueSubClass *V) { return V->getNext(); }
@ -68,10 +61,10 @@ public:
ilist_traits<ValueSubClass> > &L2,
ilist_iterator<ValueSubClass> first,
ilist_iterator<ValueSubClass> last);
//private:
void setItemParent(ItemParentClass *IP) { ItemParent = IP; }//This is private!
void setParent(SymTabClass *Parent); // This is private!
void setItemParent(ItemParentClass *IP) { ItemParent = IP; }
template<typename TPtr>
void setSymTabObject(TPtr *, TPtr);
};
} // End llvm namespace

19
llvm/include/llvm/ValueSymbolTable.h
View File

@ -18,10 +18,8 @@
#include "llvm/ADT/StringMap.h"
namespace llvm {
template<typename ValueSubClass, typename ItemParentClass,
typename SymTabClass, typename SubClass>
template<typename ValueSubClass, typename ItemParentClass>
class SymbolTableListTraits;
template<typename NodeTy> struct ilist_traits;
class BasicBlock;
class Function;
class Module;
@ -32,16 +30,11 @@ namespace llvm {
///
class ValueSymbolTable {
friend class Value;
friend class SymbolTableListTraits<Argument, Function, Function,
ilist_traits<Argument> >;
friend class SymbolTableListTraits<BasicBlock, Function, Function,
ilist_traits<BasicBlock> >;
friend class SymbolTableListTraits<Instruction, BasicBlock, Function,
ilist_traits<Instruction> >;
friend class SymbolTableListTraits<Function, Module, Module,
ilist_traits<Function> >;
friend class SymbolTableListTraits<GlobalVariable, Module, Module,
ilist_traits<GlobalVariable> >;
friend class SymbolTableListTraits<Argument, Function>;
friend class SymbolTableListTraits<BasicBlock, Function>;
friend class SymbolTableListTraits<Instruction, BasicBlock>;
friend class SymbolTableListTraits<Function, Module>;
friend class SymbolTableListTraits<GlobalVariable, Module>;
/// @name Types
/// @{
public:

28
llvm/lib/VMCore/BasicBlock.cpp
View File

@ -22,6 +22,15 @@
#include <algorithm>
using namespace llvm;
inline ValueSymbolTable *
ilist_traits<Instruction>::getSymTab(BasicBlock *BB) {
if (BB)
if (Function *F = BB->getParent())
return &F->getValueSymbolTable();
return 0;
}
namespace {
/// DummyInst - An instance of this class is used to mark the end of the
/// instruction list. This is not a real instruction.
@ -57,24 +66,24 @@ iplist<Instruction> &ilist_traits<Instruction>::getList(BasicBlock *BB) {
// Explicit instantiation of SymbolTableListTraits since some of the methods
// are not in the public header file...
template class SymbolTableListTraits<Instruction, BasicBlock, Function>;
template class SymbolTableListTraits<Instruction, BasicBlock>;
BasicBlock::BasicBlock(const std::string &Name, Function *Parent,
BasicBlock::BasicBlock(const std::string &Name, Function *NewParent,
BasicBlock *InsertBefore)
: Value(Type::LabelTy, Value::BasicBlockVal) {
// Initialize the instlist...
: 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);
if (InsertBefore) {
assert(Parent &&
assert(NewParent &&
"Cannot insert block before another block with no function!");
Parent->getBasicBlockList().insert(InsertBefore, this);
} else if (Parent) {
Parent->getBasicBlockList().push_back(this);
NewParent->getBasicBlockList().insert(InsertBefore, this);
} else if (NewParent) {
NewParent->getBasicBlockList().push_back(this);
}
setName(Name);
@ -91,7 +100,8 @@ void BasicBlock::setParent(Function *parent) {
if (getParent())
LeakDetector::addGarbageObject(this);
InstList.setParent(parent);
// Set Parent=parent, updating instruction symtab entries as appropriate.
InstList.setSymTabObject(&Parent, parent);
if (getParent())
LeakDetector::removeGarbageObject(this);

7
llvm/lib/VMCore/Function.cpp
View File

@ -44,8 +44,8 @@ iplist<Argument> &ilist_traits<Argument>::getList(Function *F) {
// Explicit instantiations of SymbolTableListTraits since some of the methods
// are not in the public header file...
template class SymbolTableListTraits<Argument, Function, Function>;
template class SymbolTableListTraits<BasicBlock, Function, Function>;
template class SymbolTableListTraits<Argument, Function>;
template class SymbolTableListTraits<BasicBlock, Function>;
//===----------------------------------------------------------------------===//
// Argument Implementation
@ -144,9 +144,7 @@ Function::Function(const FunctionType *Ty, LinkageTypes Linkage,
ParamAttrs = 0;
CallingConvention = 0;
BasicBlocks.setItemParent(this);
BasicBlocks.setParent(this);
ArgumentList.setItemParent(this);
ArgumentList.setParent(this);
SymTab = new ValueSymbolTable();
assert((getReturnType()->isFirstClassType() ||getReturnType() == Type::VoidTy)
@ -171,7 +169,6 @@ Function::~Function() {
// Delete all of the method arguments and unlink from symbol table...
ArgumentList.clear();
ArgumentList.setParent(0);
delete SymTab;
}

8
llvm/lib/VMCore/Module.cpp
View File

@ -55,8 +55,8 @@ iplist<GlobalVariable> &ilist_traits<GlobalVariable>::getList(Module *M) {
// Explicit instantiations of SymbolTableListTraits since some of the methods
// are not in the public header file.
template class SymbolTableListTraits<GlobalVariable, Module, Module>;
template class SymbolTableListTraits<Function, Module, Module>;
template class SymbolTableListTraits<GlobalVariable, Module>;
template class SymbolTableListTraits<Function, Module>;
//===----------------------------------------------------------------------===//
// Primitive Module methods.
@ -65,9 +65,7 @@ template class SymbolTableListTraits<Function, Module, Module>;
Module::Module(const std::string &MID)
: ModuleID(MID), DataLayout("") {
FunctionList.setItemParent(this);
FunctionList.setParent(this);
GlobalList.setItemParent(this);
GlobalList.setParent(this);
ValSymTab = new ValueSymbolTable();
TypeSymTab = new TypeSymbolTable();
}
@ -75,9 +73,7 @@ Module::Module(const std::string &MID)
Module::~Module() {
dropAllReferences();
GlobalList.clear();
GlobalList.setParent(0);
FunctionList.clear();
FunctionList.setParent(0);
LibraryList.clear();
delete ValSymTab;
delete TypeSymTab;

92
llvm/lib/VMCore/SymbolTableListTraitsImpl.h
View File

@ -21,53 +21,68 @@
namespace llvm {
template<typename ValueSubClass, typename ItemParentClass,typename SymTabClass,
typename SubClass>
void SymbolTableListTraits<ValueSubClass,ItemParentClass,SymTabClass,SubClass>
::setParent(SymTabClass *STO) {
iplist<ValueSubClass> &List = SubClass::getList(ItemParent);
/// setSymTabObject - This is called when (f.e.) the parent of a basic block
/// changes. This requires us to remove all the instruction symtab entries from
/// the current function and reinsert them into the new function.
template<typename ValueSubClass, typename ItemParentClass>
template<typename TPtr>
void SymbolTableListTraits<ValueSubClass,ItemParentClass>
::setSymTabObject(TPtr *Dest, TPtr Src) {
// Get the old symtab and value list before doing the assignment.
ValueSymbolTable *OldST = TraitsClass::getSymTab(ItemParent);
// Remove all of the items from the old symtab..
if (SymTabObject && !List.empty()) {
ValueSymbolTable &SymTab = SymTabObject->getValueSymbolTable();
for (typename iplist<ValueSubClass>::iterator I = List.begin();
I != List.end(); ++I)
if (I->hasName()) SymTab.removeValueName(I->getValueName());
// Do it.
*Dest = Src;
// Get the new SymTab object.
ValueSymbolTable *NewST = TraitsClass::getSymTab(ItemParent);
// 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<ValueSubClass> &ItemList = TraitsClass::getList(ItemParent);
if (ItemList.empty()) return;
if (OldST) {
// Remove all entries from the previous symtab.
for (typename iplist<ValueSubClass>::iterator I = ItemList.begin();
I != ItemList.end(); ++I)
if (I->hasName())
OldST->removeValueName(I->getValueName());
}
SymTabObject = STO;
// Add all of the items to the new symtab...
if (SymTabObject && !List.empty()) {
ValueSymbolTable &SymTab = SymTabObject->getValueSymbolTable();
for (typename iplist<ValueSubClass>::iterator I = List.begin();
I != List.end(); ++I)
if (I->hasName()) SymTab.reinsertValue(I);
if (NewST) {
// Add all of the items to the new symtab.
for (typename iplist<ValueSubClass>::iterator I = ItemList.begin();
I != ItemList.end(); ++I)
if (I->hasName())
NewST->reinsertValue(I);
}
}
template<typename ValueSubClass, typename ItemParentClass, typename SymTabClass,
typename SubClass>
void SymbolTableListTraits<ValueSubClass,ItemParentClass,SymTabClass,SubClass>
template<typename ValueSubClass, typename ItemParentClass>
void SymbolTableListTraits<ValueSubClass,ItemParentClass>
::addNodeToList(ValueSubClass *V) {
assert(V->getParent() == 0 && "Value already in a container!!");
V->setParent(ItemParent);
if (V->hasName() && SymTabObject)
SymTabObject->getValueSymbolTable().reinsertValue(V);
if (V->hasName())
if (ValueSymbolTable *ST = TraitsClass::getSymTab(ItemParent))
ST->reinsertValue(V);
}
template<typename ValueSubClass, typename ItemParentClass, typename SymTabClass,
typename SubClass>
void SymbolTableListTraits<ValueSubClass,ItemParentClass,SymTabClass,SubClass>
template<typename ValueSubClass, typename ItemParentClass>
void SymbolTableListTraits<ValueSubClass,ItemParentClass>
::removeNodeFromList(ValueSubClass *V) {
V->setParent(0);
if (V->hasName() && SymTabObject)
SymTabObject->getValueSymbolTable().removeValueName(V->getValueName());
if (V->hasName())
if (ValueSymbolTable *ST = TraitsClass::getSymTab(ItemParent))
ST->removeValueName(V->getValueName());
}
template<typename ValueSubClass, typename ItemParentClass, typename SymTabClass,
typename SubClass>
void SymbolTableListTraits<ValueSubClass,ItemParentClass,SymTabClass,SubClass>
template<typename ValueSubClass, typename ItemParentClass>
void SymbolTableListTraits<ValueSubClass,ItemParentClass>
::transferNodesFromList(iplist<ValueSubClass, ilist_traits<ValueSubClass> > &L2,
ilist_iterator<ValueSubClass> first,
ilist_iterator<ValueSubClass> last) {
@ -77,16 +92,17 @@ void SymbolTableListTraits<ValueSubClass,ItemParentClass,SymTabClass,SubClass>
// We only have to update symbol table entries if we are transferring the
// instructions to a different symtab object...
SymTabClass *NewSTO = SymTabObject, *OldSTO = L2.SymTabObject;
if (NewSTO != OldSTO) {
ValueSymbolTable *NewST = TraitsClass::getSymTab(ItemParent);
ValueSymbolTable *OldST = TraitsClass::getSymTab(OldIP);
if (NewST != OldST) {
for (; first != last; ++first) {
ValueSubClass &V = *first;
bool HasName = V.hasName();
if (OldSTO && HasName)
OldSTO->getValueSymbolTable().removeValueName(V.getValueName());
if (OldST && HasName)
OldST->removeValueName(V.getValueName());
V.setParent(NewIP);
if (NewSTO && HasName)
NewSTO->getValueSymbolTable().reinsertValue(&V);
if (NewST && HasName)
NewST->reinsertValue(&V);
}
} else {
// Just transferring between blocks in the same function, simply update the

1
llvm/lib/VMCore/Type.cpp
View File

@ -433,7 +433,6 @@ FunctionType::FunctionType(const Type *Result,
// Calculate whether or not this type is abstract
setAbstract(isAbstract);
}
StructType::StructType(const std::vector<const Type*> &Types, bool isPacked)