From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 18630 invoked by alias); 16 Jan 2007 19:06:56 -0000 Received: (qmail 18619 invoked by uid 22791); 16 Jan 2007 19:06:54 -0000 X-Spam-Check-By: sourceware.org Received: from main.gmane.org (HELO ciao.gmane.org) (80.91.229.2) by sourceware.org (qpsmtpd/0.31) with ESMTP; Tue, 16 Jan 2007 19:06:48 +0000 Received: from list by ciao.gmane.org with local (Exim 4.43) id 1H6tds-0005aJ-RZ for gdb-patches@sources.redhat.com; Tue, 16 Jan 2007 20:06:44 +0100 Received: from 68.106.109.66.static.dis.net ([66.109.106.68]) by main.gmane.org with esmtp (Gmexim 0.1 (Debian)) id 1AlnuQ-0007hv-00 for ; Tue, 16 Jan 2007 20:06:39 +0100 Received: from ghost by 68.106.109.66.static.dis.net with local (Gmexim 0.1 (Debian)) id 1AlnuQ-0007hv-00 for ; Tue, 16 Jan 2007 20:06:39 +0100 To: gdb-patches@sources.redhat.com From: Vladimir Prus Subject: Re: [mi] fix 'editable' attribute for references Date: Tue, 16 Jan 2007 19:06:00 -0000 Message-ID: References: <200701162138.39578.ghost@cs.msu.su> Mime-Version: 1.0 Content-Type: multipart/mixed; boundary="nextPart2178435.RO8NCHpkct" Content-Transfer-Encoding: 7Bit User-Agent: KNode/0.10.2 X-IsSubscribed: yes Mailing-List: contact gdb-patches-help@sourceware.org; run by ezmlm Precedence: bulk List-Id: List-Subscribe: List-Archive: List-Post: List-Help: , Sender: gdb-patches-owner@sourceware.org X-SW-Source: 2007-01/txt/msg00361.txt.bz2 --nextPart2178435.RO8NCHpkct Content-Type: text/plain; charset=utf-8 Content-Transfer-Encoding: 8Bit Content-length: 1032 Vladimir Prus wrote: > > I've noticed that the -var-show-references returns 'attr=noneditable' for > structures, but 'attr=editable' for references to structures, which makes > no sense. I've also noticed that while for structures, we don't compare old and new values, and never report varobj corresponding to structure as changed, we do all that for references to structures. This patch fixes both problems, OK? - Volodya Fix the 'editable' attribute computation for references. testsuite/ * lib/mi-support.exp (mi_delete_varobj): New. * gdb.mi/mi-var-cp.exp: Run the reference_to_struct testcase. * gdb.mi/mi-var-cp.cc (reference_to_struct): New function. (main): Call the above. (reference_update_test, base_in_reference_test) (reference_to_pointer): Delete the created varobjs. gdb/ * varobj.c (get_value_type): New function. (c_variable_editable): Use get_value_type. (varobj_value_is_changeable): Likewise. --nextPart2178435.RO8NCHpkct Content-Type: text/x-diff; name="path_3_5_references__gdb_mainline.diff" Content-Transfer-Encoding: 8Bit Content-Disposition: attachment; filename="path_3_5_references__gdb_mainline.diff" Content-length: 4666 --- gdb/testsuite/gdb.mi/mi-var-cp.exp (/mirrors/gdb_mainline) (revision 3174) +++ gdb/testsuite/gdb.mi/mi-var-cp.exp (/patches/gdb/path_3_5_references/gdb_mainline) (revision 3174) @@ -44,6 +44,7 @@ mi_prepare_inline_tests $srcfile mi_run_inline_test reference_update mi_run_inline_test base_in_reference mi_run_inline_test reference_to_pointer +mi_run_inline_test reference_to_struct mi_gdb_exit return 0 --- gdb/testsuite/gdb.mi/mi-var-cp.cc (/mirrors/gdb_mainline) (revision 3174) +++ gdb/testsuite/gdb.mi/mi-var-cp.cc (/patches/gdb/path_3_5_references/gdb_mainline) (revision 3174) @@ -30,6 +30,7 @@ void reference_update_tests () :*/ x = 567; /*: mi_varobj_update RX {} "update RX (3)" + mi_delete_varobj RX "delete RX" :*/ /* Dummy assignment to keep 'x' in scope. */ x = 444; @@ -59,7 +60,8 @@ int base_in_reference_test (S2& s2) mi_check_varobj_value "S2.S.public.i" "67" "check S2.S.public.i" mi_check_varobj_value "S2.S.public.j" "89" "check S2.S.public.j" - + mi_delete_varobj S2 "delete S2" + :*/ /*: END: base_in_reference :*/ } @@ -91,15 +93,39 @@ int reference_to_pointer () mi_check_varobj_value RPTR.public.i 67 "check i member" mi_check_varobj_value RPTR.public.j 89 "check j member" + mi_delete_varobj RPTR "delete RPTR" :*/ return 99; /*: END: reference_to_pointer :*/ } +int reference_to_struct () +{ + /*: BEGIN: reference_to_struct :*/ + S s = {7, 8}; + S& r = s; + /*: + mi_create_varobj S s "create varobj for s" + mi_create_varobj R r "create varobj for s" + mi_gdb_test "-var-show-attributes S" \ + "\\^done,attr=\"noneditable\"" \ + "check attributes of S" + mi_gdb_test "-var-show-attributes R" \ + "\\^done,attr=\"noneditable\"" \ + "check attributes of R" + :*/ + s.i = 56; + /*: mi_varobj_update * [] "-var-update should not list structure varobjs" + :*/ + return 99; + /*: END: reference_to_struct :*/ +} + int main () { reference_update_tests (); base_in_reference_test_main (); reference_to_pointer (); + reference_to_struct (); return 0; } --- gdb/testsuite/lib/mi-support.exp (/mirrors/gdb_mainline) (revision 3174) +++ gdb/testsuite/lib/mi-support.exp (/patches/gdb/path_3_5_references/gdb_mainline) (revision 3174) @@ -1023,6 +1023,13 @@ proc mi_create_varobj { name expression $testname } +# Deletes the specified NAME. +proc mi_delete_varobj { name testname } { + mi_gdb_test "-var-delete $name" \ + "\\^done,ndeleted=.*" \ + $testname +} + # Updates varobj named NAME and checks that all varobjs in EXPECTED # are reported as updated, and no other varobj is updated. # Assumes that no varobj is out of scope and that no varobj changes --- gdb/varobj.c (/mirrors/gdb_mainline) (revision 3174) +++ gdb/varobj.c (/patches/gdb/path_3_5_references/gdb_mainline) (revision 3174) @@ -176,6 +176,8 @@ static struct cleanup *make_cleanup_free static struct type *get_type (struct varobj *var); +static struct type *get_value_type (struct varobj *var); + static struct type *get_type_deref (struct varobj *var); static struct type *get_target_type (struct type *); @@ -1459,6 +1461,35 @@ get_type (struct varobj *var) return type; } +/* Return the type of the value that's stored in VAR, + or that would have being stored there if the + value were accessible. + + This differs from VAR->type in that VAR->type is always + the true type of the expession in the source language. + The return value of this function is the type we're + actually storing in varobj, and using for displaying + the values and for comparing previous and new values. + + For example, top-level references are always stripped. */ +static struct type * +get_value_type (struct varobj *var) +{ + struct type *type; + + if (var->value) + type = value_type (var->value); + else + type = var->type; + + if (TYPE_CODE (type) == TYPE_CODE_REF) + type = get_target_type (type); + + type = check_typedef (type); + + return type; +} + /* This returns the type of the variable, dereferencing references, pointers and references to pointers, too. */ static struct type * @@ -1723,7 +1754,7 @@ varobj_value_is_changeable_p (struct var if (CPLUS_FAKE_CHILD (var)) return 0; - type = get_type (var); + type = get_value_type (var); switch (TYPE_CODE (type)) { @@ -2020,7 +2051,7 @@ c_type_of_child (struct varobj *parent, static int c_variable_editable (struct varobj *var) { - switch (TYPE_CODE (get_type (var))) + switch (TYPE_CODE (get_value_type (var))) { case TYPE_CODE_STRUCT: case TYPE_CODE_UNION: --nextPart2178435.RO8NCHpkct--