Fix a bug where the DWARF emitter in the JIT was not initializing alignment

[oota-llvm.git] / include / llvm / Use.h

diff --git a/include/llvm/Use.h b/include/llvm/Use.h
index d9667032652d14a2d461db41230878a4fdcdf451..489dbc50a041251ba870b0dadab7067bd13e6dfd 100644 (file)
--- a/include/llvm/Use.h
+++ b/include/llvm/Use.h
@@ -11,6 +11,15 @@
 // 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
@@ -18,46 +27,27 @@
 
 #include "llvm/Support/Casting.h"
 #include "llvm/ADT/iterator.h"
+#include "llvm/ADT/PointerIntPair.h"
 
 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);
   }
@@ -238,7 +231,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