[llvm-commits] CVS: llvm/include/llvm/Use.h

[Chris Lattner]

Changes in directory llvm/include/llvm:

Use.h updated: 1.8 -> 1.9
---
Log message:

Adjust to ilist changes.

Based on the ilist changes avoid allocating an entire Use object for the 
end of the Use chain.  This saves 8 bytes of memory for each Value allocated
in the program.  For 176.gcc, this reduces us from 69.5M -> 66.0M, a 5.3% 
memory savings.


---
Diffs of the changes:  (+25 -13)

 Use.h |   38 +++++++++++++++++++++++++-------------
 1 files changed, 25 insertions(+), 13 deletions(-)


Index: llvm/include/llvm/Use.h
diff -u llvm/include/llvm/Use.h:1.8 llvm/include/llvm/Use.h:1.9
--- llvm/include/llvm/Use.h:1.8	Fri Jan 28 18:30:52 2005
+++ llvm/include/llvm/Use.h	Sat Jan 29 12:43:28 2005
@@ -32,10 +32,6 @@
 // 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 struct ilist_traits<Use>;
 public:
   inline void init(Value *V, User *U);
 
@@ -65,19 +61,35 @@
 
         Value *operator->()       { return Val; }
   const Value *operator->() const { return Val; }
+
+private:
+  // NOTE!! The Next/Prev fields MUST stay at the start of this structure.  The
+  // end-token for the ilist is allocated as JUST the next/prev pair to reduce
+  // memory usage instead of allocating an entire Use.
+  struct NextPrevPtrs {
+    Use *Next, *Prev;
+  } UseLinks;
+
+  Value *Val;
+  User *U;
+  friend struct ilist_traits<Use>;
 };
 
 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); }
+  static Use *getPrev(Use *N) { return N->UseLinks.Prev; }
+  static Use *getNext(Use *N) { return N->UseLinks.Next; }
+  static const Use *getPrev(const Use *N) { return N->UseLinks.Prev; }
+  static const Use *getNext(const Use *N) { return N->UseLinks.Next; }
+  static void setPrev(Use *N, Use *Prev) { N->UseLinks.Prev = Prev; }
+  static void setNext(Use *N, Use *Next) { N->UseLinks.Next = Next; }
+
+  /// createSentinal - this is used to create the end marker for the use list.
+  /// Note that we only allocate a UseLinks structure, which is just enough to
+  /// hold the next/prev pointers.  This saves us 8 bytes of memory for every
+  /// Value allocated.
+  static Use *createSentinal() { return (Use*)new Use::NextPrevPtrs(); }
+  static void destroySentinal(Use *S) { delete (Use::NextPrevPtrs*)S; }
 
   void addNodeToList(Use *NTy) {}
   void removeNodeFromList(Use *NTy) {}