///
class GetElementPtrInst : public Instruction {
GetElementPtrInst(const GetElementPtrInst &GEPI);
- void init(Value *Ptr, Value* const *Idx, unsigned NumIdx, const std::string &Name);
+ void init(Value *Ptr, Value* const *Idx, unsigned NumIdx,
+ const std::string &Name);
void init(Value *Ptr, Value *Idx, const std::string &Name);
template<typename InputIterator>
/// ExtractValueInst - This instruction extracts a struct member or array
/// element value from an aggregate value.
///
-class ExtractValueInst : public Instruction {
+class ExtractValueInst : public UnaryInstruction {
SmallVector<unsigned, 4> Indices;
ExtractValueInst(const ExtractValueInst &EVI);
- void init(Value *Agg, const unsigned *Idx, unsigned NumIdx, const std::string &Name);
- void init(Value *Agg, unsigned Idx, const std::string &Name);
+ void init(const unsigned *Idx, unsigned NumIdx,
+ const std::string &Name);
+ void init(unsigned Idx, const std::string &Name);
template<typename InputIterator>
- void init(Value *Agg, InputIterator IdxBegin, InputIterator IdxEnd,
+ void init(InputIterator IdxBegin, InputIterator IdxEnd,
const std::string &Name,
// This argument ensures that we have an iterator we can
// do arithmetic on in constant time
assert(NumIdx > 0 && "ExtractValueInst must have at least one index");
// This requires that the iterator points to contiguous memory.
- init(Agg, &*IdxBegin, NumIdx, Name); // FIXME: for the general case
+ init(&*IdxBegin, NumIdx, Name); // FIXME: for the general case
// we have to build an array here
}
if (NumIdx > 0)
// This requires that the iterator points to contiguous memory.
- return getIndexedType(Ptr, (const unsigned *)&*IdxBegin, NumIdx);
+ return getIndexedType(Ptr, &*IdxBegin, NumIdx);
else
return getIndexedType(Ptr, (const unsigned *)0, NumIdx);
}
InputIterator IdxBegin, InputIterator IdxEnd,
const std::string &Name, BasicBlock *InsertAtEnd);
- /// Constructors - These two constructors are convenience methods because one
- /// and two index extractvalue instructions are so common.
- ExtractValueInst(Value *Agg, unsigned Idx, const std::string &Name = "",
- Instruction *InsertBefore = 0);
- ExtractValueInst(Value *Agg, unsigned Idx,
- const std::string &Name, BasicBlock *InsertAtEnd);
-public:
// allocate space for exactly one operand
void *operator new(size_t s) {
return User::operator new(s, 1);
}
+public:
template<typename InputIterator>
static ExtractValueInst *Create(Value *Agg, InputIterator IdxBegin,
InputIterator IdxEnd,
static ExtractValueInst *Create(Value *Agg, unsigned Idx,
const std::string &Name = "",
Instruction *InsertBefore = 0) {
- return new ExtractValueInst(Agg, Idx, Name, InsertBefore);
+ unsigned Idxs[1] = { Idx };
+ return new ExtractValueInst(Agg, Idxs, Idxs + 1, Name, InsertBefore);
}
static ExtractValueInst *Create(Value *Agg, unsigned Idx,
const std::string &Name,
BasicBlock *InsertAtEnd) {
- return new ExtractValueInst(Agg, Idx, Name, InsertAtEnd);
+ unsigned Idxs[1] = { Idx };
+ return new ExtractValueInst(Agg, Idxs, Idxs + 1, Name, InsertAtEnd);
}
virtual ExtractValueInst *clone() const;
- /// Transparently provide more efficient getOperand methods.
- DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
-
// getType - Overload to return most specific pointer type...
const PointerType *getType() const {
return reinterpret_cast<const PointerType*>(Instruction::getType());
}
static const Type *getIndexedType(const Type *Ptr, unsigned Idx);
- inline const unsigned *idx_begin() const { return Indices.begin(); }
- inline const unsigned *idx_end() const { return Indices.end(); }
+ typedef const unsigned* idx_iterator;
+ inline idx_iterator idx_begin() const { return Indices.begin(); }
+ inline idx_iterator idx_end() const { return Indices.end(); }
Value *getAggregateOperand() {
return getOperand(0);
}
unsigned getNumIndices() const { // Note: always non-negative
- return Indices.size();
+ return (unsigned)Indices.size();
}
bool hasIndices() const {
}
};
-template <>
-struct OperandTraits<ExtractValueInst> : FixedNumOperandTraits<1> {
-};
-
template<typename InputIterator>
ExtractValueInst::ExtractValueInst(Value *Agg,
InputIterator IdxBegin,
InputIterator IdxEnd,
const std::string &Name,
Instruction *InsertBefore)
- : Instruction(checkType(getIndexedType(Agg->getType(), IdxBegin, IdxEnd)),
- ExtractValue,
- OperandTraits<ExtractValueInst>::op_begin(this),
- 1, InsertBefore) {
- init(Agg, IdxBegin, IdxEnd, Name,
+ : UnaryInstruction(checkType(getIndexedType(Agg->getType(),
+ IdxBegin, IdxEnd)),
+ ExtractValue, Agg, InsertBefore) {
+ init(IdxBegin, IdxEnd, Name,
typename std::iterator_traits<InputIterator>::iterator_category());
}
template<typename InputIterator>
InputIterator IdxEnd,
const std::string &Name,
BasicBlock *InsertAtEnd)
- : Instruction(checkType(getIndexedType(Agg->getType(), IdxBegin, IdxEnd)),
- ExtractValue,
- OperandTraits<ExtractValueInst>::op_begin(this),
- 1, InsertAtEnd) {
- init(Agg, IdxBegin, IdxEnd, Name,
+ : UnaryInstruction(checkType(getIndexedType(Agg->getType(),
+ IdxBegin, IdxEnd)),
+ ExtractValue, Agg, InsertAtEnd) {
+ init(IdxBegin, IdxEnd, Name,
typename std::iterator_traits<InputIterator>::iterator_category());
}
-DEFINE_TRANSPARENT_OPERAND_ACCESSORS(ExtractValueInst, Value)
-
//===----------------------------------------------------------------------===//
// InsertValueInst Class
void *operator new(size_t, unsigned); // Do not implement
InsertValueInst(const InsertValueInst &IVI);
- void init(Value *Agg, Value *Val, const unsigned *Idx, unsigned NumIdx, const std::string &Name);
+ void init(Value *Agg, Value *Val, const unsigned *Idx, unsigned NumIdx,
+ const std::string &Name);
void init(Value *Agg, Value *Val, unsigned Idx, const std::string &Name);
template<typename InputIterator>
}
template<typename InputIterator>
- static InsertValueInst *Create(Value *Agg, Value *Val, InputIterator IdxBegin,
+ static InsertValueInst *Create(Value *Agg, Value *Val, InputIterator IdxBegin,
InputIterator IdxEnd,
const std::string &Name = "",
Instruction *InsertBefore = 0) {
return reinterpret_cast<const PointerType*>(Instruction::getType());
}
- inline const unsigned *idx_begin() const { return Indices.begin(); }
- inline const unsigned *idx_end() const { return Indices.end(); }
+ typedef const unsigned* idx_iterator;
+ inline idx_iterator idx_begin() const { return Indices.begin(); }
+ inline idx_iterator idx_end() const { return Indices.end(); }
Value *getAggregateOperand() {
return getOperand(0);
}
unsigned getNumIndices() const { // Note: always non-negative
- return Indices.size();
+ return (unsigned)Indices.size();
}
bool hasIndices() const {