Value reference counting

[Daniel Jacobowitz <drow@false.org>]

This patch, based on an old patch from Vladimir, implements reference
counting for values.  Tom, this is the approach I discussed with you
on IRC: instead of treating the value chain as a normal reference and
using release_value to take references, this separates the value chain
(which is boolean; a value is either on it or not) from references
(which are counted).  So you take a reference with value_incref.
release_value transforms the value chain's reference into a normal
reference.  That's an entirely theoretical operation, by which I mean
release_value doesn't have to do anything special.

Does this look OK?  Tom, will it work for the Python code?

Tested on x86_64-linux, no regressions.

-- 
Daniel Jacobowitz
CodeSourcery

2009-07-17  Daniel Jacobowitz  <dan@codesourcery.com>
	    Vladimir Prus <vladimir@codesourcery.com>

	* value.c (struct value): Add reference_count field.
	(allocate_value_lazy): Initialize reference_count.
	(value_incref): New function.
	(value_free): Check the reference count.
	* value.h (value_incref): New prototype.

---
 gdb/value.c |   27 +++++++++++++++++++++++++++
 gdb/value.h |    2 ++
 2 files changed, 29 insertions(+)

Index: src/gdb/value.c
===================================================================
--- src.orig/gdb/value.c	2009-07-17 09:52:16.000000000 -0400
+++ src/gdb/value.c	2009-07-17 10:07:10.000000000 -0400
@@ -194,6 +194,11 @@ struct value
   /* Actual contents of the value.  Target byte-order.  NULL or not
      valid if lazy is nonzero.  */
   gdb_byte *contents;
+
+  /* The number of references to this value.  This initially includes
+     one reference from the value chain; if release_value is called,
+     it converts that into a normal reference.  */
+  int reference_count;
 };
 
 /* Prototypes for local functions. */
@@ -259,6 +264,10 @@ allocate_value_lazy (struct type *type)
   val->pointed_to_offset = 0;
   val->modifiable = 1;
   val->initialized = 1;  /* Default to initialized.  */
+
+  /* Values start out on the all_values chain.  */
+  val->reference_count = 1;
+
   return val;
 }
 
@@ -583,11 +592,29 @@ value_mark (void)
   return all_values;
 }
 
+/* Take a reference to VAL.  VAL will not be deallocated until all
+   references are released.  */
+
+void
+value_incref (struct value *val)
+{
+  val->reference_count++;
+}
+
+/* Release a reference to VAL, which was acquired with value_incref.
+   This function is also called to deallocate values from the value
+   chain.  */
+
 void
 value_free (struct value *val)
 {
   if (val)
     {
+      gdb_assert (val->reference_count > 0);
+      val->reference_count--;
+      if (val->reference_count > 0)
+	return;
+
       if (VALUE_LVAL (val) == lval_computed)
 	{
 	  struct lval_funcs *funcs = val->location.computed.funcs;
Index: src/gdb/value.h
===================================================================
--- src.orig/gdb/value.h	2009-07-17 10:05:12.000000000 -0400
+++ src/gdb/value.h	2009-07-17 10:05:17.000000000 -0400
@@ -582,6 +582,8 @@ extern int unop_user_defined_p (enum exp
 
 extern int destructor_name_p (const char *name, const struct type *type);
 
+extern void value_incref (struct value *val);
+
 extern void value_free (struct value *val);
 
 extern void free_all_values (void);