From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 18335 invoked by alias); 28 Sep 2009 09:55:15 -0000 Mailing-List: contact archer-help@sourceware.org; run by ezmlm Sender: Precedence: bulk List-Post: List-Help: List-Subscribe: List-Id: Received: (qmail 18319 invoked by uid 22791); 28 Sep 2009 09:55:14 -0000 X-SWARE-Spam-Status: No, hits=-2.5 required=5.0 tests=AWL,BAYES_00,SPF_PASS X-Spam-Check-By: sourceware.org Message-ID: <4AC087F9.2040706@googlemail.com> Date: Mon, 28 Sep 2009 09:55:00 -0000 From: Richard Ward User-Agent: Thunderbird 2.0.0.23 (X11/20090817) MIME-Version: 1.0 To: archer@sourceware.org Subject: Re: Patch to add rtti_type member to gdb.Value Content-Type: multipart/mixed; boundary="------------090805030405090600050804" X-SW-Source: 2009-q3/txt/msg00260.txt.bz2 This is a multi-part message in MIME format. --------------090805030405090600050804 Content-Type: text/plain; charset=ISO-8859-1; format=flowed Content-Transfer-Encoding: 7bit Content-length: 1970 Tom Tromey wrote: >>>>>> "Richard" == Richard Ward writes: > > Richard> I'll look at the other points later when I have time, but In this case > Richard> if Py_None is used it will be incremented twice before being handed > Richard> back to the caller. > > Yeah -- once for the store to obj->type, and once for the caller. > The caller needs a new reference, always. > For obj->type, this lets us call Py_DECREF without checking whether > obj->type is None. > > Tom Ah, I missed the inc for the store. Thanks for explaining. As for if it is always the case that the run time type is stored in the value struct, the comments say it is (gdb/value.c:140 or there abouts). The value seems to be determined in valops.c, in value_ind (actually in the call to value_full_type). So as soon as a pointer is dereferenced its run time type is stored. Originally I was calling value_rtti_type in valpy_get_rtti_type but it seemed sensible to use enclosing_type seeing as it was there. The fact that you don't know the run time type until a pointer is dereferenced seemed sensible to me (as the type of a Base* is always a Base*, even if the thing it points to is actually a Sub). If the value in question is a reference, the only way I see in python of getting a gdb.Value object representing the value being referred to by the reference is to take the address of the reference, and then dereference that (so we still dereference a pointer and value_rtti_type is still called). It seems that print object looks at the type before the dereference. I guess the question is whether the rtti_type attribute of a pointer/reference gdb.Value should be a pointer/reference to the rtti_type of the dereferenced object, or the compile time pointer type. IMO it should be the compile time pointer type, it seems to make more sense that way. As for the non GNU coding standards, I think I've fixed that (and the python inc) in the attached. Richard. --------------090805030405090600050804 Content-Type: text/x-patch; name="rtti_type.patch" Content-Transfer-Encoding: 7bit Content-Disposition: inline; filename="rtti_type.patch" Content-length: 4045 >From 07e2b27c05579d02bc6ccde77b6e06e34b161d30 Mon Sep 17 00:00:00 2001 From: Richard Ward Date: Mon, 28 Sep 2009 10:43:36 +0100 Subject: [PATCH] 2009-09-28 Richard Ward add attribute rtti_type to gdb.Value * gdb/python/py-value.c: new function valpy_get_rtti_type to get and return the real type of a value from the gdb value struct, and store it as a type_object in value_object. * gdb/doc/gdb.texinfo updated to refelect the above. --- gdb/ChangeLog | 6 ++++++ gdb/doc/ChangeLog | 4 ++++ gdb/doc/gdb.texinfo | 8 ++++++++ gdb/python/py-value.c | 23 +++++++++++++++++++++++ 4 files changed, 41 insertions(+), 0 deletions(-) diff --git a/gdb/ChangeLog b/gdb/ChangeLog index e7b2748..f50b737 100644 --- a/gdb/ChangeLog +++ b/gdb/ChangeLog @@ -1,3 +1,9 @@ +2009-09-23 Richard Ward + + * py-value.c: Added an attribute called rtti_type + denoting the actual run time type of an object where + rtti is applicable. + 2009-09-10 Joel Brobecker * top.c (interactive_mode): New static variable. diff --git a/gdb/doc/ChangeLog b/gdb/doc/ChangeLog index b3f8fc7..22c80ac 100644 --- a/gdb/doc/ChangeLog +++ b/gdb/doc/ChangeLog @@ -1,3 +1,7 @@ +2009-09-23 Richard Ward + + * gdb.texinfo: Document new attribute rtti_type in gdb.Value + 2009-09-10 Joel Brobecker Add documentation for set/show interactive-mode. diff --git a/gdb/doc/gdb.texinfo b/gdb/doc/gdb.texinfo index 18ffb09..597757f 100644 --- a/gdb/doc/gdb.texinfo +++ b/gdb/doc/gdb.texinfo @@ -19104,6 +19104,14 @@ this value, thus it is not available for fetching from the inferior. The type of this @code{gdb.Value}. The value of this attribute is a @code{gdb.Type} object. @end defivar + +@defivar Value rtti_type +A @code{gdb.Type} object representing the actual type of this +@code{gdb.Value} determined using Run Time Type Information where +applicable. If the value has no RTTI associated with it or if the type +could not be determined then this attribute will be identical to the +@code{type} attribute. +@end defivar @end table The following methods are provided: diff --git a/gdb/python/py-value.c b/gdb/python/py-value.c index 14efd79..3c0deb2 100644 --- a/gdb/python/py-value.c +++ b/gdb/python/py-value.c @@ -60,6 +60,7 @@ typedef struct value_object { struct value *value; PyObject *address; PyObject *type; + PyObject *rtti_type; } value_object; /* List of all values which are currently exposed to Python. It is @@ -224,6 +225,26 @@ valpy_get_type (PyObject *self, void *closure) return obj->type; } +/* Return the real type of the value determined using rtti */ +static PyObject * +valpy_get_rtti_type (PyObject *self, void *closure) +{ + value_object *obj = (value_object *) self; + struct type * rtti_type; + if (!obj->rtti_type) + { + rtti_type=value_enclosing_type(obj->value); + obj->rtti_type = type_to_type_object (rtti_type); + if (!obj->rtti_type) + { + obj->rtti_type = Py_None; + Py_INCREF (obj->rtti_type); + } + } + Py_INCREF (obj->rtti_type); + return obj->rtti_type; +} + /* Implementation of gdb.Value.string ([encoding] [, errors] [, length]) -> string. Return Unicode string with value contents. If ENCODING is not given, the string is assumed to be encoded in @@ -854,6 +875,7 @@ value_to_value_object (struct value *val) value_incref (val); val_obj->address = NULL; val_obj->type = NULL; + val_obj->rtti_type = NULL; note_value (val_obj); } @@ -1021,6 +1043,7 @@ static PyGetSetDef value_object_getset[] = { "Boolean telling whether the value is optimized out (i.e., not available).", NULL }, { "type", valpy_get_type, NULL, "Type of the value.", NULL }, + { "rtti_type", valpy_get_rtti_type, NULL, "Actual type of the value determined using rtti.", NULL }, {NULL} /* Sentinel */ }; -- 1.6.0.4 --------------090805030405090600050804--