gdb/testsuite/gdb.cp/virtfunc.exp

# 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}VA\\(VA const ?&\\);${ws}VA\\((void|)\\);" \
	"VA & operator=\\(VA const ?&\\);${ws}VA\\(VA const ?&\\);${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}VB\\(VB const ?&\\);${ws}VB\\((void|)\\);" \
	"VB & operator=\\(VB const ?&\\);${ws}VB\\(VB const ?&\\);${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}V\\(V const ?&\\);${ws}V\\((void|)\\);" \
	"V & operator=\\(V const ?&\\);${ws}V\\(V const ?&\\);${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}A\\(int, A const ?&\\);${ws}A\\(int\\);" \
	"A & operator=\\(A const ?&\\);${ws}A\\(A const ?&\\);${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}B\\(int, B const ?&\\);${ws}B\\(int\\);" \
	"B & operator=\\(B const ?&\\);${ws}B\\(B const ?&\\);${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}C\\(int, C const ?&\\);${ws}C\\(int\\);" \
	"C & operator=\\(C const ?&\\);${ws}C\\(C const ?&\\);${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}AD\\(AD const ?&\\);${ws}AD\\((void|)\\);" \
	"AD & operator=\\(AD const ?&\\);${ws}AD\\(AD const ?&\\);${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}D\\(int, D const ?&\\);${ws}D\\(int\\);" \
	"D & operator=\\(D const ?&\\);${ws}D\\(D const ?&\\);${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}E\\(int, E const ?&\\);${ws}E\\(int\\);" \
	"E & operator=\\(E const ?&\\);${ws}E\\(E const ?&\\);${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}D\\(int, D const ?&\\);${ws}D\\(int\\);" \
	"D & operator=\\(D const ?&\\);${ws}D\\(D const ?&\\);${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}D\\(int, D const ?&\\);${ws}D\\(int\\);" \
	"D & operator=\\(D const ?&\\);${ws}D\\(D const ?&\\);${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}AD\\(AD const ?&\\);${ws}AD\\((void|)\\);" \
	"AD & operator=\\(AD const ?&\\);${ws}AD\\(AD const ?&\\);${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}A\\(int, A const ?&\\);${ws}A\\(int\\);" \
	"A & operator=\\(A const ?&\\);${ws}A\\(A const ?&\\);${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}B\\(int, B const ?&\\);${ws}B\\(int\\);" \
	"B & operator=\\(B const ?&\\);${ws}B\\(B const ?&\\);${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}C\\(int, C const ?&\\);${ws}C\\(int\\);" \
	"C & operator=\\(C const ?&\\);${ws}C\\(C const ?&\\);${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}D\\(int, D const ?&\\);${ws}D\\(int\\);" \
	"D & operator=\\(D const ?&\\);${ws}D\\(D const ?&\\);${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}E\\(int, E const ?&\\);${ws}E\\(int\\);" \
	"E & operator=\\(E const ?&\\);${ws}E\\(E const ?&\\);${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}V\\(V const ?&\\);${ws}V\\((void|)\\);" \
	"V & operator=\\(V const ?&\\);${ws}V\\(V const ?&\\);${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}VB\\(VB const ?&\\);${ws}VB\\((void|)\\);" \
	"VB & operator=\\(VB const ?&\\);${ws}VB\\(VB const ?&\\);${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}A\\(int, A const ?&\\);${ws}A\\(int\\);" \
	"A & operator=\\(A const ?&\\);${ws}A\\(A const ?&\\);${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}A\\(int, A const ?&\\);${ws}A\\(int\\);" \
	"A & operator=\\(A const ?&\\);${ws}A\\(A const ?&\\);${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}B\\(int, B const ?&\\);${ws}B\\(int\\);" \
	"B & operator=\\(B const ?&\\);${ws}B\\(B const ?&\\);${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}D\\(int, D const ?&\\);${ws}D\\(int\\);" \
	"D & operator=\\(D const ?&\\);${ws}D\\(D const ?&\\);${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}D\\(int, D const ?&\\);${ws}D\\(int\\);" \
	"D & operator=\\(D const ?&\\);${ws}D\\(D const ?&\\);${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}V\\(V const ?&\\);${ws}V\\((void|)\\);" \
	"V & operator=\\(V const ?&\\);${ws}V\\(V const ?&\\);${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}V\\(V const ?&\\);${ws}V\\((void|)\\);" \
	"V & operator=\\(V const ?&\\);${ws}V\\(V const ?&\\);${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}V\\(V const ?&\\);${ws}V\\((void|)\\);" \
	"V & operator=\\(V const ?&\\);${ws}V\\(V const ?&\\);${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}V\\(V const ?&\\);${ws}V\\((void|)\\);" \
	"V & operator=\\(V const ?&\\);${ws}V\\(V const ?&\\);${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}AD\\(AD const ?&\\);${ws}AD\\((void|)\\);" \
	"AD & operator=\\(AD const ?&\\);${ws}AD\\(AD const ?&\\);${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}E\\(int, E const ?&\\);${ws}E\\(int\\);" \
	"E & operator=\\(E const ?&\\);${ws}E\\(E const ?&\\);${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}VB\\(VB const ?&\\);${ws}VB\\((void|)\\);" \
	"VB & operator=\\(VB const ?&\\);${ws}VB\\(VB const ?&\\);${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