llvm-6502/lib/VMCore/SymbolTableListTraitsImpl.h
Reid Spencer 78d033e086 For PR411:
Take an incremental step towards type plane elimination. This change
separates types from values in the symbol tables by finally making use
of the TypeSymbolTable class. This yields more natural interfaces for
dealing with types and unclutters the SymbolTable class.


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@32956 91177308-0d34-0410-b5e6-96231b3b80d8
2007-01-06 07:24:44 +00:00

102 lines
3.7 KiB
C++

//===-- llvm/SymbolTableListTraitsImpl.h - Implementation ------*- C++ -*--===//
//
// The LLVM Compiler Infrastructure
//
// This file was developed by the LLVM research group and is distributed under
// the University of Illinois Open Source License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file implements the stickier parts of the SymbolTableListTraits class,
// and is explicitly instantiated where needed to avoid defining all this code
// in a widely used header.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_SYMBOLTABLELISTTRAITS_IMPL_H
#define LLVM_SYMBOLTABLELISTTRAITS_IMPL_H
#include "llvm/SymbolTableListTraits.h"
#include "llvm/SymbolTable.h"
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);
// Remove all of the items from the old symtab..
if (SymTabObject && !List.empty()) {
SymbolTable &SymTab = SymTabObject->getValueSymbolTable();
for (typename iplist<ValueSubClass>::iterator I = List.begin();
I != List.end(); ++I)
if (I->hasName()) SymTab.remove(I);
}
SymTabObject = STO;
// Add all of the items to the new symtab...
if (SymTabObject && !List.empty()) {
SymbolTable &SymTab = SymTabObject->getValueSymbolTable();
for (typename iplist<ValueSubClass>::iterator I = List.begin();
I != List.end(); ++I)
if (I->hasName()) SymTab.insert(I);
}
}
template<typename ValueSubClass, typename ItemParentClass, typename SymTabClass,
typename SubClass>
void SymbolTableListTraits<ValueSubClass,ItemParentClass,SymTabClass,SubClass>
::addNodeToList(ValueSubClass *V) {
assert(V->getParent() == 0 && "Value already in a container!!");
V->setParent(ItemParent);
if (V->hasName() && SymTabObject)
SymTabObject->getValueSymbolTable().insert(V);
}
template<typename ValueSubClass, typename ItemParentClass, typename SymTabClass,
typename SubClass>
void SymbolTableListTraits<ValueSubClass,ItemParentClass,SymTabClass,SubClass>
::removeNodeFromList(ValueSubClass *V) {
V->setParent(0);
if (V->hasName() && SymTabObject)
SymTabObject->getValueSymbolTable().remove(V);
}
template<typename ValueSubClass, typename ItemParentClass, typename SymTabClass,
typename SubClass>
void SymbolTableListTraits<ValueSubClass,ItemParentClass,SymTabClass,SubClass>
::transferNodesFromList(iplist<ValueSubClass, ilist_traits<ValueSubClass> > &L2,
ilist_iterator<ValueSubClass> first,
ilist_iterator<ValueSubClass> last) {
// We only have to do work here if transferring instructions between BBs
ItemParentClass *NewIP = ItemParent, *OldIP = L2.ItemParent;
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...
SymTabClass *NewSTO = SymTabObject, *OldSTO = L2.SymTabObject;
if (NewSTO != OldSTO) {
for (; first != last; ++first) {
ValueSubClass &V = *first;
bool HasName = V.hasName();
if (OldSTO && HasName)
OldSTO->getValueSymbolTable().remove(&V);
V.setParent(NewIP);
if (NewSTO && HasName)
NewSTO->getValueSymbolTable().insert(&V);
}
} else {
// Just transferring between blocks in the same function, simply update the
// parent fields in the instructions...
for (; first != last; ++first)
first->setParent(NewIP);
}
}
} // End llvm namespace
#endif