1 files changed, 146 insertions, 0 deletions
diff --git a/include/llvm/Use.h b/include/llvm/Use.h
new file mode 100644
index 0000000000..a0f920d2e5
--- /dev/null
+++ b/include/llvm/Use.h
@@ -0,0 +1,146 @@
+//===-- llvm/Use.h - Definition of the Use class ----------------*- C++ -*-===//
+//
+// This defines the Use class.  The Use class represents the operand of an
+// instruction or some other User instance which refers to a Value.  The Use
+// class keeps the "use list" of the referenced value up to date.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_USE_H
+#define LLVM_USE_H
+
+#include "Support/ilist"
+template<typename NodeTy> struct ilist_traits;
+class Value;
+class User;
+
+
+//===----------------------------------------------------------------------===//
+//                                  Use Class
+//===----------------------------------------------------------------------===//
+
+// Use is here to make keeping the "use" list of a Value up-to-date really easy.
+//
+class Use {
+  Value *Val;
+  User *U;
+  Use *Prev, *Next;
+  friend class ilist_traits<Use>;
+public:
+  inline Use(Value *v, User *user);
+  inline Use(const Use &u);
+  inline ~Use();
+
+  operator Value*() const { return Val; }
+  Value *get() const { return Val; }
+  User *getUser() const { return U; }
+
+  inline void set(Value *Val);
+
+  Value *operator=(Value *RHS) {
+    set(RHS);
+    return RHS;
+  }
+  const Use &operator=(const Use &RHS) {
+    set(RHS.Val);
+    return *this;
+  }
+
+        Value *operator->()       { return Val; }
+  const Value *operator->() const { return Val; }
+};
+
+template<>
+struct ilist_traits<Use> {
+  static Use *getPrev(Use *N) { return N->Prev; }
+  static Use *getNext(Use *N) { return N->Next; }
+  static const Use *getPrev(const Use *N) { return N->Prev; }
+  static const Use *getNext(const Use *N) { return N->Next; }
+  static void setPrev(Use *N, Use *Prev) { N->Prev = Prev; }
+  static void setNext(Use *N, Use *Next) { N->Next = Next; }
+
+  // createNode - this is used to create the end marker for the use list
+  static Use *createNode() { return new Use(0,0); }
+
+  void addNodeToList(Use *NTy) {}
+  void removeNodeFromList(Use *NTy) {}
+  void transferNodesFromList(iplist<Use, ilist_traits> &L2,
+                             ilist_iterator<Use> first,
+                             ilist_iterator<Use> last) {}
+};
+
+
+template<> struct simplify_type<Use> {
+  typedef Value* SimpleType;
+  static SimpleType getSimplifiedValue(const Use &Val) {
+    return (SimpleType)Val.get();
+  }
+};
+template<> struct simplify_type<const Use> {
+  typedef Value* SimpleType;
+  static SimpleType getSimplifiedValue(const Use &Val) {
+    return (SimpleType)Val.get();
+  }
+};
+
+struct UseListIteratorWrapper : public iplist<Use>::iterator {
+  typedef iplist<Use>::iterator Super;
+  UseListIteratorWrapper() {}
+  UseListIteratorWrapper(const Super &RHS) : Super(RHS) {}
+
+  UseListIteratorWrapper &operator=(const Super &RHS) {
+    Super::operator=(RHS);
+    return *this;
+  }
+
+  inline User *operator*() const;
+  User *operator->() const { return operator*(); }
+
+  UseListIteratorWrapper operator--() { return Super::operator--(); }
+  UseListIteratorWrapper operator++() { return Super::operator++(); }
+
+  UseListIteratorWrapper operator--(int) {    // postdecrement operators...
+    UseListIteratorWrapper tmp = *this;
+    --*this;
+    return tmp;
+  }
+  UseListIteratorWrapper operator++(int) {    // postincrement operators...
+    UseListIteratorWrapper tmp = *this;
+    ++*this;
+    return tmp;
+  }
+};
+
+struct UseListConstIteratorWrapper : public iplist<Use>::const_iterator {
+  typedef iplist<Use>::const_iterator Super;
+  UseListConstIteratorWrapper() {}
+  UseListConstIteratorWrapper(const Super &RHS) : Super(RHS) {}
+
+  // Allow conversion from non-const to const iterators
+  UseListConstIteratorWrapper(const UseListIteratorWrapper &RHS) : Super(RHS) {}
+  UseListConstIteratorWrapper(const iplist<Use>::iterator &RHS) : Super(RHS) {}
+
+  UseListConstIteratorWrapper &operator=(const Super &RHS) {
+    Super::operator=(RHS);
+    return *this;
+  }
+
+  inline const User *operator*() const;
+  const User *operator->() const { return operator*(); }
+
+  UseListConstIteratorWrapper operator--() { return Super::operator--(); }
+  UseListConstIteratorWrapper operator++() { return Super::operator++(); }
+
+  UseListConstIteratorWrapper operator--(int) {    // postdecrement operators...
+    UseListConstIteratorWrapper tmp = *this;
+    --*this;
+    return tmp;
+  }
+  UseListConstIteratorWrapper operator++(int) {    // postincrement operators...
+    UseListConstIteratorWrapper tmp = *this;
+    ++*this;
+    return tmp;
+  }
+};
+
+#endif