mirror of
https://github.com/RPCS3/llvm-mirror.git
synced 2024-11-24 19:52:54 +01:00
101 lines
4.1 KiB
C++
101 lines
4.1 KiB
C++
//===-- llvm/ValueHolder.h - Class to hold multiple values -------*- C++ -*--=//
|
|
//
|
|
// This defines a class that is used as a fancy Definition container. It is
|
|
// special because it helps keep the symbol table of the container method up to
|
|
// date with the goings on inside of it.
|
|
//
|
|
// This is used to represent things like the instructions of a basic block and
|
|
// the arguments to a method.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#ifndef LLVM_VALUEHOLDER_H
|
|
#define LLVM_VALUEHOLDER_H
|
|
|
|
#include <vector>
|
|
class SymTabValue;
|
|
|
|
// ItemParentType ItemParent - I call setParent() on all of my
|
|
// "ValueSubclass" items, and this is the value that I pass in.
|
|
//
|
|
template<class ValueSubclass, class ItemParentType>
|
|
class ValueHolder {
|
|
// TODO: Should I use a deque instead of a vector?
|
|
vector<ValueSubclass*> ValueList;
|
|
|
|
ItemParentType *ItemParent;
|
|
SymTabValue *Parent;
|
|
|
|
ValueHolder(const ValueHolder &V); // DO NOT IMPLEMENT
|
|
public:
|
|
inline ValueHolder(ItemParentType *IP, SymTabValue *parent = 0) {
|
|
assert(IP && "Item parent may not be null!");
|
|
ItemParent = IP;
|
|
Parent = 0;
|
|
setParent(parent);
|
|
}
|
|
|
|
inline ~ValueHolder() {
|
|
// The caller should have called delete_all first...
|
|
assert(empty() && "ValueHolder contains definitions!");
|
|
assert(Parent == 0 && "Should have been unlinked from method!");
|
|
}
|
|
|
|
inline const SymTabValue *getParent() const { return Parent; }
|
|
inline SymTabValue *getParent() { return Parent; }
|
|
void setParent(SymTabValue *Parent); // Defined in ValueHolderImpl.h
|
|
|
|
inline unsigned size() const { return ValueList.size(); }
|
|
inline bool empty() const { return ValueList.empty(); }
|
|
inline const ValueSubclass *front() const { return ValueList.front(); }
|
|
inline ValueSubclass *front() { return ValueList.front(); }
|
|
inline const ValueSubclass *back() const { return ValueList.back(); }
|
|
inline ValueSubclass *back() { return ValueList.back(); }
|
|
|
|
//===--------------------------------------------------------------------===//
|
|
// sub-Definition iterator code
|
|
//===--------------------------------------------------------------------===//
|
|
//
|
|
typedef vector<ValueSubclass*>::iterator iterator;
|
|
typedef vector<ValueSubclass*>::const_iterator const_iterator;
|
|
typedef reverse_iterator<const_iterator> const_reverse_iterator;
|
|
typedef reverse_iterator<iterator> reverse_iterator;
|
|
|
|
inline iterator begin() { return ValueList.begin(); }
|
|
inline const_iterator begin() const { return ValueList.begin(); }
|
|
inline iterator end () { return ValueList.end(); }
|
|
inline const_iterator end () const { return ValueList.end(); }
|
|
|
|
inline reverse_iterator rbegin() { return ValueList.rbegin(); }
|
|
inline const_reverse_iterator rbegin() const { return ValueList.rbegin(); }
|
|
inline reverse_iterator rend () { return ValueList.rend(); }
|
|
inline const_reverse_iterator rend () const { return ValueList.rend(); }
|
|
|
|
void delete_all() { // Delete all removes and deletes all elements
|
|
while (!empty()) {
|
|
iterator it = end();
|
|
delete remove(--it); // Delete all instructions...
|
|
}
|
|
}
|
|
|
|
// ValueHolder::remove(iterator &) this removes the element at the location
|
|
// specified by the iterator, and leaves the iterator pointing to the element
|
|
// that used to follow the element deleted.
|
|
//
|
|
ValueSubclass *remove(iterator &DI); // Defined in ValueHolderImpl.h
|
|
ValueSubclass *remove(const iterator &DI); // Defined in ValueHolderImpl.h
|
|
void remove(ValueSubclass *D); // Defined in ValueHolderImpl.h
|
|
ValueSubclass *pop_back(); // Defined in ValueHolderImpl.h
|
|
|
|
void push_front(ValueSubclass *Inst); // Defined in ValueHolderImpl.h
|
|
void push_back(ValueSubclass *Inst); // Defined in ValueHolderImpl.h
|
|
|
|
// ValueHolder::insert - This method inserts the specified value *BEFORE* the
|
|
// indicated iterator position, and returns an interator to the newly inserted
|
|
// value.
|
|
//
|
|
iterator insert(iterator Pos, ValueSubclass *Inst);
|
|
};
|
|
|
|
#endif
|