2004-01-01 Michael Chastain <mec.gnu@mindspring.com>

[deliverable/binutils-gdb.git] / gdb / testsuite / gdb.cp / derivation.exp

# Copyright 1998, 1999, 2000, 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.  

# Please email any bugs, comments, and/or additions to this file to:
# bug-gdb@prep.ai.mit.edu

# This file was written by Elena Zannoni (ezannoni@cygnus.com)
# And rewritten by Michael Chastain <mec.gnu@mindspring.com>

# This file is part of the gdb testsuite

# tests for inheritance, with several derivations types combinations
# (private, public, protected) 
# classes have simple members and member functions.

set ws "\[\r\n\t \]+"
set nl "\[\r\n\]+"

if $tracelevel then {
    strace $tracelevel
}

# Start program.

set prms_id 0
set bug_id 0

if { [skip_cplus_tests] } { continue }

set testfile "derivation"
set srcfile ${testfile}.cc
set binfile ${objdir}/${subdir}/${testfile}

if  { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {debug c++}] != "" } {
     gdb_suppress_entire_file "Testcase compile failed, so all tests in this file will automatically fail."
}

gdb_exit
gdb_start
gdb_reinitialize_dir $srcdir/$subdir
gdb_load ${binfile}

# Set it up at a breakpoint so we can play with the variable values.

if ![runto 'marker1'] then {
    perror "couldn't run to marker1"
    continue
}

gdb_test "up" ".*main.*" "up from marker1"

# Print class types and values.
# See virtfunc.exp for a discussion of ptype.

# class A

set re_class		"((struct|class) A \{${ws}public:|struct A \{)"
set re_fields		"int a;${ws}int aa;"
set re_methods		"A\\((void|)\\);${ws}int afoo\\((void|)\\);${ws}int foo\\((void|)\\);"
set re_synth_gcc_23	"A & operator=\\(A const ?&\\);${ws}A\\(A const ?&\\);"
set re_all_methods	"($re_methods|$re_methods${ws}$re_synth_gcc_23|$re_synth_gcc_23${ws}$re_methods)"

gdb_test "print a_instance" "\\$\[0-9\]+ = \{a = 1, aa = 2\}" "print value of a_instance"

gdb_test_multiple "ptype a_instance" "ptype a_instance" {
    -re "type = $re_class${ws}$re_fields${ws}$re_methods$nl\}$nl$gdb_prompt $" {
	pass "ptype a_instance (no synth ops)"
    }
    -re "type = $re_class${ws}$re_fields${ws}$re_synth_gcc_23${ws}$re_methods${ws}$nl\}$nl$gdb_prompt $" {
	pass "ptype a_instance (with synth ops)"
    }
    -re "type = $re_class${ws}$re_fields${ws}$re_methods${ws}$re_synth_gcc_23$nl\}$nl$gdb_prompt $" {
	# TODO: this is fine, it's just gcc abi 2
	# pass "ptype a_instance (with synth ops) (abi 2)"
	fail "ptype a_instance"
    }
}

# class D

set re_class		"class D : private A, public B, protected C \{${ws}public:"
set XX_class		"class D : private A, public B, private C \{${ws}public:"
set re_fields		"int d;${ws}int dd;"
set re_methods		"D\\((void|)\\);${ws}int dfoo\\((void|)\\);${ws}int foo\\((void|)\\);"
set re_synth_gcc_23	"D & operator=\\(D const ?&\\);${ws}D\\(D const ?&\\);"
set re_all_methods	"($re_methods|$re_methods${ws}$re_synth_gcc_23|$re_synth_gcc_23${ws}$re_methods)"

gdb_test_multiple "print d_instance" "print value of d_instance" {
    -re "\\$\[0-9\]+ = \{<(class A|A)> = \{a = 1, aa = 2\}, <(class B|B)> = \{b = 3, bb = 4\}, <(class C|C)> = \{c = 5, cc = 6\}, d = 7, dd = 8\}$nl$gdb_prompt $" {
	pass "print value of d_instance"
    }
}

gdb_test_multiple "ptype d_instance" "ptype d_instance" {
    -re "type = $re_class${ws}$re_fields${ws}$re_methods${ws}$re_synth_gcc_23$nl\}$nl$gdb_prompt $" {
	# TODO: this is okay, gcc abi 2.
	fail "ptype d_instance"
    }
    -re "type = $re_class${ws}$re_fields${ws}$re_all_methods$nl\}$nl$gdb_prompt $" {
	pass "ptype d_instance"
    }
    -re "type = $XX_class${ws}$re_fields${ws}$re_methods${ws}$re_synth_gcc_23$nl\}$nl$gdb_prompt $" {
	# TODO: this is okay, gcc abi 2.
	# kfail "gdb/1498" "ptype d_instance"
	fail "ptype d_instance"
    }
    -re "type = $XX_class${ws}$re_fields${ws}$re_all_methods$nl\}$nl$gdb_prompt $" {
	# TODO: this is a gcc bug.
	# kfail "gdb/1498" "ptype d_instance"
	pass "ptype d_instance"
    }
}

# class E

set re_class		"class E : public A, private B, protected C \{${ws}public:"
set XX_class		"class E : public A, private B, private C \{${ws}public:"
set re_fields		"int e;${ws}int ee;"
set re_methods		"E\\((void|)\\);${ws}int efoo\\((void|)\\);${ws}int foo\\((void|)\\);"
set re_synth_gcc_23	"E & operator=\\(E const ?&\\);${ws}E\\(E const ?&\\);"
set re_all_methods	"($re_methods|$re_methods${ws}$re_synth_gcc_23|$re_synth_gcc_23${ws}$re_methods)"

