From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 4238 invoked by alias); 5 Oct 2012 19:45:24 -0000 Received: (qmail 4230 invoked by uid 22791); 5 Oct 2012 19:45:23 -0000 X-SWARE-Spam-Status: No, hits=-7.1 required=5.0 tests=AWL,BAYES_00,KAM_STOCKGEN,KHOP_RCVD_UNTRUST,KHOP_SPAMHAUS_DROP,KHOP_THREADED,RCVD_IN_DNSWL_HI,RCVD_IN_HOSTKARMA_W,RP_MATCHES_RCVD,SPF_HELO_PASS,TW_VT X-Spam-Check-By: sourceware.org Received: from mx1.redhat.com (HELO mx1.redhat.com) (209.132.183.28) by sourceware.org (qpsmtpd/0.43rc1) with ESMTP; Fri, 05 Oct 2012 19:45:09 +0000 Received: from int-mx12.intmail.prod.int.phx2.redhat.com (int-mx12.intmail.prod.int.phx2.redhat.com [10.5.11.25]) by mx1.redhat.com (8.14.4/8.14.4) with ESMTP id q95Jj9nU022879 (version=TLSv1/SSLv3 cipher=DHE-RSA-AES256-SHA bits=256 verify=OK) for ; Fri, 5 Oct 2012 15:45:09 -0400 Received: from valrhona.uglyboxes.com (ovpn01.gateway.prod.ext.phx2.redhat.com [10.5.9.1]) by int-mx12.intmail.prod.int.phx2.redhat.com (8.14.4/8.14.4) with ESMTP id q95Jj6wW002563 (version=TLSv1/SSLv3 cipher=DHE-RSA-CAMELLIA256-SHA bits=256 verify=NO) for ; Fri, 5 Oct 2012 15:45:08 -0400 Message-ID: <506F38C2.4050107@redhat.com> Date: Fri, 05 Oct 2012 19:45:00 -0000 From: Keith Seitz User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:13.0) Gecko/20120605 Thunderbird/13.0 MIME-Version: 1.0 To: "gdb-patches@sourceware.org ml" Subject: Re: [RFA] c++/13615 References: <505119AE.6040401@redhat.com> <87sja4wlqt.fsf@fleche.redhat.com> In-Reply-To: <87sja4wlqt.fsf@fleche.redhat.com> Content-Type: multipart/mixed; boundary="------------020907060504030801000709" 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: 2012-10/txt/msg00102.txt.bz2 This is a multi-part message in MIME format. --------------020907060504030801000709 Content-Type: text/plain; charset=ISO-8859-1; format=flowed Content-Transfer-Encoding: 7bit Content-length: 1833 On 09/26/2012 01:51 PM, Tom Tromey wrote: >>>>>> "Keith" == Keith Seitz writes: > > Keith> $SUBJECT deals with various symbol lookup failures with inherited > Keith> typedefs. Tom reported these failures in both the expression parser > Keith> and gdb.lookup_type (part of the python support). > > Sorry, no review yet -- however I was wondering if you could check how > this patch relates to this thread: > > http://sourceware.org/ml/gdb-patches/2010-11/threads.html#00014 Yeah, the two are rather similar, but not exactly. Nonetheless, with much hair-pulling [I haven't much left!], I've been able to modify my original patch to fix the problem reported in the above thread. [I did not use anything from the suggested patch other than the test case, which I've updated a bit.] I'm attaching the latest revision of this patch. BTW, this patch relies on the cp_test_ptype_class-typedef.patch, http://sourceware.org/ml/gdb-patches/2012-10/msg00051.html . Keith ChangeLog 2012-10-05 Keith Seitz c++/13615 * cp-namespace.c (cp_lookup_symbol_nonlocal): If no symbol is found, search through any base classes to find it. (find_symbol_in_baseclass): New function. (cp_lookup_nested_symbol): Search through base classes, too. testsuite/ChangeLog 2012-10-05 Keith Seitz c++/13615 * gdb.cp/baseenum.cc: New file. * gdb.cp/baseenum.exp: New file. * gdb.cp/derivation.cc (A): Add a typedef. (B): Use A::value_type instead of int. Change all references. (D): Use value_type instead of int. Change all references. (E): Likewise. (F); Likewise. (Z): New class. (ZZ): New class. (main): Add instances of Z and ZZ. * gdb.cp/derivation.exp: Update typedef changes in tests. Add tests for class typedefs both before and after starting the inferior. --------------020907060504030801000709 Content-Type: text/x-patch; name="13615+.patch" Content-Transfer-Encoding: 7bit Content-Disposition: inline; filename="13615+.patch" Content-length: 14838 diff --git a/gdb/cp-namespace.c b/gdb/cp-namespace.c index e2291a9..a78f163 100644 --- a/gdb/cp-namespace.c +++ b/gdb/cp-namespace.c @@ -252,6 +252,10 @@ cp_lookup_symbol_nonlocal (const char *name, const domain_enum domain) { struct symbol *sym; + char *klass, *nested; + unsigned int prefix_len; + struct cleanup *cleanup; + struct symbol *klass_sym; const char *scope = block_scope (block); sym = lookup_namespace_scope (name, block, @@ -259,8 +263,63 @@ cp_lookup_symbol_nonlocal (const char *name, if (sym != NULL) return sym; - return cp_lookup_symbol_namespace (scope, name, - block, domain); + sym = cp_lookup_symbol_namespace (scope, name, + block, domain); + if (sym != NULL) + return sym; + + /* A simple lookup failed. Check if the symbol was defined in + a base class. */ + + cleanup = make_cleanup (null_cleanup, NULL); + + /* Find the name of the class and the name of the method, variable, etc. */ + prefix_len = cp_entire_prefix_len (name); + + /* If no prefix was found, search "this". */ + if (prefix_len == 0) + { + struct type *type; + struct symbol *this; + + this = lookup_language_this (language_def (language_cplus), block); + if (this == NULL) + { + do_cleanups (cleanup); + return NULL; + } + + type = check_typedef (TYPE_TARGET_TYPE (SYMBOL_TYPE (this))); + klass = xstrdup (TYPE_NAME (type)); + nested = xstrdup (name); + } + else + { + /* The class name is everything up to and including PREFIX_LEN. */ + klass = savestring (name, prefix_len); + + /* The rest of the name is everything else past the initial scope + operator. */ + nested = xstrdup (name + prefix_len + 2); + } + + /* Add cleanups to free memory for these strings. */ + make_cleanup (xfree, klass); + make_cleanup (xfree, nested); + + /* Lookup a class named KLASS. If none is found, there is nothing + more that can be done. */ + klass_sym = lookup_symbol (klass, block, domain, NULL); + if (klass_sym == NULL) + { + do_cleanups (cleanup); + return NULL; + } + + /* Look for a symbol named NESTED in this class. */ + sym = cp_lookup_nested_symbol (SYMBOL_TYPE (klass_sym), nested, block); + do_cleanups (cleanup); + return sym; } /* Look up NAME in the C++ namespace NAMESPACE. Other arguments are @@ -660,6 +719,62 @@ lookup_symbol_file (const char *name, return sym; } +/* Search through the base classes of PARENT_TYPE for a symbol named + NAME in block BLOCK. */ + +static struct symbol * +find_symbol_in_baseclass (struct type *parent_type, const char *name, + const struct block *block) +{ + int i; + struct symbol *sym; + struct cleanup *cleanup; + char *concatenated_name; + + sym = NULL; + concatenated_name = NULL; + cleanup = make_cleanup (null_cleanup, NULL); + for (i = 0; i < TYPE_N_BASECLASSES (parent_type); ++i) + { + const char *base_name = TYPE_BASECLASS_NAME (parent_type, i); + + /* Search this particular base class. */ + sym = cp_lookup_symbol_namespace (base_name, name, block, VAR_DOMAIN); + if (sym != NULL) + break; + + discard_cleanups (cleanup); + concatenated_name = xrealloc (concatenated_name, + (strlen (base_name) + 2 + + strlen (name) + 1)); + cleanup = make_cleanup (xfree, concatenated_name); + sprintf (concatenated_name, "%s::%s", base_name, name); + sym = lookup_symbol_static (concatenated_name, block, VAR_DOMAIN); + + /* If there is currently no BLOCK, e.g., the inferior hasn't yet + been started, then try searching all STATIC_BLOCK symbols in + all objfiles. */ + if (block == NULL) + { + sym = lookup_static_symbol_aux (concatenated_name, VAR_DOMAIN); + if (sym != NULL) + break; + } + + /* If this class has base classes, search them next. */ + if (TYPE_N_BASECLASSES (TYPE_BASECLASS (parent_type, i)) > 0) + { + sym = find_symbol_in_baseclass (TYPE_BASECLASS (parent_type, i), + name, block); + if (sym != NULL) + break; + } + } + + do_cleanups (cleanup); + return sym; +} + /* Look up a symbol named NESTED_NAME that is nested inside the C++ class or namespace given by PARENT_TYPE, from within the context given by BLOCK. Return NULL if there is no such nested type. */ @@ -700,7 +815,7 @@ cp_lookup_nested_symbol (struct type *parent_type, /* Now search all static file-level symbols. Not strictly correct, but more useful than an error. We do not try to guess any imported namespace as even the fully specified - namespace seach is is already not C++ compliant and more + namespace search is already not C++ compliant and more assumptions could make it too magic. */ concatenated_name = alloca (strlen (parent_name) + 2 @@ -711,7 +826,9 @@ cp_lookup_nested_symbol (struct type *parent_type, if (sym != NULL) return sym; - return NULL; + /* If no matching symbols were found, try searching any + base classes. */ + return find_symbol_in_baseclass (parent_type, nested_name, block); } default: internal_error (__FILE__, __LINE__, diff --git a/gdb/testsuite/gdb.cp/baseenum.cc b/gdb/testsuite/gdb.cp/baseenum.cc new file mode 100644 index 0000000..3eb6876 --- /dev/null +++ b/gdb/testsuite/gdb.cp/baseenum.cc @@ -0,0 +1,63 @@ +class A +{ +public: + enum E {X,Y,Z}; +}; + +class B1 : public A +{ +}; + +class B2 : public A +{ +}; + +class C : public B1, public B2 +{ +public: + void test(E e); +}; + +void C::test(E e) +{ + if (e == X) // breakpoint 1 + { + } +} + +namespace N +{ + class A + { + public: + enum E {X, Y, Z}; + }; + + class B1 {}; + class B2 : public A {}; + + class C : public B1, public B2 + { + public: + void test (E e); + }; + + void + C::test (E e) + { + if (e == X) // breakpoint 2 + { + } + } +} + +int main() +{ + C c; + c.test(A::X); + + N::C nc; + nc.test (N::A::X); + return 0; +} + diff --git a/gdb/testsuite/gdb.cp/baseenum.exp b/gdb/testsuite/gdb.cp/baseenum.exp new file mode 100644 index 0000000..826b4aa --- /dev/null +++ b/gdb/testsuite/gdb.cp/baseenum.exp @@ -0,0 +1,36 @@ +# Copyright 2012 Free Software Foundation, Inc. + +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 3 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program. If not, see . + +# Test searching enum constant symbols derived from base classes. + +standard_testfile .cc + +if {[prepare_for_testing $testfile.exp $testfile $srcfile {debug c++}]} { + return -1 +} + +if {![runto_main]} { + untested "could not run to main" + return -1 +} + +gdb_breakpoint [gdb_get_line_number "breakpoint 1" $srcfile] +gdb_continue_to_breakpoint "breakpoint 1" +gdb_test "print X" "= A::X" "Print enum constant X of class A" + +gdb_breakpoint [gdb_get_line_number "breakpoint 2" $srcfile] +gdb_continue_to_breakpoint "breakpoint 2" +gdb_test "print X" "= N::A::X" \ + "Print enum constant X of class A in namespace N" diff --git a/gdb/testsuite/gdb.cp/derivation.cc b/gdb/testsuite/gdb.cp/derivation.cc index fcd57ce..439eadf 100644 --- a/gdb/testsuite/gdb.cp/derivation.cc +++ b/gdb/testsuite/gdb.cp/derivation.cc @@ -1,32 +1,32 @@ class A { public: - int a; - int aa; + typedef int value_type; + value_type a; + value_type aa; A() { a=1; aa=2; } - int afoo(); - int foo(); - + value_type afoo(); + value_type foo(); }; class B { public: - int b; - int bb; + A::value_type b; + A::value_type bb; B() { b=3; bb=4; } - int bfoo(); - int foo(); + A::value_type bfoo(); + A::value_type foo(); }; @@ -51,48 +51,48 @@ public: class D : private A, public B, protected C { public: - int d; - int dd; + value_type d; + value_type dd; D() { d =7; dd=8; } - int dfoo(); - int foo(); + value_type dfoo(); + value_type foo(); }; class E : public A, B, protected C { public: - int e; - int ee; + value_type e; + value_type ee; E() { e =9; ee=10; } - int efoo(); - int foo(); + value_type efoo(); + value_type foo(); }; class F : A, public B, C { public: - int f; - int ff; + value_type f; + value_type ff; F() { f =11; ff=12; } - int ffoo(); - int foo(); + value_type ffoo(); + value_type foo(); }; @@ -118,6 +118,19 @@ public: }; +class Z : public A +{ +public: + typedef float value_type; + value_type z; +}; + +class ZZ : public Z +{ +public: + value_type zz; +}; + class V_base { public: @@ -150,27 +163,27 @@ public: V_derived vderived; -int A::afoo() { +A::value_type A::afoo() { return 1; } -int B::bfoo() { +A::value_type B::bfoo() { return 2; } -int C::cfoo() { +A::value_type C::cfoo() { return 3; } -int D::dfoo() { +D::value_type D::dfoo() { return 4; } -int E::efoo() { +E::value_type E::efoo() { return 5; } -int F::ffoo() { +F::value_type F::ffoo() { return 6; } @@ -178,37 +191,37 @@ int G::gfoo() { return 77; } -int A::foo() +A::value_type A::foo() { return 7; } -int B::foo() +A::value_type B::foo() { return 8; } -int C::foo() +A::value_type C::foo() { return 9; } -int D::foo() +D::value_type D::foo() { return 10; } -int E::foo() +E::value_type E::foo() { return 11; } -int F::foo() +F::value_type F::foo() { return 12; @@ -236,7 +249,9 @@ int main(void) E e_instance; F f_instance; G g_instance; - + Z z_instance; + ZZ zz_instance; + marker1(); // marker1-returns-here a_instance.a = 20; // marker1-returns-here @@ -251,10 +266,10 @@ int main(void) e_instance.ee =29; f_instance.f =30; f_instance.ff =31; - - - - + g_instance.g = 32; + g_instance.gg = 33; + z_instance.z = 34.0; + zz_instance.zz = 35.0; return 0; } diff --git a/gdb/testsuite/gdb.cp/derivation.exp b/gdb/testsuite/gdb.cp/derivation.exp index f4b4888..863e889 100644 --- a/gdb/testsuite/gdb.cp/derivation.exp +++ b/gdb/testsuite/gdb.cp/derivation.exp @@ -38,6 +38,18 @@ if {[prepare_for_testing $testfile.exp $testfile $srcfile {debug c++}]} { return -1 } +# Check inheritance of typedefs. +foreach klass {"A" "D" "E" "F"} { + gdb_test "ptype ${klass}::value_type" "type = int" + gdb_test "whatis ${klass}::value_type" "type = int" + gdb_test "p (${klass}::value_type) 0" " = 0" +} +foreach klass {"Z" "ZZ"} { + gdb_test "ptype ${klass}::value_type" "type = float" + gdb_test "whatis ${klass}::value_type" "type = float" + gdb_test "p (${klass}::value_type) 0" " = 0" +} + # Set it up at a breakpoint so we can play with the variable values. if ![runto 'marker1'] then { @@ -56,11 +68,12 @@ gdb_test "print a_instance" "\\$\[0-9\]+ = \{a = 1, aa = 2\}" "print value of a_ cp_test_ptype_class \ "ptype a_instance" "" "class" "A" \ { - { field public "int a;" } - { field public "int aa;" } + { field public "A::value_type a;" } + { field public "A::value_type aa;" } { method public "A();" } - { method public "int afoo();" } - { method public "int foo();" } + { method public "A::value_type afoo();" } + { method public "A::value_type foo();" } + { typedef public "typedef int value_type;" } } # class D @@ -77,11 +90,11 @@ cp_test_ptype_class \ { base "private A" } { base "public B" } { base "protected C" } - { field public "int d;" } - { field public "int dd;" } + { field public "A::value_type d;" } + { field public "A::value_type dd;" } { method public "D();" } - { method public "int dfoo();" } - { method public "int foo();" } + { method public "A::value_type dfoo();" } + { method public "A::value_type foo();" } } \ "" \ { @@ -102,11 +115,11 @@ cp_test_ptype_class \ { base "public A" } { base "private B" } { base "protected C" } - { field public "int e;" } - { field public "int ee;" } + { field public "A::value_type e;" } + { field public "A::value_type ee;" } { method public "E();" } - { method public "int efoo();" } - { method public "int foo();" } + { method public "A::value_type efoo();" } + { method public "A::value_type foo();" } } \ "" \ { @@ -127,11 +140,11 @@ cp_test_ptype_class \ { base "private A" } { base "public B" } { base "private C" } - { field public "int f;" } - { field public "int ff;" } + { field public "A::value_type f;" } + { field public "A::value_type ff;" } { method public "F();" } - { method public "int ffoo();" } - { method public "int foo();" } + { method public "A::value_type ffoo();" } + { method public "A::value_type foo();" } } # class G @@ -193,6 +206,35 @@ gdb_test_multiple "frame" "re-selected 'main' frame after inferior call" { gdb_test "print g_instance.bfoo()" "\\$\[0-9\]+ = 2" "print value of g_instance.bfoo()" gdb_test "print g_instance.cfoo()" "\\$\[0-9\]+ = 3" "print value of g_instance.cfoo()" +# Check typedefs of fields +foreach Klass {"C" "G"} { + set klass [string tolower $Klass] + set instance "${klass}_instance" + set var "${instance}.$klass" + gdb_test "whatis $var" "int" + gdb_test "ptype $var" "int" +} + +foreach Klass {"A" "B" "D" "E" "F"} { + set klass [string tolower $Klass] + set instance "${klass}_instance" + set var "${instance}.$klass" + gdb_test "whatis $var" "A::value_type" + gdb_test "ptype $var" "int" + if {![string equal $Klass "B"]} { + gdb_test "p (${Klass}::value_type) 0" " = 0" + } +} + +foreach Klass {"Z" "ZZ"} { + set klass [string tolower $Klass] + set instance "${klass}_instance" + set var "${instance}.$klass" + gdb_test "whatis $var" "Z::value_type" + gdb_test "ptype $var" "float" + gdb_test "p (${Klass}::value_type) 0" " = 0" +} + # This is a regression test for a bug that caused a crash when trying # to print the vtbl pointer. We don't care about the output so much # here (it is tested elsewhere), just that gdb doesn't crash. We test --------------020907060504030801000709--