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
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:
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
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
/// 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; }
// 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 {
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;
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
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
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
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,
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
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
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(); }
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
#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;
///
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:
#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.
// 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);
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);
// 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
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)
// Delete all of the method arguments and unlink from symbol table...
ArgumentList.clear();
- ArgumentList.setParent(0);
delete SymTab;
}
// 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.
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();
}
Module::~Module() {
dropAllReferences();
GlobalList.clear();
- GlobalList.setParent(0);
FunctionList.clear();
- FunctionList.setParent(0);
LibraryList.clear();
delete ValSymTab;
delete TypeSymTab;
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) {
// 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
// Calculate whether or not this type is abstract
setAbstract(isAbstract);
-
}
StructType::StructType(const std::vector<const Type*> &Types, bool isPacked)