gdb_test_multiple "print e_instance" "print value of e_instance" {
    -re "\\$\[0-9\]+ = \{<(class A|A)> = \{a = 1, aa = 2\}, <(class B|B)> = \{b = 3, bb = 4\}, <(class C|C)> = \{c = 5, cc = 6\}, e = 9, ee = 10\}$nl$gdb_prompt $" {
	pass "print value of e_instance"
    }
}

gdb_test_multiple "ptype e_instance" "ptype e_instance" {
    -re "type = $re_class${ws}$re_fields${ws}$re_methods${ws}$re_synth_gcc_23$nl\}$nl$gdb_prompt $" {
	# TODO: this is okay, just gcc abi 2
	fail "ptype e_instance"
    }
    -re "type = $re_class${ws}$re_fields${ws}$re_all_methods$nl\}$nl$gdb_prompt $" {
	pass "ptype e_instance"
    }
    -re "type = $XX_class${ws}$re_fields${ws}$re_methods${ws}$re_synth_gcc_23$nl\}$nl$gdb_prompt $" {
	# TODO: this is okay, just gcc abi 2
	# TODO: this is a gcc bug.
	# kfail "gdb/1498" "ptype e_instance"
	fail "ptype e_instance"
    }
    -re "type = $XX_class${ws}$re_fields${ws}$re_all_methods$nl\}$nl$gdb_prompt $" {
	# TODO: this is a gcc bug.
	# kfail "gdb/1498" "ptype e_instance"
	pass "ptype e_instance"
    }
}

# class F

set re_class		"class F : private A, public B, private C \{${ws}public:"
set re_fields		"int f;${ws}int ff;"
set re_methods		"F\\((void|)\\);${ws}int ffoo\\((void|)\\);${ws}int foo\\((void|)\\);"
set re_synth_gcc_23	"F & operator=\\(F const ?&\\);${ws}F\\(F const ?&\\);"
set re_all_methods	"($re_methods|$re_methods${ws}$re_synth_gcc_23|$re_synth_gcc_23${ws}$re_methods)"

gdb_test_multiple "print f_instance" "print value of f_instance" {
    -re "\\$\[0-9\]+ = \{<(class A|A)> = \{a = 1, aa = 2\}, <(class B|B)> = \{b = 3, bb = 4\}, <(class C|C)> = \{c = 5, cc = 6\}, f = 11, ff = 12\}$nl$gdb_prompt $" {
	pass "print value of f_instance"
    }
}

gdb_test_multiple "ptype f_instance" "ptype f_instance" {
    -re "type = $re_class${ws}$re_fields${ws}$re_methods${ws}$re_synth_gcc_23$nl\}$nl$gdb_prompt $" {
	# TODO: this is okay, just gcc abi 2
	fail "ptype f_instance"
    }
    -re "type = $re_class${ws}$re_fields${ws}$re_all_methods$nl\}$nl$gdb_prompt $" {
	pass "ptype f_instance"
    }
}

# Print individual fields.

gdb_test "print d_instance.a"  "\\$\[0-9\]+ = 1" "print value of d_instance.a"
gdb_test "print d_instance.aa" "\\$\[0-9\]+ = 2" "print value of d_instance.aa"
gdb_test "print d_instance.b"  "\\$\[0-9\]+ = 3" "print value of d_instance.b"
gdb_test "print d_instance.bb" "\\$\[0-9\]+ = 4" "print value of d_instance.bb"
gdb_test "print d_instance.c"  "\\$\[0-9\]+ = 5" "print value of d_instance.c"
gdb_test "print d_instance.cc" "\\$\[0-9\]+ = 6" "print value of d_instance.cc"
gdb_test "print d_instance.d"  "\\$\[0-9\]+ = 7" "print value of d_instance.d"
gdb_test "print d_instance.dd" "\\$\[0-9\]+ = 8" "print value of d_instance.dd"

# Print some fields which are defined in the top of class G
# and in its base classes.  This is not be ambiguous.

gdb_test "print g_instance.a"  "\\$\[0-9\]+ = 15" "print value of g_instance.a"
gdb_test "print g_instance.b"  "\\$\[0-9\]+ = 16" "print value of g_instance.b"
gdb_test "print g_instance.c"  "\\$\[0-9\]+ = 17" "print value of g_instance.c"

# Print a function call.

gdb_test "print g_instance.afoo()" "\\$\[0-9\]+ = 1" "print value of g_instance.afoo()"

# If GDB fails to restore the selected frame properly after the
# inferior function call above (see GDB PR 1155 for an explanation of
# why this might happen), all the subsequent tests will fail.  We
# should detect report that failure, but let the marker call finish so
# that the rest of the tests can run undisturbed.

gdb_test_multiple "frame" "re-selected 'main' frame after inferior call" {
    -re "#0  marker1.*$gdb_prompt $" {
        setup_kfail "gdb/1155" s390-*-linux-gnu
        fail "re-selected 'main' frame after inferior call"
        gdb_test "finish" ".*main.*at .*derivation.cc:.*// marker1-returns-here.*" \
            "finish call to marker1"
    }
    -re "#1  ($hex in )?main.*$gdb_prompt $" {
        pass "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()"