ValueRef(const ValueRef&);
~ValueRef();
+ ValueRef& operator=(const ValueRef&) = delete;
+
inline bool exists() const { return value != NULL; }
void set(Value *);
ValueDef(const ValueDef&);
~ValueDef();
+ ValueDef& operator=(const ValueDef&) = delete;
+
inline bool exists() const { return value != NULL; }
inline Value *get() const { return value; }
Value();
virtual ~Value() { }
+ Value(const Value&) = delete;
+ Value& operator=(const Value&) = delete;
+
virtual Value *clone(ClonePolicy<Function>&) const = 0;
virtual int print(char *, size_t, DataType ty = TYPE_NONE) const = 0;
Instruction(Function *, operation, DataType);
virtual ~Instruction();
+ Instruction(const Instruction&) = delete;
+ Instruction& operator=(const Instruction&) = delete;
+
virtual Instruction *clone(ClonePolicy<Function>&,
Instruction * = NULL) const;
BasicBlock(Function *);
~BasicBlock();
+ BasicBlock(const BasicBlock&) = delete;
+ BasicBlock& operator=(const BasicBlock&) = delete;
+
BasicBlock *clone(ClonePolicy<Function>&) const;
inline int getId() const { return id; }
Function(Program *, const char *name, uint32_t label);
~Function();
+ Function(const Function&) = delete;
+ Function& operator=(const Function&) = delete;
+
static inline Function *get(Graph::Node *node);
inline Program *getProgram() const { return prog; }
Program(Type type, Target *targ);
~Program();
+ Program(const Program&) = delete;
+ Program& operator=(const Program&) = delete;
+
void print();
Type getType() const { return progType; }
DLList() : head(0) { }
~DLList() { clear(); }
+ DLList(const DLList&) = delete;
+ DLList& operator=(const DLList&) = delete;
+
inline void insertHead(void *data)
{
Item *item = new Item(data);
Stack() : size(0), limit(0), array(0) { }
~Stack() { if (array) FREE(array); }
+ Stack(const Stack&) = delete;
+ Stack& operator=(const Stack&) = delete;
+
inline void push(int i) { Item data; data.u.i = i; push(data); }
inline void push(unsigned int u) { Item data; data.u.u = u; push(data); }
inline void push(void *p) { Item data; data.u.p = p; push(data); }
~DynArray() { if (data) FREE(data); }
+ DynArray(const DynArray&) = delete;
+ DynArray& operator=(const DynArray&) = delete;
+
inline Item& operator[](unsigned int i)
{
if (i >= size)
Interval(const Interval&);
~Interval();
+ Interval& operator=(const Interval&) = delete;
+
bool extend(int, int);
void insert(const Interval&);
void unify(Interval&); // clears source interval
FREE(data);
}
+ BitSet(const BitSet&) = delete;
+
// allocate will keep old data iff size is unchanged
bool allocate(unsigned int nBits, bool zero);
bool resize(unsigned int nBits); // keep old data, zero additional bits
FREE(allocArray);
}
+ MemoryPool(const MemoryPool&) = delete;
+ MemoryPool& operator=(const MemoryPool&) = delete;
+
void *allocate()
{
void *ret;