X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=include%2Fllvm%2FUse.h;h=970f69b9da883553e2fbb8a664839fa8162295b8;hb=9e6d1d1f5034347d237941f1bf08fba5c1583cd3;hp=d9667032652d14a2d461db41230878a4fdcdf451;hpb=a870039277d26d3d8f3ff774345db90096b544ad;p=oota-llvm.git

diff --git a/include/llvm/Use.h b/include/llvm/Use.h
index d9667032652..970f69b9da8 100644
--- a/include/llvm/Use.h
+++ b/include/llvm/Use.h
@@ -11,53 +11,43 @@
 // 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.
 //
+// Pointer tagging is used to efficiently find the User corresponding
+// to a Use without having to store a User pointer in every Use. A
+// User is preceded in memory by all the Uses corresponding to its
+// operands, and the low bits of one of the fields (Prev) of the Use
+// class are used to encode offsets to be able to find that User given
+// a pointer to any Use. For details, see:
+//
+//   http://www.llvm.org/docs/ProgrammersManual.html#UserLayout
+//
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_USE_H
 #define LLVM_USE_H
 
 #include "llvm/Support/Casting.h"
-#include "llvm/ADT/iterator.h"
+#include "llvm/ADT/PointerIntPair.h"
+#include <iterator>
 
 namespace llvm {
 
 class Value;
 class User;
-
-
-//===----------------------------------------------------------------------===//
-//                          Generic Tagging Functions
-//===----------------------------------------------------------------------===//
+class Use;
 
 /// Tag - generic tag type for (at least 32 bit) pointers
 enum Tag { noTag, tagOne, tagTwo, tagThree };
 
-/// addTag - insert tag bits into an (untagged) pointer
-template <typename T, typename TAG>
-inline T *addTag(const T *P, TAG Tag) {
-    return reinterpret_cast<T*>(ptrdiff_t(P) | Tag);
-}
-
-/// stripTag - remove tag bits from a pointer,
-/// making it dereferencable
-template <ptrdiff_t MASK, typename T>
-inline T *stripTag(const T *P) {
-  return reinterpret_cast<T*>(ptrdiff_t(P) & ~MASK);
-}
-
-/// extractTag - extract tag bits from a pointer
-template <typename TAG, TAG MASK, typename T>
-inline TAG extractTag(const T *P) {
-  return TAG(ptrdiff_t(P) & MASK);
-}
-
-/// transferTag - transfer tag bits from a pointer,
-/// to an untagged pointer
-template <ptrdiff_t MASK, typename T>
-inline T *transferTag(const T *From, const T *To) {
-  return reinterpret_cast<T*>((ptrdiff_t(From) & MASK) | ptrdiff_t(To));
-}
-
+// Use** is only 4-byte aligned.
+template<>
+class PointerLikeTypeTraits<Use**> {
+public:
+  static inline void *getAsVoidPointer(Use** P) { return P; }
+  static inline Use **getFromVoidPointer(void *P) {
+    return static_cast<Use**>(P);
+  }
+  enum { NumLowBitsAvailable = 2 };
+};
 
 //===----------------------------------------------------------------------===//
 //                                  Use Class
@@ -121,15 +111,18 @@ public:
   /// a User changes.
   static void zap(Use *Start, const Use *Stop, bool del = false);
 
+  /// getPrefix - Return deletable pointer if appropriate
+  Use *getPrefix();
 private:
   const Use* getImpliedUser() const;
   static Use *initTags(Use *Start, Use *Stop, ptrdiff_t Done = 0);
   
   Value *Val;
-  Use *Next, **Prev;
+  Use *Next;
+  PointerIntPair<Use**, 2, PrevPtrTag> Prev;
 
   void setPrev(Use **NewPrev) {
-    Prev = transferTag<fullStopTag>(Prev, NewPrev);
+    Prev.setPointer(NewPrev);
   }
   void addToList(Use **List) {
     Next = *List;
@@ -138,7 +131,7 @@ private:
     *List = this;
   }
   void removeFromList() {
-    Use **StrippedPrev = stripTag<fullStopTag>(Prev);
+    Use **StrippedPrev = Prev.getPointer();
     *StrippedPrev = Next;
     if (Next) Next->setPrev(StrippedPrev);
   }
@@ -165,8 +158,9 @@ template<> struct simplify_type<const Use> {
 
 
 template<typename UserTy>  // UserTy == 'User' or 'const User'
-class value_use_iterator : public forward_iterator<UserTy*, ptrdiff_t> {
-  typedef forward_iterator<UserTy*, ptrdiff_t> super;
+class value_use_iterator : public std::iterator<std::forward_iterator_tag,
+                                                UserTy*, ptrdiff_t> {
+  typedef std::iterator<std::forward_iterator_tag, UserTy*, ptrdiff_t> super;
   typedef value_use_iterator<UserTy> _Self;
 
   Use *U;
@@ -238,7 +232,7 @@ template<> struct simplify_type<value_use_iterator<const User> > {
 
 template<> struct simplify_type<const value_use_iterator<const User> >
   : public simplify_type<value_use_iterator<const User> > {};
-
+ 
 } // End llvm namespace
 
 #endif