Use Source;
public:
- // getUnaryOperator() - Construct a unary instruction, given the opcode
+ // create() - Construct a unary instruction, given the opcode
// and its operand.
//
- static UnaryOperator *getUnaryOperator(unsigned Op, Value *Source);
+ static UnaryOperator *create(unsigned Op, Value *Source);
UnaryOperator(Value *S, unsigned iType, const string &Name = "")
: Instruction(S->getType(), iType, Name), Source(S, this) {
inline ~UnaryOperator() { dropAllReferences(); }
virtual Instruction *clone() const {
- return getUnaryOperator(getInstType(), Source);
+ return create(getInstType(), Source);
}
virtual void dropAllReferences() {
Use Source1, Source2;
public:
- // getBinaryOperator() - Construct a binary instruction, given the opcode
+ // create() - Construct a binary instruction, given the opcode
// and the two operands.
//
- static BinaryOperator *getBinaryOperator(unsigned Op, Value *S1, Value *S2);
+ static BinaryOperator *create(unsigned Op, Value *S1, Value *S2,
+ const string &Name = "");
BinaryOperator(unsigned iType, Value *S1, Value *S2,
const string &Name = "")
}
inline ~BinaryOperator() { dropAllReferences(); }
- virtual Instruction *clone() const {
- return getBinaryOperator(getInstType(), Source1, Source2);
+ virtual Instruction *clone() const {
+ return create(getInstType(), Source1, Source2);
}
virtual void dropAllReferences() {
return iType >= FirstBinaryOp && iType < NumBinaryOps;
}
+ // isPHINode() - This is used frequently enough to allow it to exist
+ inline bool isPHINode() const { return iType == PHINode; }
+
//----------------------------------------------------------------------
// Exported enumerations...
void remove(Value *N);
Value *type_remove(const type_iterator &It);
+ // getUniqueName - Given a base name, return a string that is either equal to
+ // it (or derived from it) that does not already occur in the symbol table for
+ // the specified type.
+ //
+ string getUniqueName(const Type *Ty, const string &BaseName);
+
inline unsigned type_size(const Type *TypeID) const {
return find(TypeID)->second.size();
}
// 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 *remove(iterator &DI); // Defined in ValueHolderImpl.h
+ ValueSubclass *remove(const iterator &DI); // Defined in ValueHolderImpl.h
+ void remove(ValueSubclass *D); // Defined in ValueHolderImpl.h
- inline void push_front(ValueSubclass *Inst); // Defined in ValueHolderImpl.h
- inline void push_back(ValueSubclass *Inst); // 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
Parent->getSymbolTableSure()->insert(Inst);
}
+// ValueHolder::insert - This method inserts the specified value *BEFORE* the
+// indicated iterator position, and returns an interator to the newly inserted
+// value.
+//
+template<class ValueSubclass, class ItemParentType>
+ValueHolder<ValueSubclass,ItemParentType>::iterator
+ValueHolder<ValueSubclass,ItemParentType>::insert(iterator Pos,
+ ValueSubclass *Inst){
+ assert(Inst->getParent() == 0 && "Value already has parent!");
+ Inst->setParent(ItemParent);
+
+ iterator I = ValueList.insert(Pos, Inst);
+ if (Inst->hasName() && Parent)
+ Parent->getSymbolTableSure()->insert(Inst);
+ return I;
+}
+
#endif