Value reference counting

Daniel Jacobowitz
2009-07-17T18:42:05Z

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);