# Copyright 1992, 1994, 1995, 1996, 1997, 1998, 1999, 2001, 2002, 2003, 2004
# 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 2 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, write to the Free Software
# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
# This file was written by Fred Fish. (fnf@cygnus.com)
# And rewritten by Michael Chastain <mec.gnu@mindspring.com>.
set wsopt "\[\r\n\t \]*"
set ws "\[\r\n\t \]+"
set nl "\[\r\n\]+"
if $tracelevel then {
strace $tracelevel
}
if { [skip_cplus_tests] } { continue }
set testfile "virtfunc"
set srcfile ${testfile}.cc
set binfile ${objdir}/${subdir}/${testfile}
if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {c++ debug}] != "" } {
gdb_suppress_entire_file "Testcase compile failed, so all tests in this file will automatically fail."
}
# Test ptype of a class.
#
# Different C++ compilers produce different output. I build up regular
# expressions piece by piece to accommodate all the compilers that I
# have seen: gcc 2.95.3, gcc 3.3.2 (ABI 1), gcc 3.4 prerelease (ABI 2);
# and all the debug formats I have seen: dwarf-2 and stabs+.
#
# A complicated class declaration looks like this:
#
# class A : public virtual V { // re_class
# private:
# V * _vb$V; // re_vbptr
# int a; // re_fields
#
# public: // re_access_methods
# A & operator=(A const &); // re_synth_gcc_2
# A(int, A const &); // ...
# A(int); // ...
# virtual int f(void); // re_methods
# }
#
# RE_CLASS matches the class declaration. C++ allows multiple ways of
# expressing this.
#
# struct ... { private: ... };
# class ... { private: ... };
# class ... { ... };
#
# RE_VBPTR matches the virtual base declarations. gcc 2.95.3 sometimes
# emits these, but gcc 3.X.Y never emits these. The name depends on the
# debug format.
#
# RE_FIELDS matches the data fields of the class.
# RE_METHODS matches the methods explicitly declared for the class.
#
# RE_SYNTH_GCC_2 and RE_SYNTH_GCC_3 match the optional synthetic methods
# of the class. gcc -gstabs+ emits these methods, and gcc -gdwarf-2
# does not.
#
# RE_ACCESS_METHODS is an access specifier after RE_FIELDS and before
# the methods (explicit methods and/or synthetic methods).
# There is also an RE_ACCESS_FIELDS.
#
# When I get HP-UX aCC, I hope that I can just add RE_SYNTH_ACC_NNN.
#
# Yet another twist: with gcc v2, ctor and dtor methods have a hidden
# argument in front, the "in-charge" flag. With gcc v3, there is no
# hidden argument; instead, there are multiple object functions for
# each ctor and dtor.
#
# -- chastain 2004-01-01
proc test_one_ptype { command testname re_class re_vbptr re_access_fields re_fields re_access_methods re_methods re_synth_gcc_2 re_synth_gcc_3 re_star } {
global gdb_prompt
global wsopt
global ws
global nl
gdb_test_multiple "$command" "$testname" {
-re "type = $re_class${wsopt}$re_access_fields${wsopt}$re_fields${wsopt}$re_access_methods${wsopt}$re_methods$nl\}$re_star$nl$gdb_prompt $" {
# gcc 2.95.3, dwarf-2, no vbptr
# gcc 3.X, abi 1, dwarf-2
# gcc 3.X, abi 2, dwarf-2
pass "$testname"
}
-re "type = $re_class${wsopt}$re_vbptr${wsopt}$re_access_fields${wsopt}$re_fields${wsopt}$re_access_methods${wsopt}$re_methods$nl\}$re_star$nl$gdb_prompt $" {
# gcc 2.95.3, dwarf-2, vbptr
# TODO: drow says the vbptr is a bug
pass "$testname"
}
-re "type = $re_class${wsopt}$re_access_fields${wsopt}$re_fields${wsopt}$re_access_methods${wsopt}$re_synth_gcc_2${wsopt}$re_methods$nl\}$re_star$nl$gdb_prompt $" {
# gcc 2.95.3, stabs+, no vbptr
pass "$testname"
}
-re "type = $re_class${wsopt}$re_vbptr${wsopt}$re_access_fields${wsopt}$re_fields${wsopt}$re_access_methods${wsopt}$re_synth_gcc_2${wsopt}$re_methods$nl\}$re_star$nl$gdb_prompt $" {
# gcc 2.95.3, stabs+, vbptr
# TODO: drow says the vbptr is a bug
pass "$testname"
}
-re "type = $re_class${wsopt}$re_access_fields${wsopt}$re_fields${wsopt}$re_access_methods${wsopt}$re_synth_gcc_3${wsopt}$re_methods$nl\}$re_star$nl$gdb_prompt $" {
# gcc 3.X, abi 1, stabs+
pass "$testname"
}
-re "type = $re_class${wsopt}$re_access_fields${wsopt}$re_fields${wsopt}$re_access_methods${wsopt}$re_methods${wsopt}$re_synth_gcc_3$nl\}$re_star$nl$gdb_prompt $" {
# gcc 3.X, abi 2, stabs+
pass "$testname"
}
}
}
proc test_ptype_of_classes {} {
global gdb_prompt
global ws
global nl
# class VA
test_one_ptype "ptype VA" "ptype VA" \
"((struct|class) VA \{${ws}public:|struct VA \{)" \
"" \
"" "int va;" \
"" "" \
"VA & operator=\\(VA const ?&\\);${ws}\(void|\)${ws}VA\\(VA const ?&\\);${ws}\(void|\)${ws}VA\\((void|)\\);" \
"VA & operator=\\(VA const ?&\\);${ws}\(void|\)${ws}VA\\(VA const ?&\\);${ws}\(void|\)${ws}VA\\((void|)\\);" \
""
# class VB
test_one_ptype "ptype VB" "ptype VB" \
"((struct|class) VB \{${ws}public:|struct VB \{)" \
"" \
"" "int vb;" \
"" "int fvb\\((void|)\\);${ws}virtual int vvb\\((void|)\\);" \
"VB & operator=\\(VB const ?&\\);${ws}\(void|\)${ws}VB\\(VB const ?&\\);${ws}\(void|\)${ws}VB\\((void|)\\);" \
"VB & operator=\\(VB const ?&\\);${ws}\(void|\)${ws}VB\\(VB const ?&\\);${ws}\(void|\)${ws}VB\\((void|)\\);" \
""
# class V
test_one_ptype "ptype V" "ptype V" \
"class V : public VA, public VB \{${ws}public:" \
"" \
"" "int w;" \
"" "int f\\((void|)\\);${ws}virtual int vv\\((void|)\\);" \
"V & operator=\\(V const ?&\\);${ws}\(void|\)${ws}V\\(V const ?&\\);${ws}\(void|\)${ws}V\\((void|)\\);" \
"V & operator=\\(V const ?&\\);${ws}\(void|\)${ws}V\\(V const ?&\\);${ws}\(void|\)${ws}V\\((void|)\\);" \
""
# class A
test_one_ptype "ptype A" "ptype A" \
"class A : public virtual V \{(${ws}private:|)" \
"V \\*(_vb.1V|_vb.V);" \
"" "int a;" \
"public:" "virtual int f\\((void|)\\);" \
"A & operator=\\(A const ?&\\);${ws}\(void|\)${ws}A\\(int, A const ?&\\);${ws}\(void|\)${ws}A\\(int\\);" \
"A & operator=\\(A const ?&\\);${ws}\(void|\)${ws}A\\(A const ?&\\);${ws}\(void|\)${ws}A\\((void|)\\);" \
""
# class B
test_one_ptype "ptype B" "ptype B" \
"class B : public A \{(${ws}private:|)" \
"V \\*(_vb.1V|_vb.V);" \
"" "int b;" \
"public:" "virtual int f\\((void|)\\);" \
"B & operator=\\(B const ?&\\);${ws}\(void|\)${ws}B\\(int, B const ?&\\);${ws}\(void|\)${ws}B\\(int\\);" \
"B & operator=\\(B const ?&\\);${ws}\(void|\)${ws}B\\(B const ?&\\);${ws}\(void|\)${ws}B\\((void|)\\);" \
""
# class C
test_one_ptype "ptype C" "ptype C" \
"class C : public virtual V \{(${ws}private:|)" \
"V \\*(_vb.1V|_vb.V);" \
"public:" "int c;" \
"" "" \
"C & operator=\\(C const ?&\\);${ws}\(void|\)${ws}C\\(int, C const ?&\\);${ws}\(void|\)${ws}C\\(int\\);" \
"C & operator=\\(C const ?&\\);${ws}\(void|\)${ws}C\\(C const ?&\\);${ws}\(void|\)${ws}C\\((void|)\\);" \
""
# class AD
test_one_ptype "ptype AD" "ptype AD" \
"((struct|class) AD \{${ws}public:|struct AD \{)" \
"" \
"" "" \
"" "virtual int vg\\((void|)\\);" \
"AD & operator=\\(AD const ?&\\);${ws}\(void|\)${ws}AD\\(AD const ?&\\);${ws}\(void|\)${ws}AD\\((void|)\\);" \
"AD & operator=\\(AD const ?&\\);${ws}\(void|\)${ws}AD\\(AD const ?&\\);${ws}\(void|\)${ws}AD\\((void|)\\);" \
""
# class D
test_one_ptype "ptype D" "ptype D" \
"class D : public AD, public virtual V \{(${ws}private:|)" \
"V \\*(_vb.1V|_vb.V);" \
"public:" "int d;" \
"" "static void s\\((void|)\\);${ws}virtual int vg\\((void|)\\);${ws}virtual int vd\\((void|)\\);${ws}int fd\\((void|)\\);" \
"D & operator=\\(D const ?&\\);${ws}\(void|\)${ws}D\\(int, D const ?&\\);${ws}\(void|\)${ws}D\\(int\\);" \
"D & operator=\\(D const ?&\\);${ws}\(void|\)${ws}D\\(D const ?&\\);${ws}\(void|\)${ws}D\\((void|)\\);" \
""
# class E
# TODO: E does not show a vbptr for V. That seems strange.
test_one_ptype "ptype E" "ptype E" \
"class E : public B, public virtual V, public D, public C \{(${ws}private:|)" \
"" \
"public:" "int e;" \
"" "virtual int f\\((void|)\\);${ws}virtual int vg\\((void|)\\);${ws}virtual int vv\\((void|)\\);" \
"E & operator=\\(E const ?&\\);${ws}\(void|\)${ws}E\\(int, E const ?&\\);${ws}\(void|\)${ws}E\\(int\\);" \
"E & operator=\\(E const ?&\\);${ws}\(void|\)${ws}E\\(E const ?&\\);${ws}\(void|\)${ws}E\\((void|)\\);" \
""
# An instance of D
test_one_ptype "ptype dd" "ptype dd" \
"class D : public AD, public virtual V \{(${ws}private:|)" \
"V \\*(_vb.1V|_vb.V);" \
"public:" "int d;" \
"" "static void s\\((void|)\\);${ws}virtual int vg\\((void|)\\);${ws}virtual int vd\\((void|)\\);${ws}int fd\\((void|)\\);" \
"D & operator=\\(D const ?&\\);${ws}\(void|\)${ws}D\\(int, D const ?&\\);${ws}\(void|\)${ws}D\\(int\\);" \
"D & operator=\\(D const ?&\\);${ws}\(void|\)${ws}D\\(D const ?&\\);${ws}\(void|\)${ws}D\\((void|)\\);" \
""
# An instance of D *
test_one_ptype "ptype ppd" "ptype ppd" \
"class D : public AD, public virtual V \{(${ws}private:|)" \
"V \\*(_vb.1V|_vb.V);" \
"public:" "int d;" \
"" "static void s\\((void|)\\);${ws}virtual int vg\\((void|)\\);${ws}virtual int vd\\((void|)\\);${ws}int fd\\((void|)\\);" \
"D & operator=\\(D const ?&\\);${ws}\(void|\)${ws}D\\(int, D const ?&\\);${ws}\(void|\)${ws}D\\(int\\);" \
"D & operator=\\(D const ?&\\);${ws}\(void|\)${ws}D\\(D const ?&\\);${ws}\(void|\)${ws}D\\((void|)\\);" \
" ?\\*"
# An instance of AD *
# TODO: this should be named pADd, not pAd.
test_one_ptype "ptype pAd" "ptype pAd" \
"((struct|class) AD \{${ws}public:|struct AD \{)" \
"" \
"" "" \
"" "virtual int vg\\((void|)\\);" \
"AD & operator=\\(AD const ?&\\);${ws}\(void|\)${ws}AD\\(AD const ?&\\);${ws}\(void|\)${ws}AD\\((void|)\\);" \
"AD & operator=\\(AD const ?&\\);${ws}\(void|\)${ws}AD\\(AD const ?&\\);${ws}\(void|\)${ws}AD\\((void|)\\);" \
" ?\\*"
# An instance of A
test_one_ptype "ptype a" "ptype a" \
"class A : public virtual V \{(${ws}private:|)" \
"V \\*(_vb.1V|_vb.V);" \
"" "int a;" \
"public:" "virtual int f\\((void|)\\);" \
"A & operator=\\(A const ?&\\);${ws}\(void|\)${ws}A\\(int, A const ?&\\);${ws}\(void|\)${ws}A\\(int\\);" \
"A & operator=\\(A const ?&\\);${ws}\(void|\)${ws}A\\(A const ?&\\);${ws}\(void|\)${ws}A\\((void|)\\);" \
""
# An instance of B
test_one_ptype "ptype b" "ptype b" \
"class B : public A \{(${ws}private:|)" \
"V \\*(_vb.1V|_vb.V);" \
"" "int b;" \
"public:" "virtual int f\\((void|)\\);" \
"B & operator=\\(B const ?&\\);${ws}\(void|\)${ws}B\\(int, B const ?&\\);${ws}\(void|\)${ws}B\\(int\\);" \
"B & operator=\\(B const ?&\\);${ws}\(void|\)${ws}B\\(B const ?&\\);${ws}\(void|\)${ws}B\\((void|)\\);" \
""
# An instance of C
test_one_ptype "ptype c" "ptype c" \
"class C : public virtual V \{(${ws}private:|)" \
"V \\*(_vb.1V|_vb.V);" \
"public:" "int c;" \
"" "" \
"C & operator=\\(C const ?&\\);${ws}\(void|\)${ws}C\\(int, C const ?&\\);${ws}\(void|\)${ws}C\\(int\\);" \
"C & operator=\\(C const ?&\\);${ws}\(void|\)${ws}C\\(C const ?&\\);${ws}\(void|\)${ws}C\\((void|)\\);" \
""
# An instance of D
test_one_ptype "ptype d" "ptype d" \
"class D : public AD, public virtual V \{(${ws}private:|)" \
"V \\*(_vb.1V|_vb.V);" \
"public:" "int d;" \
"" "static void s\\((void|)\\);${ws}virtual int vg\\((void|)\\);${ws}virtual int vd\\((void|)\\);${ws}int fd\\((void|)\\);" \
"D & operator=\\(D const ?&\\);${ws}\(void|\)${ws}D\\(int, D const ?&\\);${ws}\(void|\)${ws}D\\(int\\);" \
"D & operator=\\(D const ?&\\);${ws}\(void|\)${ws}D\\(D const ?&\\);${ws}\(void|\)${ws}D\\((void|)\\);" \
""
# An instance of E
test_one_ptype "ptype e" "ptype e" \
"class E : public B, public virtual V, public D, public C \{(${ws}private:|)" \
"" \
"public:" "int e;" \
"" "virtual int f\\((void|)\\);${ws}virtual int vg\\((void|)\\);${ws}virtual int vv\\((void|)\\);" \
"E & operator=\\(E const ?&\\);${ws}\(void|\)${ws}E\\(int, E const ?&\\);${ws}\(void|\)${ws}E\\(int\\);" \
"E & operator=\\(E const ?&\\);${ws}\(void|\)${ws}E\\(E const ?&\\);${ws}\(void|\)${ws}E\\((void|)\\);" \
""
# An instance of V
test_one_ptype "ptype v" "ptype v" \
"class V : public VA, public VB \{${ws}public:" \
"" \
"" "int w;" \
"" "int f\\((void|)\\);${ws}virtual int vv\\((void|)\\);" \
"V & operator=\\(V const ?&\\);${ws}\(void|\)${ws}V\\(V const ?&\\);${ws}\(void|\)${ws}V\\((void|)\\);" \
"V & operator=\\(V const ?&\\);${ws}\(void|\)${ws}V\\(V const ?&\\);${ws}\(void|\)${ws}V\\((void|)\\);" \
""
# An instance of VB
test_one_ptype "ptype vb" "ptype vb" \
"((struct|class) VB \{${ws}public:|struct VB \{)" \
"" \
"" "int vb;" \
"" "int fvb\\((void|)\\);${ws}virtual int vvb\\((void|)\\);" \
"VB & operator=\\(VB const ?&\\);${ws}\(void|\)${ws}VB\\(VB const ?&\\);${ws}\(void|\)${ws}VB\\((void|)\\);" \
"VB & operator=\\(VB const ?&\\);${ws}\(void|\)${ws}VB\\(VB const ?&\\);${ws}\(void|\)${ws}VB\\((void|)\\);" \
""
# An instance of A *
test_one_ptype "ptype pAa" "ptype pAa" \
"class A : public virtual V \{(${ws}private:|)" \
"V \\*(_vb.1V|_vb.V);" \
"" "int a;" \
"public:" "virtual int f\\((void|)\\);" \
"A & operator=\\(A const ?&\\);${ws}\(void|\)${ws}A\\(int, A const ?&\\);${ws}\(void|\)${ws}A\\(int\\);" \
"A & operator=\\(A const ?&\\);${ws}\(void|\)${ws}A\\(A const ?&\\);${ws}\(void|\)${ws}A\\((void|)\\);" \
" ?\\*"
# An instance of A *
test_one_ptype "ptype pAe" "ptype pAe" \
"class A : public virtual V \{(${ws}private:|)" \
"V \\*(_vb.1V|_vb.V);" \
"" "int a;" \
"public:" "virtual int f\\((void|)\\);" \
"A & operator=\\(A const ?&\\);${ws}\(void|\)${ws}A\\(int, A const ?&\\);${ws}\(void|\)${ws}A\\(int\\);" \
"A & operator=\\(A const ?&\\);${ws}\(void|\)${ws}A\\(A const ?&\\);${ws}\(void|\)${ws}A\\((void|)\\);" \
" ?\\*"
# An instance of B *
test_one_ptype "ptype pBe" "ptype pBe" \
"class B : public A \{(${ws}private:|)" \
"V \\*(_vb.1V|_vb.V);" \
"" "int b;" \
"public:" "virtual int f\\((void|)\\);" \
"B & operator=\\(B const ?&\\);${ws}\(void|\)${ws}B\\(int, B const ?&\\);${ws}\(void|\)${ws}B\\(int\\);" \
"B & operator=\\(B const ?&\\);${ws}\(void|\)${ws}B\\(B const ?&\\);${ws}\(void|\)${ws}B\\((void|)\\);" \
" ?\\*"
# An instance of D *
test_one_ptype "ptype pDd" "ptype pDd" \
"class D : public AD, public virtual V \{(${ws}private:|)" \
"V \\*(_vb.1V|_vb.V);" \
"public:" "int d;" \
"" "static void s\\((void|)\\);${ws}virtual int vg\\((void|)\\);${ws}virtual int vd\\((void|)\\);${ws}int fd\\((void|)\\);" \
"D & operator=\\(D const ?&\\);${ws}\(void|\)${ws}D\\(int, D const ?&\\);${ws}\(void|\)${ws}D\\(int\\);" \
"D & operator=\\(D const ?&\\);${ws}\(void|\)${ws}D\\(D const ?&\\);${ws}\(void|\)${ws}D\\((void|)\\);" \
" ?\\*"
# An instance of D *
test_one_ptype "ptype pDe" "ptype pDe" \
"class D : public AD, public virtual V \{(${ws}private:|)" \
"V \\*(_vb.1V|_vb.V);" \
"public:" "int d;" \
"" "static void s\\((void|)\\);${ws}virtual int vg\\((void|)\\);${ws}virtual int vd\\((void|)\\);${ws}int fd\\((void|)\\);" \
"D & operator=\\(D const ?&\\);${ws}\(void|\)${ws}D\\(int, D const ?&\\);${ws}\(void|\)${ws}D\\(int\\);" \
"D & operator=\\(D const ?&\\);${ws}\(void|\)${ws}D\\(D const ?&\\);${ws}\(void|\)${ws}D\\((void|)\\);" \
" ?\\*"
# An instance of V *
test_one_ptype "ptype pVa" "ptype pVa" \
"class V : public VA, public VB \{${ws}public:" \
"" \
"" "int w;" \
"" "int f\\((void|)\\);${ws}virtual int vv\\((void|)\\);" \
"V & operator=\\(V const ?&\\);${ws}\(void|\)${ws}V\\(V const ?&\\);${ws}\(void|\)${ws}V\\((void|)\\);" \
"V & operator=\\(V const ?&\\);${ws}\(void|\)${ws}V\\(V const ?&\\);${ws}\(void|\)${ws}V\\((void|)\\);" \
" ?\\*"
# An instance of V *
test_one_ptype "ptype pVv" "ptype pVv" \
"class V : public VA, public VB \{${ws}public:" \
"" \
"" "int w;" \
"" "int f\\((void|)\\);${ws}virtual int vv\\((void|)\\);" \
"V & operator=\\(V const ?&\\);${ws}\(void|\)${ws}V\\(V const ?&\\);${ws}\(void|\)${ws}V\\((void|)\\);" \
"V & operator=\\(V const ?&\\);${ws}\(void|\)${ws}V\\(V const ?&\\);${ws}\(void|\)${ws}V\\((void|)\\);" \
" ?\\*"
# An instance of V *
test_one_ptype "ptype pVe" "ptype pVe" \
"class V : public VA, public VB \{${ws}public:" \
"" \
"" "int w;" \
"" "int f\\((void|)\\);${ws}virtual int vv\\((void|)\\);" \
"V & operator=\\(V const ?&\\);${ws}\(void|\)${ws}V\\(V const ?&\\);${ws}\(void|\)${ws}V\\((void|)\\);" \
"V & operator=\\(V const ?&\\);${ws}\(void|\)${ws}V\\(V const ?&\\);${ws}\(void|\)${ws}V\\((void|)\\);" \
" ?\\*"
# An instance of V *
test_one_ptype "ptype pVd" "ptype pVd" \
"class V : public VA, public VB \{${ws}public:" \
"" \
"" "int w;" \
"" "int f\\((void|)\\);${ws}virtual int vv\\((void|)\\);" \
"V & operator=\\(V const ?&\\);${ws}\(void|\)${ws}V\\(V const ?&\\);${ws}\(void|\)${ws}V\\((void|)\\);" \
"V & operator=\\(V const ?&\\);${ws}\(void|\)${ws}V\\(V const ?&\\);${ws}\(void|\)${ws}V\\((void|)\\);" \
" ?\\*"
# An instance of AD *
test_one_ptype "ptype pADe" "ptype pADe" \
"((struct|class) AD \{${ws}public:|struct AD \{)" \
"" \
"" "" \
"" "virtual int vg\\((void|)\\);" \
"AD & operator=\\(AD const ?&\\);${ws}\(void|\)${ws}AD\\(AD const ?&\\);${ws}\(void|\)${ws}AD\\((void|)\\);" \
"AD & operator=\\(AD const ?&\\);${ws}\(void|\)${ws}AD\\(AD const ?&\\);${ws}\(void|\)${ws}AD\\((void|)\\);" \
" ?\\*"
# An instance of E *
test_one_ptype "ptype pEe" "ptype pEe" \
"class E : public B, public virtual V, public D, public C \{(${ws}private:|)" \
"" \
"public:" "int e;" \
"" "virtual int f\\((void|)\\);${ws}virtual int vg\\((void|)\\);${ws}virtual int vv\\((void|)\\);" \
"E & operator=\\(E const ?&\\);${ws}\(void|\)${ws}E\\(int, E const ?&\\);${ws}\(void|\)${ws}E\\(int\\);" \
"E & operator=\\(E const ?&\\);${ws}\(void|\)${ws}E\\(E const ?&\\);${ws}\(void|\)${ws}E\\((void|)\\);" \
" ?\\*"
# An instance of VB *
test_one_ptype "ptype pVB" "ptype pVB" \
"((struct|class) VB \{${ws}public:|struct VB \{)" \
"" \
"" "int vb;" \
"" "int fvb\\((void|)\\);${ws}virtual int vvb\\((void|)\\);" \
"VB & operator=\\(VB const ?&\\);${ws}\(void|\)${ws}VB\\(VB const ?&\\);${ws}\(void|\)${ws}VB\\((void|)\\);" \
"VB & operator=\\(VB const ?&\\);${ws}\(void|\)${ws}VB\\(VB const ?&\\);${ws}\(void|\)${ws}VB\\((void|)\\);" \
" ?\\*"
}
# Call virtual functions.
proc test_virtual_calls {} {
global gdb_prompt
global nl
if [target_info exists gdb,cannot_call_functions] {
setup_xfail "*-*-*" 2416
fail "This target can not call functions"
return 0
}
gdb_test "print pAe->f()" "\\$\[0-9\]+ = 20"
gdb_test "print pAa->f()" "\\$\[0-9\]+ = 1"
gdb_test "print pDe->vg()" "\\$\[0-9\]+ = 202"
gdb_test "print pADe->vg()" "\\$\[0-9\]+ = 202"
gdb_test "print pDd->vg()" "\\$\[0-9\]+ = 101"
gdb_test "print pEe->vvb()" "\\$\[0-9\]+ = 411"
gdb_test "print pVB->vvb()" "\\$\[0-9\]+ = 407"
gdb_test "print pBe->vvb()" "\\$\[0-9\]+ = 411"
gdb_test "print pDe->vvb()" "\\$\[0-9\]+ = 411"
gdb_test "print pEe->vd()" "\\$\[0-9\]+ = 282"
gdb_test "print pEe->fvb()" "\\$\[0-9\]+ = 311"
# more recent results:
# wrong value "202"
# gcc 2.95.3 -gdwarf-2
# gcc 2.95.3 -gstabs+
# attempt to take addres of value not located in memory
# gcc 3.3.2 -gdwarf-2
# gcc 3.3.2 -gstabs+
#
# -- chastain 2003-12-31
gdb_test_multiple "print pEe->D::vg()" "print pEe->D::vg()" {
-re "\\$\[0-9]+ = 102$nl$gdb_prompt $" {
pass "print pEe->D::vg()"
}
-re "Attempt to take address of value not located in memory.$nl$gdb_prompt $" {
kfail "gdb/1064" "print pEe->D::vg()"
}
}
}
proc do_tests {} {
global prms_id
global bug_id
global srcdir subdir binfile
global gdb_prompt
set prms_id 0
set bug_id 0
gdb_exit
gdb_start
gdb_reinitialize_dir $srcdir/$subdir
gdb_load $binfile
gdb_test "set language c++" "" ""
gdb_test "set width 0" "" ""
runto_main
test_ptype_of_classes
gdb_breakpoint test_calls
gdb_test "continue" ".*Breakpoint .* test_calls.*" ""
test_virtual_calls
}
do_tests