//
// The LLVM Compiler Infrastructure
//
-// This file was developed by the LLVM research group and is distributed under
-// the University of Illinois Open Source License. See LICENSE.TXT for details.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
Use(Value *V, User *U) { init(V, U); }
Use(const Use &U) { init(U.Val, U.U); }
- inline ~Use();
+ inline ~Use() {
+ if (Val) removeFromList();
+ }
/// Default ctor - This leaves the Use completely unitialized. The only thing
/// that is valid to do with this use is to call the "init" method.
typedef value_use_iterator<UserTy> _Self;
Use *U;
- value_use_iterator(Use *u) : U(u) {}
+ explicit value_use_iterator(Use *u) : U(u) {}
friend class Value;
public:
typedef typename super::reference reference;
return !operator==(x);
}
+ /// atEnd - return true if this iterator is equal to use_end() on the value.
+ bool atEnd() const { return U == 0; }
+
// Iterator traversal: forward iteration only
_Self &operator++() { // Preincrement
assert(U && "Cannot increment end iterator!");
_Self tmp = *this; ++*this; return tmp;
}
- // Retrieve a reference to the current SCC
- UserTy *operator*() const {
+ // Retrieve a reference to the current User
+ UserTy *operator*() const {
assert(U && "Cannot increment end iterator!");
return U->getUser();
}
UserTy *operator->() const { return operator*(); }
Use &getUse() const { return *U; }
+
+ /// getOperandNo - Return the operand # of this use in its User. Defined in
+ /// User.h
+ ///
+ unsigned getOperandNo() const;
+};
+
+
+template<> struct simplify_type<value_use_iterator<User> > {
+ typedef User* SimpleType;
+
+ static SimpleType getSimplifiedValue(const value_use_iterator<User> &Val) {
+ return *Val;
+ }
};
+template<> struct simplify_type<const value_use_iterator<User> >
+ : public simplify_type<value_use_iterator<User> > {};
+
+template<> struct simplify_type<value_use_iterator<const User> > {
+ typedef const User* SimpleType;
+
+ static SimpleType getSimplifiedValue(const
+ value_use_iterator<const User> &Val) {
+ return *Val;
+ }
+};
+
+template<> struct simplify_type<const value_use_iterator<const User> >
+ : public simplify_type<value_use_iterator<const User> > {};
+
} // End llvm namespace
#endif