//
//===----------------------------------------------------------------------===//
-#ifndef LLVM_USER_H
-#define LLVM_USER_H
+#ifndef LLVM_IR_USER_H
+#define LLVM_IR_USER_H
+#include "llvm/ADT/iterator.h"
+#include "llvm/ADT/iterator_range.h"
#include "llvm/IR/Value.h"
#include "llvm/Support/ErrorHandling.h"
friend struct HungoffOperandTraits;
virtual void anchor();
protected:
+ /// NumOperands - The number of values used by this User.
+ ///
+ unsigned NumOperands;
+
/// OperandList - This is a pointer to the array of Uses for this User.
/// For nodes of fixed arity (e.g. a binary operator) this array will live
/// prefixed to some derived class instance. For nodes of resizable variable
/// allocated and should be destroyed by the classes' virtual dtor.
Use *OperandList;
- /// NumOperands - The number of values used by this User.
- ///
- unsigned NumOperands;
-
void *operator new(size_t s, unsigned Us);
User(Type *ty, unsigned vty, Use *OpList, unsigned NumOps)
- : Value(ty, vty), OperandList(OpList), NumOperands(NumOps) {}
+ : Value(ty, vty), NumOperands(NumOps), OperandList(OpList) {}
Use *allocHungoffUses(unsigned) const;
void dropHungoffUses() {
Use::zap(OperandList, OperandList + NumOperands, true);
- OperandList = 0;
+ OperandList = nullptr;
// Reset NumOperands so User::operator delete() does the right thing.
NumOperands = 0;
}
//
typedef Use* op_iterator;
typedef const Use* const_op_iterator;
+ typedef iterator_range<op_iterator> op_range;
+ typedef iterator_range<const_op_iterator> const_op_range;
inline op_iterator op_begin() { return OperandList; }
inline const_op_iterator op_begin() const { return OperandList; }
inline op_iterator op_end() { return OperandList+NumOperands; }
inline const_op_iterator op_end() const { return OperandList+NumOperands; }
+ inline op_range operands() {
+ return op_range(op_begin(), op_end());
+ }
+ inline const_op_range operands() const {
+ return const_op_range(op_begin(), op_end());
+ }
/// Convenience iterator for directly iterating over the Values in the
/// OperandList
- class value_op_iterator : public std::iterator<std::forward_iterator_tag,
- Value*> {
- op_iterator OI;
- public:
- explicit value_op_iterator(Use *U) : OI(U) {}
-
- bool operator==(const value_op_iterator &x) const {
- return OI == x.OI;
- }
- bool operator!=(const value_op_iterator &x) const {
- return !operator==(x);
- }
-
- /// Iterator traversal: forward iteration only
- value_op_iterator &operator++() { // Preincrement
- ++OI;
- return *this;
- }
- value_op_iterator operator++(int) { // Postincrement
- value_op_iterator tmp = *this; ++*this; return tmp;
- }
-
- /// Retrieve a pointer to the current Value.
- Value *operator*() const {
- return *OI;
- }
+ struct value_op_iterator
+ : iterator_adaptor_base<value_op_iterator, op_iterator,
+ std::random_access_iterator_tag, Value *,
+ ptrdiff_t, Value *, Value *> {
+ explicit value_op_iterator(Use *U = nullptr) : iterator_adaptor_base(U) {}
+ Value *operator*() const { return *I; }
Value *operator->() const { return operator*(); }
};
inline value_op_iterator value_op_end() {
return value_op_iterator(op_end());
}
+ inline iterator_range<value_op_iterator> operand_values() {
+ return iterator_range<value_op_iterator>(value_op_begin(), value_op_end());
+ }
// dropAllReferences() - This function is in charge of "letting go" of all
// objects that this User refers to. This allows one to
// delete.
//
void dropAllReferences() {
- for (op_iterator i = op_begin(), e = op_end(); i != e; ++i)
- i->set(0);
+ for (Use &U : operands())
+ U.set(nullptr);
}
/// replaceUsesOfWith - Replaces all references to the "From" definition with
template<> struct simplify_type<User::op_iterator> {
typedef Value* SimpleType;
-
- static SimpleType getSimplifiedValue(const User::op_iterator &Val) {
- return static_cast<SimpleType>(Val->get());
+ static SimpleType getSimplifiedValue(User::op_iterator &Val) {
+ return Val->get();
}
};
-
-template<> struct simplify_type<const User::op_iterator>
- : public simplify_type<User::op_iterator> {};
-
template<> struct simplify_type<User::const_op_iterator> {
- typedef Value* SimpleType;
-
- static SimpleType getSimplifiedValue(const User::const_op_iterator &Val) {
- return static_cast<SimpleType>(Val->get());
+ typedef /*const*/ Value* SimpleType;
+ static SimpleType getSimplifiedValue(User::const_op_iterator &Val) {
+ return Val->get();
}
};
-template<> struct simplify_type<const User::const_op_iterator>
- : public simplify_type<User::const_op_iterator> {};
-
-
-// value_use_iterator::getOperandNo - Requires the definition of the User class.
-template<typename UserTy>
-unsigned value_use_iterator<UserTy>::getOperandNo() const {
- return U - U->getUser()->op_begin();
-}
-
} // End llvm namespace
#endif