From d55ea55c195aab3e86dbc401c123ed42167e6a6c Mon Sep 17 00:00:00 2001 From: David Taylor Date: Mon, 11 Jan 1999 05:36:48 +0000 Subject: [PATCH] new files -- part of HP merge. --- gdb/testsuite/gdb.hp/ambiguous.cc | 110 ++++ gdb/testsuite/gdb.hp/ambiguous.exp | 216 +++++++ gdb/testsuite/gdb.hp/attach.exp | 416 ++++++++++++++ gdb/testsuite/gdb.hp/attach2.exp | 263 +++++++++ gdb/testsuite/gdb.hp/classes-hp.exp | 859 ++++++++++++++++++++++++++++ gdb/testsuite/gdb.hp/ctti-add.cc | 29 + gdb/testsuite/gdb.hp/ctti-add1.cc | 16 + gdb/testsuite/gdb.hp/ctti-add2.cc | 22 + gdb/testsuite/gdb.hp/ctti-add3.cc | 33 ++ gdb/testsuite/gdb.hp/ctti.exp | 269 +++++++++ gdb/testsuite/gdb.hp/dbx.exp | 217 +++++++ gdb/testsuite/gdb.hp/exception.cc | 48 ++ gdb/testsuite/gdb.hp/exception.exp | 408 +++++++++++++ gdb/testsuite/gdb.hp/foll-exec.c | 35 ++ gdb/testsuite/gdb.hp/foll-exec.exp | 412 +++++++++++++ gdb/testsuite/gdb.hp/foll-fork,c | 25 + gdb/testsuite/gdb.hp/foll-fork.exp | 385 +++++++++++++ gdb/testsuite/gdb.hp/foll-vfork.c | 15 + gdb/testsuite/gdb.hp/foll-vfork.exp | 381 ++++++++++++ gdb/testsuite/gdb.hp/inherit-hp.exp | 849 +++++++++++++++++++++++++++ gdb/testsuite/gdb.hp/more-steps.exp | 152 +++++ gdb/testsuite/gdb.hp/namespace.cc | 103 ++++ gdb/testsuite/gdb.hp/namespace.exp | 195 +++++++ gdb/testsuite/gdb.hp/optimize.exp | 144 +++++ gdb/testsuite/gdb.hp/pxdb.c | 20 + gdb/testsuite/gdb.hp/pxdb.exp | 114 ++++ gdb/testsuite/gdb.hp/quicksort.exp | 809 ++++++++++++++++++++++++++ gdb/testsuite/gdb.hp/reg-test.exp | 190 ++++++ gdb/testsuite/gdb.hp/reg-test.s | 96 ++++ gdb/testsuite/gdb.hp/sized-enum.c | 43 ++ gdb/testsuite/gdb.hp/sized-enum.exp | 162 ++++++ gdb/testsuite/gdb.hp/start-stop.exp | 360 ++++++++++++ gdb/testsuite/gdb.hp/templ-hp.cc | 785 +++++++++++++++++++++++++ gdb/testsuite/gdb.hp/templ-hp.exp | 381 ++++++++++++ gdb/testsuite/gdb.hp/thr-lib.c | 79 +++ gdb/testsuite/gdb.hp/thr-lib.exp | 234 ++++++++ gdb/testsuite/gdb.hp/thr-lib.h | 7 + gdb/testsuite/gdb.hp/thr-liblib.c | 92 +++ gdb/testsuite/gdb.hp/thr-stg.exp | 255 +++++++++ gdb/testsuite/gdb.hp/watch-cmd.exp | 146 +++++ gdb/testsuite/gdb.hp/watch-hp.c | 166 ++++++ gdb/testsuite/gdb.hp/watch-hp.exp | 779 +++++++++++++++++++++++++ gdb/testsuite/gdb.hp/xdb1.exp | 71 +++ gdb/testsuite/gdb.hp/xdb2.exp | 97 ++++ gdb/testsuite/gdb.hp/xdb3.exp | 301 ++++++++++ 45 files changed, 10789 insertions(+) create mode 100644 gdb/testsuite/gdb.hp/ambiguous.cc create mode 100644 gdb/testsuite/gdb.hp/ambiguous.exp create mode 100644 gdb/testsuite/gdb.hp/attach.exp create mode 100644 gdb/testsuite/gdb.hp/attach2.exp create mode 100644 gdb/testsuite/gdb.hp/classes-hp.exp create mode 100644 gdb/testsuite/gdb.hp/ctti-add.cc create mode 100644 gdb/testsuite/gdb.hp/ctti-add1.cc create mode 100644 gdb/testsuite/gdb.hp/ctti-add2.cc create mode 100644 gdb/testsuite/gdb.hp/ctti-add3.cc create mode 100644 gdb/testsuite/gdb.hp/ctti.exp create mode 100644 gdb/testsuite/gdb.hp/dbx.exp create mode 100644 gdb/testsuite/gdb.hp/exception.cc create mode 100644 gdb/testsuite/gdb.hp/exception.exp create mode 100644 gdb/testsuite/gdb.hp/foll-exec.c create mode 100644 gdb/testsuite/gdb.hp/foll-exec.exp create mode 100644 gdb/testsuite/gdb.hp/foll-fork,c create mode 100644 gdb/testsuite/gdb.hp/foll-fork.exp create mode 100644 gdb/testsuite/gdb.hp/foll-vfork.c create mode 100644 gdb/testsuite/gdb.hp/foll-vfork.exp create mode 100644 gdb/testsuite/gdb.hp/inherit-hp.exp create mode 100644 gdb/testsuite/gdb.hp/more-steps.exp create mode 100644 gdb/testsuite/gdb.hp/namespace.cc create mode 100644 gdb/testsuite/gdb.hp/namespace.exp create mode 100644 gdb/testsuite/gdb.hp/optimize.exp create mode 100644 gdb/testsuite/gdb.hp/pxdb.c create mode 100644 gdb/testsuite/gdb.hp/pxdb.exp create mode 100644 gdb/testsuite/gdb.hp/quicksort.exp create mode 100644 gdb/testsuite/gdb.hp/reg-test.exp create mode 100644 gdb/testsuite/gdb.hp/reg-test.s create mode 100644 gdb/testsuite/gdb.hp/sized-enum.c create mode 100644 gdb/testsuite/gdb.hp/sized-enum.exp create mode 100644 gdb/testsuite/gdb.hp/start-stop.exp create mode 100644 gdb/testsuite/gdb.hp/templ-hp.cc create mode 100644 gdb/testsuite/gdb.hp/templ-hp.exp create mode 100644 gdb/testsuite/gdb.hp/thr-lib.c create mode 100644 gdb/testsuite/gdb.hp/thr-lib.exp create mode 100644 gdb/testsuite/gdb.hp/thr-lib.h create mode 100644 gdb/testsuite/gdb.hp/thr-liblib.c create mode 100644 gdb/testsuite/gdb.hp/thr-stg.exp create mode 100644 gdb/testsuite/gdb.hp/watch-cmd.exp create mode 100644 gdb/testsuite/gdb.hp/watch-hp.c create mode 100644 gdb/testsuite/gdb.hp/watch-hp.exp create mode 100644 gdb/testsuite/gdb.hp/xdb1.exp create mode 100644 gdb/testsuite/gdb.hp/xdb2.exp create mode 100644 gdb/testsuite/gdb.hp/xdb3.exp diff --git a/gdb/testsuite/gdb.hp/ambiguous.cc b/gdb/testsuite/gdb.hp/ambiguous.cc new file mode 100644 index 00000000000..6ee7bc18ea9 --- /dev/null +++ b/gdb/testsuite/gdb.hp/ambiguous.cc @@ -0,0 +1,110 @@ + +void marker1() +{ + return; +} + +class A1 { +public: + int x; + int y; +}; + +class A2 { +public: + int x; + int y; +}; + +class A3 { +public: + int x; + int y; +}; + +class X : public A1, public A2 { +public: + int z; +}; + +class L : public A1 { +public: + int z; +}; + +class LV : public virtual A1 { +public: + int z; +}; + +class M : public A2 { +public: + int w; +}; + +class N : public L, public M { +public: + int r; +}; + +class K : public A1 { +public: + int i; +}; + +class KV : public virtual A1 { +public: + int i; +}; + +class J : public K, public L { +public: + int j; +}; + +class JV : public KV, public LV { +public: + int jv; +}; + +class JVA1 : public KV, public LV, public A1 { +public: + int jva1; +}; + +class JVA2 : public KV, public LV, public A2 { +public: + int jva2; +}; + +class JVA1V : public KV, public LV, public virtual A1 { +public: + int jva1v; +}; + +int main() +{ + A1 a1; + A2 a2; + A3 a3; + X x; + L l; + M m; + N n; + K k; + J j; + JV jv; + JVA1 jva1; + JVA2 jva2; + JVA1V jva1v; + + int i; + + i += k.i + m.w + a1.x + a2.x + a3.x + x.z + l.z + n.r + j.j; + + marker1(); + +} + + + diff --git a/gdb/testsuite/gdb.hp/ambiguous.exp b/gdb/testsuite/gdb.hp/ambiguous.exp new file mode 100644 index 00000000000..5b87af36d79 --- /dev/null +++ b/gdb/testsuite/gdb.hp/ambiguous.exp @@ -0,0 +1,216 @@ +# Copyright (C) 1998 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 is part of the gdb testsuite + +# tests relating to ambiguous class members +# Written by Satish Pai 1997-07-28 + +# This file is part of the gdb testsuite + +if $tracelevel then { + strace $tracelevel + } + +# +# test running programs +# + +set prms_id 0 +set bug_id 0 + +set testfile "ambiguous" +set srcfile ${testfile}.cc +set binfile ${objdir}/${subdir}/${testfile} + +if [get_compiler_info ${binfile} "c++"] { + return -1; +} + + +if {[skip_hp_tests $gcc_compiled]} then { continue } + +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_main] then { + perror "couldn't run to breakpoint" + continue +} + +send_gdb "break marker1\n" ; gdb_expect -re ".*$gdb_prompt $" + send_gdb "cont\n" + gdb_expect { + -re "Break.* marker1 \\(\\) at .*:$decimal.*$gdb_prompt $" { + send_gdb "up\n" + gdb_expect { + -re ".*$gdb_prompt $" { pass "up from marker1" } + timeout { fail "up from marker1" } + } + } + -re "$gdb_prompt $" { fail "continue to marker1" } + timeout { fail "(timeout) continue to marker1" } + } + +# print out various class objects' members. The values aren't +# important, just check that the warning is emitted at the +# right times. + +# X is derived from A1 and A2; both A1 and A2 have a member 'x' +send_gdb "print x.x\n" +gdb_expect { + -re "warning: x ambiguous; using X::A1::x. Use a cast to disambiguate.\r\n\\$\[0-9\]* = 0\r\n$gdb_prompt $" { + pass "print x.x" + } + -re ".*$gdb_prompt $" { fail "print x.x" } + timeout { fail "(timeout) print x.x" } +} + + +# N is derived from A1 and A2, but not immediately -- two steps +# up in the hierarchy. Both A1 and A2 have a member 'x'. +send_gdb "print n.x\n" +gdb_expect { + -re "warning: x ambiguous; using N::L::A1::x. Use a cast to disambiguate.\r\n\\$\[0-9\]* = 0\r\n$gdb_prompt $" { + pass "print n.x" + } + -re ".*$gdb_prompt $" { fail "print n.x" } + timeout { fail "(timeout) print n.x" } +} + +# J is derived from A1 twice. A1 has a member x. +send_gdb "print j.x\n" +gdb_expect { + -re "warning: x ambiguous; using J::K::A1::x. Use a cast to disambiguate.\r\n\\$\[0-9\]* = 0\r\n$gdb_prompt $" { + pass "print j.x" + } + -re ".*$gdb_prompt $" { fail "print j.x" } + timeout { fail "(timeout) print j.x" } +} + +# JV is derived from A1 but A1 is a virtual base. Should not +# report an ambiguity in this case. +send_gdb "print jv.x\n" +gdb_expect { + -re "warning: x ambiguous.*Use a cast to disambiguate.\r\n\\$\[0-9\]* = 0\r\n$gdb_prompt $" { + fail "print jv.x (ambiguity reported)" + } + -re "\\$\[0-9\]* = 0\r\n$gdb_prompt $" { pass "print jv.x" } + -re ".*$gdb_prompt $" { fail "print jv.x (??)" } + timeout { fail "(timeout) print jv.x" } +} + +# JVA1 is derived from A1; A1 occurs as a virtual base in two +# ancestors, and as a non-virtual immediate base. Ambiguity must +# be reported. +send_gdb "print jva1.x\n" +gdb_expect { + -re "warning: x ambiguous; using JVA1::KV::A1::x. Use a cast to disambiguate.\r\n\\$\[0-9\]* = 0\r\n$gdb_prompt $" { + pass "print jva1.x" + } + -re ".*$gdb_prompt $" { fail "print jva1.x" } + timeout { fail "(timeout) print jva1.x" } +} + +# JVA2 is derived from A1 & A2; A1 occurs as a virtual base in two +# ancestors, and A2 is a non-virtual immediate base. Ambiguity must +# be reported as A1 and A2 both have a member 'x'. +send_gdb "print jva2.x\n" +gdb_expect { + -re "warning: x ambiguous; using JVA2::KV::A1::x. Use a cast to disambiguate.\r\n\\$\[0-9\]* = 0\r\n$gdb_prompt $" { + pass "print jva2.x" + } + -re ".*$gdb_prompt $" { fail "print jva2.x" } + timeout { fail "(timeout) print jva2.x" } +} + +# JVA1V is derived from A1; A1 occurs as a virtual base in two +# ancestors, and also as a virtual immediate base. Ambiguity must +# not be reported. +send_gdb "print jva1v.x\n" +gdb_expect { + -re "warning: x ambiguous.*Use a cast to disambiguate.\r\n\\$\[0-9\]* = 0\r\n$gdb_prompt $" { + fail "print jva1v.x (ambiguity reported)" + } + -re "\\$\[0-9\]* = 0\r\n$gdb_prompt $" { pass "print jva1v.x" } + -re ".*$gdb_prompt $" { fail "print jva1v.x (??)" } + timeout { fail "(timeout) print jva1v.x" } +} + +# Now check for ambiguous bases. + +# J is derived from A1 twice; report ambiguity if a J is +# cast to an A1. +send_gdb "print (A1)j\n" +gdb_expect { + -re "warning: A1 ambiguous; using J::K::A1. Use a cast to disambiguate.\r\n\\$\[0-9\]* = \{x = 0, y = 0\}\r\n$gdb_prompt $" { + pass "print (A1)j" + } + -re ".*$gdb_prompt $" { fail "print (A1)j" } + timeout { fail "(timeout) print (A1)j" } +} + +# JV is derived from A1 twice, but A1 is a virtual base; should +# not report ambiguity when a JV is cast to an A1. +send_gdb "print (A1)jv\n" +gdb_expect { + -re "warning: A1 ambiguous.*Use a cast to disambiguate.\r\n\\$\[0-9\]* = \{x = 0, y = 0\}\r\n$gdb_prompt $" { + fail "print (A1)jv (ambiguity reported)" + } + -re "\\$\[0-9\]* = \{x = 0, y = 0\}\r\n$gdb_prompt $" { pass "print (A1)jv" } + -re ".*$gdb_prompt $" { fail "print (A1)jv (??)" } + timeout { fail "(timeout) print (A1)jv" } +} + +# JVA1 is derived from A1; A1 is a virtual base and also a +# non-virtual base. Must report ambiguity if a JVA1 is cast to an A1. +send_gdb "print (A1)jva1\n" +gdb_expect { + -re "warning: A1 ambiguous; using JVA1::KV::A1. Use a cast to disambiguate.\r\n\\$\[0-9\]* = \{x = 0, y = 0\}\r\n$gdb_prompt $" { + pass "print (A1)jva1" + } + -re ".*$gdb_prompt $" { fail "print (A1)jva1" } + timeout { fail "(timeout) print (A1)jva1" } +} + +# JVA1V is derived from A1; A1 is a virtual base indirectly +# and also directly; must not report ambiguity when a JVA1V is cast to an A1. +send_gdb "print (A1)jva1v\n" +gdb_expect { + -re "warning: A1 ambiguous.*Use a cast to disambiguate.\r\n\\$\[0-9\]* = \{x = 0, y = 0\}\r\n$gdb_prompt $" { + fail "print (A1)jva1v (ambiguity reported)" + } + -re "\\$\[0-9\]* = \{x = 0, y = 0\}\r\n$gdb_prompt $" { pass "print (A1)jva1v" + } + -re ".*$gdb_prompt $" { fail "print (A1)jva1v (??)" } + timeout { fail "(timeout) print (A1)jva1v" } +} + + diff --git a/gdb/testsuite/gdb.hp/attach.exp b/gdb/testsuite/gdb.hp/attach.exp new file mode 100644 index 00000000000..372acd05d7e --- /dev/null +++ b/gdb/testsuite/gdb.hp/attach.exp @@ -0,0 +1,416 @@ +# Copyright (C) 1997 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 + +# On HP-UX 11.0, this test is causing a process running +# the program "attach" to be left around spinning. +# Until we figure out why, I am commenting out the test +# to avoid polluting tiamat (our 11.0 nightly test machine) +# with these processes. RT +# +# Setting the magic bit in the target app should work. +# I added a "kill", and also a test for the R3 register +# warning. JB +# +if $tracelevel then { + strace $tracelevel + } + +set prms_id 0 +set bug_id 0 + + +# are we on a target board +if ![isnative] then { + return +} + +if { ![istarget "hppa*-*-hpux10.30"] && ![istarget "hppa*-*-hpux11.*"] } { + #setup_xfail "*-*-*" + return 0 +} + +set testfile "attach" +set srcfile ${testfile}.c +set srcfile2 ${testfile}2.c +set binfile ${objdir}/${subdir}/${testfile} +set binfile2 ${objdir}/${subdir}/${testfile}2 +set cleanupfile ${objdir}/${subdir}/${testfile}.awk + +#execute_anywhere "rm -f ${binfile} ${binfile2}" +remote_exec build "rm -f ${binfile} ${binfile2}" +# For debugging this test +# +#log_user 1 + +# Clean out any old files from past runs. +# +remote_exec build "${cleanupfile}" + +# build the first test case +# +if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {debug}] != "" } { + gdb_suppress_entire_file "Testcase compile failed, so all tests in this file will automatically fail." +} + +# Build the in-system-call test + +if { [gdb_compile "${srcdir}/${subdir}/${srcfile2}" "${binfile2}" executable {debug}] != "" } { + gdb_suppress_entire_file "Testcase compile failed, so all tests in this file will automatically fail." +} + +#if { [compile "-E ${srcdir}/${subdir}/compiler.c >> ${objdir}/${subdir}/${testfile}.tmp"] != ""# } { +# perror "Couldn't make ${testfile}.tmp" +# return -1 +#} + +#execute_anywhere "mv ${objdir}/${subdir}/${testfile}.tmp ${binfile}.ci" + +#source ${binfile}.ci + +proc do_attach_tests {} { + global gdb_prompt + global binfile + global srcfile + global testfile + global objdir + global subdir + global timeout + + # Start the program running and then wait for a bit, to be sure + # that it can be attached to. + # + set testpid [eval exec $binfile &] + exec sleep 2 + + # Verify that we cannot attach to nonsense. + # + send_gdb "attach abc\n" + gdb_expect { + -re "Illegal process-id: abc.*$gdb_prompt $"\ + {pass "attach to nonsense is prohibited"} + -re "Attaching to.*$gdb_prompt $"\ + {fail "attach to nonsense is prohibited (bogus pid allowed)"} + -re "$gdb_prompt $" {fail "attach to nonsense is prohibited"} + timeout {fail "(timeout) attach to nonsense is prohibited"} + } + + # Verify that we cannot attach to what appears to be a valid + # process ID, but is a process that doesn't exist. (I don't + # believe any process is ever assigned #0, at least on HPUX.) + # + send_gdb "attach 0\n" + gdb_expect { + # This reponse is expected on HP-UX 10.20 (i.e., ptrace-based). + -re "Attaching to.*, process 0.*No such process.*$gdb_prompt $"\ + {pass "attach to nonexistent process is prohibited"} + # This response is expected on HP-UX 10.30 & 11.0 (i.e., ttrace-based). + -re "Attaching to.*, process 0.*Permission denied.*$gdb_prompt $"\ + {pass "attach to nonexistent process is prohibited"} + -re "$gdb_prompt $" {fail "attach to nonexistent process is prohibited"} + timeout {fail "(timeout) attach to nonexistent process is prohibited"} + } + + # Verify that we can attach to the process by first giving its + # executable name via the file command, and using attach with + # the process ID. + # + # (Actually, the test system appears to do this automatically + # for us. So, we must also be prepared to be asked if we want + # to discard an existing set of symbols.) + # + send_gdb "file $binfile\n" + gdb_expect { + -re "Load new symbol table from.*y or n.*$" { + send_gdb "y\n" + gdb_expect { + -re "Reading symbols from $binfile\.\.\.*done.*$gdb_prompt $"\ + {pass "(re)set file, before attach1"} + -re "$gdb_prompt $" {fail "(re)set file, before attach1"} + timeout {fail "(timeout) (re)set file, before attach1"} + } + } + -re "Reading symbols from $binfile\.\.\.*done.*$gdb_prompt $"\ + {pass "set file, before attach1"} + -re "$gdb_prompt $" {fail "set file, before attach1"} + timeout {fail "(timeout) set file, before attach1"} + } + + send_gdb "attach $testpid\n" + gdb_expect { + -re "Attaching to program.*$binfile, process $testpid.*main.*at .*$srcfile:.*$gdb_prompt $"\ + {pass "attach1, after setting file"} + -re "$gdb_prompt $" {fail "attach1, after setting file"} + timeout {fail "(timeout) attach1, after setting file"} + } + + # Verify that we can "see" the variable "should_exit" in the + # program, and that it is zero. + # + send_gdb "print should_exit\n" + gdb_expect { + -re ".* = 0.*$gdb_prompt $"\ + {pass "after attach1, print should_exit"} + -re "$gdb_prompt $" {fail "after attach1, print should_exit"} + timeout {fail "(timeout) after attach1, print should_exit"} + } + + # Detach the process. + # + send_gdb "detach\n" + gdb_expect { + -re "Detaching from program: .*$binfile.*$gdb_prompt $"\ + {pass "attach1 detach"} + -re "$gdb_prompt $" {fail "attach1 detach"} + timeout {fail "(timeout) attach1 detach"} + } + + # Wait a bit for gdb to finish detaching + # + exec sleep 5 + + # Purge the symbols from gdb's brain. (We want to be certain + # the next attach, which won't be preceded by a "file" command, + # is really getting the executable file without our help.) + # + set old_timeout $timeout + set timeout [expr $timeout + 20] + send_gdb "file\n" + gdb_expect { + -re ".*gdb internal error.*$" { + fail "Internal error, prob. Memory corruption" + } + -re "No exec file now.*Discard symbol table.*y or n.*$" { + send_gdb "y\n" + gdb_expect { + -re "No symbol file now.*$gdb_prompt $"\ + {pass "attach1, purging symbols after detach"} + -re "$gdb_prompt $" {fail "attach1, purging symbols after detach"} + timeout {fail "(timeout) attach1, purging symbols after detach"} + } + } + -re "$gdb_prompt $" {fail "attach1, purging file after detach"} + timeout { + fail "(timeout) attach1, purging file after detach" + } + } + set timeout $old_timeout + + # Verify that we can attach to the process just by giving the + # process ID. + # + send_gdb "attach $testpid\n" + gdb_expect { + -re "Attaching to process $testpid.*Reading symbols from $binfile.*main.*at .*$gdb_prompt $"\ + {pass "attach2"} + -re "$gdb_prompt $" {fail "attach2"} + timeout {fail "(timeout) attach2"} + } + + # Verify that we can modify the variable "should_exit" in the + # program. + # + send_gdb "set should_exit=1\n" + gdb_expect { + -re "$gdb_prompt $" {pass "after attach2, set should_exit"} + timeout {fail "(timeout) after attach2, set should_exit"} + } + + # Verify that the modification really happened. + # + send_gdb "tbreak 19\n" + gdb_expect { + -re "Breakpoint .*at.*$srcfile, line 19.*$gdb_prompt $"\ + {pass "after attach2, set tbreak postloop"} + -re "$gdb_prompt $" {fail "after attach2, set tbreak postloop"} + timeout {fail "(timeout) after attach2, set tbreak postloop"} + } + send_gdb "continue\n" + gdb_expect { + -re "main.*at.*$srcfile:19.*$gdb_prompt $"\ + {pass "after attach2, reach tbreak postloop"} + -re "$gdb_prompt $" {fail "after attach2, reach tbreak postloop"} + timeout {fail "(timeout) after attach2, reach tbreak postloop"} + } + + # Allow the test process to exit, to cleanup after ourselves. + # + send_gdb "continue\n" + gdb_expect { + -re "Program exited normally.*$gdb_prompt $"\ + {pass "after attach2, exit"} + -re "$gdb_prompt $" {fail "after attach2, exit"} + timeout {fail "(timeout) after attach2, exit"} + } + + # Make sure we don't leave a process around to confuse + # the next test run (and prevent the compile by keeping + # the text file busy), in case the "set should_exit" didn't + # work. + # +# execute_anywhere "kill -9 ${testpid}" +remote_exec build "kill -9 ${testpid}" + # Start the program running and then wait for a bit, to be sure + # that it can be attached to. + # + set testpid [eval exec $binfile &] + exec sleep 2 + + # Verify that we can attach to the process, and find its a.out + # when we're cd'd to some directory that doesn't contain the + # a.out. (We use the source path set by the "dir" command.) + # + send_gdb "dir ${objdir}/${subdir}\n" + gdb_expect { + -re ".*Source directories searched: .*$gdb_prompt $"\ + {pass "set source path"} + -re "$gdb_prompt $" {fail "set source path"} + timeout {fail "(timeout) set source path"} + } + + send_gdb "cd /tmp\n" + gdb_expect { + -re ".*Working directory /tmp.*$gdb_prompt $"\ + {pass "cd away from process' a.out"} + -re "$gdb_prompt $" {fail "cd away from process' a.out"} + timeout {fail "(timeout) cd away from process' a.out"} + } + + # Explicitly flush out any knowledge of the previous attachment. + send_gdb "symbol\n" + gdb_expect { + -re ".*Discard symbol table from.*y or n. $"\ + {send_gdb "y\n" + gdb_expect { + -re ".*No symbol file now.*$gdb_prompt $"\ + {pass "before attach3, flush symbols"} + -re "$gdb_prompt $" {fail "before attach3, flush symbols"} + timeout {fail "(timeout) before attach3, flush symbols"} + } + } + -re ".*No symbol file now.*$gdb_prompt $"\ + {pass "before attach3, flush symbols"} + -re "$gdb_prompt $" {fail "before attach3, flush symbols"} + timeout {fail "(timeout) before attach3, flush symbols"} + } + send_gdb "exec\n" + gdb_expect { + -re ".*No exec file now.*$gdb_prompt $"\ + {pass "before attach3, flush exec"} + -re "$gdb_prompt $" {fail "before attach3, flush exec"} + timeout {fail "(timeout) before attach3, flush exec"} + } + + send_gdb "attach $testpid\n" + gdb_expect { + -re "Attaching to process $testpid.*Reading symbols from $binfile.*main.*at .*$gdb_prompt $"\ + {pass "attach when process' a.out not in cwd"} + -re "$gdb_prompt $" {fail "attach when process' a.out not in cwd"} + timeout {fail "(timeout) attach when process' a.out not in cwd"} + } + + send_gdb "kill\n" + gdb_expect { + -re ".*Kill the program being debugged.*y or n. $"\ + {send_gdb "y\n" + gdb_expect { + -re "$gdb_prompt $" {pass "after attach3, exit"} + timeout {fail "(timeout) after attach3, exit"} + } + } + -re "$gdb_prompt $" {fail "after attach3, exit"} + timeout {fail "(timeout) after attach3, exit"} + } +} + +proc do_call_attach_tests {} { + global gdb_prompt + global binfile2 + + # Start the program running and then wait for a bit, to be sure + # that it can be attached to. + # + set testpid [eval exec $binfile2 &] + exec sleep 2 + + # Attach + # + send_gdb "attach $testpid\n" + gdb_expect { + -re ".*warning: reading register.*I.*O error.*$gdb_prompt $" { + fail "attach call, read register 3 error" + } + -re "Attaching to.*process $testpid.*libc.*$gdb_prompt $" { + pass "attach call" + } + -re "$gdb_prompt $" {fail "attach call"} + timeout {fail "(timeout) attach call"} + } + + # See if other registers are problems + # + send_gdb "i r r3\n" + gdb_expect { + -re ".*warning: reading register.*$gdb_prompt $" { + pass "CHFts23490: known bug" + } + -re ".*r3.*$gdb_prompt $" { + pass "Bug fixed, Yayyy!" + } + timeout { fail "timeout on info reg" } + } + + # Get rid of the process + # + gdb_test "p should_exit = 1" ".*" "" + gdb_test "c" ".*Program exited normally.*" "" + + # Be paranoid + # +# execute_anywhere "kill -9 ${testpid}" +remote_exec build "kill -9 ${testpid}" + +} + + +# Start with a fresh gdb +# +gdb_exit +gdb_start +gdb_reinitialize_dir $srcdir/$subdir +gdb_load ${binfile} + +# This is a test of gdb's ability to attach to a running process. +# +do_attach_tests + +# Test attaching when the target is inside a system call +# +gdb_exit +gdb_start +gdb_reinitialize_dir $srcdir/$subdir +do_call_attach_tests + +# Until "set follow-fork-mode" and "catch fork" are implemented on +# other targets... +# +if ![istarget "hppa*-hp-hpux*"] then { + setup_xfail "*-*-*" +} + +return 0 diff --git a/gdb/testsuite/gdb.hp/attach2.exp b/gdb/testsuite/gdb.hp/attach2.exp new file mode 100644 index 00000000000..e298ee93f7a --- /dev/null +++ b/gdb/testsuite/gdb.hp/attach2.exp @@ -0,0 +1,263 @@ +# attach.exp -- Expect script to test attaching to a threaded pgm +# Copyright (C) 1992 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 + +# use this to debug: +# +#log_user 1 + +# Temporarily comment out - hanging +#return 0 + +if $tracelevel then { + strace $tracelevel +} + +# Thread stuff is _slow_; prepare for long waits. +# +# Further, this test has some "null" lines designed +# to consume output from gdb that was too late to be +# matched (sequence is "gdb_test" sends; timeout and +# on to next send; result finally comes in; mismatch). +# +# The null command is 'gdb_test "p \$pc" ".*" ""' +# NOTE: this command undoes any up/down stuff! +# +proc pre_timeout { how_long } { + global timeout + + set timeout [expr "$timeout + $how_long"] +} + +proc post_timeout {} { + global timeout + global oldtimeout + + set timeout $oldtimeout + gdb_test "p \$pc" ".*" "" +} + +if { ![istarget "hppa*-*-hpux10.30"] && ![istarget "hppa*-*-hpux11.*"] } { + verbose "HPUX thread test ignored for non-hppa or pre-HP/UX-10.30 targets." + return 0 +} + +# We used to wait 5 seconds , but tiamat is faster than +# hydra...or is it that the OS allocates time differently(?). +# +set delay 5 +if { ![istarget "hppa*-*-hpux11.*"] } { + set delay 45 +} + +set testfile quicksort +set srcfile ${srcdir}/${subdir}/${testfile}.c +set binfile ${objdir}/${subdir}/${testfile} + +if [get_compiler_info ${binfile}] { + return -1 +} + +set oldtimeout $timeout +#set timeout [expr "$timeout + 100"] +set oldverbose $verbose +#set verbose 40 + +# To build the executable we need to link against the thread library. +# +# cc -Ae -g -o quicksort -lpthread quicksort.c +# +#remote_exec build "${srcfile} -Ae -g -lpthread -o ${binfile}" +#gdb_compile "${srcfile} -Ae -g -lpthread -o ${binfile}" + +if {$gcc_compiled == 0} { + set additional_flags "additional_flags=-Ae" +} else { + set additional_flags "" +} + +if { [gdb_compile "${srcdir}/${subdir}/${testfile}.c" "${binfile}.o" object [list debug $additional_flags]] != "" } { + gdb_suppress_entire_file "Testcase compile failed, so all tests in this file will automatically fail." +} +remote_exec build "ld /usr/ccs/lib/crt0.o ${binfile}.o -lcl -lpthread -lc /opt/langtools/lib/end.o -o ${binfile}" + + +gdb_exit +gdb_start +gdb_reinitialize_dir $srcdir/$subdir + +# Start the application running and get its pid. +# Then we wait for it to get started and attach. +# +set testpid [eval exec $binfile 1 &] +exec sleep $delay + +# Now attach to the file. +# +pre_timeout 100 +gdb_test "attach $testpid" ".*Attaching to process.*Reading symbols from.*done.*" "attach to target" +post_timeout + +# Wait for things to quiesce. +# +exec sleep 0 + +send_gdb "bt\n" + +set do_return 0 +set do_go_to_118 0 +pre_timeout 400 +gdb_expect { + -re ".*sleep.*work_init.*main.*$gdb_prompt $" { + pass "at expected location" + } + -re ".*drand48.*$gdb_prompt $" { + set do_go_to_118 1 + } + -re ".*pthread_mutex_lock.*$gdb_prompt $" { + set do_go_to_118 1 + } + -re ".*pthread_mutex_unlock.*$gdb_prompt $" { + set do_go_to_118 1 + } + -re ".*main.*$gdb_prompt $" { + set do_go_to_118 1 + } + -re ".*No stack.*$gdb_prompt $" { + fail "Failed attach, change wait amount down, rest would fail" + set do_return 1 + } + -re ".*$gdb_prompt $" { + # Who knows? + # + set do_go_to_118 1 + } + timeout { + set do_return 1 + fail "timeout on bt, avoiding rest of test" + } +} +post_timeout + +# Too late; just give up. +# +if { $do_return } { + set timeout $oldtimeout + set verbose $oldverbose + return 0 +} + +# Maybe too early--set a temp break and continue. +# We have to set this on both paths, so that we can +# know what numbers breakpoints will be. +# +gdb_test "tb 118" ".*Breakpoint 1.*118.*" "" +if { $do_go_to_118 } { + pre_timeout 100 + send_gdb "c\n" + gdb_expect { + -re ".*at.*118.*118.*$gdb_prompt $" { + # Ok, just keep going + } + -re ".*Program exited.*$gdb_prompt $" { + fail "Attached too late, set wait amount downwards" + set timeout $oldtimeout + set verbose $oldverbose + return 0 + } + -re ".*$gdb_prompt $" { + fail "Unexpected result on attach" + set timeout $oldtimeout + set verbose $oldverbose + return 0 + } + timeout { + fail "timeout on continue " + } + } + post_timeout +} + +# Look at the threads. +# +pre_timeout 100 +gdb_test "info thread" ".*7.*6.*5.*4.*3.*2.*\\\* 1.*thread.*" "first info thread" +post_timeout + +# We expect to be inside the "sleep" call, so check that. +# +if { [expr "!$do_go_to_118"] } { + gdb_test "up" ".*\#1.*nanosleep.*" "up 1" + gdb_test "up" ".*\#2.*sleep.*" "up 2" + pre_timeout 100 + gdb_test "up" ".*\#3.*work_init.*$testfile.*c:118.*sleep.*" "up 3" + post_timeout +} else { + send_user "Skipped three tests\n" +} + +# Get out of that call. +# +gdb_test "b 120" ".*Breakpoint 2.*120.*" "set bp" +pre_timeout 100 +gdb_test "c" ".*Breakpoint 2.*at.*120.*" "hit bp" +post_timeout + +# Look at the threads. +# +pre_timeout 100 +gdb_test "info thread" ".*7.*6.*5.*4.*3.*2.*1.*thread.*$testfile.*c*120.*" "2nd info thread" +post_timeout + +# Do some more stuff, to make sure we can +# +gdb_test "thread 3" ".*Switching to.*thread.*ksleep.*" "switch thread" + +gdb_test "up" ".*_lwp_cond_timedwait.*" "up 5" +gdb_test "up" ".*pthread_cond_wait.*" "up 6" +gdb_test "up" ".*\#3.*worker.*144.*" "up 7" +gdb_test "up" ".*__pthread_exit.*" "up 8" +gdb_test "up" ".*Initial.*cannot go up.*" "found thread base" + +gdb_test "b 145 thr 3" ".*Breakpoint 3.*145.*" "thread-specific bp" +gdb_test "i b" ".*2.*breakpoint.*at.*120.*3.*breakpoint.*at.*145 thread 3.*" "show thread-specific bp" +gdb_test "del 2" ".*" "" + +gdb_test "c" ".*Breakpoint 3.*145.*" "hit thread-specific bp" +gdb_test "i th" ".*\\\* 3.*145.*" "at correct thread" + +pre_timeout 100 +gdb_test "n" ".*146.*" "next from thread-specific bp" +post_timeout + +gdb_test "d 3" ".*" "" +gdb_test "c" ".*Program exited normally\..*" "run to finish" + +# Done! +# +gdb_exit + +set timeout $oldtimeout +set verbose $oldverbose + +# execute_anywhere "rm -f ${binfile}" +# +return 0 + + diff --git a/gdb/testsuite/gdb.hp/classes-hp.exp b/gdb/testsuite/gdb.hp/classes-hp.exp new file mode 100644 index 00000000000..cb22c96e8fc --- /dev/null +++ b/gdb/testsuite/gdb.hp/classes-hp.exp @@ -0,0 +1,859 @@ +# Copyright (C) 1992, 1994, 1995, 1997 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 Fred Fish. (fnf@cygnus.com) + +set ws "\[\r\n\t \]+" + +if $tracelevel then { + strace $tracelevel +} + + +# Check to see if we have an executable to test. If not, then either we +# haven't tried to compile one, or the compilation failed for some reason. +# In either case, just notify the user and skip the tests in this file. + +set testfile "misc-hp" +set srcfile ${testfile}.cc +set binfile ${objdir}/${subdir}/${testfile} + +if [get_compiler_info ${binfile} "c++"] { + return -1; +} + + +if {[skip_hp_tests $gcc_compiled]} then { continue } + +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." +} + +# +# Test ptype of class objects. +# + +proc test_ptype_class_objects {} { + global gdb_prompt + global ws + + # Note that struct members are public by default, so we don't print + # "public:" for the public members of structs. + # Accept it as an expected failure if gdb just fails to distinguish between + # class and struct, and everything else is OK. + + send_gdb "ptype struct default_public_struct\n" + gdb_expect { + -re "type = struct default_public_struct \{${ws}int a;${ws}int b;\r\n\}\r\n$gdb_prompt $" { + pass "ptype struct default_public_struct" + } + -re "type = class default_public_struct \{\r\n.*int a;${ws}int b;\r\n.*\}\r\n$gdb_prompt $" { + setup_xfail "*-*-*" + fail "ptype struct default_public_struct" + } + -re ".*$gdb_prompt $" { fail "ptype struct default_public_struct" } + timeout { fail "ptype struct default_public_struct (timeout)" ; return } + } + + # Note that struct members are public by default, so we don't print + # "public:" for the public members of structs. + # Accept it as an expected failure if gdb just fails to distinguish between + # class and struct, and everything else is OK. + + send_gdb "ptype struct explicit_public_struct\n" + gdb_expect { + -re "type = struct explicit_public_struct \{${ws}int a;${ws}int b;\r\n.*\}\r\n$gdb_prompt $" { + pass "ptype struct explicit_public_struct" + } + -re "type = class explicit_public_struct \{\r\n.*int a;${ws}int b;\r\n.*\}\r\n$gdb_prompt $" { + setup_xfail "*-*-*" + fail "ptype struct explicit_public_struct" + } + -re ".*$gdb_prompt $" { fail "ptype struct explicit_public_struct" } + timeout { fail "ptype struct explicit_public_struct (timeout)" ; return } + } + + # Accept it as an expected failure if gdb just fails to distinguish between + # class and struct, and everything else is OK. + + setup_xfail_format "DWARF 1" + send_gdb "ptype struct protected_struct\n" + gdb_expect { + -re "type = struct protected_struct \{${ws}protected:${ws}int a;${ws}int b;\r\n\}\r\n$gdb_prompt $" { + pass "ptype struct protected_struct (FIXME)" + } + -re "type = class protected_struct \{${ws}protected:${ws}int a;${ws}int b;\r\n.*\}\r\n$gdb_prompt $" { + setup_xfail "*-*-*" + fail "ptype struct protected_struct (FIXME)" + } + -re ".*$gdb_prompt $" { fail "ptype struct protected_struct" } + timeout { fail "ptype struct protected_struct (timeout)" ; return } + } + + # Accept it as an expected failure if gdb just fails to distinguish between + # class and struct, and everything else is OK. + + setup_xfail_format "DWARF 1" + send_gdb "ptype struct private_struct\n" + gdb_expect { + -re "type = struct private_struct \{${ws}private:${ws}int a;${ws}int b;\r\n\}\r\n$gdb_prompt $" { + pass "ptype struct private_struct (FIXME)" + } + -re "type = class private_struct \{${ws}private:${ws}int a;${ws}int b;\r\n.*\}\r\n$gdb_prompt $" { + setup_xfail "*-*-*" + fail "ptype struct private_struct (FIXME)" + } + -re ".*$gdb_prompt $" { fail "ptype struct private_struct" } + timeout { fail "ptype struct private_struct (timeout)" ; return } + } + + # Accept it as an expected failure if gdb just fails to distinguish between + # class and struct, and everything else is OK. + + setup_xfail_format "DWARF 1" + send_gdb "ptype struct mixed_protection_struct\n" + gdb_expect { + -re "type = struct mixed_protection_struct \{${ws}int a;${ws}int b;${ws}private:${ws}int c;${ws}int d;${ws}protected:${ws}int e;${ws}int f;${ws}public:${ws}int g;${ws}private:${ws}int h;${ws}protected:${ws}int i;\[\r\n\]+\}\[\r\n\]+$gdb_prompt $" { + pass "ptype struct mixed_protection_struct (FIXME)" + } + -re "type = struct mixed_protection_struct \{\r\n\[ \]*public:\r\n\[ \]*int a;\r\n\[ \]*int b;\r\n\[ \]*private:\r\n\[ \]*int c;\r\n\[ \]*int d;\r\n\[ \]*protected:\r\n\[ \]*int e;\r\n\[ \]*int f;\r\n\[ \]*public:\r\n\[ \]*int g;\r\n\[ \]*private:\r\n\[ \]*int h;\r\n\[ \]*protected:\r\n\[ \]*int i;\r\n.*\}\r\n$gdb_prompt $" { + pass "ptype struct mixed_protection_struct (extra public)" + } + -re "type = class mixed_protection_struct \{${ws}public:${ws}int a;${ws}int b;${ws}private:${ws}int c;${ws}int d;${ws}protected:${ws}int e;${ws}int f;${ws}public:${ws}int g;${ws}private:${ws}int h;${ws}protected:${ws}int i;\r\n.*\}\r\n$gdb_prompt $" { + setup_xfail "*-*-*" + fail "ptype struct mixed_protection_struct (FIXME)" + } + -re ".*$gdb_prompt $" { fail "ptype struct mixed_protection_struct" } + timeout { fail "ptype struct mixed_protection_struct (timeout)" ; return } + } + + # Accept it as an expected failure if gdb just fails to distinguish between + # class and struct, and everything else is OK. + + send_gdb "ptype class public_class\n" + gdb_expect { + -re "type = class public_class \{${ws}public:${ws}int a;${ws}int b;\r\n.*\}\r\n$gdb_prompt $" { + pass "ptype class public_class (FIXME)" + } + -re "type = struct public_class \{${ws}int a;${ws}int b;\r\n\}\r\n$gdb_prompt $" { + setup_xfail "*-*-*" + fail "ptype class public_class (FIXME)" + } + -re ".*$gdb_prompt $" { fail "ptype class public_class" } + timeout { fail "ptype class public_class (timeout)" ; return } + } + + send_gdb "ptype class protected_class\n" + gdb_expect { + -re "type = class protected_class \{${ws}protected:${ws}int a;${ws}int b;\r\n.*\}\r\n$gdb_prompt $" { + pass "ptype class protected_class" + } + -re "type = struct protected_class \{${ws}int a;${ws}int b;\r\n\}\r\n$gdb_prompt $" { + setup_xfail "*-*-*" + fail "ptype class protected_class" + } + -re ".*$gdb_prompt $" { fail "ptype class protected_class" } + timeout { fail "ptype class protected_class (timeout)" ; return } + } + + # Accept it as an expected failure if gdb just emits a superflous "private:" + # attribute, since classes default to private and for consistency with + # structs (where we don't print the "public:" attribute) we don't print + # the "private:" attribute. + + setup_xfail_format "DWARF 1" + send_gdb "ptype class default_private_class\n" + gdb_expect { + -re "type = class default_private_class \{${ws}int a;${ws}int b;\r\n.*\}\r\n$gdb_prompt $" { + pass "ptype class default_private_class (FIXME)" + } + -re "type = class default_private_class \{${ws}private:${ws}int a;${ws}int b;\r\n.*\}\r\n$gdb_prompt $" { + setup_xfail "*-*-*" + fail "ptype class default_private_class (FIXME)" + } + -re ".*$gdb_prompt $" { fail "ptype class default_private_class" } + timeout { fail "ptype class default_private_class (timeout)" ; return } + } + + send_gdb "ptype class explicit_private_class\n" + gdb_expect { + -re "type = class explicit_private_class \{${ws}private:${ws}int a;${ws}int b;\r\n.*\}\r\n$gdb_prompt $" { + pass "ptype class explicit_private_class" + } + -re "type = class explicit_private_class \{\r\n\[ \]*int a;\r\n\[ \]*int b;\r\n.*\}\r\n$gdb_prompt $" { + pass "ptype class explicit_private_class (OK for HP aCC)" + } + -re "type = struct explicit_private_class \{${ws}int a;${ws}int b;\r\n.*\}\r\n$gdb_prompt $" { + setup_xfail "*-*-*" + fail "ptype class explicit_private_class" + } + -re ".*$gdb_prompt $" { fail "ptype class explicit_private_class" } + timeout { fail "ptype class explicit_private_class (timeout)" ; return } + } + + send_gdb "ptype class mixed_protection_class\n" + gdb_expect { + -re "type = class mixed_protection_class \{${ws}public:${ws}int a;${ws}int b;${ws}private:${ws}int c;${ws}int d;${ws}protected:${ws}int e;${ws}int f;${ws}public:${ws}int g;${ws}private:${ws}int h;${ws}protected:${ws}int i;\r\n.*\}\r\n$gdb_prompt $" { + pass "ptype class mixed_protection_class" + } + -re "type = struct mixed_protection_class \{${ws}int a;${ws}int b;${ws}int c;${ws}int d;${ws}int e;${ws}int f;${ws}int g;${ws}int h;${ws}int i;\r\n.*\}\r\n$gdb_prompt $" { + setup_xfail "*-*-*" + fail "ptype class mixed_protection_class" + } + -re ".*$gdb_prompt $" { fail "ptype class mixed_protection_class" } + timeout { fail "ptype class mixed_protection_class (timeout)" ; return } + } + + # This class does not use any C++-specific features, so it's fine for + # it to print as "struct". + send_gdb "ptype class A\n" + gdb_expect { + -re "type = (class|struct) A \{(${ws}public:|)${ws}int a;${ws}int x;((${ws}A & operator=\\(A const &\\);)|(${ws}A\\(A const &\\);)|(${ws}A\\(void\\);))*${ws}\}\r\n$gdb_prompt $" { + pass "ptype class A" + } + -re ".*$gdb_prompt $" { + fail "ptype class A" + } + timeout { + fail "ptype class A (timeout)" + return + } + } + + setup_xfail_format "DWARF 1" + send_gdb "ptype class B\n" + gdb_expect { + -re "type = class B : public A \{${ws}public:${ws}int b;${ws}int x;${ws}B & operator=\\(B const &\\);${ws}B\\(B const &\\);${ws}B\\(void\\);${ws}\}\r\n$gdb_prompt $" { + pass "ptype class B" + } + -re "type = class B : public A \{${ws}public:${ws}int b;${ws}int x;((${ws}B & operator=\\(B const &\\);)|(${ws}B\\(B const &\\);)|(${ws}B\\(void\\);))*${ws}\}\r\n$gdb_prompt $" { + pass "ptype class B (obsolescent gcc or gdb)" + } + -re ".*$gdb_prompt $" { + fail "ptype class B" + } + timeout { + fail "ptype class B (timeout)" + return + } + } + + setup_xfail_format "DWARF 1" + send_gdb "ptype class C\n" + gdb_expect { + -re "type = class C : public A \{${ws}public:${ws}int c;${ws}int x;${ws}C & operator=\\(C const &\\);${ws}C\\(C const &\\);${ws}C\\(void\\);${ws}\}\r\n$gdb_prompt $" { + pass "ptype class C" + } + -re "type = class C : public A \{${ws}public:${ws}int c;${ws}int x;((${ws}C & operator=\\(C const &\\);)|(${ws}C\\(C const &\\);)|(${ws}C\\(void\\);))*${ws}\}\r\n$gdb_prompt $" { + pass "ptype class C (obsolescent gcc or gdb)" + } + -re ".*$gdb_prompt $" { + fail "ptype class C" + } + timeout { + fail "ptype class C (timeout)" + return + } + } + + setup_xfail_format "DWARF 1" + send_gdb "ptype class D\n" + gdb_expect { + -re "type = class D : public B, public C \{${ws}public:${ws}int d;${ws}int x;${ws}D & operator=\\(D const &\\);${ws}D\\(D const &\\);${ws}D\\(void\\);${ws}\}\r\n$gdb_prompt $" { + pass "ptype class D" + } + -re "type = class D : public B, public C \{${ws}public:${ws}int d;${ws}int x;((${ws}D & operator=\\(D const &\\);)|(${ws}D\\(D const &\\);)|(${ws}D\\(void\\);))*${ws}\}\r\n$gdb_prompt $" { + pass "ptype class D (obsolescent gcc or gdb)" + } + -re ".*$gdb_prompt $" { + fail "ptype class D" + } + timeout { + fail "ptype class D (timeout)" + return + } + } + + setup_xfail_format "DWARF 1" + send_gdb "ptype class E\n" + gdb_expect { + -re "type = class E : public D \{${ws}public:${ws}int e;${ws}int x;${ws}E & operator=\\(E const &\\);${ws}E\\(E const &\\);${ws}E\\(void\\);${ws}\}\r\n$gdb_prompt $" { + pass "ptype class E" + } + -re "type = class E : public D \{${ws}public:${ws}int e;${ws}int x;((${ws}E & operator=\\(E const &\\);)|(${ws}E\\(E const &\\);)|(${ws}E\\(void\\);))*${ws}\}\r\n$gdb_prompt $" { + pass "ptype class E" + } + -re ".*$gdb_prompt $" { + fail "ptype class E" + } + timeout { + fail "ptype class E (timeout)" + return + } + } + + send_gdb "ptype class vA\n" + gdb_expect { + -re "type = (class|struct) vA \{(${ws}public:|)${ws}int va;${ws}int vx;${ws}vA & operator=\\(vA const &\\);${ws}vA\\(vA const &\\);${ws}vA\\(void\\);${ws}\}\r\n$gdb_prompt $" { + pass "ptype class vA" + } + -re "type = (class|struct) vA \{(${ws}public:|)${ws}int va;${ws}int vx;((${ws}vA & operator=\\(vA const &\\);)|(${ws}vA\\(vA const &\\);)|(${ws}vA\\(void\\);))*${ws}\}\r\n$gdb_prompt $" { + pass "ptype class vA (obsolescent gcc or gdb)" + } + -re ".*$gdb_prompt $" { + fail "ptype class vA" + } + timeout { + fail "ptype class vA (timeout)" + return + } + } + + # Accept the form with embedded GNU style mangled virtual table constructs + # for now, but with a FIXME. At some future point, gdb should use a + # portable representation for the virtual table constructs. + + setup_xfail_format "DWARF 1" + send_gdb "ptype class vB\n" + gdb_expect { + -re "type = class vB : public virtual vA \{${ws}private:${ws}vA \\*_vb.vA;${ws}public:${ws}int vb;${ws}int vx;${ws}vB & operator=\\(vB const &\\);${ws}vB\\(int, vB const &\\);${ws}vB\\(int\\);${ws}\}\r\n$gdb_prompt $" { + setup_xfail "*-*-*" + fail "ptype class vB (FIXME: non-portable virtual table constructs)" + } + -re "type = class vB : public virtual vA \{\r\n\[ \]*public:\r\n\[ \]*int vb;\r\n\[ \]*int vx;\[\r\n\t \]+\}\r\n$gdb_prompt $" { + pass "ptype class vB (aCC)" + } + -re "type = class vB : public virtual vA \{${ws}private:${ws}vA \\*_vb.vA;${ws}public:${ws}int vb;${ws}int vx;((${ws}vB & operator=\\(vB const &\\);)|(${ws}vB\\(int, vB const &\\);)|(${ws}vB\\(int\\);))*${ws}\}\r\n$gdb_prompt $" { + setup_xfail "*-*-*" + fail "ptype class vB (FIXME) (obsolescent gcc or gdb)" + } + -re ".*$gdb_prompt $" { + fail "ptype class vB" + } + timeout { + fail "ptype class vB (timeout)" + return + } + } + + # Accept the form with embedded GNU style mangled virtual table constructs + # for now, but with a FIXME. At some future point, gdb should use a + # portable representation for the virtual table constructs. + + setup_xfail_format "DWARF 1" + send_gdb "ptype class vC\n" + gdb_expect { + -re "type = class vC : public virtual vA \{${ws}private:${ws}vA \\*_vb.vA;${ws}public:${ws}int vc;${ws}int vx;${ws}vC & operator=\\(vC const &\\);${ws}vC\\(int, vC const &\\);${ws}vC\\(int\\);${ws}\}\r\n$gdb_prompt $" { + setup_xfail "*-*-*" + fail "ptype class vC (FIXME: non-portable virtual table constructs)" + } + -re "type = class vC : public virtual vA \{\r\n\[ \]*public:\r\n\[ \]*int vc;\r\n\[ \]*int vx;\[\r\n\t \]+\}\r\n$gdb_prompt $" { + pass "ptype class vC (aCC)" + } + -re "type = class vC : public virtual vA \{${ws}private:${ws}vA \\*_vb.vA;${ws}public:${ws}int vc;${ws}int vx;((${ws}vC & operator=\\(vC const &\\);)|(${ws}vC\\(int, vC const &\\);)|(${ws}vC\\(int\\);))*${ws}\}\r\n$gdb_prompt $" { + setup_xfail "*-*-*" + fail "ptype class vC (FIXME) (obsolescent gcc or gdb)" + } + -re ".*$gdb_prompt $" { + fail "ptype class vC" + } + timeout { + fail "ptype class vC (timeout)" + return + } + } + + # Accept the form with embedded GNU style mangled virtual table constructs + # for now, but with a FIXME. At some future point, gdb should use a + # portable representation for the virtual table constructs. + + setup_xfail_format "DWARF 1" + send_gdb "ptype class vD\n" + gdb_expect { + -re "type = class vD : public virtual vB, public virtual vC \{${ws}private:${ws}vC \\*_vb.vC;${ws}vB \\*_vb.vB;${ws}public:${ws}int vd;${ws}int vx;${ws}vD & operator=\\(vD const &\\);${ws}vD\\(int, vD const &\\);${ws}vD\\(int\\);${ws}\}\r\n$gdb_prompt $" { + setup_xfail "*-*-*" + fail "ptype class vD (FIXME: non-portable virtual table constructs)" + } + -re "type = class vD : public virtual vB, public virtual vC \{\r\n\[ \]*public:\r\n\[ \]*int vd;\r\n\[ \]*int vx;\[\r\n\t \]+\}\r\n$gdb_prompt $" { + pass "ptype class vD (aCC)" + } + -re "type = class vD : public virtual vB, public virtual vC \{${ws}private:${ws}vC \\*_vb.vC;${ws}vB \\*_vb.vB;${ws}public:${ws}int vd;${ws}int vx;((${ws}vD & operator=\\(vD const &\\);)|(${ws}vD\\(int, vD const &\\);)|(${ws}vD\\(int\\);))*${ws}\}\r\n$gdb_prompt $" { + setup_xfail "*-*-*" + fail "ptype class vD (FIXME) (obsolescent gcc or gdb)" + } + -re ".*$gdb_prompt $" { + fail "ptype class vD" + } + timeout { + fail "ptype class vD (timeout)" + return + } + } + + # Accept the form with embedded GNU style mangled virtual table constructs + # for now, but with a FIXME. At some future point, gdb should use a + # portable representation for the virtual table constructs. + + setup_xfail_format "DWARF 1" + send_gdb "ptype class vE\n" + gdb_expect { + -re "type = class vE : public virtual vD \{${ws}private:${ws}vD \\*_vb.vD;${ws}public:${ws}int ve;${ws}int vx;${ws}vE & operator=\\(vE const &\\);${ws}vE\\(int, vE const &\\);${ws}vE\\(int\\);${ws}\}\r\n$gdb_prompt $" { + setup_xfail "*-*-*" + fail "ptype class vE (FIXME: non-portable virtual table constructs)" + } + -re "type = class vE : public virtual vD \{\r\n\[ \]*public:\r\n\[ \]*int ve;\r\n\[ \]*int vx;\[\r\n\t \]+\}\r\n$gdb_prompt $" { + pass "ptype class vE (aCC)" + } + -re "type = class vE : public virtual vD \{${ws}private:${ws}vD \\*_vb.vD;${ws}public:${ws}int ve;${ws}int vx;((${ws}vE & operator=\\(vE const &\\);)|(${ws}vE\\(int, vE const &\\);)|(${ws}vE\\(int\\);))*${ws}\}\r\n$gdb_prompt $" { + setup_xfail "*-*-*" + fail "ptype class vE (FIXME) (obsolescent gcc or gdb)" + } + -re ".*$gdb_prompt $" { + fail "ptype class vE" + } + timeout { + fail "ptype class vE (timeout)" + return + } + } + + setup_xfail_format "DWARF 1" + send_gdb "ptype class Base1\n" + gdb_expect { + -re "type = class Base1 \{${ws}public:${ws}int x;${ws}Base1 & operator=\\(Base1 const &\\);${ws}Base1\\(Base1 const &\\);${ws}Base1\\(int\\);${ws}\}\r\n$gdb_prompt $" { + pass "ptype class Base1" + } + -re "type = class Base1 \{${ws}public:${ws}int x;((${ws}Base1 & operator=\\(Base1 const &\\);)|(${ws}Base1\\(Base1 const &\\);)|(${ws}Base1\\(int\\);))*${ws}\}\r\n$gdb_prompt $" { + pass "ptype class Base1 (obsolescent gcc or gdb)" + } + -re ".*$gdb_prompt $" { + fail "ptype class Base1" + } + timeout { + fail "ptype class Base1 (timeout)" + return + } + } + + setup_xfail_format "DWARF 1" + send_gdb "ptype class Foo\n" + gdb_expect { + -re "type = class Foo \{\r\n\[ \]*public:\r\n\[ \]*int x;\r\n\[ \]*int y;\r\n\[ \]*static int st;\r\n\r\n\[ \]*Foo\\(int, int\\);\r\n\[ \]*int operator!.void.;\r\n\[ \]*operator int.void.;\r\n\[ \]*int times.int.;\r\n\}\r\n$gdb_prompt $" { + pass "ptype class Foo(aCC)" + } + -re "type = class Foo \{${ws}public:${ws}int x;${ws}int y;${ws}static int st;${ws}Foo & operator=\\(Foo const &\\);${ws}Foo\\(Foo const &\\);${ws}Foo\\(int, int\\);${ws}int operator!\\(void\\);${ws}int operator int\\(void\\);${ws}int times\\(int\\);${ws}\}\r\n$gdb_prompt $" { + pass "ptype class Foo" + } + -re "type = class Foo \{${ws}public:${ws}int x;${ws}int y;${ws}static int st;((${ws}Foo & operator=\\(Foo const &\\);)|(${ws}Foo\\(Foo const &\\);)|(${ws}Foo\\(int, int\\);)|(${ws}int operator!\\(void\\);)|(${ws}int operator int\\(void\\);)|(${ws}int times\\(int\\);))*${ws}\}\r\n$gdb_prompt $" { + pass "ptype class Foo (obsolescent gcc or gdb)" + } + -re ".*$gdb_prompt $" { + fail "ptype class Foo" + } + timeout { + fail "ptype class Foo (timeout)" + return + } + } + + setup_xfail_format "DWARF 1" + send_gdb "ptype class Bar\n" + gdb_expect { + -re "type = class Bar : public Base1, public Foo \{${ws}public:${ws}int z;${ws}Bar & operator=\\(Bar const &\\);${ws}Bar\\(Bar const &\\);${ws}Bar\\(int, int, int\\);${ws}\}\r\n$gdb_prompt $" { + pass "ptype class Bar" + } + -re "type = class Bar : public Base1, public Foo \{${ws}public:${ws}int z;((${ws}Bar & operator=\\(Bar const &\\);)|(${ws}Bar\\(Bar const &\\);)|(${ws}Bar\\(int, int, int\\);))*${ws}\}\r\n$gdb_prompt $" { + pass "ptype class Bar (obsolescent gcc or gdb)" + } + -re ".*$gdb_prompt $" { + fail "ptype class Bar" + } + timeout { + fail "ptype class Bar (timeout)" + return + } + } +} + +# +# Test simple access to class members. +# + +proc test_non_inherited_member_access {} { + global gdb_prompt + + # Print non-inherited members of g_A. + + gdb_test "print g_A.a" ".* = 1" "g_A.a incorrect" + + gdb_test "print g_A.x" ".* = 2" "g_A.x incorrect" + + # Print non-inherited members of g_B. + + gdb_test "print g_B.b" ".* = 5" "g_B.b incorrect" + + gdb_test "print g_B.x" ".* = 6" "g_B.x incorrect" + + # Print non-inherited members of g_C. + + gdb_test "print g_C.c" ".* = 9" "g_C.c incorrect" + + gdb_test "print g_C.x" ".* = 10" "g_C.x incorrect" + + # Print non-inherited members of g_D. + + gdb_test "print g_D.d" ".* = 19" "g_D.d incorrect" + + gdb_test "print g_D.x" ".* = 20" "g_D.x incorrect" + + # Print non-inherited members of g_E. + + gdb_test "print g_E.e" ".* = 31" "g_E.e incorrect" + + gdb_test "print g_E.x" ".* = 32" "g_E.x incorrect" +} + +# +# Try access to non-members that are members of another class. +# Should give errors. +# + +proc test_wrong_class_members {} { + global gdb_prompt + + gdb_test "print g_A.b" "There is no member( or method|) named b." "print g_A.b should be error" + + gdb_test "print g_B.c" "There is no member( or method|) named c." "print g_B.c should be error" + + gdb_test "print g_B.d" "There is no member( or method|) named d." "print g_B.d should be error" + + gdb_test "print g_C.b" "There is no member( or method|) named b." "print g_C.b should be error" + + gdb_test "print g_C.d" "There is no member( or method|) named d." "print g_C.d should be error" + + gdb_test "print g_D.e" "There is no member( or method|) named e." "print g_D.e should be error" +} + +# +# Try access to non-members that are not members of any class. +# Should give errors. +# + +proc test_nonexistant_members {} { + global gdb_prompt + + gdb_test "print g_A.y" "There is no member( or method|) named y." "print g_A.y should be error" + + gdb_test "print g_B.z" "There is no member( or method|) named z." "print g_B.z should be error" + + gdb_test "print g_C.q" "There is no member( or method|) named q." "print g_C.q should be error" + + gdb_test "print g_D.p" "There is no member( or method|) named p." "print g_D.p should be error" +} + +# +# Pointers to class members +# + +proc test_pointers_to_class_members {} { + global gdb_prompt + global decimal + + gdb_test "print Bar::z" ".* = .int\[ \]*\[( \]*Bar::&\[)\]+\[ \]*Bar::z" "print Bar::z" + + gdb_test "print &Foo::x" ".* = .int\[ \]*\[( \]*Foo::\[*)\]+\[ \]*&Foo::x" "print &Foo::x" + + gdb_test "print (int)&Foo::x" ".* = 0" "print (int)&Foo::x" + + send_gdb "print (int)&Bar::y == 2*sizeof(int)\n" + gdb_expect { + -re ".* = true\r\n$gdb_prompt $" { + pass "print (int)&Bar::y == 2*sizeof(int)" + } + -re "There is no field named y.*$gdb_prompt $" { + setup_xfail "*-*-*" + fail "print (int)&Bar::y == 2*sizeof(int)" + } + -re ".*$gdb_prompt $" { fail "print (int)&Bar::y == 2*sizeof(int)" } + timeout { fail "print (int)&Bar::y == 2*sizeof(int) (timeout)" ; return } + } + + send_gdb "next\n" + setup_xfail "*-*-*" + gdb_expect { + -re "$decimal\[ \t\]+inheritance3 \[)(\]+;\r\n$gdb_prompt $" {} + -re ".*$gdb_prompt $" { fail "next to inheritance3" ; return } + } + clear_xfail "*-*-*" + + setup_xfail_format "DWARF 1" + gdb_test "print (int)pmi == sizeof(int)" ".* = false" "print (int)pmi == sizeof(int)" +} + +# +# Test static members. +# + +proc test_static_members {} { + global gdb_prompt + global hex + + send_gdb "print Foo::st\n" + gdb_expect { + -re ".* = 100\r\n$gdb_prompt $" { + pass "print Foo::st" + } + -re "There is no field named st.*$gdb_prompt $" { + setup_xfail "*-*-*" + fail "print Foo::st" + } + -re ".*$gdb_prompt $" { fail "print Foo::st" } + timeout { fail "print Foo::st (timeout)" ; return } + } + + send_gdb "set foo.st = 200\n" + gdb_expect { + -re ".*$gdb_prompt $" {} + } + + send_gdb "print bar.st\n" + gdb_expect { + -re ".* = 200\r\n$gdb_prompt $" { + pass "print bar.st" + } + -re "There is no member( or method|) named st.*$gdb_prompt $" { + setup_xfail "*-*-*" + fail "print bar.st" + } + -re ".*$gdb_prompt $" { fail "print bar.st" } + timeout { fail "print bar.st (timeout)" ; return } + } + + send_gdb "print &foo.st\n" + gdb_expect { + -re ".* = .int \[*)\]+ $hex\r\n$gdb_prompt $" { + pass "print &foo.st" + } + -re "There is no member( or method|) named st.*$gdb_prompt $" { + setup_xfail "*-*-*" + fail "print &foo.st" + } + -re ".*$gdb_prompt $" { fail "print &foo.st" } + timeout { fail "print &foo.st (timeout)" ; return } + } + + set got_bar_st 0 + send_gdb "print &Bar::st\n" + gdb_expect { + -re ".* = .int \[*)\]+ $hex\r\n$gdb_prompt $" { + pass "print &Bar::st" + set got_bar_st 1 + } + -re "There is no field named st.*$gdb_prompt $" { + setup_xfail "*-*-*" + fail "print &Bar::st" + } + -re ".*$gdb_prompt $" { fail "print &Bar::st" } + timeout { fail "print &Bar::st (timeout)" ; return } + } + + if $got_bar_st then { + gdb_test "print *\$" ".* = 200" "print *\$" + } + + gdb_test "set print static-members off" "" + gdb_test "print csi" \ + "{x = 10, y = 20}" \ + "print csi without static members" + gdb_test "print cnsi" \ + "{x = 30, y = 40}" \ + "print cnsi without static members" + + gdb_test "set print static-members on" "" + setup_xfail_format "DWARF 1" + gdb_test "print csi" \ + "{x = 10, y = 20, static null = {x = 0, y = 0, static null = }}" \ + "print csi with static members" + setup_xfail_format "DWARF 1" + gdb_test "print cnsi" \ + "{x = 30, y = 40, static null = {x = 0, y = 0, static null = , static yy = {z = 5, static xx = {x = 1, y = 2, static null = , static yy = }}}, static yy = }" \ + "print cnsi with static members" +} + +proc do_tests {} { + global prms_id + global bug_id + global subdir + global objdir + global srcdir + global binfile + global gdb_prompt + + set prms_id 0 + set bug_id 0 + + # Start with a fresh gdb. + + gdb_exit + gdb_start + gdb_reinitialize_dir $srcdir/$subdir + gdb_load $binfile + + send_gdb "set language c++\n" + gdb_expect -re "$gdb_prompt $" + send_gdb "set width 0\n" + gdb_expect -re "$gdb_prompt $" + + # Get the debug format for the compiled test case. + + if [ runto_main ] then { + get_debug_format + } + + test_ptype_class_objects + + if [ runto 'inheritance2(void)' ] then { + test_non_inherited_member_access + test_wrong_class_members + test_nonexistant_members + } + + if [istarget "mips-idt-*"] then { + # Restart because IDT/SIM runs out of file descriptors. + gdb_exit + gdb_start + gdb_reinitialize_dir $srcdir/$subdir + gdb_load $binfile + } + + if [ runto_main ] then { + test_pointers_to_class_members + test_static_members + } + + if [istarget "mips-idt-*"] then { + # Restart because IDT/SIM runs out of file descriptors. + gdb_exit + gdb_start + gdb_reinitialize_dir $srcdir/$subdir + gdb_load $binfile + } + + if [ runto marker_reg1 ] then { + + gdb_test "finish" "Run till exit from.*" "finish from marker_reg1" + + send_gdb "print v.method ()\n" + gdb_expect { + -re "= 82.*$gdb_prompt $" { + pass "calling method for small class" + } + -re "Address requested for identifier .v. which is in a register.*$gdb_prompt $" { + setup_xfail "*-*-*" 2972 + fail "calling method for small class" + } + -re ".*$gdb_prompt $" { fail "calling method for small class" } + timeout { fail "calling method for small class (timeout)" } + eof { fail "calling method for small class (eof)" } + } + } + +} + +do_tests + + +# Some additional tests for enums inside classes + + +# set a breakpoint and go there +send_gdb "break 498\n" +gdb_expect { + -re "Breakpoint \[0-9\] at.*$gdb_prompt $" { pass "set break 498" } + -re "$gdb_prompt $" { fail "set break 498" } + timeout { fail "(timeout) set break 498" } +} +send_gdb "continue\n" +gdb_expect { + -re "Continuing\\.\r\n\r\nBreakpoint \[0-9\]*, main....at ${srcdir}/${subdir}/${srcfile}:498\r\n498.*\r\n$gdb_prompt $" { pass "continue" } + -re "$gdb_prompt $" { fail "continue" } + timeout { fail "(timeout) continue" } +} + +# print the object +send_gdb "print obj_with_enum\n" +gdb_expect { + -re "\\$\[0-9\]* = \\{priv_enum = red, x = 0\\}.*$gdb_prompt $" { pass "print obj_with_enum (1)" } + -re "$gdb_prompt $" { fail "print obj_with_enum (1)" } + timeout { fail "(timeout) print obj_with_enum (1)" } +} + +send_gdb "next\n" +gdb_expect { + -re "$gdb_prompt $" { pass "next" } + timeout { fail "(timeout) next" } +} + +# print the object again +send_gdb "print obj_with_enum\n" +gdb_expect { + -re "\\$\[0-9\]* = \\{priv_enum = green, x = 0\\}.*$gdb_prompt $" { pass "print obj_with_enum (2)" } + -re "$gdb_prompt $" { fail "print obj_with_enum (2)" } + timeout { fail "(timeout) print obj_with_enum (2)" } +} + +# print out the enum member +send_gdb "print obj_with_enum.priv_enum\n" +gdb_expect { + -re "\\$\[0-9\]* = green.*$gdb_prompt $" { pass "print obj_with_enum.priv_enum" } + -re "$gdb_prompt $" { fail "print obj_with_enum.priv_enum" } + timeout { fail "(timeout) print obj_with_enum.priv_enum" } +} + +# ptype on the enum member +send_gdb "ptype obj_with_enum.priv_enum\n" +gdb_expect { + -re "type = enum ClassWithEnum::PrivEnum \\{red, green, blue, yellow = 42\\}.*$gdb_prompt $" { pass "ptype obj_with_enum.priv_enum" } + -re "$gdb_prompt $" { fail "ptype obj_with_enum.priv_enum" } + timeout { fail "(timeout) ptype obj_with_enum.priv_enum" } +} + +# ptype on the object +send_gdb "ptype obj_with_enum\n" +gdb_expect { + -re "type = class ClassWithEnum \\{\r\n\[ \t\]*public:\r\n\[ \t\]*enum ClassWithEnum::PrivEnum priv_enum;\r\n\[ \t\]*int x;\r\n\\}\r\n$gdb_prompt $" { pass "ptype obj_with_enum" } + -re "$gdb_prompt $" { fail "ptype obj_with_enum" } + timeout { fail "(timeout) ptype obj_with_enum" } +} + +send_gdb "print (ClassWithEnum::PrivEnum) 42\n" +gdb_expect { + -re "\\$\[0-9\]* = yellow.*$gdb_prompt $" { pass "print (ClassWithEnum::PrivEnum) 42" } + -re "$gdb_prompt $" { fail "print (ClassWithEnum::PrivEnum) 42" } + timeout { fail "(timeout) print (ClassWithEnum::PrivEnum) 42" } +} + + +send_gdb "maint demangle inheritance1__Fv\n" +gdb_expect { + -re "inheritance1\\(void\\).*$gdb_prompt $" { pass "demangle" } + -re ".*$gdb_prompt $" { fail "demangle" } + timeout { fail "(timeout) demangle" } +} + diff --git a/gdb/testsuite/gdb.hp/ctti-add.cc b/gdb/testsuite/gdb.hp/ctti-add.cc new file mode 100644 index 00000000000..1f50fae24c1 --- /dev/null +++ b/gdb/testsuite/gdb.hp/ctti-add.cc @@ -0,0 +1,29 @@ +template T add(T v1, T v2) +{ + T v3; + v3 = v1; + v3 += v2; + return v3; + } + +int main() +{ + char c; + int i; + float f; + extern void add1(); + extern void subr2(); + extern void subr3(); + + c = 'a'; + i = 2; + f = 4.5; + + c = add(c, c); + i = add(i, i); + f = add(f, f); + + add1(); + subr2(); + subr3(); +} diff --git a/gdb/testsuite/gdb.hp/ctti-add1.cc b/gdb/testsuite/gdb.hp/ctti-add1.cc new file mode 100644 index 00000000000..7113ecea421 --- /dev/null +++ b/gdb/testsuite/gdb.hp/ctti-add1.cc @@ -0,0 +1,16 @@ +template T add(T v1, T v2); + +void add1() +{ + char c; + int i; + float f; + + c = 'b'; + i = 3; + f = 6.5; + + c = add(c, c); + i = add(i, i); + f = add(f, f); +} diff --git a/gdb/testsuite/gdb.hp/ctti-add2.cc b/gdb/testsuite/gdb.hp/ctti-add2.cc new file mode 100644 index 00000000000..d0d9891fb2f --- /dev/null +++ b/gdb/testsuite/gdb.hp/ctti-add2.cc @@ -0,0 +1,22 @@ +template T add2(T v1, T v2) +{ + T v3; + v3 = v1; + v3 += v2; + return v3; +} + +void subr2() +{ + char c; + int i; + float f; + + c = 'b'; + i = 3; + f = 6.5; + + c = add2(c, c); + i = add2(i, i); + f = add2(f, f); +} diff --git a/gdb/testsuite/gdb.hp/ctti-add3.cc b/gdb/testsuite/gdb.hp/ctti-add3.cc new file mode 100644 index 00000000000..7ba1b019f16 --- /dev/null +++ b/gdb/testsuite/gdb.hp/ctti-add3.cc @@ -0,0 +1,33 @@ +template T add3(T v1, T v2) +{ + T v3; + v3 = v1; + v3 += v2; + return v3; +} + +template T add4(T v1, T v2) +{ + T v3; + v3 = v1; + v3 += v2; + return v3; +} + +void subr3() +{ + char c; + int i; + float f; + + c = 'b'; + i = 3; + f = 6.5; + + c = add3(c, c); + i = add3(i, i); + f = add3(f, f); + c = add4(c, c); + i = add4(i, i); + f = add4(f, f); +} diff --git a/gdb/testsuite/gdb.hp/ctti.exp b/gdb/testsuite/gdb.hp/ctti.exp new file mode 100644 index 00000000000..e53210dda0b --- /dev/null +++ b/gdb/testsuite/gdb.hp/ctti.exp @@ -0,0 +1,269 @@ +# Copyright (C) 1998 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 is part of the gdb testsuite +# file written by Elena Zannoni (ezannoni@cygnus.com) +# +# source files ctti-add.cc, ctti-add1.cc, ctti-add2.cc, ctti-add3.cc +# + + +if $tracelevel then { + strace $tracelevel +} + + +# Check to see if we have an executable to test. If not, then either we +# haven't tried to compile one, or the compilation failed for some reason. +# In either case, just notify the user and skip the tests in this file. + +set testfile "ctti-add" +set srcfile ${testfile}.cc +set srcfile1 ${testfile}1.cc +set srcfile2 ${testfile}2.cc +set srcfile3 ${testfile}3.cc +set binfile ${objdir}/${subdir}/${testfile} + +if [get_compiler_info ${binfile} "c++"] { + return -1; +} + + +if {[skip_hp_tests $gcc_compiled]} then { continue } + +#if { [gdb_compile "${srcdir}/${subdir}/${srcfile} ${srcdir}/${subdir}/${srcfile1} ${srcdir}/${subdir}/${srcfile2} ${srcdir}/${subdir}/${srcfile3}" "${binfile}" executable {debug c++}] != "" } { +# gdb_suppress_entire_file "Testcase compile failed, so all tests in this file will automatically fail." +#} + +set cmdline "$CXX ${srcdir}/${subdir}/${srcfile} ${srcdir}/${subdir}/${srcfile1} ${srcdir}/${subdir}/${srcfile2} ${srcdir}/${subdir}/${srcfile3} -g -o ${binfile}" + +remote_exec build $cmdline + +gdb_exit +gdb_start +gdb_reinitialize_dir $srcdir/$subdir +gdb_load ${binfile} + + + +if ![runto_main] then { + perror "couldn't run to breakpoint" + continue +} + + +send_gdb "n\n" +gdb_expect { + -re "$decimal.*i = 2;.*$gdb_prompt $" { + pass "next " + } + -re ".*$gdb_prompt $" { fail "next " } + timeout { fail "next " } + } + + +send_gdb "n\n" +gdb_expect { + -re "$decimal.*f = 4.5;.*$gdb_prompt $" { + pass "next " + } + -re ".*$gdb_prompt $" { fail "next " } + timeout { fail "next " } + } + +send_gdb "n\n" +gdb_expect { + -re "$decimal.*c = add\\(c, c\\);.*$gdb_prompt $" { + pass "next " + } + -re ".*$gdb_prompt $" { fail "next " } + timeout { fail "next " } + } + +send_gdb "n\n" +gdb_expect { + -re "$decimal.*i = add\\(i, i\\);.*$gdb_prompt $" { + pass "next " + } + -re ".*$gdb_prompt $" { fail "next " } + timeout { fail "next " } + } + +send_gdb "n\n" +gdb_expect { + -re "$decimal.*f = add\\(f, f\\);.*$gdb_prompt $" { + pass "next " + } + -re ".*$gdb_prompt $" { fail "next " } + timeout { fail "next " } + } + +send_gdb "n\n" +gdb_expect { + -re "$decimal.*add1\\(\\);.*$gdb_prompt $" { + pass "next " + } + -re ".*$gdb_prompt $" { fail "next " } + timeout { fail "next " } + } + +send_gdb "print c\n" +gdb_expect { + -re ".$decimal = -62.*\r\n$gdb_prompt $" { + pass "print value of c" + } + -re ".*$gdb_prompt $" { fail "print value of c" } + timeout { fail "(timeout) print value of c" } + } + + +send_gdb "print f\n" +gdb_expect { + -re ".$decimal = 9\r\n$gdb_prompt $" { + pass "print value of f" + } + -re ".*$gdb_prompt $" { fail "print value of f" } + timeout { fail "(timeout) print value of f" } + } + + +send_gdb "print i\n" +gdb_expect { + -re ".$decimal = 4\r\n$gdb_prompt $" { + pass "print value of i" + } + -re ".*$gdb_prompt $" { fail "print value of i" } + timeout { fail "(timeout) print value of i" } + } + + + +send_gdb "print add(2,2)\n" +gdb_expect { + -re ".$decimal = 4\r\n$gdb_prompt $" { + pass "print value of add(2,2)" + } + -re ".*$gdb_prompt $" { fail "print value of add(2,2)" } + timeout { fail "(timeout) print value of add(2,2)" } + } + +send_gdb "print add(2.3,2.3)\n" +gdb_expect { + -re ".$decimal = 4\\.5\[0-9\]+\r\n$gdb_prompt $" { + pass "print value of add(2.3,2.3)" + } + -re ".*$gdb_prompt $" { fail "print value of add(2.3,2.3)" } + timeout { fail "(timeout) print value of add(2.3,2.3)" } + } + +send_gdb "print add('A','A')\n" +gdb_expect { + -re ".$decimal = -126.*202.\r\n$gdb_prompt $" { + pass "print value of add('A','A')" + } + -re ".*$gdb_prompt $" { fail "print value of add('A','A')" } + timeout { fail "(timeout) print value of add('A','A')" } + } + + +send_gdb "print add2(2,2)\n" +gdb_expect { + -re ".$decimal = 4\r\n$gdb_prompt $" { + pass "print value of add2(2,2)" + } + -re ".*$gdb_prompt $" { fail "print value of add2(2,2)" } + timeout { fail "(timeout) print value of add2(2,2)" } + } + +send_gdb "print add2(2.3,2.3)\n" +gdb_expect { + -re ".$decimal = 4\\.5\[0-9\]+\r\n$gdb_prompt $" { + pass "print value of add2(2.3,2.3)" + } + -re ".*$gdb_prompt $" { fail "print value of add2(2.3,2.3)" } + timeout { fail "(timeout) print value of add2(2.3,2.3)" } + } + +send_gdb "print add2('A','A')\n" +gdb_expect { + -re ".$decimal = -126.*202.\r\n$gdb_prompt $" { + pass "print value of add2('A','A')" + } + -re ".*$gdb_prompt $" { fail "print value of add2('A','A')" } + timeout { fail "(timeout) print value of add2('A','A')" } + } + +send_gdb "print add3(2,2)\n" +gdb_expect { + -re ".$decimal = 4\r\n$gdb_prompt $" { + pass "print value of add3(2,2)" + } + -re ".*$gdb_prompt $" { fail "print value of add3(2,2)" } + timeout { fail "(timeout) print value of add3(2,2)" } + } + +send_gdb "print add3(2.3,2.3)\n" +gdb_expect { + -re ".$decimal = 4\\.5\[0-9\]+\r\n$gdb_prompt $" { + pass "print value of add3(2.3,2.3)" + } + -re ".*$gdb_prompt $" { fail "print value of add3(2.3,2.3)" } + timeout { fail "(timeout) print value of add3(2.3,2.3)" } + } + +send_gdb "print add3('A','A')\n" +gdb_expect { + -re ".$decimal = -126.*202.\r\n$gdb_prompt $" { + pass "print value of add3('A','A')" + } + -re ".*$gdb_prompt $" { fail "print value of add3('A','A')" } + timeout { fail "(timeout) print value of add3('A','A')" } + } + +send_gdb "print add4(2,2)\n" +gdb_expect { + -re ".$decimal = 4\r\n$gdb_prompt $" { + pass "print value of add4(2,2)" + } + -re ".*$gdb_prompt $" { fail "print value of add4(2,2)" } + timeout { fail "(timeout) print value of add4(2,2)" } + } + +send_gdb "print add4(2.3,2.3)\n" +gdb_expect { + -re ".$decimal = 4\\.5\[0-9\]+\r\n$gdb_prompt $" { + pass "print value of add4(2.3,2.3)" + } + -re ".*$gdb_prompt $" { fail "print value of add4(2.3,2.3)" } + timeout { fail "(timeout) print value of add4(2.3,2.3)" } + } + +send_gdb "print add4('A','A')\n" +gdb_expect { + -re ".$decimal = -126.*202.\r\n$gdb_prompt $" { + pass "print value of add4('A','A')" + } + -re ".*$gdb_prompt $" { fail "print value of add4('A','A')" } + timeout { fail "(timeout) print value of add4('A','A')" } + } + + +gdb_exit +return 0 diff --git a/gdb/testsuite/gdb.hp/dbx.exp b/gdb/testsuite/gdb.hp/dbx.exp new file mode 100644 index 00000000000..ea953f3d52d --- /dev/null +++ b/gdb/testsuite/gdb.hp/dbx.exp @@ -0,0 +1,217 @@ +# Copyright (C) 1998 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 + + +if $tracelevel then { + strace $tracelevel +} + +set testfile1 "average" +set testfile2 "sum" +set testfile "dbx-test" +set binfile1 ${objdir}/${subdir}/${testfile1} +set binfile2 ${objdir}/${subdir}/${testfile2} +set binfile ${objdir}/${subdir}/${testfile} + + + +if { [gdb_compile "${srcdir}/${subdir}/average.c" "${binfile1}.o" object {debug}] != "" } { + gdb_suppress_entire_file "Testcase compile failed, so all tests in this file will automatically fail." +} + +if { [gdb_compile "${srcdir}/${subdir}/sum.c" "${binfile2}.o" object {debug}] != "" } { + gdb_suppress_entire_file "Testcase compile failed, so all tests in this file will automatically fail." +} + +if { [gdb_compile "${binfile1}.o ${binfile2}.o" ${binfile} executable {debug}] != "" } { + gdb_suppress_entire_file "Testcase compile failed, so all tests in this file will automatically fail." +} + + +proc dbx_reinitialize_dir { subdir } { + global gdb_prompt + + send_gdb "use\n" + gdb_expect { + -re "Reinitialize source path to empty.*y or n. " { + send_gdb "y\n" + gdb_expect { + -re "Source directories searched.*$gdb_prompt $" { + send_gdb "use $subdir\n" + gdb_expect { + -re "Source directories searched.*$gdb_prompt $" { + verbose "Dir set to $subdir" + } + -re ".*$gdb_prompt $" { + perror "Dir \"$subdir\" failed." + } + } + } + -re ".*$gdb_prompt $" { + perror "Dir \"$subdir\" failed." + } + } + } + -re ".*$gdb_prompt $" { + perror "Dir \"$subdir\" failed." + } + } +} + +# In "testsuite/config/unix-gdb.exp", the routine "gdb_load" +# is defined as "gdb_file_cmd". The binding of "gdb_file_cmd" +# is done at invocation time. Before this file is processed, +# it binds to the definition in "testsuite/lib/gdb.exp"; after +# this file is processed, it binds to this definition. +# TCL lets us overrides a previous routine definition without a +# warning (isn't that special?). +# +# This means that tests before use "file" to load a target, and +# tests afterwards use the pair "symbol-file" "exec-file". +# +# I'm leaving it as it is for now because at the moment it +# is the only test we have of the use of the combination of +# "symbol-file" and "exec-file" to load a debugging target (the +# other definition uses "file". +# +# Symbol-file and exec-file should be tested explicitly, not +# as a side effect of running a particular test (in this case, +# "testsuite/gdb.compat/dbx.exp"). +# +# +proc gdb_file_cmd {arg } { + global verbose + global loadpath + global loadfile + global GDB + global gdb_prompt + global spawn_id + upvar timeout timeout + + send_gdb "symbol-file $arg\n" + gdb_expect { + -re "Reading symbols from.*done.*$gdb_prompt $" { + verbose "\t\tLoaded $arg into the $GDB" + send_gdb "exec-file $arg\n" + return 0 + } + -re "has no symbol-table.*$gdb_prompt $" { + perror "$arg wasn't compiled with \"-g\"" + return -1 + } + -re "A program is being debugged already.*Kill it.*y or n. $" { + send_gdb "y\n" + verbose "\t\tKilling previous program being debugged" + exp_continue + } + -re "Load new symbol table from \".*\".*y or n. $" { + send_gdb "y\n" + gdb_expect { + -re "Reading symbols from.*done.*$gdb_prompt $" { + verbose "\t\tLoaded $arg with new symbol table into $GDB" + return 0 + } + timeout { + perror "(timeout) Couldn't load $arg, other program already loaded." + return -1 + } + } + } + -re ".*No such file or directory.*$gdb_prompt $" { + perror "($arg) No such file or directory\n" + return -1 + } + -re "$gdb_prompt $" { + perror "couldn't load $arg into $GDB." + return -1 + } + timeout { + perror "couldn't load $arg into $GDB (timed out)." + return -1 + } + eof { + # This is an attempt to detect a core dump, but seems not to + # work. Perhaps we need to match .* followed by eof, in which + # expect does not seem to have a way to do that. + perror "couldn't load $arg into $GDB (end of file)." + return -1 + } + } +} + +# +#test_breakpoints +# +proc test_breakpoints { } { + gdb_test "stop in main" "Breakpoint.*at.*: file.*average\.c, line 31\." + gdb_test "status" "Num.*Type.*Disp.*Enb.*Address.*What\r\n1\[ \r\]+breakpoint\[ \r\]+keep y.*in main at.*average\.c:31.*" + gdb_test "stop at 36" "Breakpoint.*at.*: file.*average\.c, line 36.*" + gdb_test "stop in 36" "Usage: stop in " + gdb_test "stop at main" "Usage: stop at " +} + +# +#test_assign +# +proc test_assign { } { + gdb_test "run" "" + gdb_test "assign first=1" "" + gdb_test "print first" ".1 = 1" +} + +# +#test_whereis +# +proc test_whereis { } { + gdb_test "whereis my_list" "All variables matching regular expression \"my_list\":\r\n\r\nFile.*average\.c:\r\nstatic int my_list\\\[10\\\];" +} + +# +#test_func +# +proc test_func { } { + gdb_test "cont" "" + gdb_test "step" "" + gdb_test "func sum" "'sum' not within current stack frame\." + gdb_test "stop in sum" "Breakpoint.*at.*: file.*sum\.c, line 11\." + gdb_test "cont" + gdb_test "func print_average" ".*in print_average.*\\(list=.*, low=0, high=6\\).*at.*average\.c:17\r\n17\[ \t\]+total = sum\\(list, low, high\\);" +} + +# Start with a fresh gdb. + +gdb_exit +global GDBFLAGS +set saved_gdbflags $GDBFLAGS + +set GDBFLAGS "$GDBFLAGS --dbx" +gdb_start +dbx_reinitialize_dir $srcdir/$subdir +gdb_load ${binfile} +send_gdb "set width 0\n" +gdb_expect -re "$gdb_prompt $" +test_breakpoints +test_assign +test_whereis +gdb_test "file average.c:1" "1\[ \t\]+/. This is a sample program.*" +test_func + +gdb_exit +set GDBFLAGS $saved_gdbflags +return 0 diff --git a/gdb/testsuite/gdb.hp/exception.cc b/gdb/testsuite/gdb.hp/exception.cc new file mode 100644 index 00000000000..27459329a8b --- /dev/null +++ b/gdb/testsuite/gdb.hp/exception.cc @@ -0,0 +1,48 @@ +// Test file for exception handling support. + +#include + +int foo (int i) +{ + if (i < 32) + throw (int) 13; + else + return i * 2; +} + +extern "C" int bar (int k, unsigned long eharg, int flag); + +int bar (int k, unsigned long eharg, int flag) +{ + cout << "k is " << k << " eharg is " << eharg << " flag is " << flag << endl; + return 1; +} + +int main() +{ + int j; + + try { + j = foo (20); + } + catch (int x) { + cout << "Got an except " << x << endl; + } + + try { + try { + j = foo (20); + } + catch (int x) { + cout << "Got an except " << x << endl; + throw; + } + } + catch (int y) { + cout << "Got an except (rethrown) " << y << endl; + } + + // Not caught + foo (20); + +} diff --git a/gdb/testsuite/gdb.hp/exception.exp b/gdb/testsuite/gdb.hp/exception.exp new file mode 100644 index 00000000000..4cafbdcd001 --- /dev/null +++ b/gdb/testsuite/gdb.hp/exception.exp @@ -0,0 +1,408 @@ +# Copyright (C) 1997, 1998 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 + +# +# tests for exception-handling support +# Written by Satish Pai 1997-07-23 + +# This file is part of the gdb testsuite + +# Note: These tests are geared to the HP aCC compiler, +# which has an idiosyncratic way of emitting debug info +# for exceptions -- it uses a callback mechanism, which +# is different from the way g++ records exception info +# for debugging + +# The tests are in two parts; the first part deals with +# statically linked (archive-bound) executables, and the +# second part repeats those tests with dynamically linked +# (shared bound) executables. (In the latter case we use +# a different mechanism to get the address of the notification +# hook in the C++ support library.) The tests themselves are +# the same in both parts. +# +# IMPORTANT: +# --------- +# IF YOU CHANGE A TEST IN ONE PART MAKE SURE YOU CHANGE IT +# -------------------------------------------------------- +# IN THE OTHER PART TOO! +# ---------------------- + + + +if $tracelevel then { + strace $tracelevel + } + + +# +# test running programs +# + +# Part I : Archive-bound executables +# ---------------------------------- + +set testfile "exception" +set srcfile ${testfile}.cc +set binfile ${objdir}/${subdir}/${testfile} + +if [get_compiler_info ${binfile} "c++"] { + return -1; +} + + +if {[skip_hp_tests $gcc_compiled]} then { continue } + +set cmdline "$CXX ${srcdir}/${subdir}/${srcfile} +A -Wl,-a,archive -g -o ${binfile}" + +remote_exec build $cmdline + +# Start with a fresh gdb + +set prms_id 0 +set bug_id 0 + +gdb_exit +gdb_start +gdb_reinitialize_dir $srcdir/$subdir +gdb_load ${binfile} + +if ![runto_main] then { + perror "couldn't run to breakpoint" + continue +} + +# Set a catch catchpoint + +send_gdb "catch catch\n" +gdb_expect { + -re "Catchpoint \[0-9\]* \\(catch\\)\r\n$gdb_prompt $" { + pass "catch catch (static executable)" + } + -re ".*$gdb_prompt $" { fail "catch catch (static executable)" } + timeout { fail "(timeout) catch catch (static executable)" } +} + +# Set a throw catchpoint + +send_gdb "catch throw\n" +gdb_expect { + -re "Catchpoint \[0-9\]* \\(throw\\)\r\n$gdb_prompt $" { + pass "catch throw (static executable)" + } + -re ".*$gdb_prompt $" { fail "catch throw (static executable)" } + timeout { fail "(timeout) catch throw (static executable)" } +} + +# The catchpoints should be listed in the list of breakpoints. + +send_gdb "info break\n" +gdb_expect { + -re ".*\[0-9\]*\[ \]*catch catch\[ \]*keep y\[ \]*exception catch\[ \]*\r\n\[0-9\]*\[ \]*catch throw\[ \]*keep y\[ \]*exception throw\[ \]*\r\n$gdb_prompt $" { + pass "info break with catchpoints (static executable)" + } + -re ".*$gdb_prompt $" { fail "info break (static executable)" } + timeout { fail "(timeout) info break (static executable)" } +} + +# Info catch currently does not work with HP aCC. No easy way to +# list the active handlers on the stack. + +send_gdb "info catch\n" +gdb_expect { + -re "Info catch not supported with this target/compiler combination.\r\n$gdb_prompt $" { + pass "info catch (static executable)" + } + -re ".*$gdb_prompt $" { fail "info catch (static executable)" } + timeout { fail "(timeout) info catch (static executable)" } +} + +# Get the first exception thrown + +send_gdb "continue\n" +gdb_expect { + -re "Continuing.*Catchpoint \[0-9\]* \\(exception thrown\\), throw location.*exception\\.cc:8, catch location .*exception\\.cc:28\r\n.*$gdb_prompt $" { + pass "caught a throw (static executable)" + } + -re ".*$gdb_prompt $" { fail "didn't catch a throw (static executable)" } + timeout { fail "(timeout) after continue -- didn't catch a throw? (static executable)" } +} + +send_gdb "backtrace\n" +gdb_expect { + -re "#0\[ \]*__d_eh_break.*\r\n#1\[ \]*$hex in __d_eh_notify_callback \\(eh_type=__EH_NOTIFY_THROW.*\r\n#2\[ \]*$hex in __eh_notify_throw.*\r\n#3\[ \]*$hex in foo \\(i=20\\) at .*exception\\.cc:8\r\n#4\[ \]*$hex in main.* at .*exception\\.cc:26\r\n$gdb_prompt $" { + pass "backtrace after throw (static executable)" + } + -re ".*$gdb_prompt $" { fail "backtrace after throw (static executable)" } + timeout { fail "(timeout) backtrace after throw (static executable)" } +} + +# Now intercept it when it is caught. + +send_gdb "continue\n" +gdb_expect { + -re "Continuing.*Catchpoint \[0-9\]* \\(exception caught\\), throw location.*exception\\.cc:8, catch location .*exception\\.cc:28\r\n.*$gdb_prompt $" { + pass "caught a catch (static executable)" + } + -re ".*$gdb_prompt $" { fail "didn't catch a catch (static executable)" } + timeout { fail "(timeout) after continue -- didn't catch a catch? (static executable)" } +} + +send_gdb "backtrace\n" +gdb_expect { + -re "#0\[ \]*__d_eh_break.*\r\n#1\[ \]*$hex in __d_eh_notify_callback \\(eh_type=__EH_NOTIFY_CATCH.*\r\n.*\r\n#3\[ \]*$hex in __throw__.*\r\n#4\[ \]*$hex in foo \\(i=20\\) at .*exception.cc:8\r\n#5\[ \]*$hex in main.* at .*exception.cc:26\r\n$gdb_prompt $" { + pass "backtrace after catch (static executable)" + } + -re ".*$gdb_prompt $" { fail "backtrace after catch (static executable)" } + timeout { fail "(timeout) backtrace after catch (static executable)" } +} + +send_gdb "continue\n" +gdb_expect { + -re "Continuing\\.\r\nGot.*\r\nCatchpoint \[0-9\]* \\(exception thrown\\), throw location.*exception\\.cc:8, catch location .*exception\\.cc:36\r\n.*$gdb_prompt $" { + pass "caught a throw (2) (static executable)" + } + -re ".*$gdb_prompt $" { fail "didn't catch a throw (2) (static executable)" } + timeout { fail "(timeout) after continue -- didn't catch a throw (2)? (static executable)" } +} + +send_gdb "continue\n" +gdb_expect { + -re "Continuing.*Catchpoint \[0-9\]* \\(exception caught\\), throw location.*exception\\.cc:8, catch location .*exception\\.cc:36\r\n.*$gdb_prompt $" { + pass "caught a catch (2) (static executable)" + } + -re ".*$gdb_prompt $" { fail "didn't catch a catch (2) (static executable)" } + timeout { fail "(timeout) after continue -- didn't catch a catch (2)? (static executable)" } +} + +# Now the exception will be rethrown. + +send_gdb "continue\n" +gdb_expect { + -re "Continuing\\.\r\nGot.*\r\nCatchpoint \[0-9\]* \\(exception thrown\\), throw location.*exception\\.cc:38, catch location .*exception\\.cc:41\r\n.*$gdb_prompt $" { + pass "caught a rethrow (static executable)" + } + -re ".*$gdb_prompt $" { fail "didn't catch a rethrow (static executable)" } + timeout { fail "(timeout) after continue -- didn't catch a rethrow? (static executable)" } +} + +send_gdb "continue\n" +gdb_expect { + -re "Continuing.*Catchpoint \[0-9\]* \\(exception caught\\), throw location.*exception\\.cc:38, catch location .*exception\\.cc:41\r\n.*$gdb_prompt $" { + pass "caught a catch (3) (static executable)" + } + -re ".*$gdb_prompt $" { fail "didn't catch a catch (3) (static executable)" } + timeout { fail "(timeout) after continue -- didn't catch a catch (3)? (static executable)" } +} + +send_gdb "backtrace\n" +gdb_expect { + -re "#0\[ \]*__d_eh_break.*\r\n#1\[ \]*$hex in __d_eh_notify_callback \\(eh_type=__EH_NOTIFY_CATCH.*\r\n.*\r\n#3\[ \]*$hex in __rethrow.*\r\n#4\[ \]*$hex in main.* at .*exception\\.cc:38\r\n#5\[ \]*$hex in foo \\(i=20\\) at .*exception.cc:8\r\n#6\[ \]*$hex in main.* at .*exception.cc:34\r\n$gdb_prompt $" { + pass "backtrace after catch (3) (static executable)" + } + -re ".*$gdb_prompt $" { fail "backtrace after catch (3) (static executable)" } + timeout { fail "(timeout) backtrace after catch (3) (static executable)" } +} + +# Now the exception will be thrown, but not catch-able anywhere. + +send_gdb "continue\n" +gdb_expect { + -re "Continuing\\.\r\nGot.*\r\nCatchpoint \[0-9\]* \\(exception thrown\\), throw location.*exception\\.cc:8, catch location unknown\r\n.*$gdb_prompt $" { + pass "caught an uncatchable throw (static executable)" + } + -re ".*$gdb_prompt $" { fail "didn't catch an uncatchable throw (static executable)" } + timeout { fail "(timeout) after continue -- didn't catch an uncatchable throw? (static executable)" } +} + +# Part II : Shared-bound executables +# ---------------------------------- + +# Start with a fresh gdb +gdb_exit +gdb_start +gdb_reinitialize_dir $srcdir/$subdir + +set prms_id 0 +set bug_id 0 + +set testfile "exception" +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 a +utomatically fail." +} + + +gdb_exit +gdb_start +gdb_reinitialize_dir $srcdir/$subdir +gdb_load ${binfile} + + +if ![runto_main] then { + perror "couldn't run to breakpoint" + continue +} + +# Set a catch catchpoint + +send_gdb "catch catch\n" +gdb_expect { + -re "Catchpoint \[0-9\]* \\(catch\\)\r\n$gdb_prompt $" { + pass "catch catch (dynamic executable)" + } + -re ".*$gdb_prompt $" { fail "catch catch (dynamic executable)" } + timeout { fail "(timeout) catch catch (dynamic executable)" } +} + +# Set a throw catchpoint + +send_gdb "catch throw\n" +gdb_expect { + -re "Catchpoint \[0-9\]* \\(throw\\)\r\n$gdb_prompt $" { + pass "catch throw (dynamic executable)" + } + -re ".*$gdb_prompt $" { fail "catch throw (dynamic executable)" } + timeout { fail "(timeout) catch throw (dynamic executable)" } +} + +# The catchpoints should be listed in the list of breakpoints. + +send_gdb "info break\n" +gdb_expect { + -re ".*\[0-9\]*\[ \]*catch catch\[ \]*keep y\[ \]*exception catch\[ \]*\r\n\[0-9\]*\[ \]*catch throw\[ \]*keep y\[ \]*exception throw\[ \]*\r\n$gdb_prompt $" { + pass "info break with catchpoints (dynamic executable)" + } + -re ".*$gdb_prompt $" { fail "info break (dynamic executable)" } + timeout { fail "(timeout) info break (dynamic executable)" } +} + +# Info catch currently does not work with HP aCC. No easy way to +# list the active handlers on the stack. + +send_gdb "info catch\n" +gdb_expect { + -re "Info catch not supported with this target/compiler combination.\r\n$gdb_prompt $" { + pass "info catch (dynamic executable)" + } + -re ".*$gdb_prompt $" { fail "info catch (dynamic executable)" } + timeout { fail "(timeout) info catch (dynamic executable)" } +} + +# Get the first exception thrown + +send_gdb "continue\n" +gdb_expect { + -re "Continuing.*Catchpoint \[0-9\]* \\(exception thrown\\), throw location.*exception\\.cc:8, catch location .*exception\\.cc:28\r\n.*$gdb_prompt $" { + pass "caught a throw (dynamic executable)" + } + -re ".*$gdb_prompt $" { fail "didn't catch a throw (dynamic executable)" } + timeout { fail "(timeout) after continue -- didn't catch a throw? (dynamic executable)" } +} + +send_gdb "backtrace\n" +gdb_expect { + -re "#0\[ \]*__d_eh_break.*\r\n#1\[ \]*$hex in __d_eh_notify_callback \\(eh_type=__EH_NOTIFY_THROW.*\r\n#2\[ \]*$hex in __eh_notify_throw.*\r\n#3\[ \]*$hex in foo \\(i=20\\) at .*exception\\.cc:8\r\n#4\[ \]*$hex in main.* at .*exception\\.cc:26\r\n$gdb_prompt $" { + pass "backtrace after throw (dynamic executable)" + } + -re ".*$gdb_prompt $" { fail "backtrace after throw (dynamic executable)" } + timeout { fail "(timeout) backtrace after throw (dynamic executable)" } +} + +# Now intercept it when it is caught. + +send_gdb "continue\n" +gdb_expect { + -re "Continuing.*Catchpoint \[0-9\]* \\(exception caught\\), throw location.*exception\\.cc:8, catch location .*exception\\.cc:28\r\n.*$gdb_prompt $" { + pass "caught a catch (dynamic executable)" + } + -re ".*$gdb_prompt $" { fail "didn't catch a catch (dynamic executable)" } + timeout { fail "(timeout) after continue -- didn't catch a catch? (dynamic executable)" } +} + +send_gdb "backtrace\n" +gdb_expect { + -re "#0\[ \]*__d_eh_break.*\r\n#1\[ \]*$hex in __d_eh_notify_callback \\(eh_type=__EH_NOTIFY_CATCH.*\r\n.*\r\n#3\[ \]*$hex in __throw__.*\r\n#4\[ \]*$hex in foo \\(i=20\\) at .*exception.cc:8\r\n#5\[ \]*$hex in main.* at .*exception.cc:26\r\n$gdb_prompt $" { + pass "backtrace after catch (dynamic executable)" + } + -re ".*$gdb_prompt $" { fail "backtrace after catch (dynamic executable)" } + timeout { fail "(timeout) backtrace after catch (dynamic executable)" } +} + +send_gdb "continue\n" +gdb_expect { + -re "Continuing\\.\r\nGot.*\r\nCatchpoint \[0-9\]* \\(exception thrown\\), throw location.*exception\\.cc:8, catch location .*exception\\.cc:36\r\n.*$gdb_prompt $" { + pass "caught a throw (2) (dynamic executable)" + } + -re ".*$gdb_prompt $" { fail "didn't catch a throw (2) (dynamic executable)" } + timeout { fail "(timeout) after continue -- didn't catch a throw (2)? (dynamic executable)" } +} + +send_gdb "continue\n" +gdb_expect { + -re "Continuing.*Catchpoint \[0-9\]* \\(exception caught\\), throw location.*exception\\.cc:8, catch location .*exception\\.cc:36\r\n.*$gdb_prompt $" { + pass "caught a catch (2) (dynamic executable)" + } + -re ".*$gdb_prompt $" { fail "didn't catch a catch (2) (dynamic executable)" } + timeout { fail "(timeout) after continue -- didn't catch a catch (2)? (dynamic executable)" } +} + +# Now the exception will be rethrown. + +send_gdb "continue\n" +gdb_expect { + -re "Continuing\\.\r\nGot.*\r\nCatchpoint \[0-9\]* \\(exception thrown\\), throw location.*exception\\.cc:38, catch location .*exception\\.cc:41\r\n.*$gdb_prompt $" { + pass "caught a rethrow (dynamic executable)" + } + -re ".*$gdb_prompt $" { fail "didn't catch a rethrow (dynamic executable)" } + timeout { fail "(timeout) after continue -- didn't catch a rethrow? (dynamic executable)" } +} + +send_gdb "continue\n" +gdb_expect { + -re "Continuing.*Catchpoint \[0-9\]* \\(exception caught\\), throw location.*exception\\.cc:38, catch location .*exception\\.cc:41\r\n.*$gdb_prompt $" { + pass "caught a catch (3) (dynamic executable)" + } + -re ".*$gdb_prompt $" { fail "didn't catch a catch (3) (dynamic executable)" } + timeout { fail "(timeout) after continue -- didn't catch a catch (3)? (dynamic executable)" } +} + +send_gdb "backtrace\n" +gdb_expect { + -re "#0\[ \]*__d_eh_break.*\r\n#1\[ \]*$hex in __d_eh_notify_callback \\(eh_type=__EH_NOTIFY_CATCH.*\r\n.*\r\n#3\[ \]*$hex in __rethrow.*\r\n#4\[ \]*$hex in main.* at .*exception\\.cc:38\r\n#5\[ \]*$hex in foo \\(i=20\\) at .*exception.cc:8\r\n#6\[ \]*$hex in main.* at .*exception.cc:34\r\n$gdb_prompt $" { + pass "backtrace after catch (3) (dynamic executable)" + } + -re ".*$gdb_prompt $" { fail "backtrace after catch (3) (dynamic executable)" } + timeout { fail "(timeout) backtrace after catch (3) (dynamic executable)" } +} + +# Now the exception will be thrown, but not catch-able anywhere. + +send_gdb "continue\n" +gdb_expect { + -re "Continuing\\.\r\nGot.*\r\nCatchpoint \[0-9\]* \\(exception thrown\\), throw location.*exception\\.cc:8, catch location unknown\r\n.*$gdb_prompt $" { + pass "caught an uncatchable throw (dynamic executable)" + } + -re ".*$gdb_prompt $" { fail "didn't catch an uncatchable throw (dynamic executable)" } + timeout { fail "(timeout) after continue -- didn't catch an uncatchable throw? (dynamic executable)" } +} + diff --git a/gdb/testsuite/gdb.hp/foll-exec.c b/gdb/testsuite/gdb.hp/foll-exec.c new file mode 100644 index 00000000000..c51fa52dcfd --- /dev/null +++ b/gdb/testsuite/gdb.hp/foll-exec.c @@ -0,0 +1,35 @@ +#include + +int global_i = 100; + +main () +{ + int local_j = global_i+1; + int local_k = local_j+1; + + printf ("follow-exec is about to execlp(execd-program)...\n"); + + execlp ("gdb.hp/execd-program", + "gdb.hp/execd-program", + "execlp arg1 from follow-exec", + (char *)0); + + printf ("follow-exec is about to execl(execd-program)...\n"); + + execl ("gdb.hp/execd-program", + "gdb.hp/execd-program", + "execl arg1 from follow-exec", + "execl arg2 from follow-exec", + (char *)0); + + { + static char * argv[] = { + "gdb.hp/execd-program", + "execv arg1 from follow-exec", + 0}; + + printf ("follow-exec is about to execv(execd-program)...\n"); + + execv ("gdb.hp/execd-program", argv); + } +} diff --git a/gdb/testsuite/gdb.hp/foll-exec.exp b/gdb/testsuite/gdb.hp/foll-exec.exp new file mode 100644 index 00000000000..f7d6089931c --- /dev/null +++ b/gdb/testsuite/gdb.hp/foll-exec.exp @@ -0,0 +1,412 @@ +# Copyright (C) 1997 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 + +if $tracelevel then { + strace $tracelevel + } + +set prms_id 0 +set bug_id 0 + +# are we on a target board +if ![isnative] then { + return +} + +if {![istarget "hppa*-*-hpux10.30"] && ![istarget "hppa*-*-hpux11.*"]} { + #setup_xfail "*-*.*" + return 0 +} + +set testfile "foll-exec" +set testfile2 "execd-program" +set srcfile ${testfile}.c +set srcfile2 ${testfile2}.c +set binfile ${objdir}/${subdir}/${testfile} +set binfile2 ${objdir}/${subdir}/${testfile2} + +# build the first test case +#if { [compile "-g -DNO_PROTOTYPES ${srcdir}/${subdir}/${srcfile2} -o ${binfile2} "] != "" } { +# perror "Couldn't compile ${srcfile2}" +# return -1 +#} +if { [gdb_compile "${srcdir}/${subdir}/${srcfile2}" "${binfile2}" executable {debug}] != "" } { + gdb_suppress_entire_file "Testcase compile failed, so all tests in this file will automatically fail." +} + +#if { [compile "-g ${srcdir}/${subdir}/${srcfile} -o ${binfile} "] != "" } { +# execute_anywhere "rm -f ${objdir}/${subdir}/${testfile}.tmp" + # built the second test case since we can't use prototypes +# warning "Prototypes not supported, rebuilding with -DNO_PROTOTYPES" +# execute_anywhere "echo set prototypes 0 > ${objdir}/${subdir}/${testfile}.tmp" +# if { [compile "-g -DNO_PROTOTYPES ${srcdir}/${subdir}/${srcfile} -o ${binfile} "] != "" } { +# perror "Couldn't compile ${testfile}.c" +# return -1 +# } +#} + +if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {debug}] != "" } { + gdb_suppress_entire_file "Testcase compile failed, so all tests in this file will automatically fail." +} + + +# Until "catch exec" is implemented on other targets... +# +if ![istarget "hppa*-hp-hpux*"] then { + setup_xfail "*-*-*" +} + +proc zap_session {} { + global gdb_prompt + global binfile + + send_gdb "kill\n" + gdb_expect { + -re ".*Kill the program being debugged.*y or n. $" { + send_gdb "y\n" + send_gdb "file $binfile\n" + gdb_expect { + -re ".*Load new symbol table from.*y or n. $" { + send_gdb "y\n" + gdb_expect { + -re "Reading symbols from.*$gdb_prompt $" {} + timeout { fail "loading symbols (timeout)"; return } + } + } + -re ".*gdb_prompt $" {} + timeout { fail "loading symbols (timeout)"; return } + } + } + -re ".*$gdb_prompt $" {} + timeout { fail "killing inferior (timeout)" ; return } + } +} + +proc do_exec_tests {} { + global gdb_prompt + global binfile + global srcfile + global srcfile2 + global testfile + global testfile2 + + # Start the program running, and stop at main. + # + if ![runto_main] then { + perror "Couldn't run ${testfile}" + return + } + + # Verify that we can see various global and local variables + # in this program, and that they have expected values. Some + # of these variables are also declared in the program we'll + # exec in a moment. + # + send_gdb "next 3\n" + gdb_expect { + -re "12.*execlp.*$gdb_prompt $"\ + {pass "step to exec call"} + -re "$gdb_prompt $" {fail "step to exec call"} + timeout {fail "(timeout) step to exec call"} + } + send_gdb "print global_i\n" + gdb_expect { + -re ".* = 100.*$gdb_prompt $"\ + {pass "print follow-exec/global_i"} + -re "$gdb_prompt $" {fail "print follow-exec/global_i"} + timeout {fail "(timeout) print follow-exec/global_i"} + } + send_gdb "print local_j\n" + gdb_expect { + -re ".* = 101.*$gdb_prompt $"\ + {pass "print follow-exec/local_j"} + -re "$gdb_prompt $" {fail "print follow-exec/local_j"} + timeout {fail "(timeout) print follow-exec/local_j"} + } + send_gdb "print local_k\n" + gdb_expect { + -re ".* = 102.*$gdb_prompt $"\ + {pass "print follow-exec/local_k"} + -re "$gdb_prompt $" {fail "print follow-exec/local_k"} + timeout {fail "(timeout) print follow-exec/local_k"} + } + + # Try stepping through an execlp call, without catching it. + # We should stop in execd-program, at its first statement. + # + send_gdb "next\n" + gdb_expect { + -re "Executing new program: .*${testfile2}.*${srcfile2}:17.*int local_j = argc;.*$gdb_prompt $"\ + {pass "step through execlp call"} + -re "$gdb_prompt $" {fail "step through execlp call"} + timeout {fail "(timeout) step through execlp call"} + } + + # Verify that we can see the variables defined in the newly-exec'd + # program, and CANNOT see those defined in the exec'ing program. + # + send_gdb "next\n" + gdb_expect { + -re "20.*printf.*$gdb_prompt $"\ + {pass "step after execlp call"} + -re "$gdb_prompt $" {fail "step after execlp call"} + timeout {fail "(timeout) step after execlp call"} + } + send_gdb "print global_i\n" + gdb_expect { + -re ".* = 0.*$gdb_prompt $"\ + {pass "print execd-program/global_i (after execlp)"} + -re "$gdb_prompt $" {fail "print execd-program/global_i (after execlp)"} + timeout {fail "(timeout) print execd-program/global_i (after execlp)"} + } + send_gdb "print local_j\n" + gdb_expect { + -re ".* = 2.*$gdb_prompt $"\ + {pass "print execd-program/local_j (after execlp)"} + -re "$gdb_prompt $" {fail "print execd-program/local_j (after execlp)"} + timeout {fail "(timeout) print execd-program/local_j (after execlp)"} + } + send_gdb "print local_k\n" + gdb_expect { + -re "No symbol \"local_k\" in current context.*$gdb_prompt $"\ + {pass "print follow-exec/local_k (after execlp)"} + -re "$gdb_prompt $" {fail "print follow-exec/local_k (after execlp)"} + timeout {fail "(timeout) print follow-exec/local_k (after execlp)"} + } + + # Explicitly kill this program, or a subsequent rerun actually runs + # the exec'd program, not the original program... + zap_session + + # Start the program running, and stop at main. + # + if ![runto_main] then { + perror "Couldn't run ${testfile} (2nd try)" + return + } + + # Verify that we can catch an exec event, and then continue + # to follow through the exec. (Since there's a breakpoint on + # "main", it'll also be transferred to the exec'd program, + # and we expect to stop there.) + # + send_gdb "catch exec\n" + gdb_expect { + -re "Catchpoint .*(exec).*$gdb_prompt $"\ + {pass "set catch exec"} + -re "$gdb_prompt $" {fail "set catch exec"} + timeout {fail "(timeout) set catch exec"} + } + + # Verify that the catchpoint is mentioned in an "info breakpoints", + # and further that the catchpoint mentions no program name. + # + send_gdb "info breakpoints\n" + gdb_expect { + -re ".*catch exec.*keep y.*$gdb_prompt $"\ + {pass "info shows catchpoint without exec pathname"} + -re ".*catch exec.*program \"\".*$gdb_prompt $"\ + {fail "info shows catchpoint without exec pathname"} + -re "$gdb_prompt $" {fail "info shows catchpoint without exec pathname"} + timeout {fail "(timeout) info shows catchpoint without exec pathname"} + } + + send_gdb "continue\n" + gdb_expect { + -re ".*Executing new program:.*${testfile2}.*Catchpoint .*(exec\'d .*${testfile2}).*in .START..*$gdb_prompt $"\ + {pass "hit catch exec"} + -re "$gdb_prompt $" {fail "hit catch exec"} + timeout {fail "(timeout) hit catch exec"} + } + + # Verify that the catchpoint is mentioned in an "info breakpoints", + # and further that the catchpoint managed to capture the exec'd + # program's name. + # + send_gdb "info breakpoints\n" + gdb_expect { + -re ".*catch exec .*program \".*${testfile2}\".*$gdb_prompt $"\ + {pass "info shows catchpoint exec pathname"} + -re "$gdb_prompt $" {fail "info shows catchpoint exec pathname"} + timeout {fail "(timeout) info shows catchpoint exec pathname"} + } + + # Verify that we can continue from the catchpoint, and land in the + # main of the newly-exec'd program. + # + send_gdb "continue\n" + gdb_expect { + -re ".*${srcfile2}:17.*$gdb_prompt $"\ + {pass "continue after hit catch exec"} + -re "$gdb_prompt $" {fail "continue after hit catch exec"} + timeout {fail "(timeout) continue after hit catch exec"} + } + + # Explicitly kill this program, or a subsequent rerun actually runs + # the exec'd program, not the original program... + zap_session + + # Start the program running, and stop at main. + # + if ![runto_main] then { + perror "Couldn't run ${testfile} (3rd try)" + return + } + + # Verify that we can follow through follow an execl() + # call. (We must jump around earlier exec* calls.) + # + send_gdb "tbreak 19\n" + gdb_expect { + -re "Breakpoint .*file .*${srcfile}, line 19.*$gdb_prompt $"\ + {pass "prepare to jump to execl call"} + -re "$gdb_prompt $" {fail "prepare to jump to execl call"} + timeout {fail "(timeout) prepare to jump to execl call"} + } + send_gdb "jump 19\n" + gdb_expect { + -re "main.* at .*${srcfile}:19.*$gdb_prompt $"\ + {pass "jump to execl call"} + -re "$gdb_prompt $" {fail "jump to execl call"} + timeout {fail "(timeout) jump to execl call"} + } + # Note that stepping through an exec call causes the step-count + # to be reset to zero. I.e.: you may specify "next 2" at the + # call, but you'll actually stop at the first breakpoint set in + # the newly-exec'd program, not after the remaining step-count + # reaches zero. + # + send_gdb "next 2\n" + gdb_expect { + -re "Executing new program: .*${testfile2}.*${srcfile2}:17.*int local_j = argc;.*$gdb_prompt $"\ + {pass "step through execl call"} + -re "$gdb_prompt $" {fail "step through execl call"} + timeout {fail "(timeout) step through execl call"} + } + send_gdb "next\n" + gdb_expect { + -re "20.*printf.*$gdb_prompt $"\ + {pass "step after execl call"} + -re "$gdb_prompt $" {fail "step after execl call"} + timeout {fail "(timeout) step after execl call"} + } + + # Verify that we can print a local variable (which happens to be + # assigned the value of main's argc). + # + send_gdb "print local_j\n" + gdb_expect { + -re ".* = 3.*$gdb_prompt $"\ + {pass "print execd-program/local_j (after execl)"} + -re "$gdb_prompt $" {fail "print execd-program/local_j (after execl)"} + timeout {fail "(timeout) print execd-program/local_j (after execl)"} + } + + # Explicitly kill this program, or a subsequent rerun actually runs + # the exec'd program, not the original program... + zap_session + + # Start the program running, and stop at main. + # + if ![runto_main] then { + perror "Couldn't run ${testfile} (4th try)" + return + } + + # Verify that we can follow through follow an execv() + # call. (We must jump around earlier exec* calls.) + # + send_gdb "tbreak 33\n" + gdb_expect { + -re "Breakpoint .*file .*${srcfile}, line 33.*$gdb_prompt $"\ + {pass "prepare to jump to execv call"} + -re "$gdb_prompt $" {fail "prepare to jump to execv call"} + timeout {fail "(timeout) prepare to jump to execv call"} + } + send_gdb "jump 33\n" + gdb_expect { + -re "main.* at .*${srcfile}:33.*$gdb_prompt $"\ + {pass "jump to execv call"} + -re "$gdb_prompt $" {fail "jump to execv call"} + timeout {fail "(timeout) jump to execv call"} + } + send_gdb "next\n" + gdb_expect { + -re "Executing new program: .*${testfile2}.*${srcfile2}:17.*int local_j = argc;.*$gdb_prompt $"\ + {pass "step through execv call"} + -re "$gdb_prompt $" {fail "step through execv call"} + timeout {fail "(timeout) step through execv call"} + } + send_gdb "next\n" + gdb_expect { + -re "20.*printf.*$gdb_prompt $"\ + {pass "step after execv call"} + -re "$gdb_prompt $" {fail "step after execv call"} + timeout {fail "(timeout) step after execv call"} + } + + # Verify that we can print a local variable (which happens to be + # assigned the value of main's argc). + # + send_gdb "print local_j\n" + gdb_expect { + -re ".* = 2.*$gdb_prompt $"\ + {pass "print execd-program/local_j (after execv)"} + -re "$gdb_prompt $" {fail "print execd-program/local_j (after execv)"} + timeout {fail "(timeout) print execd-program/local_j (after execv)"} + } + + # Explicitly kill this program, or a subsequent rerun actually runs + # the exec'd program, not the original program... + zap_session + + # Start the program running, and stop at main. + # + if ![runto_main] then { + perror "Couldn't run ${testfile} (4th try)" + return + } + + # Verify that we can just continue and thereby follow through an + # exec call. (Since the breakpoint on "main" is reset, we should + # just stop in main of the newly-exec'd program.) + # + send_gdb "continue\n" + gdb_expect { + -re "Executing new program: .*${testfile2}.*${srcfile2}:17.*int local_j = argc;.*$gdb_prompt $"\ + {pass "continue through exec"} + -re "$gdb_prompt $" {fail "continue through exec"} + timeout {fail "(timeout) continue through exec"} + } +} + +# Start with a fresh gdb + +gdb_exit +gdb_start +gdb_reinitialize_dir $srcdir/$subdir +gdb_load ${binfile} + + +# This is a test of gdb's ability to follow a process through a +# Unix exec() system call. +# +do_exec_tests + +return 0 diff --git a/gdb/testsuite/gdb.hp/foll-fork,c b/gdb/testsuite/gdb.hp/foll-fork,c new file mode 100644 index 00000000000..89f92ae22fe --- /dev/null +++ b/gdb/testsuite/gdb.hp/foll-fork,c @@ -0,0 +1,25 @@ +#include + +void callee (i) + int i; +{ + printf("callee: %d\n", i); +} + +main () +{ + int pid; + int v = 5; + + pid = fork (); + if (pid == 0) + { + v++; + /* printf ("I'm the child!\n"); */ + } + else + { + v--; + /* printf ("I'm the proud parent of child #%d!\n", pid); */ + } +} diff --git a/gdb/testsuite/gdb.hp/foll-fork.exp b/gdb/testsuite/gdb.hp/foll-fork.exp new file mode 100644 index 00000000000..7231764f3b4 --- /dev/null +++ b/gdb/testsuite/gdb.hp/foll-fork.exp @@ -0,0 +1,385 @@ +# Copyright (C) 1997 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 + +if $tracelevel then { + strace $tracelevel + } + +set prms_id 0 +set bug_id 0 + +# are we on a target board +if ![isnative] then { + return +} + +if {![istarget "hppa*-*-hpux10.30"] && ![istarget "hppa*-*-hpux11.*"]} { + #setup_xfail "*-*.*" + return 0 +} + +set testfile "foll-fork" +set srcfile ${testfile}.c +set binfile ${objdir}/${subdir}/${testfile} + +# build the first test case +#if { [compile "-g ${srcdir}/${subdir}/${srcfile} -o ${binfile} "] != "" } { +# execute_anywhere "rm -f ${objdir}/${subdir}/${testfile}.tmp" + # built the second test case since we can't use prototypes +# warning "Prototypes not supported, rebuilding with -DNO_PROTOTYPES" +# execute_anywhere "echo set prototypes 0 > ${objdir}/${subdir}/${testfile}.tmp" +# if { [compile "-g -DNO_PROTOTYPES ${srcdir}/${subdir}/${srcfile} -o ${binfile} "] != "" } { +# perror "Couldn't compile ${testfile}.c" +# return -1 +# } +#} + +if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {debug}] != "" } { + gdb_suppress_entire_file "Testcase compile failed, so all tests in this file will automatically fail." +} + + + +# Until "set follow-fork-mode" and "catch fork" are implemented on +# other targets... +# +if ![istarget "hppa*-hp-hpux*"] then { + setup_xfail "*-*-*" +} + +proc default_fork_parent_follow {} { + global gdb_prompt + + send_gdb "show follow\n" + gdb_expect { + -re "Debugger response to a program call of fork or vfork is \"parent\"..*$gdb_prompt $"\ + {pass "default show parent follow, no catchpoints"} + -re "$gdb_prompt $" {fail "default show parent follow, no catchpoints"} + timeout {fail "(timeout) default show parent follow, no catchpoints"} + } + send_gdb "next 2\n" + gdb_expect { + -re "Detaching after fork from.*$gdb_prompt $"\ + {pass "default parent follow, no catchpoints"} + -re "$gdb_prompt $" {fail "default parent follow, no catchpoints"} + timeout {fail "(timeout) default parent follow, no catchpoints" } + } + # The child has been detached; allow time for any output it might + # generate to arrive, so that output doesn't get confused with + # any expected debugger output from a subsequent testpoint. + # + exec sleep 1 +} + +proc explicit_fork_parent_follow {} { + global gdb_prompt + + send_gdb "set follow parent\n" + gdb_expect { + -re "$gdb_prompt $" {pass "set follow parent"} + timeout {fail "(timeout) set follow parent"} + } + send_gdb "show follow\n" + gdb_expect { + -re "Debugger response to a program call of fork or vfork is \"parent\"..*$gdb_prompt $"\ + {pass "explicit show parent follow, no catchpoints"} + -re "$gdb_prompt $" {fail "explicit show parent follow, no catchpoints"} + timeout {fail "(timeout) explicit show parent follow, no catchpoints"} + } + send_gdb "next 2\n" + gdb_expect { + -re "Detaching after fork from.*$gdb_prompt $"\ + {pass "explicit parent follow, no catchpoints"} + -re "$gdb_prompt $" {fail "explicit parent follow, no catchpoints"} + timeout {fail "(timeout) explicit parent follow, no catchpoints"} + } + # The child has been detached; allow time for any output it might + # generate to arrive, so that output doesn't get confused with + # any expected debugger output from a subsequent testpoint. + # + exec sleep 1 +} + +proc explicit_fork_child_follow {} { + global gdb_prompt + + send_gdb "set follow child\n" + gdb_expect { + -re "$gdb_prompt $" {pass "set follow child"} + timeout {fail "(timeout) set follow child"} + } + send_gdb "show follow\n" + gdb_expect { + -re "Debugger response to a program call of fork or vfork is \"child\"..*$gdb_prompt $"\ + {pass "explicit show child follow, no catchpoints"} + -re "$gdb_prompt $" {fail "explicit show child follow, no catchpoints"} + timeout {fail "(timeout) explicit show child follow, no catchpoints"} + } + send_gdb "next 2\n" + gdb_expect { + -re "Detaching from program:.*Attaching after fork to.*$gdb_prompt $"\ + {pass "explicit child follow, no catchpoints"} + -re "$gdb_prompt $" {fail "explicit child follow, no catchpoints"} + timeout {fail "(timeout) explicit child follow, no catchpoints"} + } + # The child has been detached; allow time for any output it might + # generate to arrive, so that output doesn't get confused with + # any gdb_expected debugger output from a subsequent testpoint. + # + exec sleep 1 +} + +proc catch_fork_child_follow {} { + global gdb_prompt + + send_gdb "catch fork\n" + gdb_expect { + -re "Catchpoint .*(fork).*$gdb_prompt $"\ + {pass "explicit child follow, set catch fork"} + -re "$gdb_prompt $" {fail "explicit child follow, set catch fork"} + timeout {fail "(timeout) explicit child follow, set catch fork"} + } + + # Verify that the catchpoint is mentioned in an "info breakpoints", + # and further that the catchpoint mentions no process id. + # + send_gdb "info breakpoints\n" + gdb_expect { + -re ".*catch fork.*keep y.*$gdb_prompt $"\ + {pass "info shows catchpoint without pid"} + -re ".*catch fork.*process .*$gdb_prompt $"\ + {fail "info shows catchpoint without pid"} + -re "$gdb_prompt $" {fail "info shows catchpoint without pid"} + timeout {fail "(timeout) info shows catchpoint without pid"} + } + + send_gdb "continue\n" + gdb_expect { + -re "Catchpoint.*(forked process.*),.*in _fork_sys.*$gdb_prompt $"\ + {pass "explicit child follow, catch fork"} + -re "$gdb_prompt $" {fail "explicit child follow, catch fork"} + timeout {fail "(timeout) explicit child follow, catch fork"} + } + + # Verify that the catchpoint is mentioned in an "info breakpoints", + # and further that the catchpoint managed to capture a process id. + # + send_gdb "info breakpoints\n" + gdb_expect { + -re ".*catch fork .*process \[0-9\]+.*$gdb_prompt $"\ + {pass "info shows catchpoint pid"} + -re "$gdb_prompt $" {fail "info shows catchpoint pid"} + timeout {fail "(timeout) info shows catchpoint pid"} + } + + send_gdb "set follow child\n" + gdb_expect { + -re "$gdb_prompt $" {pass "set follow child"} + timeout {fail "(timeout) set follow child"} + } + send_gdb "tbreak 15\n" + gdb_expect { + -re "Breakpoint.*, line 15.*$gdb_prompt $"\ + {pass "set follow child, tbreak"} + -re "$gdb_prompt $" {fail "set follow child, tbreak"} + timeout {fail "(timeout) set follow child, tbreak"} + } + send_gdb "continue\n" + gdb_expect { + -re ".*Detaching from program:.*Attaching after fork to.* at .*15.*$gdb_prompt $"\ + {pass "set follow child, hit tbreak"} + -re "$gdb_prompt $" {fail "set follow child, hit tbreak"} + timeout {fail "(timeout) set follow child, hit tbreak"} + } + # The child has been detached; allow time for any output it might + # generate to arrive, so that output doesn't get confused with + # any expected debugger output from a subsequent testpoint. + # + exec sleep 1 + send_gdb "delete breakpoints\n" + gdb_expect { + -re "Delete all breakpoints.*$" { + send_gdb "y\n" + gdb_expect { + -re "$gdb_prompt $"\ + {pass "set follow child, cleanup"} + timeout {fail "(timeout) set follow child, cleanup"} + } + } + -re "$gdb_prompt $" {fail "set follow child, cleanup"} + timeout {fail "(timeout) set follow child, cleanup"} + } +} + +proc tcatch_fork_parent_follow {} { + global gdb_prompt + + send_gdb "catch fork\n" + gdb_expect { + -re "Catchpoint .*(fork).*$gdb_prompt $"\ + {pass "explicit parent follow, set tcatch fork"} + -re "$gdb_prompt $" {fail "explicit parent follow, set tcatch fork"} + timeout {fail "(timeout) explicit parent follow, set tcatch fork"} + } +# ??rehrauer: I don't yet know how to get the id of the tcatch +# via this script, so that I can add a -do list to it. For now, +# do the follow stuff after the catch happens. + + send_gdb "continue\n" + gdb_expect { + -re ".*in _fork_sys.*$gdb_prompt $"\ + {pass "explicit parent follow, tcatch fork"} + -re "$gdb_prompt $" {fail "explicit parent follow, tcatch fork"} + timeout {fail "(timeout) explicit parent follow, tcatch fork"} + } + send_gdb "set follow parent\n" + gdb_expect { + -re "$gdb_prompt $" {pass "set follow parent"} + timeout {fail "(timeout) set follow parent"} + } + send_gdb "tbreak 15\n" + gdb_expect { + -re "Breakpoint.*, line 15.*$gdb_prompt $"\ + {pass "set follow parent, tbreak"} + -re "$gdb_prompt $" {fail "set follow parent, tbreak"} + timeout {fail "(timeout) set follow child, tbreak"} + } + send_gdb "continue\n" + gdb_expect { + -re ".*Detaching after fork from.* at .*15.*$gdb_prompt $"\ + {pass "set follow parent, hit tbreak"} + -re "$gdb_prompt $" {fail "set follow parent, hit tbreak"} + timeout {fail "(timeout) set follow parent, hit tbreak"} + } + # The child has been detached; allow time for any output it might + # generate to arrive, so that output doesn't get confused with + # any expected debugger output from a subsequent testpoint. + # + exec sleep 1 + send_gdb "delete breakpoints\n" + gdb_expect { + -re "Delete all breakpoints.*$" { + send_gdb "y\n" + gdb_expect { + -re "$gdb_prompt $"\ + {pass "set follow parent, cleanup"} + timeout {fail "(timeout) set follow parent, cleanup"} + } + } + -re "$gdb_prompt $" {fail "set follow parent, cleanup"} + timeout {fail "(timeout) set follow parent, cleanup"} + } +} + +proc do_fork_tests {} { + global gdb_prompt + + # Verify that help is available for "set follow-fork-mode". + # + send_gdb "help set follow-fork-mode\n" + gdb_expect { + -re "Set debugger response to a program call of fork or vfork..* +A fork or vfork creates a new process. follow-fork-mode can be:.* +.*parent - the original process is debugged after a fork.* +.*child - the new process is debugged after a fork.* +.*ask - the debugger will ask for one of the above choices.* +For \"parent\" or \"child\", the unfollowed process will run free..* +By default, the debugger will follow the parent process..*$gdb_prompt $"\ + { pass "help set follow" } + -re "$gdb_prompt $" { fail "help set follow" } + timeout { fail "(timeout) help set follow" } + } + + # Verify that we can set follow-fork-mode, using an abbreviation + # for both the flag and its value. + # + send_gdb "set follow ch\n" + send_gdb "show fol\n" + gdb_expect { + -re "Debugger response to a program call of fork or vfork is \"child\".*$gdb_prompt $"\ + {pass "set follow, using abbreviations"} + timeout {fail "(timeout) set follow, using abbreviations"} + } + + # Verify that we cannot set follow-fork-mode to nonsense. + # + send_gdb "set follow chork\n" + gdb_expect { + -re "Undefined item: \"chork\".*$gdb_prompt $"\ + {pass "set follow to nonsense is prohibited"} + -re "$gdb_prompt $" {fail "set follow to nonsense is prohibited"} + timeout {fail "(timeout) set follow to nonsense is prohibited"} + } + send_gdb "set follow parent\n" + gdb_expect { + -re "$gdb_prompt $" {pass "set follow to nonsense is prohibited (reset parent)"} + timeout {fail "set follow to nonsense is prohibited (reset parent)"} + } + + # Test the default behaviour, which is to follow the parent of a + # fork, and detach from the child. Do this without catchpoints. + # + if [runto_main] then { default_fork_parent_follow } + + # Test the ability to explicitly follow the parent of a fork, and + # detach from the child. Do this without catchpoints. + # + if [runto_main] then { explicit_fork_parent_follow } + + # Test the ability to follow the child of a fork, and detach from + # the parent. Do this without catchpoints. + # + if [runto_main] then { explicit_fork_child_follow } + + # Test the ability to follow both child and parent of a fork. Do + # this without catchpoints. + # ??rehrauer: NYI. Will add testpoints here when implemented. + # + + # Test the ability to have the debugger ask the user at fork-time + # whether to follow the parent, child or both. Do this without + # catchpoints. + # ??rehrauer: NYI. Will add testpoints here when implemented. + # + + # Test the ability to catch a fork, specify that the child be + # followed, and continue. Make the catchpoint permanent. + # + if [runto_main] then { catch_fork_child_follow } + + # Test the ability to catch a fork, specify via a -do clause that + # the parent be followed, and continue. Make the catchpoint temporary. + # + if [runto_main] then { tcatch_fork_parent_follow } +} + +# Start with a fresh gdb + +gdb_exit +gdb_start +gdb_reinitialize_dir $srcdir/$subdir +gdb_load ${binfile} + + +# This is a test of gdb's ability to follow the parent, child or both +# parent and child of a Unix fork() system call. +# +do_fork_tests + +return 0 diff --git a/gdb/testsuite/gdb.hp/foll-vfork.c b/gdb/testsuite/gdb.hp/foll-vfork.c new file mode 100644 index 00000000000..c7e6cd32909 --- /dev/null +++ b/gdb/testsuite/gdb.hp/foll-vfork.c @@ -0,0 +1,15 @@ +#include + +main () +{ + int pid; + + pid = vfork (); + if (pid == 0) { + printf ("I'm the child!\n"); + execlp ("gdb.hp/vforked-program", "gdb.hp/vforked-program", (char *)0); + } + else { + printf ("I'm the proud parent of child #%d!\n", pid); + } +} diff --git a/gdb/testsuite/gdb.hp/foll-vfork.exp b/gdb/testsuite/gdb.hp/foll-vfork.exp new file mode 100644 index 00000000000..26c6981f974 --- /dev/null +++ b/gdb/testsuite/gdb.hp/foll-vfork.exp @@ -0,0 +1,381 @@ +# Copyright (C) 1997 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 + +if $tracelevel then { + strace $tracelevel + } + +set prms_id 0 +set bug_id 0 + +# are we on a target board +if ![isnative] then { + return +} + +if {![istarget "hppa*-*-hpux10.30"] && ![istarget "hppa*-*-hpux11.*"]} { + #setup_xfail "*-*.*" + return 0 +} + +set testfile "foll-vfork" +set testfile2 "vforked-program" +set srcfile ${testfile}.c +set srcfile2 ${testfile2}.c +set binfile ${objdir}/${subdir}/${testfile} +set binfile2 ${objdir}/${subdir}/${testfile2} + +# build the first test case +#execute_anywhere "echo set prototypes 1 > ${objdir}/${subdir}/${testfile}.tmp" +#if { [compile "-g -DNO_PROTOTYPES ${srcdir}/${subdir}/${srcfile2} -o ${binfile2} "] != "" } { +# perror "Couldn't compile ${srcfile2}" +# return -1 +#} + +if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {debug}] != "" } { + gdb_suppress_entire_file "Testcase compile failed, so all tests in this file will automatically fail." +} + +#if { [compile "-g ${srcdir}/${subdir}/${srcfile} -o ${binfile} "] != "" } { +# execute_anywhere "rm -f ${objdir}/${subdir}/${testfile}.tmp" + # built the second test case since we can't use prototypes +# warning "Prototypes not supported, rebuilding with -DNO_PROTOTYPES" +# execute_anywhere "echo set prototypes 0 > ${objdir}/${subdir}/${testfile}.tmp" +# if { [compile "-g -DNO_PROTOTYPES ${srcdir}/${subdir}/${srcfile} -o ${binfile} "] != "" } { +# perror "Couldn't compile ${testfile}.c" +# return -1 +# } +#} + +if { [gdb_compile "${srcdir}/${subdir}/${srcfile2}" "${binfile2}" executable {debug}] != "" } { + gdb_suppress_entire_file "Testcase compile failed, so all tests in this file will automatically fail." +} + + +# Until "set follow-fork-mode" and "catch vfork" are implemented on +# other targets... +# +if ![istarget "hppa*-hp-hpux*"] then { + setup_xfail "*-*-*" +} + + +# A few of these tests require a little more time than the standard +# timeout allows. +set oldtimeout $timeout +set timeout [expr "$timeout + 10"] + +proc vfork_parent_follow_through_step {} { + global gdb_prompt + + send_gdb "set follow parent\n" + gdb_expect { + -re "$gdb_prompt $" {pass "set follow parent, vfork through step"} + timeout {fail "set follow parent, vfork through step"} + } + send_gdb "next\n" + gdb_expect { + -re "Detaching after fork from.*8.*$gdb_prompt $"\ + {pass "vfork parent follow, through step"} + -re "$gdb_prompt $" {fail "vfork parent follow, through step"} + timeout {fail "(timeout) vfork parent follow, through step" } + } + # The child has been detached; allow time for any output it might + # generate to arrive, so that output doesn't get confused with + # any gdb_expected debugger output from a subsequent testpoint. + # + exec sleep 1 +} + +proc vfork_parent_follow_to_bp {} { + global gdb_prompt + + send_gdb "set follow parent\n" + gdb_expect { + -re "$gdb_prompt $" {pass "set follow parent, vfork to bp"} + timeout {fail "set follow parent, vfork to bp"} + } + send_gdb "break 13\n" + gdb_expect { + -re "$gdb_prompt $" {pass "break, vfork to bp"} + timeout {fail "break, vfork to bp"} + } + send_gdb "continue\n" + gdb_expect { + -re ".*Detaching after fork from process.*Breakpoint.*13.*$gdb_prompt $"\ + {pass "vfork parent follow, to bp"} + -re "$gdb_prompt $" {fail "vfork parent follow, to bp"} + timeout {fail "(timeout) vfork parent follow, to bp" } + } + # The child has been detached; allow time for any output it might + # generate to arrive, so that output doesn't get confused with + # any expected debugger output from a subsequent testpoint. + # + exec sleep 1 +} + +proc vfork_and_exec_child_follow_to_main_bp {} { + global gdb_prompt + global binfile + + send_gdb "set follow child\n" + gdb_expect { + -re "$gdb_prompt $" {pass "set follow child, vfork and exec to main bp"} + timeout {fail "set follow child, vfork and exec to main bp"} + } + send_gdb "continue\n" + gdb_expect { + -re "Detaching from program.*Attaching after fork to.*Executing new program.*Breakpoint.*vforked-program.c:5.*$gdb_prompt $"\ + {pass "vfork and exec child follow, to main bp"} + -re "$gdb_prompt $" {fail "vfork and exec child follow, to main bp"} + timeout {fail "(timeout) vfork and exec child follow, to main bp" } + } + # The parent has been detached; allow time for any output it might + # generate to arrive, so that output doesn't get confused with + # any gdb_expected debugger output from a subsequent testpoint. + # + exec sleep 1 + + # Explicitly kill this child, or a subsequent rerun actually runs + # the exec'd child, not the original program... + send_gdb "kill\n" + gdb_expect { + -re ".*Kill the program being debugged.*y or n. $" { + send_gdb "y\n" + send_gdb "file $binfile\n" + gdb_expect { + -re ".*Load new symbol table from.*y or n. $" { + send_gdb "y\n" + gdb_expect { + -re "Reading symbols from.*$gdb_prompt $" {} + timeout { fail "loading symbols (timeout)"; return } + } + } + -re ".*gdb_prompt $" {} + timeout { fail "loading symbols (timeout)"; return } + } + } + -re ".*$gdb_prompt $" {} + timeout { fail "killing inferior (timeout)" ; return } + } +} + +proc vfork_and_exec_child_follow_through_step {} { + global gdb_prompt + global binfile + +# This test cannot be performed prior to HP-UX 10.30, because ptrace-based +# debugging of a vforking program basically doesn't allow the child to do +# things like hit a breakpoint between a vfork and exec. This means that +# saying "set follow child; next" at a vfork() call won't work, because +# the implementation of "next" sets a "step resume" breakpoint at the +# return from the vfork(), which the child will hit on its way to exec'ing. +# + if { ![istarget "hppa*-*-hpux10.30"] && ![istarget "hppa*-*-hpux11.*"] } { + verbose "vfork child-following next test ignored for non-hppa or pre-HP/UX-10.30 targets." + return 0 + } + + send_gdb "set follow child\n" + gdb_expect { + -re "$gdb_prompt $" {pass "set follow child, vfork and exec through step"} + timeout {fail "set follow child, vfork and exec through step"} + } + send_gdb "next\n" + gdb_expect { + -re "Detaching from program.*Attaching after fork to.*Executing new program.*Breakpoint.*vforked_program.c:5.*$gdb_prompt $"\ + {pass "vfork and exec child follow, through step"} + -re "$gdb_prompt $" {fail "vfork and exec child follow, through step"} + timeout {fail "(timeout) vfork and exec child follow, through step" } + } + # The parent has been detached; allow time for any output it might + # generate to arrive, so that output doesn't get confused with + # any expected debugger output from a subsequent testpoint. + # + exec sleep 1 + + # Explicitly kill this child, or a subsequent rerun actually runs + # the exec'd child, not the original program... + send_gdb "kill\n" + gdb_expect { + -re ".*Kill the program being debugged.*y or n. $" { + send_gdb "y\n" + send_gdb "file $binfile\n" + gdb_expect { + -re ".*Load new symbol table from.*y or n. $" { + send_gdb "y\n" + gdb_expect { + -re "Reading symbols from.*$gdb_prompt $" {} + timeout { fail "loading symbols (timeout)"; return } + } + } + -re ".*gdb_prompt $" {} + timeout { fail "loading symbols (timeout)"; return } + } + } + -re ".*$gdb_prompt $" {} + timeout { fail "killing inferior (timeout)" ; return } + } +} + +proc tcatch_vfork_then_parent_follow {} { + global gdb_prompt + global srcfile + + send_gdb "set follow parent\n" + gdb_expect { + -re "$gdb_prompt $" {pass "set follow parent, tcatch vfork"} + timeout {fail "set follow parent, tcatch vfork"} + } + send_gdb "tcatch vfork\n" + gdb_expect { + -re "Catchpoint .*(vfork).*$gdb_prompt $"\ + {pass "vfork parent follow, set tcatch vfork"} + -re "$gdb_prompt $" {fail "vfork parent follow, set tcatch vfork"} + timeout {fail "(timeout) vfork parent follow, set tcatch vfork"} + } + send_gdb "continue\n" +# HP-UX 10.20 seems to stop you in "vfork", while more recent HP-UXs +# stop you in "_vfork". + gdb_expect { + -re "0x\[0-9a-fA-F\]*.*vfork.*$gdb_prompt $"\ + {pass "vfork parent follow, tcatch vfork"} + -re "0x\[0-9a-fA-F\]*.*_vfork.*$gdb_prompt $"\ + {pass "vfork parent follow, tcatch vfork"} + -re "$gdb_prompt $" {fail "vfork parent follow, tcatch vfork"} + timeout {fail "(timeout) vfork parent follow, tcatch vfork"} + } + send_gdb "finish\n" + gdb_expect { + -re "Run till exit from.*vfork.*0x\[0-9a-fA-F\]* in main .* at .*${srcfile}:7.*$gdb_prompt $"\ + {pass "vfork parent follow, finish after tcatch vfork"} + -re "$gdb_prompt $" {fail "vfork parent follow, finish after tcatch vfork"} + timeout {fail "(timeout) vfork parent follow, finish after tcatch vfork" } + } + # The child has been detached; allow time for any output it might + # generate to arrive, so that output doesn't get confused with + # any expected debugger output from a subsequent testpoint. + # + exec sleep 1 +} + +proc tcatch_vfork_then_child_follow {} { + global gdb_prompt + global srcfile2 + + send_gdb "set follow child\n" + gdb_expect { + -re "$gdb_prompt $" {pass "set follow child, tcatch vfork"} + timeout {fail "set follow child, tcatch vfork"} + } + send_gdb "tcatch vfork\n" + gdb_expect { + -re "Catchpoint .*(vfork).*$gdb_prompt $"\ + {pass "vfork child follow, set tcatch vfork"} + -re "$gdb_prompt $" {fail "vfork child follow, set tcatch vfork"} + timeout {fail "(timeout) vfork child follow, set tcatch vfork"} + } + send_gdb "continue\n" +# HP-UX 10.20 seems to stop you in "vfork", while more recent HP-UXs +# stop you in "_vfork". + gdb_expect { + -re "0x\[0-9a-fA-F\]*.*vfork.*$gdb_prompt $"\ + {pass "vfork child follow, tcatch vfork"} + -re "0x\[0-9a-fA-F\]*.*_vfork.*$gdb_prompt $"\ + {pass "vfork child follow, tcatch vfork"} + -re "$gdb_prompt $" {fail "vfork child follow, tcatch vfork"} + timeout {fail "(timeout) vfork child follow, tcatch vfork"} + } + send_gdb "finish\n" + gdb_expect { + -re "Run till exit from.*vfork.*${srcfile2}:5.*$gdb_prompt $"\ + {pass "vfork child follow, finish after tcatch vfork"} + -re "$gdb_prompt $" {fail "vfork child follow, finish after tcatch vfork"} + timeout {fail "(timeout) vfork child follow, finish after tcatch vfork" } + } + # The parent has been detached; allow time for any output it might + # generate to arrive, so that output doesn't get confused with + # any expected debugger output from a subsequent testpoint. + # + exec sleep 1 +} + +proc do_vfork_and_exec_tests {} { + global gdb_prompt + + # Try following the parent process by stepping through a call to + # vfork. Do this without catchpoints. + if [runto_main] then { vfork_parent_follow_through_step } + + # Try following the parent process by setting a breakpoint on the + # other side of a vfork, and running to that point. Do this + # without catchpoints. + if [runto_main] then { vfork_parent_follow_to_bp } + + # Try following the child process by just continuing through the + # vfork, and letting the parent's breakpoint on "main" be auto- + # magically reset in the child. + # + if [runto_main] then { vfork_and_exec_child_follow_to_main_bp } + + # Try following the child process by stepping through a call to + # vfork. The child also executes an exec. Since the child cannot + # be debugged until after it has exec'd, and since there's a bp on + # "main" in the parent, and since the bp's for the parent are + # recomputed in the exec'd child, the step through a vfork should + # land us in the "main" for the exec'd child, too. + # + if [runto_main] then { vfork_and_exec_child_follow_through_step } + + # Try catching a vfork, and stepping out to the parent. + # + if [runto_main] then { tcatch_vfork_then_parent_follow } + + # Try catching a vfork, and stepping out to the child. + # + if [runto_main] then { tcatch_vfork_then_child_follow } + + # Test the ability to follow both child and parent of a vfork. Do + # this without catchpoints. + # ??rehrauer: NYI. Will add testpoints here when implemented. + # + + # Test the ability to have the debugger ask the user at vfork-time + # whether to follow the parent, child or both. Do this without + # catchpoints. + # ??rehrauer: NYI. Will add testpoints here when implemented. + # +} + +# Start with a fresh gdb + +gdb_exit +gdb_start +gdb_reinitialize_dir $srcdir/$subdir +gdb_load ${binfile} + + +# This is a test of gdb's ability to follow the parent or child +# of a Unix vfork() system call. (The child will subsequently +# call a variant of a Unix exec() system call.) +# +do_vfork_and_exec_tests + +set timeout $oldtimeout +return 0 diff --git a/gdb/testsuite/gdb.hp/inherit-hp.exp b/gdb/testsuite/gdb.hp/inherit-hp.exp new file mode 100644 index 00000000000..645358ec0da --- /dev/null +++ b/gdb/testsuite/gdb.hp/inherit-hp.exp @@ -0,0 +1,849 @@ +# Copyright (C) 1992, 1993, 1994, 1997 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 Fred Fish. (fnf@cygnus.com) + +set ws "\[\r\n\t \]+" + +if $tracelevel then { + strace $tracelevel +} + +# Check to see if we have an executable to test. If not, then either we +# haven't tried to compile one, or the compilation failed for some reason. +# In either case, just notify the user and skip the tests in this file. +# Note - create separate "inherit" executable from misc.cc + +set testfile "inherit-hp" +set srcfile misc-hp.cc +set binfile ${objdir}/${subdir}/${testfile} + +if [get_compiler_info ${binfile} "c++"] { + return -1; +} + + +if {[skip_hp_tests $gcc_compiled]} then { continue } + + +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." +} + +# +# Single inheritance, print individual members. +# + +proc test_print_si_members {} { + # Print all members of g_A using fully qualified form. + + gdb_test "print g_A.A::a" ".* = 1" "print g_A.A::a" + + gdb_test "print g_A.A::x" ".* = 2" "print g_A.A::x" + + # Print members of g_A using nonambiguous compact form. + + gdb_test "print g_A.a" ".* = 1" "print g_A.a" + + gdb_test "print g_A.x" ".* = 2" "print g_A.x" + + # Print all members of g_B using fully qualified form. + + gdb_test "print g_B.A::a" ".* = 3" "print g_B.A::a" + + gdb_test "print g_B.A::x" ".* = 4" "print g_B.A::x" + + gdb_test "print g_B.B::b" ".* = 5" "print g_B.B::b" + + gdb_test "print g_B.B::x" ".* = 6" "print g_B.B::x" + + # Print members of g_B using nonambiguous compact form. + + setup_xfail_format "DWARF 1" + gdb_test "print g_B.a" ".* = 3" "print g_B.a" + + gdb_test "print g_B.b" ".* = 5" "print g_B.b" + + gdb_test "print g_B.x" ".* = 6" "print g_B.x" + + # Print all members of g_C using fully qualified form. + + gdb_test "print g_C.A::a" ".* = 7" "print g_C.A::a" + + gdb_test "print g_C.A::x" ".* = 8" "print g_C.A::x" + + gdb_test "print g_C.C::c" ".* = 9" "print g_C.C::c" + + gdb_test "print g_C.C::x" ".* = 10" "print g_C.C::x" + + # Print members of g_C using nonambiguous compact form. + + setup_xfail_format "DWARF 1" + gdb_test "print g_C.a" ".* = 7" "print g_C.a" + + gdb_test "print g_C.c" ".* = 9" "print g_C.c" + + gdb_test "print g_C.x" ".* = 10" "print g_C.x" +} + +# +# Single inheritance, print type definitions. +# + +proc test_ptype_si {} { + global gdb_prompt + global ws + + # Print class A as a type. + + send_gdb "ptype A\n" + gdb_expect { + -re "type = class A \{\r\n.*\[ \]*int a;\r\n\[ \]*int x;\r\n.*\[ \]*\}\r\n$gdb_prompt $" { + pass "ptype A (FIXME)" + } + -re "type = struct A \{\r\n\[ \]*int a;\r\n\[ \]*int x;\r\n\[ \]*\}\r\n$gdb_prompt $" { + setup_xfail "*-*-*" + fail "ptype A (FIXME)" + } + -re ".*$gdb_prompt $" { fail "ptype A" } + timeout { fail "ptype A (timeout)" ; return } + } + + # Print class A as an explicit class. + + send_gdb "ptype class A\n" + gdb_expect { + -re "type = class A \{\r\n.*\[ \]*int a;\r\n\[ \]*int x;\r\n.*\[ \]*\}\r\n$gdb_prompt $" { + pass "ptype class A (FIXME)" + } + -re "type = struct A \{\r\n\[ \]*int a;\r\n\[ \]*int x;\r\n\[ \]*\}\r\n$gdb_prompt $" { + setup_xfail "*-*-*" + fail "ptype class A (FIXME)" + } + -re ".*$gdb_prompt $" { fail "ptype class A" } + timeout { fail "ptype class A (timeout)" ; return } + } + + # Print type of an object of type A. + + send_gdb "ptype g_A\n" + gdb_expect { + -re "type = class A \{\r\n.*\[ \]*int a;\r\n\[ \]*int x;\r\n.*\[ \]*\}\r\n$gdb_prompt $" { + pass "ptype g_A (FIXME)" + } + -re "type = struct A \{\r\n\[ \]*int a;\r\n\[ \]*int x;\r\n\[ \]*\}\r\n$gdb_prompt $" { + setup_xfail "*-*-*" + fail "ptype g_A (FIXME)" + } + -re ".*$gdb_prompt $" { fail "ptype g_A" } + timeout { fail "ptype g_A (timeout)" ; return } + } + + # Print class B as a type. + + setup_xfail_format "DWARF 1" + gdb_test "ptype B" "type = class B : public A \{\r\n\[ \]*public:\r\n\[ \]*int b;\r\n\[ \]*int x;\r\n.*\}" "ptype B" + + # Print class B as an explicit class. + + setup_xfail_format "DWARF 1" + gdb_test "ptype class B" "type = class B : public A \{\r\n\[ \]*public:\r\n\[ \]*int b;\r\n\[ \]*int x;\r\n.*\}" "ptype class B" + + # Print type of an object of type B. + + setup_xfail_format "DWARF 1" + gdb_test "ptype g_B" "type = class B : public A \{\r\n\[ \]*public:\r\n\[ \]*int b;\r\n\[ \]*int x;\r\n.*\}" "ptype g_B" + + # Print class C as a type. + + setup_xfail_format "DWARF 1" + gdb_test "ptype C" "type = class C : public A \{\r\n\[ \]*public:\r\n\[ \]*int c;\r\n\[ \]*int x;\r\n.*\}" "ptype C" + + # Print class C as an explicit class. + + setup_xfail_format "DWARF 1" + gdb_test "ptype class C" "type = class C : public A \{\r\n\[ \]*public:\r\n\[ \]*int c;\r\n\[ \]*int x;\r\n.*\}" "ptype class C" + + # Print type of an object of type g_C. + + setup_xfail_format "DWARF 1" + gdb_test "ptype g_C" "type = class C : public A \{\r\n\[ \]*public:\r\n\[ \]*int c;\r\n\[ \]*int x;\r\n.*\}" "ptype g_C" + + # gcc cygnus-2.3.3 (Q1) has this bug, but it was fixed as of + # cygnus-2.3.3-930417. PR 2819. + send_gdb "ptype tagless_struct\n" + gdb_expect { + -re "type = class \{${ws}public:${ws}int one;${ws}int two;${ws}tagless_struct & operator=\\(tagless_struct &\\);${ws}\\\$_1 \\(tagless_struct &\\);${ws}\\\$_1 \\(\\);${ws}\}\r\n$gdb_prompt $" { + pass "ptype tagless struct" + } + -re "type = (struct|class).*\{.*int one;.*int two;.*\}\r\n$gdb_prompt $" { + pass "ptype tagless struct (obsolete gcc or gdb)" + } + -re ".*$gdb_prompt $" { + fail "ptype tagless struct" + } + timeout { + fail "ptype tagless struct (timeout)" + } + } + + send_gdb "ptype v_tagless\n" + gdb_expect { + -re "type = class \{${ws}public:${ws}int one;${ws}int two;${ws}tagless_struct & operator=\\(tagless_struct &\\);${ws}\\\$_1 \\(tagless_struct &\\);${ws}\\\$_1 \\(\\);${ws}\}\r\n$gdb_prompt $" { + pass "ptype variable of type tagless struct" + } + -re "type = (struct|class).*\{.*int one;.*int two;.*\}\r\n$gdb_prompt $" { + pass "ptype variable of type tagless struct (obsolete gcc or gdb)" + } + -re ".*$gdb_prompt $" { + fail "ptype variable of type tagless struct" + } + timeout { + fail "ptype variable of type tagless struct (timeout)" + } + } +} + +# +# Single inheritance, print complete classes. +# + +proc test_print_si_classes {} { + # Print all members of g_A. + + gdb_test "print g_A" ".* = \{a = 1, x = 2\}" "print g_A" + + # Print all members of g_B. + + setup_xfail_format "DWARF 1" + gdb_test "print g_B" ".* = \{\ = \{a = 3, x = 4\}, b = 5, x = 6\}" "print g_B" + + # Print all members of g_C. + + setup_xfail_format "DWARF 1" + gdb_test "print g_C" ".* = \{\ = \{a = 7, x = 8\}, c = 9, x = 10\}" "print g_C" +} + +# +# Single inheritance, print anonymous unions. +# GDB versions prior to 4.14 entered an infinite loop when printing +# the type of a class containing an anonymous union, and they were also +# incapable of printing the member of an anonymous union. +# We test the printing of the member first, and perform the other tests +# only if the test succeeds, to avoid the infinite loop. +# + +proc test_print_anon_union {} { + global gdb_prompt + global ws + + setup_xfail_format "DWARF 1" + gdb_test "print g_anon_union.a" ".* = 2" "print anonymous union member" + setup_xfail_format "DWARF 1" + send_gdb "print g_anon_union\n" + gdb_expect { + -re ".* = \{one = 1, \{a = 2, b = 2\}\}\r\n$gdb_prompt $" { + pass "print variable of type anonymous union" + } + -re ".* = .*\{one = 1, = \{a = 2, b = .*\}\}\r\n$gdb_prompt $" { + pass "print variable of type anonymous union (obsolete gcc or gdb)" + } + -re ".*\r\n$gdb_prompt $" { + fail "print variable of type anonymous union" + } + timeout { + fail "print variableof type anonymous union (timeout)" + } + } + setup_xfail_format "DWARF 1" + send_gdb "ptype g_anon_union\n" + gdb_expect { + -re "type = class class_with_anon_union \{${ws}public:${ws}int one;${ws}union \{${ws}public:${ws}int a;${ws}long int b;${ws}union \{\.\.\.\} & operator=\\(union \{\.\.\.\} &\\);${ws}\\\$_0 \\(union \{\.\.\.\} &\\);${ws}\\\$_0 \\(\\);${ws}\};${ws}class_with_anon_union & operator=\\(class_with_anon_union const &\\);${ws}class_with_anon_union\\(class_with_anon_union const &\\);${ws}class_with_anon_union\\(void\\);${ws}\}\r\n$gdb_prompt $" { + pass "print type of anonymous union" + } + -re "type = (struct|class).*\{.*int one;.*union \{.*int a;.*(long|long int|int) b;.*\};.*\}\r\n$gdb_prompt $" { + pass "print type of anonymous union (obsolete gcc or gdb)" + } + -re ".*\r\n$gdb_prompt $" { + fail "print type of anonymous union" + } + timeout { + fail "print type of anonymous union (timeout)" + } + } +} + +# +# Multiple inheritance, print individual members. +# + +proc test_print_mi_members {} { + global gdb_prompt + + # Print all members of g_A. + + gdb_test "print g_A.A::a" ".* = 1" "print g_A.A::a" + + gdb_test "print g_A.A::x" ".* = 2" "print g_A.A::x" + + # Print all members of g_B. + + gdb_test "print g_B.A::a" ".* = 3" "print g_B.A::a" + + gdb_test "print g_B.A::x" ".* = 4" "print g_B.A::x" + + gdb_test "print g_B.B::b" ".* = 5" "print g_B.B::b" + + gdb_test "print g_B.B::x" ".* = 6" "print g_B.B::x" + + # Print all members of g_C. + + gdb_test "print g_C.A::a" ".* = 7" "print g_C.A::a" + + gdb_test "print g_C.A::x" ".* = 8" "print g_C.A::x" + + gdb_test "print g_C.C::c" ".* = 9" "print g_C.C::c" + + gdb_test "print g_C.C::x" ".* = 10" "print g_C.C::x" + + # Print all members of g_D. + + # The following is ambiguous, and gdb should detect this. + # For now, accept gdb's behavior as an expected failure if it + # simply prints either member correctly. + + # setup_xfail "*-*-*" + send_gdb "print g_D.A::a\n" + gdb_expect { + -re "warning: A ambiguous; using D::B::A. Use a cast to disambiguate.\r\n\\$\[0-9\]* = 11\r\n$gdb_prompt $" { + pass "print g_D.A::a" + } + -re ".* = 15\r\n$gdb_prompt $" { + fail "print g_D.A::a (did GDB's algorithm change?)" + } + -re ".* = 11\r\n$gdb_prompt $" { + fail "print g_D.A::a (ambiguity not reported)" + } + -re ".*$gdb_prompt $" { fail "print g_D.A::a" } + timeout { fail "print g_D.A::a (timeout)" ; return } + } + + # The following is ambiguous, and gdb should detect this. + # For now, accept gdb's behavior as an expected failure if it + # simply prints either member correctly. + + # setup_xfail "*-*-*" + send_gdb "print g_D.A::x\n" + gdb_expect { + -re "warning: A ambiguous; using D::B::A. Use a cast to disambiguate.\r\n\\$\[0-9\]* = 12\r\n$gdb_prompt $" { + pass "print g_D.A::x" + } + -re ".* = 16\r\n$gdb_prompt $" { + fail "print g_D.A::x (did GDB's algorithm change?)" + } + -re ".* = 12\r\n$gdb_prompt $" { + fail "print g_D.A::x (ambiguity not reported)" + } + -re ".*$gdb_prompt $" { fail "print g_D.A::x" } + timeout { fail "print g_D.A::x (timeout)" ; return } + } + + gdb_test "print g_D.B::b" ".* = 13" "print g_D.B::b" + + gdb_test "print g_D.B::x" ".* = 14" "print g_D.B::x" + + setup_xfail_format "DWARF 1" + gdb_test "print g_D.C::c" ".* = 17" "print g_D.C::c" + + setup_xfail_format "DWARF 1" + gdb_test "print g_D.C::x" ".* = 18" "print g_D.C::x" + + gdb_test "print g_D.D::d" ".* = 19" "print g_D.D::d" + + gdb_test "print g_D.D::x" ".* = 20" "print g_D.D::x" + + # Print all members of g_E. + + # The following is ambiguous, and gdb should detect this. + # For now, accept gdb's behavior as an expected failure if it + # simply prints either member correctly. + + #setup_xfail "*-*-*" + send_gdb "print g_E.A::a\n" + gdb_expect { + -re "warning: A ambiguous; using E::D::B::A. Use a cast to disambiguate.\r\n\\$\[0-9\]* = 21\r\n$gdb_prompt $" { + pass "print g_E.A::a" + } + -re ".* = 25\r\n$gdb_prompt $" { + fail "print g_E.A::a (did GDB's algorithm change?)" + } + -re ".* = 21\r\n$gdb_prompt $" { + fail "print g_E.A::a (ambiguity not reported)" + } + -re ".*$gdb_prompt $" { fail "print g_E.A::a" } + timeout { fail "print g_E.A::a (timeout)" ; return } + } + + # The following is ambiguous, and gdb should detect this. + # For now, accept gdb's behavior as an expected failure if it + # simply prints either member correctly. + + # setup_xfail "*-*-*" + send_gdb "print g_E.A::x\n" + gdb_expect { + -re "warning: A ambiguous; using E::D::B::A. Use a cast to disambiguate.\r\n\\$\[0-9\]* = 22\r\n$gdb_prompt $" { + pass "print g_E.A::x" + } + -re ".* = 26\r\n$gdb_prompt $" { + fail "print g_E.A::x (did GDB's algorithm change?)" + } + -re ".* = 22\r\n$gdb_prompt $" { + fail "print g_E.A::x (ambiguity not reported)" + } + -re ".*$gdb_prompt $" { fail "print g_E.A::x" } + timeout { fail "print g_E.A::x (timeout)" ; return } + } + + gdb_test "print g_E.B::b" ".* = 23" "print g_E.B::b" + + gdb_test "print g_E.B::x" ".* = 24" "print g_E.B::x" + + setup_xfail_format "DWARF 1" + gdb_test "print g_E.C::c" ".* = 27" "print g_E.C::c" + + setup_xfail_format "DWARF 1" + gdb_test "print g_E.C::x" ".* = 28" "print g_E.C::x" + + gdb_test "print g_E.D::d" ".* = 29" "print g_E.D::d" + + gdb_test "print g_E.D::x" ".* = 30" "print g_E.D::x" + + gdb_test "print g_E.E::e" ".* = 31" "print g_E.E::e" + + gdb_test "print g_E.E::x" ".* = 32" "print g_E.E::x" +} + +# +# Multiple inheritance, print type definitions. +# + +proc test_ptype_mi {} { + setup_xfail_format "DWARF 1" + gdb_test "ptype D" "type = class D : public B, public C \{\r\n\[ \]*public:\r\n\[ \]*int d;\r\n\[ \]*int x;\r\n.*\}" "ptype D" + + setup_xfail_format "DWARF 1" + gdb_test "ptype class D" "type = class D : public B, public C \{\r\n\[ \]*public:\r\n\[ \]*int d;\r\n\[ \]*int x;\r\n.*\}" "ptype class D" + + setup_xfail_format "DWARF 1" + gdb_test "ptype g_D" "type = class D : public B, public C \{\r\n\[ \]*public:\r\n\[ \]*int d;\r\n\[ \]*int x;\r\n.*\}" "ptype g_D" + + setup_xfail_format "DWARF 1" + gdb_test "ptype E" "type = class E : public D \{\r\n\[ \]*public:\r\n\[ \]*int e;\r\n\[ \]*int x;\r\n.*\}" "ptype E" + + setup_xfail_format "DWARF 1" + gdb_test "ptype class E" "type = class E : public D \{\r\n\[ \]*public:\r\n\[ \]*int e;\r\n\[ \]*int x;\r\n.*\}" "ptype class E" + + setup_xfail_format "DWARF 1" + gdb_test "ptype g_E" "type = class E : public D \{\r\n\[ \]*public:\r\n\[ \]*int e;\r\n\[ \]*int x;\r\n.*\}" "ptype g_E" +} + +# +# Multiple inheritance, print complete classes. +# + +proc test_print_mi_classes {} { + # Print all members of g_D. + + setup_xfail_format "DWARF 1" + gdb_test "print g_D" ".* = \{\ = \{\ = \{a = 11, x = 12\}, b = 13, x = 14\}, \ = \{\ = \{a = 15, x = 16\}, c = 17, x = 18\}, d = 19, x = 20\}" "print g_D" + + # Print all members of g_E. + + setup_xfail_format "DWARF 1" + gdb_test "print g_E" ".* = \{\ = \{\ = \{\ = \{a = 21, x = 22\}, b = 23, x = 24\}, \ = \{\ = \{a = 25, x = 26\}, c = 27, x = 28\}, d = 29, x = 30\}, e = 31, x = 32\}" "print g_E" +} + +# +# Single virtual inheritance, print individual members. +# + +proc test_print_svi_members {} { + global gdb_prompt + global decimal + + # Print all members of g_vA. + + gdb_test "print g_vA.vA::va" ".* = 1" "print g_vA.vA::va" + + gdb_test "print g_vA.vA::vx" ".* = 2" "print g_vA.vA::vx" + + # Print members of g_vA using compact form. + + gdb_test "print g_vA.va" ".* = 1" "print g_vA.va" + + gdb_test "print g_vA.vx" ".* = 2" "print g_vA.vx" + + # Print all members of g_vB. + + setup_xfail_format "DWARF 1" + send_gdb "print g_vB.vA::va\n" + gdb_expect { + -re ".* = 3\r\n$gdb_prompt $" { pass "print g_vB.vA::va" } + -re ".*virtual baseclass botch.*$gdb_prompt $" { + # Does not happen with gcc cygnus-2.4.5-930828 + fail "print g_vB.vA::va (known bug with gcc cygnus-2.4.5-930417)" + # Many of the rest of these tests have the same problem. + return 0 + } + -re ".*$gdb_prompt $" { fail "print g_vB.vA::va" } + timeout { fail "print g_vB.vA::va (timeout)" ; return } + } + + setup_xfail_format "DWARF 1" + gdb_test "print g_vB.vA::vx" ".* = 4" "print g_vB.vA::vx" + + gdb_test "print g_vB.vB::vb" ".* = 5" "print g_vB.vB::vb" + + gdb_test "print g_vB.vB::vx" ".* = 6" "print g_vB.vB::vx" + + # Print members of g_vB using compact form. + + setup_xfail_format "DWARF 1" + gdb_test "print g_vB.va" ".* = 3" "print g_vB.va" + + gdb_test "print g_vB.vb" ".* = 5" "print g_vB.vb" + + gdb_test "print g_vB.vx" ".* = 6" "print g_vB.vx" + + # Print all members of g_vC. + + setup_xfail_format "DWARF 1" + gdb_test "print g_vC.vA::va" ".* = 7" "print g_vC.vA::va" + + setup_xfail_format "DWARF 1" + gdb_test "print g_vC.vA::vx" ".* = 8" "print g_vC.vA::vx" + + gdb_test "print g_vC.vC::vc" ".* = 9" "print g_vC.vC::vc" + + gdb_test "print g_vC.vC::vx" ".* = 10" "print g_vC.vC::vx" + + # Print members of g_vC using compact form. + + setup_xfail_format "DWARF 1" + gdb_test "print g_vC.va" ".* = 7" "print g_vC.va" + + gdb_test "print g_vC.vc" ".* = 9" "print g_vC.vc" + + gdb_test "print g_vC.vx" ".* = 10" "print g_vC.vx" +} + +# +# Single virtual inheritance, print type definitions. +# + +proc test_ptype_vi {} { + global gdb_prompt + + # This class does not use any C++-specific features, so it's fine for + # it to print as "struct". + send_gdb "ptype vA\n" + gdb_expect { + -re "type = class vA \{\[\r\n\]+\[ \]*public:\[\r\n\]+\[ \]*int va;\[\r\n\]+\[ \]*int vx;\[\r\n\]+.*\}\[\r\n\]+$gdb_prompt $" { + pass "ptype vA" + } + -re "type = struct vA \{\[\r\n\]+\[ \]*int va;\[\r\n\]+\[ \]*int vx;\[\r\n\]+\}\[\r\n\]+$gdb_prompt $" { + pass "ptype vA" + } + -re ".*$gdb_prompt $" { fail "ptype vA" } + timeout { fail "ptype vA (timeout)" ; return } + } + + # This class does not use any C++-specific features, so it's fine for + # it to print as "struct". + send_gdb "ptype class vA\n" + gdb_expect { + -re "type = class vA \{\[\r\n\]+\[ \]*public:\[\r\n\]+\[ \]*int va;\[\r\n\]+\[ \]*int vx;\[\r\n\]+.*\}\[\r\n\]+$gdb_prompt $" { + pass "ptype class vA" + } + -re "type = struct vA \{\[\r\n\]+\[ \]*int va;\[\r\n\]+\[ \]*int vx;\[\r\n\]+\}\[\r\n\]+$gdb_prompt $" { + pass "ptype class vA" + } + -re ".*$gdb_prompt $" { fail "ptype class vA" } + timeout { fail "ptype class vA (timeout)" ; return } + } + + # This class does not use any C++-specific features, so it's fine for + # it to print as "struct". + send_gdb "ptype g_vA\n" + gdb_expect { + -re "type = class vA \{\[\r\n\]+\[ \]*public:\[\r\n\]+\[ \]*int va;\[\r\n\]+\[ \]*int vx;\[\r\n\]+.*\}\[\r\n\]+$gdb_prompt $" { + pass "ptype g_vA" + } + -re "type = struct vA \{\[\r\n\]+\[ \]*int va;\[\r\n\]+\[ \]*int vx;\[\r\n\]+\}\[\r\n\]+$gdb_prompt $" { + pass "ptype g_vA" + } + -re ".*$gdb_prompt $" { fail "ptype g_vA" } + timeout { fail "ptype g_vA (timeout)" ; return } + } + + setup_xfail_format "DWARF 1" + gdb_test "ptype vB" "ptype vB\[\r\n\]+type = class vB : public virtual vA \{\[\r\n\]+ public:\r\n\[ \]+int vb;\r\n\[ \]+int vx;\r\n.*\}" "ptype vB (aCC)" + + setup_xfail_format "DWARF 1" + gdb_test "ptype class vB" "type = class vB : public virtual vA \{\r\n\[ \]*public:\r\n\[ \]*int vb;\r\n\[ \]*int vx;\r\n.*\}" "ptype class vB (aCC)" + + setup_xfail_format "DWARF 1" + gdb_test "ptype g_vB" "type = class vB : public virtual vA \{\r\n\[ \]*public:\r\n\[ \]*int vb;\r\n\[ \]*int vx;\r\n.*\}" "ptype g_vB (aCC)" + + setup_xfail_format "DWARF 1" + gdb_test "ptype vC" "type = class vC : public virtual vA \{\r\n\[ \]*public:\r\n\[ \]*int vc;\r\n\[ \]*int vx;\r\n.*\}" "ptype vC (aCC)" + + setup_xfail_format "DWARF 1" + gdb_test "ptype class vC" "type = class vC : public virtual vA \{\r\n\[ \]*public:\r\n\[ \]*int vc;\r\n\[ \]*int vx;\r\n.*\}" "ptype class vC (aCC)" + + setup_xfail_format "DWARF 1" + gdb_test "ptype g_vC" "type = class vC : public virtual vA \{\r\n\[ \]*public:\r\n\[ \]*int vc;\r\n\[ \]*int vx;\r\n.*\}" "ptype g_vC (aCC)" +} + +# +# Single virtual inheritance, print complete classes. +# + +proc test_print_svi_classes {} { + global gdb_prompt + global hex + global decimal + + # Print all members of g_vA. + + gdb_test "print g_vA" ".* = \{va = 1, vx = 2\}" "print g_vA" + + # Print all members of g_vB. + + setup_xfail_format "DWARF 1" + send_gdb "print g_vB\n" + gdb_expect { + -re ".* = \{\ = \{va = 3, vx = 4\}, vb = 5, vx = 6, Virtual table at $hex\}\r\n$gdb_prompt $" { + pass "print g_vB" + } + -re ".*invalid address 0x0.*$gdb_prompt $" { + # Does not happen with gcc cygnus-2.4.5-930828 + fail "print g_vB (known bug with gcc cygnus-2.4.5-930417)" + # Many of the rest of these tests have the same problem. + return 0 + } + -re ".*$gdb_prompt $" { fail "print g_vB" } + timeout { fail "print g_vB (timeout)" ; return } + } + + # Print all members of g_vC. + + setup_xfail_format "DWARF 1" + gdb_test "print g_vC" ".* = \{\ = \{va = 7, vx = 8\}, vc = 9, vx = 10, Virtual table at $hex\}" "print g_vC" +} + +# +# Multiple virtual inheritance, print individual members. +# + +proc test_print_mvi_members {} { + global gdb_prompt + global decimal + + # Print all members of g_vD. + + setup_xfail_format "DWARF 1" + send_gdb "print g_vD.vA::va\n" + gdb_expect { + -re ".* = 19\r\n$gdb_prompt $" { pass "print g_vD.vA::va" } + -re ".*virtual baseclass botch.*$gdb_prompt $" { + # Does not happen with gcc cygnus-2.4.5-930828 + fail "print g_vD.vA::va (known bug with gcc cygnus-2.4.5-930417)" + # Many of the rest of these tests have the same problem. + return 0 + } + -re ".*$gdb_prompt $" { fail "print g_vD.vA::va" } + timeout { fail "print g_vD.vA::va (timeout)" ; return } + } + + setup_xfail_format "DWARF 1" + gdb_test "print g_vD.vA::vx" ".* = 20" "print g_vD.vA::vx" + + setup_xfail_format "DWARF 1" + gdb_test "print g_vD.vB::vb" ".* = 21" "print g_vD.vB::vb" + + setup_xfail_format "DWARF 1" + gdb_test "print g_vD.vB::vx" ".* = 22" "print g_vD.vB::vx" + + setup_xfail_format "DWARF 1" + gdb_test "print g_vD.vC::vc" ".* = 23" "print g_vD.vC::vc" + + setup_xfail_format "DWARF 1" + gdb_test "print g_vD.vC::vx" ".* = 24" "print g_vD.vC::vx" + + gdb_test "print g_vD.vD::vd" ".* = 25" "print g_vD.vD::vd" + + gdb_test "print g_vD.vD::vx" ".* = 26" "print g_vD.vD::vx" + + # Print all members of g_vE. + + setup_xfail_format "DWARF 1" + gdb_test "print g_vE.vA::va" ".* = 0" "print g_vE.vA::va" + + setup_xfail_format "DWARF 1" + gdb_test "print g_vE.vA::vx" ".* = 0" "print g_vE.vA::vx" + + setup_xfail_format "DWARF 1" + gdb_test "print g_vE.vB::vb" ".* = 0" "print g_vE.vB::vb" + + setup_xfail_format "DWARF 1" + gdb_test "print g_vE.vB::vx" ".* = 0" "print g_vE.vB::vx" + + setup_xfail_format "DWARF 1" + gdb_test "print g_vE.vC::vc" ".* = 0" "print g_vE.vC::vc" + + setup_xfail_format "DWARF 1" + gdb_test "print g_vE.vC::vx" ".* = 0" "print g_vE.vC::vx" + + setup_xfail_format "DWARF 1" + gdb_test "print g_vE.vD::vd" ".* = 0" "print g_vE.vD::vd" + + gdb_test "print g_vE.vD::vx" ".* = 0" "print g_vE.vD::vx" + + gdb_test "print g_vE.vE::ve" ".* = 27" "print g_vE.vE::ve" + + gdb_test "print g_vE.vE::vx" ".* = 28" "print g_vE.vE::vx" +} + +# +# Multiple virtual inheritance, print type definitions. +# + +proc test_ptype_mvi {} { + setup_xfail_format "DWARF 1" + gdb_test "ptype vD" "type = class vD : public virtual vB, public virtual vC \{\r\n\[ \]*public:\r\n\[ \]*int vd;\r\n\[ \]*int vx;\r\n.*\}" "ptype vD (aCC)" + + setup_xfail_format "DWARF 1" + gdb_test "ptype class vD" "type = class vD : public virtual vB, public virtual vC \{\r\n\[ \]*public:\r\n\[ \]*int vd;\r\n\[ \]*int vx;\r\n.*\}" "ptype class vD (aCC)" + + setup_xfail_format "DWARF 1" + gdb_test "ptype g_vD" "type = class vD : public virtual vB, public virtual vC \{\r\n\[ \]*public:\r\n\[ \]*int vd;\r\n\[ \]*int vx;\r\n.*\}" "ptype g_vD (aCC)" + + setup_xfail_format "DWARF 1" + gdb_test "ptype vE" "type = class vE : public virtual vD \{\r\n\[ \]*public:\r\n\[ \]*int ve;\r\n\[ \]*int vx;\r\n.*\}" "ptype vE (aCC)" + + setup_xfail_format "DWARF 1" + gdb_test "ptype class vE" "type = class vE : public virtual vD \{\r\n\[ \]*public:\r\n\[ \]*int ve;\r\n\[ \]*int vx;\r\n.*\}" "ptype class vE (aCC)" + + setup_xfail_format "DWARF 1" + gdb_test "ptype g_vE" "type = class vE : public virtual vD \{\r\n\[ \]*public:\r\n\[ \]*int ve;\r\n\[ \]*int vx;\r\n.*\}" "ptype g_vE (aCC)" +} + +# +# Multiple virtual inheritance, print complete classes. +# + +proc test_print_mvi_classes {} { + global gdb_prompt + global hex + global decimal + + # Print all members of g_vD. + + setup_xfail_format "DWARF 1" + send_gdb "print g_vD\n" + gdb_expect { + -re ".* = \{\ = \{\ = \{va = 19, vx = 20\}, vb = 21, vx = 22, Virtual table at $hex\}, \ = \{vc = 23, vx = 24, Virtual table at $hex\}, vd = 25, vx = 26, Virtual table at $hex\}\r\n$gdb_prompt $" { + pass "print g_vD" + } + -re ".*invalid address 0x0.*$gdb_prompt $" { + # Does not happen with gcc cygnus-2.4.5-930828 + fail "print g_vD (known bug with gcc cygnus-2.4.5-930417)" + # Many of the rest of these tests have the same problem. + return 0 + } + -re ".*$gdb_prompt $" { fail "print g_vD" } + timeout { fail "print g_vD (timeout)" ; return } + } + + # Print all members of g_vE. + + setup_xfail_format "DWARF 1" + gdb_test "print g_vE" ".* = \{\ = \{\ = \{\ = \{va = 0, vx = 0\}, vb = 0, vx = 0, Virtual table at $hex\}, \ = \{vc = 0, vx = 0, Virtual table at $hex\}, vd = 0, vx = 0, Virtual table at $hex\}, ve = 27, vx = 28, Virtual table at $hex\}" "print g_vE" +} + +proc do_tests {} { + global prms_id + global bug_id + global subdir + global objdir + global srcdir + global binfile + + set prms_id 0 + set bug_id 0 + + # Start with a fresh gdb. + + gdb_exit + gdb_start + gdb_reinitialize_dir $srcdir/$subdir + gdb_load $binfile + + gdb_test "set language c++" "" + gdb_test "set width 0" "" + + # Get the debug format for the compiled test case. + + if { ![ runto_main] } { + gdb_suppress_tests; + } else { + get_debug_format + } + + test_ptype_si + test_ptype_mi + test_ptype_vi + test_ptype_mvi + + gdb_stop_suppressing_tests; + + if { ![ runto 'inheritance2(void)' ] } { + gdb_suppress_tests; + } + + test_print_si_members + test_print_si_classes + test_print_mi_members + test_print_mi_classes + test_print_anon_union + + gdb_stop_suppressing_tests; + + if { ![ runto 'inheritance4(void)' ] } { + gdb_suppress_tests; + } + + test_print_svi_members + test_print_svi_classes + test_print_mvi_members + test_print_mvi_classes +} + +do_tests diff --git a/gdb/testsuite/gdb.hp/more-steps.exp b/gdb/testsuite/gdb.hp/more-steps.exp new file mode 100644 index 00000000000..320a0d68872 --- /dev/null +++ b/gdb/testsuite/gdb.hp/more-steps.exp @@ -0,0 +1,152 @@ +# more-steps.exp -- Expect script to test gdb's ability to step threaded pgms +# Copyright (C) 1992 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 + +# use this to debug: +# +#log_user 1 + +if $tracelevel then { + strace $tracelevel +} + +#if { ![istarget "hppa*-*-hpux10.30"] && ![istarget "hppa*-*-hpux11.*"] } { +# verbose "HPUX thread test ignored for non-hppa or pre-HP/UX-10.30 targets." +# return 0 +#} + +set testfile more-steps +set srcfile ${srcdir}/${subdir}/${testfile}.c +set binfile ${objdir}/${subdir}/${testfile} + +if [get_compiler_info ${binfile}] { + return -1 +} + +# To build the executable we need to link against the thread library. +# +# cc -Ae -g -o more-steps -lpthread more-steps.c +# +#compile "${srcfile} -Ae -g -lpthread -o ${binfile}" + +if {$gcc_compiled == 0} { + set additional_flags "additional_flags=-Ae" +} else { + set additional_flags "" +} + +if { [gdb_compile "${srcdir}/${subdir}/${testfile}.c" "${binfile}.o" object [list debug $additional_flags]] != "" } { + gdb_suppress_entire_file "Testcase compile failed, so all tests in this file will automatically fail." +} + +if { ![istarget "hppa*-*-hpux10.30"] && ![istarget "hppa*-*-hpux11.*"] } { + if { [gdb_compile "${binfile}.o" "${binfile}" executable {debug "additional_flags=-lpthread"}] != ""} { + gdb_suppress_entire_file "Testcase link failed, so all tests in this file will automatically fail." + } +} else { + remote_exec build "ld /usr/ccs/lib/crt0.o ${binfile}.o -lcl -lpthread -lc /opt/langtools/lib/end.o -o ${binfile}" +} +#remote_exec build "ld /usr/ccs/lib/crt0.o ${binfile}.o -lcl -lpthread -lc /opt/langtools/lib/end.o -o ${binfile}" + + + +# Thread stuff is _slow_; prepare for long waits. +# +set oldtimeout $timeout +set timeout [expr "$timeout + 300"] +set oldverbose $verbose +#set verbose 40 + +# Further, this test has some "null" lines designed +# to consume output from gdb that was too late to be +# matched (sequence is "gdb_test" sends; timeout and +# on to next send; result finally comes in; mismatch). +# +# The null command is 'gdb_test "p \$pc" ".*" ""' +# +# NOTE: to pass a literal "$", "/" or "*" (etc.) to gdb_test, +# remember that the pattern will be escaped once and +# $-evaluated twice: +# +# "\\\*" matches "\*" +# "\$" matches "$" +# +proc fix_timeout {} { + gdb_test "p \$pc" ".*" "" +} + +#========================= +# +# Simple sanity test first. +# +gdb_exit +gdb_start +gdb_reinitialize_dir $srcdir/$subdir +gdb_load ${binfile} + +# First, step in the main thread. +# +gdb_test "b do_pass" ".*Breakpoint 1.*" "" +gdb_test "r" ".*Breakpoint 1.*do_pass.*" "" + +# Breaks as well as nexts to make +# sure we can handle simultaneous hit +# of bpt and step, as well as stepping +# past bpts. +# +gdb_test "tb 87" ".*Breakpoint 2.*" "" +gdb_test "tb 91" ".*Breakpoint 3.*" "" +gdb_test "tb 96" ".*Breakpoint 4.*" "" +gdb_test "tb 113" ".*Breakpoint 5.*" "" +gdb_test "c" ".*do_pass.*87.*" "87" +gdb_test "n" ".*do_pass.*91.*" "n" + +# This only gets a number, as it doesn't +# hit a bpt. +# +gdb_test "n" ".*95.*" "n" + +gdb_test "n" ".*do_pass.*96.*" "n" +gdb_test "c" ".*do_pass.*113.*" "c" +gdb_test "c" ".*Program exited normally.*" "c" + +# Now step in a thread +# +gdb_test "r" ".*Breakpoint.*do_pass.*" "do_pass" +gdb_test "until 87" ".*do_pass.*87.*" "until" +gdb_test "thr 4" ".*Switching to thread 4.*spin.*56.*" "switch" +gdb_test "tb 60 thr 4" ".*Breakpoint.*" "" + +# If we do "next" now, all the other threads +# can finish! +# +gdb_test "n" ".*spin.*60.*" "" +gdb_test "i th" ".*\\\* 4 sys.*spin.*1 sys.*do_pass.*" "still in 4" + +# Done! +# +gdb_exit + +set timeout $oldtimeout +set verbose $oldverbose + +# execute_anywhere "rm -f ${binfile}" +# +return 0 + diff --git a/gdb/testsuite/gdb.hp/namespace.cc b/gdb/testsuite/gdb.hp/namespace.cc new file mode 100644 index 00000000000..53d5bd6608d --- /dev/null +++ b/gdb/testsuite/gdb.hp/namespace.cc @@ -0,0 +1,103 @@ +namespace AAA { + char c; + int i; + int A_foo (int); + char foo (char); + class inA { + public: + int xx; + int fum (int); + }; +}; + +int AAA::inA::fum (int i) +{ + return 10 + i; +} + +namespace BBB { + char c; + int i; + int B_foo (int); + char foo (char); + + namespace CCC { + char foo (char); + }; + + class Class { + public: + char foo (char); + int dummy; + }; +}; + +int AAA::A_foo (int x) +{ + return 2 * x; +} + +char AAA::foo (char c) +{ + return 'a'; +} + + +int BBB::B_foo (int x) +{ + return 3 * x; +} + +char BBB::foo (char c) +{ + return 'b'; +} + +char BBB::CCC::foo (char c) +{ + return 'z'; +} + +char BBB::Class::foo (char c) +{ + return 'o'; +} + +void marker1(void) +{ + return; +} + + +int main () +{ + using AAA::inA; + char c1; + + using namespace BBB; + + c1 = foo ('x'); + c1 = AAA::foo ('x'); + c1 = BBB::CCC::foo ('m'); + + inA ina; + + ina.xx = 33; + + int y; + + y = AAA::A_foo (33); + y += B_foo (44); + + BBB::Class cl; + + c1 = cl.foo('e'); + + marker1(); + +} + + + + + diff --git a/gdb/testsuite/gdb.hp/namespace.exp b/gdb/testsuite/gdb.hp/namespace.exp new file mode 100644 index 00000000000..1708db8ebb0 --- /dev/null +++ b/gdb/testsuite/gdb.hp/namespace.exp @@ -0,0 +1,195 @@ +# Copyright (C) 1997, 1998 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 + +# tests for namespaces +# Written by Satish Pai 1997-07-23 + +# This file is part of the gdb testsuite + +# Note: These tests are geared to the HP aCC compiler, +# which has an idiosyncratic way of emitting debug info +# for namespaces. + + +if $tracelevel then { + strace $tracelevel + } + + +# +# test running programs +# + +set prms_id 0 +set bug_id 0 + +set testfile "namespace" +set srcfile ${testfile}.cc +set binfile ${objdir}/${subdir}/${testfile} + +if [get_compiler_info ${binfile}] { + return -1; +} + + +if {[skip_hp_tests $gcc_compiled]} then { continue } + + +if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {debug c++}] != "" } { + gdb_suppress_entire_file "Testcase compile failed, so all tests in this file will a +utomatically 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_main] then { + perror "couldn't run to breakpoint" + continue +} + +send_gdb "break marker1\n" ; gdb_expect -re ".*$gdb_prompt $" + send_gdb "cont\n" + gdb_expect { + -re "Break.* marker1 \\(\\) at .*:$decimal.*$gdb_prompt $" { + send_gdb "up\n" + gdb_expect { + -re ".*$gdb_prompt $" { pass "up from marker1" } + timeout { fail "up from marker1" } + } + } + -re "$gdb_prompt $" { fail "continue to marker1" } + timeout { fail "(timeout) continue to marker1" } + } + +# Access a data item inside a namespace using colons and +# single quotes :-( + +send_gdb "print 'AAA::c'\n" +gdb_expect { + -re "\\$\[0-9\]* = 0 '\\\\000'\r\n$gdb_prompt $" { pass "print 'AAA::c'" } + -re ".*$gdb_prompt $" { fail "print 'AAA::c'" } + timeout { fail "(timeout) print 'AAA::c'" } +} + +# An object declared using "using". + +send_gdb "print ina\n" +gdb_expect { + -re "\\$\[0-9\]+ = {xx = 33}.*$gdb_prompt $" { + pass "print ina" + } + -re ".*$gdb_prompt $" { fail "print ina" } + timeout { fail "(timeout) print ina" } +} + +send_gdb "ptype ina\n" +gdb_expect { + -re "type = class AAA::inA \{\r\n\[ \]*public:\r\n\[ \]*int xx;\r\n\[ \]*\r\n\[ \]*int fum\\(int\\);\r\n\}\r\n$gdb_prompt $" { + pass "ptype ina" + } + -re ".*$gdb_prompt $" { fail "ptype ina" } + timeout { fail "(timeout) ptype ina" } +} + +# Check all functions are known to GDB + +send_gdb "info func foo\n" +gdb_expect { + -re "All functions.*File.*namespace.cc:\r\nint AAA::A_foo\\(int\\);\r\nint BBB::B_foo\\(int\\);\r\nchar AAA::foo\\(char\\);\r\nchar BBB::foo\\(char\\);\r\nchar BBB::CCC::foo\\(char\\);\r\nchar BBB::Class::foo\\(char\\);\r\n$gdb_prompt $" { + pass "info func foo" + } + -re ".*$gdb_prompt $" { fail "info func foo" } + timeout { fail "(timeout) info func foo" } +} + +# Call a function in a namespace + +send_gdb "print 'AAA::foo'('x')\n" +gdb_expect { + -re "\\$\[0-9\]* = 97 'a'\r\n$gdb_prompt $" { + pass "print 'AAA::foo'('x')" + } + -re ".*$gdb_prompt $" { fail "print 'AAA::foo'('x')" } + timeout { fail "(timeout) print 'AAA::foo'('x')" } +} + +# Break on a function in a namespace + +send_gdb "break AAA::foo\n" +gdb_expect { + -re "Breakpoint.*at $hex: file.*namespace.cc, line 42\\.\r\n$gdb_prompt $" { + pass "break AAA::foo" + } + -re ".*$gdb_prompt $" { fail "break AAA::foo" } + timeout { fail "(timeout) break AAA::foo" } +} + +# Call a function in a nested namespace + +send_gdb "print 'BBB::CCC::foo'('x')\n" +gdb_expect { + -re "\\$\[0-9\]* = 122 'z'\r\n$gdb_prompt $" { + pass "print 'BBB::CCC::foo'('x')" + } + -re ".*$gdb_prompt $" { fail "print 'BBB::CCC::foo'('x')" } + timeout { fail "(timeout) print 'BBB::CCC::foo'('x')" } +} + +# Break on a function in a nested namespace + +send_gdb "break BBB::CCC::foo\n" +gdb_expect { + -re "Breakpoint.*at $hex: file.*namespace.cc, line 58\\.\r\n$gdb_prompt $" { + pass "break BBB::CCC::foo" + } + -re ".*$gdb_prompt $" { fail "break BBB::CCC::foo" } + timeout { fail "(timeout) break BBB::CCC::foo" } +} + +# Print address of a function in a class in a namespace + +send_gdb "print 'BBB::Class'::foo\n" +gdb_expect { + -re "\\$\[0-9\]* = \{char \\(BBB::Class \\*, char\\)\} $hex \r\n$gdb_prompt $" { + pass "print 'BBB::Class'::foo" + } + -re ".*$gdb_prompt $" { fail "print 'BBB::Class'::foo" } + timeout { fail "(timeout) print 'BBB::Class'::foo" } +} + +# Break on a function in a class in a namespace + +send_gdb "break BBB::Class::foo\n" +gdb_expect { + -re "Breakpoint.*at $hex: file.*namespace.cc, line 63\\.\r\n$gdb_prompt $" { + pass "break BBB::Class::foo" + } + -re ".*$gdb_prompt $" { fail "break BBB::Class::foo" } + timeout { fail "(timeout) break BBB::Class::foo" } +} + diff --git a/gdb/testsuite/gdb.hp/optimize.exp b/gdb/testsuite/gdb.hp/optimize.exp new file mode 100644 index 00000000000..34606eb668f --- /dev/null +++ b/gdb/testsuite/gdb.hp/optimize.exp @@ -0,0 +1,144 @@ +# Copyright (C) 1998 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 + +# optimize.exp -- Expect script for testing apps compiled with -O + +global timeout + +# use this to debug: +# +#log_user 1 + +if $tracelevel then { + strace $tracelevel +} + +set testfile optimize +set srcfile ${testfile}.c +set binfile ${objdir}/${subdir}/${testfile} + +if [get_compiler_info ${binfile}] { + return -1; +} + + +if {[skip_hp_tests $gcc_compiled]} then { continue } + + +# Vanilla -O, which is the same as +O2 +# +if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {debug optimize=+O2}] != "" } { + 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 + +send_gdb "file $binfile\n" +gdb_expect { + -re ".*no debugging symbols found.*$gdb_prompt $" { + fail "Didn't find debug symbols; CHFts23488" + } + -re ".*No header section (PXDB data).*$gdb_prompt $" { + fail "pointless warning" + } + -re ".*done.*$gdb_prompt $" { + pass "load debug symbols" + } + timeout { fail "timeout on file" } +} + +# Two lines at the same place after opt. +# +gdb_test "b 28" ".*" "" +gdb_test "b 26" ".*also set at.*" "same line" + +gdb_test "b 47" ".*" "" +gdb_test "b 48" ".*also set at.*" "same line" + +gdb_test "tb main" ".*" "" + +set old_timeout $timeout +set timeout [expr "$timeout + 200"] +send_gdb "r\n" +gdb_expect { + -re ".*No header section (PXDB data).*$gdb_prompt $" { + fail "pointless warning" + } + -re ".*main.*2\[12].*$gdb_prompt $" { + # All the lines before line 21 or 22 are + # evaporated by the compiler. + # + pass "hit main" + } + -re ".*$gdb_prompt $" { + fail "didn't hit main" + } + timeout { fail "timeout on run" } +} +set timeout $old_timeout + +gdb_test "c" ".*Breakpoint 1.*33.*" "" +gdb_test "c" ".*51.*" "" +gdb_test "cle" ".*Deleted breakpoints.*" "set 2, so del 2" + +gdb_test "b callee" ".*" "" +gdb_test "c" ".*callee.*" "hit called rtn" + +gdb_exit + +# +O4, don't use -g +# +if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {optimize=+O4}] != "" } { + gdb_suppress_entire_file "Testcase compile failed, so all tests in this file will automatically fail." +} + +gdb_start +gdb_reinitialize_dir $srcdir/$subdir + +send_gdb "file $binfile\n" +gdb_expect { + -re ".*no debugging symbols found.*$gdb_prompt $" { + pass "Didn't find debug symbols, as expected" + } + -re ".*No header section (PXDB data).*$gdb_prompt $" { + fail "pointless warning" + } + -re ".*done.*$gdb_prompt $" { + fail "Somehow found debug symbols--make this a pass?" + } + timeout { fail "timeout on file" } +} + +gdb_test "b main" ".*" "" +gdb_test "b callee" ".*" "" +gdb_test "r" ".*Breakpoint 1.*main.*" "" +gdb_test "si 3" ".*main.*" "steps" +gdb_test "x/4i \$pc" ".*main.*main+4.*main+8.*" "" +gdb_test "c" ".*callee.*" "hit bp" +gdb_test "disas" ".*callee.*callee+4.*callee+12.*" "" +gdb_test "si" ".*callee.*" "" +gdb_test "fin" ".*Run till exit.*main.*" "finish" +gdb_test "x/i \$pc" ".*main+.*" "back in main" +gdb_exit + +#remote_exec build "rm -f ${binfile}" +return 0 diff --git a/gdb/testsuite/gdb.hp/pxdb.c b/gdb/testsuite/gdb.hp/pxdb.c new file mode 100644 index 00000000000..e3e3fc23e9f --- /dev/null +++ b/gdb/testsuite/gdb.hp/pxdb.c @@ -0,0 +1,20 @@ +#include + +int callee( x ) +int x; +{ + int y = x * x; + return (y - 2); +} + +main() +{ + int i; + for (i = 1; i < 10; i++) + { + printf( "%d ", callee( i )); + + } + printf( " Goodbye!\n" ); + +} diff --git a/gdb/testsuite/gdb.hp/pxdb.exp b/gdb/testsuite/gdb.hp/pxdb.exp new file mode 100644 index 00000000000..c8b3ace9961 --- /dev/null +++ b/gdb/testsuite/gdb.hp/pxdb.exp @@ -0,0 +1,114 @@ +# Copyright (C) 1998 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 is part of the gdb testsuite + + +# pxdb.exp Test that gdb calls pxdb on an application +# built without it. +# +if $tracelevel then { + strace $tracelevel +} + +set prms_id 0 +set bug_id 0 + +set testfile pxdb +set srcfile ${testfile}.c +set objfile ${objdir}/${subdir}/${testfile}.o +set binfile ${objdir}/${subdir}/${testfile} + +if [get_compiler_info ${binfile} "c++"] { + return -1; +} + + +if {[skip_hp_tests $gcc_compiled]} then { continue } + +# To build a non-pxdb-ed file, use +# +# +# export LD_PXDB /dev/null +# ld -o hello_no_pxdb hello.o /opt/langtools/lib/end.o /usr/ccs/lib/crt0.o -lc +# + +if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${objfile}" object {debug}] != "" } { + gdb_suppress_entire_file "Testcase compile failed, so all tests in this file will automatically fail." +} + +# +# use this to debug: +#log_user 1 + + +# Following should get the error message: +# +# ld: (Warning) Can't exec pxdb using path: /dev/null +# + +set cmdline "ksh -c \"LD_PXDB=/dev/null ld -o ${binfile} ${objfile} /usr/ccs/lib/crt0.o /opt/langtools/lib/end.o -lc\"" + +remote_exec build "rm ${binfile}" +remote_exec build $cmdline + +gdb_exit +gdb_start +gdb_reinitialize_dir $srcdir/$subdir + +# We expect to see this: +# +# "warning: File not processed by pxdb--about to process now. +# " +# ". +# "Procedures: 7 +# "Files: 2 +# "Reading symbols from ~/c_code.dir/hello_no_pxdb...done. +# "(gdb) +# +send_gdb "file ${binfile}\n" +gdb_expect { + + -re ".*warning: File not processed by pxdb.*Procedures: \[0-9\]+.*done.*$gdb_prompt $"\ + { pass "PXDB call" } + + -re "$gdb_prompt $" { fail "Didn't call pxdb" } + + timeout { fail "call pxdb (timeout)" } +} + +# Make sure the new data makes sense +# +if { ![runto callee] } then { return } + +send_gdb "print x\n" +gdb_expect { + -re ".*= 1.*$gdb_prompt $" { pass "Good data after pxdb call" } + -re ".*$gdb_prompt $" { fail "No data after pxdb call" } + timeout { fail "(timeout)" } +} + +gdb_exit +return 0 + + + + + diff --git a/gdb/testsuite/gdb.hp/quicksort.exp b/gdb/testsuite/gdb.hp/quicksort.exp new file mode 100644 index 00000000000..719bfdfb0a9 --- /dev/null +++ b/gdb/testsuite/gdb.hp/quicksort.exp @@ -0,0 +1,809 @@ +# quicksort.exp -- Expect script to test gdb with quicksort.c +# Copyright (C) 1992 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 + +# use this to debug: +# +#log_user 1 + +if $tracelevel then { + strace $tracelevel +} + +if { ![istarget "hppa*-*-hpux10.30"] && ![istarget "hppa*-*-hpux11.*"] } { + verbose "HPUX thread test ignored for non-hppa or pre-HP/UX-10.30 targets." + return 0 +} + +set testfile quicksort +set srcfile ${srcdir}/${subdir}/${testfile}.c +set binfile ${objdir}/${subdir}/${testfile} + +if [get_compiler_info ${binfile}] { + return -1 +} + +# To build the executable we need to link against the thread library. +# +# cc -Ae -g -o quicksort -lpthread quicksort.c +# +#compile "${srcfile} -Ae -g -lpthread -o ${binfile}" + +if {$gcc_compiled == 0} { + set additional_flags "additional_flags=-Ae" +} else { + set additional_flags "" +} + +if { [gdb_compile "${srcdir}/${subdir}/${testfile}.c" "${binfile}.o" object [list debug $additional_flags]] != "" } { + gdb_suppress_entire_file "Testcase compile failed, so all tests in this file will automatically fail." +} +remote_exec build "ld /usr/ccs/lib/crt0.o ${binfile}.o -lcl -lpthread -lc /opt/langtools/lib/end.o -o ${binfile}" + + +# Thread stuff is _slow_; prepare for long waits. +# +set oldtimeout $timeout +set timeout [expr "$timeout + 300"] +set oldverbose $verbose +#set verbose 40 + +# Further, this test has some "null" lines designed +# to consume output from gdb that was too late to be +# matched (sequence is "gdb_test" sends; timeout and +# on to next send; result finally comes in; mismatch). +# +# The null command is 'gdb_test "p \$pc" ".*" ""' +# +# NOTE: to pass a literal "$", "/" or "*" (etc.) to gdb_test, +# remember that the pattern will be escaped once and +# $-evaluated twice: +# +# "\\\*" matches "\*" +# "\$" matches "$" +# +proc fix_timeout {} { + gdb_test "p \$pc" ".*" "" +} + +#========================= +# +# Simple sanity test first. +# +gdb_exit +gdb_start +gdb_reinitialize_dir $srcdir/$subdir +gdb_load ${binfile} + +gdb_test "tb 122" ".*Breakpoint.*" "" +gdb_test "r" ".*122.*" "" +gdb_test "thr 99" ".*Thread ID 99 not known.*" "Check too-big thread number" +gdb_test "tb 145 thr 3" ".*Breakpoint.*" "set thread-specific bp 145" +gdb_test "tb 146 thr 4" ".*Breakpoint.*" "set thread-specific bp 146" +gdb_test "c" ".*Switched to thread.*145.*" "auto switch" +gdb_test "c" ".*Switched to thread.*146.*" "auto switch 2" +gdb_test "c" ".*Program exited normally.*" "" + +#========================= +# +# Test that you can't do a thread select after a program runs. +# +gdb_test "thread" ".*No stack.*" "No live thread after run" +gdb_test "thr 2" ".*No stack.*" "Can't set thread after run" + +#========================= +# +# Test thread command changes, look for frame level reset bug. +# +gdb_exit +gdb_start +gdb_reinitialize_dir $srcdir/$subdir +gdb_load ${binfile} +gdb_test "b 122" ".*" "" +gdb_test "r" ".*122.*" "" + +# Prep for frame level test--go up/info thread/check frame +# +gdb_test "up" ".*quick_sort.*" "" +gdb_test "up" ".*main.*" "" + +send_gdb "i th\n" +gdb_expect { + -re ".*7 thread.* in .* from .* in .* from .* 6 thread.*$gdb_prompt $" { + fail "old thread command, says things twice" + } + -re ".*7 system thread.*6 system th.*5 sys.*4.*3.*2.*1.*work_init.*$gdb_prompt $" { + pass "info threads" + } + -re ".*$gdb_prompt $" { fail "no info thread command" } + timeout { fail "timeout" } +} + +# We should have been restored two frames up--check. +# +send_gdb "up\n" +gdb_expect { + -re ".*Initial frame selected.*$gdb_prompt $" { + pass "Frame correctly reset after 'info threads'" + } + -re ".*quick_sort.*$gdb_prompt $" { + fail "Old gdb bug; should be fixed someday" + } + -re ".*$gdb_prompt $" { + fail "real bug--FIX!" + } + timeout { fail "timeout" } +} + +# Do it again, only just go to a middle frame, and use another thread. +# +gdb_test "thr 5" ".*" "" +gdb_test "bt" ".* ___ksleep.*_lwp_cond_timedwait.*pthread_cond_wait.*worker.*__pthread_create_system.*" "" +gdb_test "up" ".*1.*_lwp_cond_timedwait.*" "" +gdb_test "up" ".*2.*pthread_cond_wait.*" "" +gdb_test "up" ".*3.*worker.*" "" +gdb_test "i th" ".*7.*6.*work_init.*" "" +gdb_test "f" ".*3.*worker.*" "Frame restored" +gdb_test "p wp->max_pile" ".*= 128.*" "can see vars in frame" + +# Thread command changes +# +gdb_test "thr" ".*Current thread is 5.*" "threads-no-num" +gdb_test "thr 6" ".*Switching to thread 6.*" "new switch" +gdb_test "thr" ".*Current thread is 6.*" "check switch" +#gdb_test "thr 6" ".*Current thread is already 6.*" "dup, no switch" +gdb_test "thr app all p x" ".*No symbol.*" "" +gdb_test "thr" ".*Current thread is 6.*" "restore current thread" + +#========================= +# +# Test new stepping +# + +proc get_hit { } { + global hit2 + global hit3 + global hit4 + global hit5 + global hit6 + global hit7 + global gdb_prompt + + send_gdb "cont\n" + gdb_expect { + -re ".*Breakpoint.*145.*$gdb_prompt $" { + send_gdb "thr\n" + gdb_expect { + -re ".*is 7.*$gdb_prompt $" { + set hit7 [expr "$hit7 + 1"] + } + -re ".*is 6.*$gdb_prompt $" { + set hit6 [expr "$hit6 + 1"] + } + -re ".*is 5.*$gdb_prompt $" { + set hit5 [expr "$hit5 + 1"] + } + -re ".*is 4.*$gdb_prompt $" { + set hit4 [expr "$hit4 + 1"] + } + -re ".*is 3.*$gdb_prompt $" { + set hit3 [expr "$hit3 + 1"] + } + -re ".*is 2.*$gdb_prompt $" { + set hit2 [expr "$hit2 + 1"] + } + -re ".*$gdb_prompt $" { + fail "can't see which thread" + } + timeout { fail "timeout" } + } + } + -re ".*$gdb_prompt $" { + fail "thread command" + } + timeout { fail "timeout" } + } +} + +gdb_exit +gdb_start +gdb_reinitialize_dir $srcdir/$subdir +gdb_load ${binfile} +gdb_test "break 122" ".*" "" +gdb_test "run" ".*122.*" "" + +# Make sure we hit a bp on every thread. +# +# Try one, via thread-specific bps +# +gdb_test "break 145 thr 2" ".*" "set thread-specific bp thr 2" +gdb_test "break 145 thr 3" ".*" "set thread-specific bp thr 3" +gdb_test "break 145 thr 4" ".*" "set thread-specific bp thr 4" +gdb_test "break 145 thr 5" ".*" "set thread-specific bp thr 5" +gdb_test "break 145 thr 6" ".*" "set thread-specific bp thr 6" +gdb_test "break 145 thr 7" ".*" "set thread-specific bp thr 7" + +set hit2 0 +set hit3 0 +set hit4 0 +set hit5 0 +set hit6 0 +set hit7 0 + +get_hit +get_hit +get_hit +get_hit +get_hit +get_hit + +if { [expr "$hit2 == 1"] + && [expr "$hit3 == 1"] + && [expr "$hit4 == 1"] + && [expr "$hit5 == 1"] + && [expr "$hit6 == 1"] + && [expr "$hit7 == 1"] } { + pass "thread-specific bps 1" +} else { + fail "thread-specific bps 1" +} + +#==================== +# +# Now use generic bps +# +gdb_exit +gdb_start +gdb_reinitialize_dir $srcdir/$subdir +gdb_load ${binfile} +gdb_test "b 122" ".*" "" +gdb_test "r" ".*122.*" "" + +# Make sure we hit a bp on every thread. +# +# Try two, via non-thread-specific bp +# +gdb_test "b 145" ".*" "b 145" + +set hit2 0 +set hit3 0 +set hit4 0 +set hit5 0 +set hit6 0 +set hit7 0 + +get_hit +get_hit +get_hit +get_hit +get_hit +get_hit + +if { [expr "$hit2 == 1"] + && [expr "$hit3 == 1"] + && [expr "$hit4 == 1"] + && [expr "$hit5 == 1"] + && [expr "$hit6 == 1"] + && [expr "$hit7 == 1"] } { + pass "thread-specific bps 2" +} else { + fail "thread-specific bps 2" +} + +#==================== +# +# Complicated (original) test next. +# +gdb_exit +gdb_start +gdb_reinitialize_dir $srcdir/$subdir +gdb_load ${binfile} + +if ![runto_main] then { + fail "Can't run to main" + return 0 +} + +# OK, we're at "main", there should be one thread. +# +gdb_test "info thread" ".*\\\* 1 system thread .*main.*" "initial thread" + +# Try to see the threads being created: set a breakpoint +# after the creation and go around the loop a few times. +# +gdb_test "break 109" "Breakpoint.*109.*" "set bpt" + +gdb_test "c" ".*New thread.*Breakpoint.*109.*" "first continue" +fix_timeout + +# Make sure we don't wait (waiting is for attach test) +# +gdb_test "set wait_here = 0" ".*" "" + +send_gdb "info thr\n" +gdb_expect { + -re ".*2 system th.*1 sy.*109.*$gdb_prompt $" { pass "saw thread create" } + -re ".*1 system thread.*87.*$gdb_prompt $" { fail "didn't see thread create" } + -re ".*$gdb_prompt $" { fail "no info thread command" } + timeout { fail "timeout" } +} + +gdb_test "c" ".*New thread.*Breakpoint.*109.*" "continue" +fix_timeout + +send_gdb "info thr\n" +gdb_expect { + -re ".*3 system thread.*2 sys.*\\\* 1 system thread.*109.*$gdb_prompt $" { + pass "saw thread create" } + -re ".*2 system thread.*1 sys.*109.*$gdb_prompt $" { + fail "didn't see thread create" + } + -re ".*1 system thread.*109.*$gdb_prompt $" { + fail "didn't see thread create" + } + -re ".*$gdb_prompt $" { + fail "no info thread command" + } + timeout { fail "timeout" } +} + +fix_timeout +gdb_test "clear" ".*Deleted breakpoint.*" "" + +# Now go on to the end of thread creation. +# +gdb_test "b 122" ".*" "set bpt 122" +gdb_test "c" ".*New thread.*New thread.*New thread.*122.*" "" +gdb_test "p \$pc" ".*" "" +gdb_test "clear" ".*Deleted breakpoint.*" "" + +send_gdb "info thr\n" +gdb_expect { + -re ".*7 system thread.*6 sys.*5.*1 system thread.*122.*$gdb_prompt $" + { pass "saw thread creates" } + -re ".*$gdb_prompt $" + { fail "no info thread command" } + timeout { fail "timeout" } +} + +# Try a thread-specific breakpoint; we expect the other threads to +# be waiting at this point. +# +gdb_test "thr 3" ".*Switching to thread.*ksleep.*" "thread switch" +gdb_test "i th" ".*\\\* 3 system thread.*" "show new current thread" + +gdb_test "up" ".*lwp_cond_timedwait.*" "" +gdb_test "up" ".*pthread_cond_wait.*" "" +gdb_test "up" ".*worker.*144.*" "" + +gdb_test "b 145 th 3" ".*Breakpoint.*145.*" "set thread-specific bp" +gdb_test "i b" ".*breakpoint.*breakpoint.*145 thread 3.*" "show thread-specific bp" + +gdb_test "c" ".*Breakpoint.*145.*145.*" "hit thread-specific bp" +gdb_test "p \$pc" ".*" "" + +# Test thread apply command on thread specific data. +# +gdb_test "thre app all p \$pc" ".*Thread 7.*Thread 6.*Thread 5.*Thread 4.*Thread 3.*Thread 2.*Thread 1.*" "thread apply all" +gdb_test "thr ap 1 3 5 p \$pc" ".*Thread 1.*Thread 3.*Thread 5.*" "thr app 1 3 5" + +# Switch again, and test that others continue on a "next" +# This test _could_ fail due to timing issues, but that's +# unlikely. +# +gdb_test "thr 7" ".*Switching to thread.*" "" + +# Make sure that "up" stops at __pthread_exit, or +# __pthread_create, the pseudo-roots, and that we +# only see that pseudo-root once. +# +send_gdb "bt\n" +gdb_expect { + -re ".*Error accessing memory address.*" { fail "bt" } + -re ".*pthread_create.*pthread_create.*" { fail "bt" } + -re ".*worker.*pthread_create.*" { pass "bt" } + -re ".*pthread_exit.*" { pass "bt" } + timeout { fail "timeout on bt" } +} + +gdb_test "up" ".*" "" +gdb_test "up" ".*" "" +gdb_test "up" ".*144.*" "Up 3" +gdb_test "up" ".*pthread_.*" "Up 4" +gdb_test "up" ".*Initial frame selected; you cannot go up.*" "catch end of thread stack" + +#===================== +# +# Things get iffy here; when we step, sometimes the step +# completes, sometimes it doesn't. When it doesn't, we +# hit a bp somewhere else and the step never completes +# (wait_for_inferior just evaporates it). +# +# I think the right answer is that any failures here +# should stick around to trigger later fixing. +# +# Here's the plan: +# +# Bps at 148 (5) and 154 (6) on thread 7 (two bps so we +# see the difference between going around the loop and +# reporting the same bp hit twice). +# +# Bp at 144 on thread 3. +# +# Step out of a library routine. +# +# Either the step will finish or a bp will hit. Try to +# handle all the cases. +# +gdb_test "b 148 thr 7" ".*Breakpoint.*148.*" "" +gdb_test "b 154 thr 7" ".*Breakpoint.*154.*" "set bpt 2" + +set hit_154_bp 0 +set hit_148_bp 0 +set hit_145_bp 0 +set step_completed 0 + +# Expect zero hits +# +gdb_test "i b" ".*" "" + +send_gdb "n\n" +gdb_expect { + -re ".*Single stepping.*_lwp_cond_timedwait.*$gdb_prompt $" { + send_gdb "thr\n" + gdb_expect { + -re ".*is 7.*$gdb_prompt $" { + set step_completed 1 + pass "completed step in library code" + } + -re ".*$gdb_prompt $" { + fail "completed step in library code, but in wrong thread" + } + timeout { fail "timeout" } + } + } + -re ".*Single stepping.*Switched to thread 3.*Breakpoint.*$gdb_prompt $" { + pass "step cancelled; hit bp due to thread parallelism" + set hit_145_bp 1 + } + -re ".*Single stepping.*Switched to thread 7.*Breakpoint.*148.*$gdb_prompt $" { + pass "step cancelled; hit bp due to thread parallelism" + set hit_148_bp 1 + } + -re ".*Single stepping.*Switched to thread 7.*Breakpoint.*154.*$gdb_prompt $" { + pass "step cancelled; hit bp due to thread parallelism" + set hit_154_bp 1 + } + -re ".*$gdb_prompt $" { + send_gdb "thr\n" + gdb_expect { + -re ".*is 7.*$gdb_prompt $" { + fail "No event?" + } + -re ".*$gdb_prompt $" { + fail "No event" + } + timeout { fail "timeout" } + } + } + timeout { fail "timeout" } +} + +# Sometimes used to get SIGTRAP here; that should be fixed +# + +# Expect appropriate hits of bpt; too much work to parse +# result and check... +# +gdb_test "i b" ".*" "" + +send_gdb "c\n" +gdb_expect { + -re ".*SIGTRAP.*$gdb_prompt $" { + fail "got SIGTRAP" + } + -re ".*Switched to thread 7.*Breakpoint.*154.*$gdb_prompt $" { + if { $hit_154_bp == 1 } { + fail "re-hit old bp" + } else { + pass "continue; hit parallel event after continue" + } + set hit_154_bp 1 + } + -re ".*Switched to thread 7.*Breakpoint.*148.*$gdb_prompt $" { + if { $hit_148_bp == 1 } { + fail "re-hit old bp" + } else { + pass "continue; hit parallel event after continue" + } + set hit_148_bp 1 + } + -re ".*Breakpoint.*154.*$gdb_prompt $" { + if { $hit_154_bp == 1 } { + fail "re-hit old bp" + } else { + send_gdb "thr\n" + gdb_expect { + -re ".*is 7.*$gdb_prompt $" { + pass "continue; hit parallel event after continue" + } + -re ".*$gdb_prompt $" { + fail "hit bp in wrong thread" + } + timeout { fail "timeout" } + } + } + set hit_154_bp 1 + } + -re ".*Breakpoint.*148.*$gdb_prompt $" { + if { $hit_148_bp == 1 } { + fail "re-hit old bp" + } else { + send_gdb "thr\n" + gdb_expect { + -re ".*is 7.*$gdb_prompt $" { + pass "continue; hit parallel event after continue" + } + -re ".*$gdb_prompt $" { + fail "hit bp in wrong thread" + } + timeout { fail "timeout" } + } + } + set hit_148_bp 1 + } + -re ".*Breakpoint.*145.*$gdb_prompt $" { + if { $hit_145_bp == 1 } { + fail "re-hit old bp" + } else { + send_gdb "thr\n" + gdb_expect { + -re ".*is 3.*$gdb_prompt $" { + pass "continue; hit parallel event after continue" + } + -re ".*$gdb_prompt $" { + fail "hit bp in wrong thread" + } + timeout { fail "timeout" } + } + } + set hit_145_bp 1 + } + -re ".*_lwp_cond_timedwait.*$gdb_prompt $" { + pass "continue; hit step completion after continue" + } + -re ".*Program exited normally.*" { + fail "Program ended? HOW?" + } + -re ".*$gdb_prompt $" { + fail "Unexpected event" + } + timeout { fail "timeout" } +} + +# There are a number of places we _could_ be now; +# this is the price of really running in parallel. +# +send_gdb "n\n" +gdb_expect { + -re ".*Switched to thread 7.*pthread_cond_wait.*$gdb_prompt $" { + if { $step_completed } { + fail "step already completed" + } else { + pass "finish step" + } + } + -re ".*pthread_cond_wait.*$gdb_prompt $" { + # + # Unlikely, but we might finish the range step from inside + # ksleep, before anything else. + # + if { $step_completed } { + fail "step already completed" + } else { + send_gdb "thr\n" + gdb_expect { + -re ".*is 7.*$gdb_prompt $" { + pass "finish step" + } + -re ".*$gdb_prompt $" { + fail "step in wrong thread" + } + timeout { fail "timeout" } + } + } + } + -re ".*Switched to thread.*Breakpoint.*145.*$gdb_prompt $" { + pass "auto-switch thread" + } + -re ".*Breakpoint.*145.*$gdb_prompt $" { + pass "auto-switch not needed, ok" + } + -re ".*140.*while.*n_pile.*$gdb_prompt $" { + # + # This is just going around the loop from the 154 bp. + # + send_gdb "thr\n" + gdb_expect { + -re ".*is 7.*$gdb_prompt $" { + pass "finish step" + } + -re ".*$gdb_prompt $" { + fail "step in wrong thread" + } + timeout { fail "timeout" } + } + } + -re ".*149.*ptr = wp.*pile.*$gdb_prompt $" { + # + # This is just going around the loop from the 148 bp. + # + if { $hit_154_bp } { + send_gdb "thr\n" + gdb_expect { + -re ".*is 7.*$gdb_prompt $" { + pass "finish step" + } + -re ".*$gdb_prompt $" { + fail "step in wrong thread" + } + timeout { fail "timeout" } + } + } else { + pass "step from 149 but didn't hit it first" + } + } + -re ".*Breakpoint 5.*154.*$gdb_prompt $" { + gdb_test "i b" ".*" "" + if { $hit_154_bp } { + fail "hit bp again?" + } else { + pass "hit bp" + } + } + -re ".*Breakpoint 5.*148.*$gdb_prompt $" { + gdb_test "i b" ".*" "" + if { $hit_148_bp } { + fail "hit bp again?" + } else { + pass "hit bp" + } + } + -re ".*$gdb_prompt $" { + fail "no step finished" + } + timeout { fail "timeout on 'next'" } +} + +# Let's get into some kind of known state again. +# +gdb_test "thr 7" ".*" "" +gdb_test "info thread" ".*" "" +#gdb_test "i b" ".*" "" + +# Leave breakpoint "154 thr 7" as only live bp. +# +gdb_test "d 1" ".*" "del main bp" +gdb_test "d 4" ".*" "thread-specific bpt delete" +gdb_test "d 5" ".*" "other bp delete" +send_gdb "i b\n" +gdb_expect { + -re ".*breakpoint.*breakpoint.*$gdb_prompt $" { + fail "more than one bp left" + } + -re ".*breakpoint.*154.*thread.*7.*$gdb_prompt $" { + pass "Only one bp left" + } + -re ".*$gdb_prompt $" { + fail "Wrong or no bp left" + } + timeout { fail "timeout on info b" } +} + +send_gdb "c\n" +gdb_expect { + -re ".*SIGTRAP.*Switched to thread.*$gdb_prompt $" { + fail "SIGTRAP error; lost thread-specific bpt" + } + -re ".*SIGTRAP.*Switched to thread.*154.*$gdb_prompt $" { + fail "SIGTRAP, but hit right thread-specific bpt" + } + -re ".*Switched to thread.*Breakpoint.*154.*$gdb_prompt $" { + pass "auto-switch back" + } + -re ".*Breakpoint.*154.*$gdb_prompt $" { + pass "step to bp" + } + -re ".*$gdb_prompt $" { + fail "auto-switch back" + } + -re ".*Program exited normally.*$gdb_prompt $" { + fail "step lost" + } + timeout { + fail "timeout" + } +} +fix_timeout + +gdb_test "cle" ".*Deleted breakpoint.*" "delete last breakpoint" + +# Sometimes get SIGTRAP here. Continue sometimes gets another... +# +send_gdb "c\n" +gdb_expect { + -re ".*SIGTRAP.*154.*154.*$gdb_prompt $" { + fail "SIGTRAP on deleted bp 154 " + send_gdb "c\n" + gdb_expect { + -re ".*$gdb_prompt $" { pass "fixup"} + timeout { fail "fixup" } + } + } + -re ".*SIGTRAP.*144.*145.*$gdb_prompt $" { + fail "SIGTRAP on deleted bp 145 " + send_gdb "c\n" + gdb_expect { + -re ".*$gdb_prompt $" { pass "fixup"} + timeout { fail "fixup" } + } + } + -re ".*SIGTRAP.*148.*148.*$gdb_prompt $" { + fail "SIGTRAP on deleted bp 148 " + send_gdb "c\n" + gdb_expect { + -re ".*$gdb_prompt $" { pass "fixup"} + timeout { fail "fixup" } + } + } + -re ".*SIGTRAP.*$gdb_prompt $" { + fail "unknown SIGTRAP" + send_gdb "c\n" + gdb_expect { + -re ".*$gdb_prompt $" { pass "fixup"} + timeout { fail "fixup" } + } + } + -re ".*Program exited.*$gdb_prompt $" { + pass "run to end" + } + -re ".*$gdb_prompt $" { + fail "run to end" + send_gdb "c\n" + gdb_expect { + -re ".*$gdb_prompt $" { pass "fixup"} + timeout { fail "fixup" } + } + } + timeout { fail "timeout" } +} + +gdb_test "p \$pc" ".*No registers.*" "program done" + +# Done! +# +gdb_exit + +set timeout $oldtimeout +set verbose $oldverbose + +# execute_anywhere "rm -f ${binfile}" +# +return 0 + diff --git a/gdb/testsuite/gdb.hp/reg-test.exp b/gdb/testsuite/gdb.hp/reg-test.exp new file mode 100644 index 00000000000..4bdc3069293 --- /dev/null +++ b/gdb/testsuite/gdb.hp/reg-test.exp @@ -0,0 +1,190 @@ +# Copyright (C) 1998 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 + +# Tests of wide register displays for GDB on HPPA 2.0 machines + +# use this to debug: +#log_user 1 + +if $tracelevel then { + strace $tracelevel + } + +if ![istarget "hppa*-*-*"] { + verbose "Wide register test ignored for non-hppa targets." + return +} + +set testfile "reg_test" +set srcfile ${testfile}.s +set binfile ${objdir}/${subdir}/${testfile} + +# To build a pa 2.0 executable +# +# as -o reg_test reg_test.s +# or +# cc -g -o reg_test reg_test.s +# +# The +DA2.0N flag doesn't seem to be needed. +# +# Don't reject if there are warnings, as we expect this warning: +# +# (Warning) At least one PA 2.0 object file (pa2.0_test2.o) was detected. +# The linked output may not run on a PA 1.x system. +# + +if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {debug}] != "" } { + 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} + +# test machine--there's no 2.0n architecture, so we have +# to try to run the app. +# +send_gdb "break main\n" + gdb_expect { + -re "Breakpoint.*$gdb_prompt $" { + pass "initial set-up" + } + -re ".*$gdb_prompt $" { + fail "initial set-up" + } + timeout { + fail "initial set-up (timeout)" + } + } + +send_gdb "run\n" + gdb_expect { + -re ".*Executable file incompatible with hardware.*$gdb_prompt $" { + # Not hppa2.0 machine + # + return 0 + } + -re "Cannot exec.*$gdb_prompt $" { + # Not hppa2.0 machine + # + return 0 + } + -re ".*Starting program:.*$gdb_prompt $" { + pass "Ready to start test" + } + timeout { + fail "initial set-up, part 2 (timeout)" + return 0 + } + } + +# Let the program set known values. This secretly deletes +# the breakpoint at main and re-runs to mainend. +# +runto mainend + +# Look for known values +# +gdb_test "info reg r1" "r1 1" +gdb_test "info reg r4" "r4 2" +gdb_test "info reg r5" "r5 4" +gdb_test "info reg r6" "r6 8" +gdb_test "info reg r7" "r7 10" +gdb_test "info reg r8" "r8 20" +gdb_test "info reg r9" "r9 40" +gdb_test "info reg r10" "r10 80" +gdb_test "info reg r11" "r11 100" +gdb_test "info reg r12" "r12 200" +gdb_test "info reg r13" "r13 400" +gdb_test "info reg r14" "r14 800" +gdb_test "info reg r15" "r15 1000" +gdb_test "info reg r16" "r16 2000" + +# Two odd variants that GDB supports are: +# "1" means "r1", and +# "$1" means "r1" +# +gdb_test "info reg 1 4" "r1 1.*r4 2" +gdb_test "info reg \$1" "r1 1" + +# Verify that GDB responds gracefully to a register ID number that +# is out of range. +# +gdb_test "info reg 999" "999: invalid register" + +# Make sure the floating point status and error registers +# don't show up as floating point numbers! +# +gdb_test "info reg fpsr" ".*fpsr 0.*" "fpsr" +gdb_test "info reg fpe1" ".*fpe1 0.*" "fpe1" +gdb_test "info reg fpe2" ".*fpe2 0.*" "fpe2" +gdb_test "info reg fpe3" ".*fpe3 0.*" "fpe3" +gdb_test "info reg fpe4" ".*fpe4 0.*" "fpe4" +gdb_test "info reg fpe5" ".*fpe5 0.*" "fpe5" +gdb_test "info reg fpe6" ".*fpe6 0.*" "fpe6" +gdb_test "info reg fpe7" ".*fpe7 0.*" "fpe7" + +gdb_test "info reg fr4" ".*fr4.*(double precision).* 1" +gdb_test "info reg fr5" ".*fr5.*(double precision).* 2" +gdb_test "info reg fr6" ".*fr6.*(double precision).* 2" +gdb_test "info reg fr7" ".*fr7.*(double precision).* 4" +gdb_test "info reg fr8" ".*fr8.*(double precision).* 8" +gdb_test "info reg fr9" ".*fr9.*(double precision).* 32" +gdb_test "info reg fr10" ".*fr10.*(double precision).* 256" + +gdb_test "info reg r19" "r19 deadbeefbadcadee" + +# Need to add test of use of $ +# +# Q: How do you say a literal "$" in expect? +# A: You say "\$". A literal "\" is "\\". +# +# Please note that this test will fail as long as we are running +# in 32-bit mode: it will produce "$1 = 0xbadcadee". To fix it +# would require building a real 64-bit gdb (expression evaluation, +# in particular). +# +send_gdb "p/x \$r19\n" + gdb_expect { + -re ".*= 0xdeadbeefbadcadee.*$gdb_prompt $" { + pass "64-bit works" + } + -re ".*= 0xbadcadee.*$gdb_prompt $" { + pass "32-bit extract when using PRINT; expected but not good" + } + -re ".*$gdb_prompt $" { + fail "didn't print any part of right value" + } + timeout { + fail "timeout on print" + } + } + +# Need to add tests of setting wide regs too. E.g. +# +# set $r4 = 0x1234567890123456 +# p/x $r4 +# + +# done +# +gdb_exit +remote_exec build "rm -f ${binfile}" +return 0 diff --git a/gdb/testsuite/gdb.hp/reg-test.s b/gdb/testsuite/gdb.hp/reg-test.s new file mode 100644 index 00000000000..39bb5d863c1 --- /dev/null +++ b/gdb/testsuite/gdb.hp/reg-test.s @@ -0,0 +1,96 @@ +; assemble as "as -o reg_test.exe reg_test.s" +; or +; cc -g -o +DA2.0N +; +; PA-RISC 2.0 register contents test. +; + .level 2.0 + + .code + .export main,ENTRY + .export mainend,CODE + .export lab1,CODE + .space $TEXT$ + .subspa $CODE$ + +main + .proc + .callinfo NO_CALLS,FRAME=0 + .entry + + ;; Test we have right register numbers + ;; + ADD %r0,%r0,%r1 ; 0 + LDI 1,%r1 ; 1 + ;; + ;; Don't put anything into r2 or r3--they are special registers. + ;; + ADD %r1,%r1,%r4 ; 2 + ADD %r4,%r4,%r5 ; 4 + ADD %r5,%r5,%r6 ; 8 + ADD %r6,%r6,%r7 ; 16 + ADD %r7,%r7,%r8 ; 32 + ADD %r8,%r8,%r9 ; 64 + ADD %r9,%r9,%r10 ; 128 + ADD %r10,%r10,%r11 ; 256 + ADD %r11,%r11,%r12 ; 512 + ADD %r12,%r12,%r13 ; 1024 + ADD %r13,%r13,%r14 ; 2048 + ADD %r14,%r14,%r15 ; 4096 + ADD %r15,%r15,%r16 ; 9192 + + ;; Test high bits, to be sure we show them. + ;; + LDI 0xde,%r19 ; "de" + DEPD,Z %r19,55,56,%r19 ; "de00" + LDI 0xad,%r18 ; "ad" + ADD %r18,%r19,%r19 ; "dead" + DEPD,Z %r19,55,56,%r19 ; "dead00" + LDI 0xbe,%r18 ; "be" + ADD %r18,%r19,%r19 ; "deadbe" + DEPD,Z %r19,55,56,%r19 ; "deadbe00" + LDI 0xef,%r18 ; "ef" + ADD %r18,%r19,%r19 ; "deadbeef" + ; + DEPD,Z %r19,55,56,%r19 ; "deadbeef00" + LDI 0xba,%r18 ; "ba" + ADD %r18,%r19,%r19 ; "deadbeefba" + DEPD,Z %r19,55,56,%r19 ; "deadbeefba00" + LDI 0xdc,%r18 ; "dc" + ADD %r18,%r19,%r19 ; "deadbeefbadc" + DEPD,Z %r19,55,56,%r19 ; "deadbeefbadc00" + LDI 0xad,%r18 ; "ad" + ADD %r18,%r19,%r19 ; "deadbeefbadcad" + DEPD,Z %r19,55,56,%r19 ; "deadbeefbadcad00" + LDI 0xee,%r18 ; "ee" + ADD %r18,%r19,%r19 ; "deadbeefbadcadee" + +lab1 ;; Test floating point registers + ;; + LDIL LR'one,%r22 ; + FLDD RR'one(%r22),%fr4 ; 1.0 + FLDD RR'one+8(%r22),%fr5 ; 2.0 + FLDD RR'one+8(%r22),%fr6 ; 2.0 + FMPY,DBL %fr5,%fr6,%fr7 ; 4.0 + FMPY,DBL %fr6,%fr7,%fr8 ; 8.0 + FMPY,DBL %fr7,%fr8,%fr9 ; 32.0 + FMPY,DBL %fr8,%fr9,%fr10 ; 256.0 + + ;; The NOP prevents anything from end.o or crt0.o from + ;; being appended immediately after "mainend". If that + ;; happens, then we may have other labels that have the + ;; same address as "mainend", and thus the debugger + ;; may symbolize this PC to something other than "mainend". +mainend + NOP + .exit + .procend + + .space $TEXT$ + .subspa $CODE$ + .subspa $LIT$ ;; ,QUAD=0,ALIGN=8,ACCESS=0x2c,SORT=16 +one + .align 8 + .stringz "?\xF0\x00\x00\x00\x00\x00\x00@\x00\x00\x00\x00\x00\x00" + .end + diff --git a/gdb/testsuite/gdb.hp/sized-enum.c b/gdb/testsuite/gdb.hp/sized-enum.c new file mode 100644 index 00000000000..a6d57881f48 --- /dev/null +++ b/gdb/testsuite/gdb.hp/sized-enum.c @@ -0,0 +1,43 @@ + +enum Normal { + red, + blue, + green +}; + +short enum Small { + pink, + cyan, + grey +}; + +char enum Tiny { + orange, + yellow, + brown +}; + + +main() +{ + enum Normal normal[3]; + short enum Small small[3]; + char enum Tiny tiny[3]; + int i; + + for (i=0; i < 3; i++) + { + normal[i] = (enum Normal) i; + small[i] = (short enum Small) i; + tiny[i] = (char enum Tiny) i; + } + normal[0] = 0; /* place to hang a breakpoint */ +} + + + + + + + + diff --git a/gdb/testsuite/gdb.hp/sized-enum.exp b/gdb/testsuite/gdb.hp/sized-enum.exp new file mode 100644 index 00000000000..191050ada4c --- /dev/null +++ b/gdb/testsuite/gdb.hp/sized-enum.exp @@ -0,0 +1,162 @@ +# Copyright (C) 1997, 1998 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 + +# GDB tests for sized enumerations + +# This is aimed at HP-UX systems. The HP C compiler +# allows specifying "char" or "short" for an enum, to +# indicate that it is 1 or 2 bytes long. + +# This file was written by Satish Pai +# 1997-09-24 + +if $tracelevel then { + strace $tracelevel + } + +# +# test running programs +# +set prms_id 0 +set bug_id 0 + +set testfile "sized-enum" +set srcfile ${testfile}.c +set binfile ${objdir}/${subdir}/${testfile} + +if [get_compiler_info ${binfile}] { + return -1 +} + +if {[skip_hp_tests $gcc_compiled]} then { continue } + +if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {debug}] != "" } { + 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_main] then { + perror "couldn't run to breakpoint" + continue +} + +# set a breakpoint and go there +send_gdb "break 34\n" +gdb_expect { + -re "Breakpoint \[0-9\] at.*$gdb_prompt $" { pass "set break 34" } + -re "$gdb_prompt $" { fail "set break 34" } + timeout { fail "(timeout) set break 34" } +} +send_gdb "continue\n" +gdb_expect { + -re "Continuing\\.\r\n\r\nBreakpoint \[0-9\]*, main....at.*sized-enum\\.c:34\r\n34.*\r\n$gdb_prompt $" { pass "continue" } + -re "$gdb_prompt $" { fail "continue" } + timeout { fail "(timeout) continue" } +} + +# print stuff +send_gdb "print normal\n" +gdb_expect { + -re "\\$\[0-9\]* = \\{red, blue, green\\}.*$gdb_prompt $" { pass "print normal" } + -re "$gdb_prompt $" { fail "print normal" } + timeout { fail "(timeout) print normal" } +} +send_gdb "print small\n" +gdb_expect { + -re "\\$\[0-9\]* = \\{pink, cyan, grey\\}.*$gdb_prompt $" { pass "print small" } + -re "$gdb_prompt $" { fail "print small" } + timeout { fail "(timeout) print small" } +} +send_gdb "print tiny\n" +gdb_expect { + -re "\\$\[0-9\]* = \\{orange, yellow, brown\\}.*$gdb_prompt $" { pass "print tiny" } + -re "$gdb_prompt $" { fail "print tiny" } + timeout { fail "(timeout) print tiny" } +} + +# print type sizes +send_gdb "print sizeof (Normal)\n" +gdb_expect { + -re "\\$\[0-9\]* = 4.*$gdb_prompt $" { pass "print sizeof (Normal)" } + -re "$gdb_prompt $" { fail "print sizeof (Normal)" } + timeout { fail "(timeout) print sizeof (Normal)" } +} +send_gdb "print sizeof (Small)\n" +gdb_expect { + -re "\\$\[0-9\]* = 2.*$gdb_prompt $" { pass "print sizeof (Small)" } + -re "$gdb_prompt $" { fail "print sizeof (Small)" } + timeout { fail "(timeout) print sizeof (Small)" } +} +send_gdb "print sizeof (Tiny)\n" +gdb_expect { + -re "\\$\[0-9\]* = 1.*$gdb_prompt $" { pass "print sizeof (Tiny)" } + -re "$gdb_prompt $" { fail "print sizeof (Tiny)" } + timeout { fail "(timeout) print sizeof (Tiny)" } +} + +# print types +send_gdb "ptype normal\n" +gdb_expect { + -re "type = enum Normal \\{red, blue, green\\} \\\[3\\\].*$gdb_prompt $" { pass "ptype normal" } + -re "$gdb_prompt $" { fail "ptype normal" } + timeout { fail "(timeout) ptype normal" } +} +send_gdb "ptype small\n" +gdb_expect { + -re "type = short enum Small \\{pink, cyan, grey\\} \\\[3\\\].*$gdb_prompt $" { pass "ptype small" } + -re "$gdb_prompt $" { fail "ptype small" } + timeout { fail "(timeout) ptype small" } +} +send_gdb "ptype tiny\n" +gdb_expect { + -re "type = char enum Tiny \\{orange, yellow, brown\\} \\\[3\\\].*$gdb_prompt $" { pass "ptype tiny" } + -re "$gdb_prompt $" { fail "ptype tiny" } + timeout { fail "(timeout) ptype tiny" } +} + +# convert to int +send_gdb "print (int) blue\n" +gdb_expect { + -re "\\$\[0-9\]* = 1.*$gdb_prompt $" { pass "print (int) blue" } + -re "$gdb_prompt $" { fail "print (int) blue" } + timeout { fail "(timeout) print (int) blue" } +} +send_gdb "print (int) cyan\n" +gdb_expect { + -re "\\$\[0-9\]* = 1.*$gdb_prompt $" { pass "print (int) cyan" } + -re "$gdb_prompt $" { fail "print (int) cyan" } + timeout { fail "(timeout) print (int) cyan" } +} +send_gdb "print (int) yellow\n" +gdb_expect { + -re "\\$\[0-9\]* = 1.*$gdb_prompt $" { pass "print (int) yellow" } + -re "$gdb_prompt $" { fail "print (int) yellow" } + timeout { fail "(timeout) print (int) yellow" } +} + + + diff --git a/gdb/testsuite/gdb.hp/start-stop.exp b/gdb/testsuite/gdb.hp/start-stop.exp new file mode 100644 index 00000000000..4f70f51cede --- /dev/null +++ b/gdb/testsuite/gdb.hp/start-stop.exp @@ -0,0 +1,360 @@ +# start_stop.exp -- Expect script to test a threaded pgm which has terminating threads +# Copyright (C) 1992 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 + +# Comment out for now, since this test is (sometimes?) hanging on 11.0 +# +# return 0 + +# use this to debug: +# +#log_user 1 + +# Thread stuff is _slow_; prepare for long waits. +# +# Further, this test has some "null" lines designed +# to consume output from gdb that was too late to be +# matched (sequence is "gdb_test" sends; timeout and +# on to next send; result finally comes in; mismatch). +# +# The null command is 'gdb_test "p \$pc" ".*" ""' +# NOTE: this command undoes any up/down stuff! +# +proc pre_timeout {} { + global timeout + + set timeout [expr "$timeout + 100"] +} + +proc post_timeout {} { + global timeout + global oldtimeout + + set timeout $oldtimeout + gdb_test "p \$pc" ".*" "" +} + +if $tracelevel then { + strace $tracelevel +} + +if { ![istarget "hppa*-*-hpux10.30"] && ![istarget "hppa*-*-hpux11.*"] } { + verbose "HPUX thread test ignored for non-hppa or pre-HP/UX-10.30 targets." + return 0 +} + +set testfile start-stop +set srcfile ${srcdir}/${subdir}/${testfile}.c +set binfile ${objdir}/${subdir}/${testfile} + +if [get_compiler_info ${binfile}] { + return -1 +} + +# To build the executable we need to link against the thread library. +# +# cc -Ae -g -o start-stop -lpthread start-stop.c +# +#compile "${srcfile} -Ae -g -lpthread -o ${binfile}" + +if {$gcc_compiled == 0} { + set additional_flags "additional_flags=-Ae" +} else { + set additional_flags "" +} + +if { [gdb_compile "${srcdir}/${subdir}/${testfile}.c" "${binfile}.o" object [list debug $additional_flags]] != "" } { + gdb_suppress_entire_file "Testcase compile failed, so all tests in this file will automatically fail." +} +remote_exec build "ld /usr/ccs/lib/crt0.o ${binfile}.o -lcl -lpthread -lc /opt/langtools/lib/end.o -o ${binfile}" + + +gdb_exit +gdb_start +gdb_reinitialize_dir $srcdir/$subdir + +gdb_load ${binfile} +if ![runto_main] then { + fail "Can't run to main" + return 0 +} + +set oldtimeout $timeout +#set timeout [expr "$timeout + 200"] +set oldverbose $verbose +#set verbose 40 + +gdb_test "b do_pass" ".*" "set do_pass bp" +gdb_test "c" ".*Breakpoint.*do_pass.*" "run to do_pass" + +# Should be only one thread. +# +pre_timeout +send_gdb "info thread\n" +gdb_expect { + -re ".*2 process.*$gdb_prompt $" { fail "Old code for 'thread.c'" } + -re ".*2 system thread.*1 sys.*$gdb_prompt $" { fail "Too many threads" } + -re ".*1 system thread.*$gdb_prompt $" { pass "Just one thread" } + -re ".*$gdb_prompt $" { fail "no thread info" } + timeout { fail "timeout on info thread 1" } +} +post_timeout + +# Run to a point after the thread creates (105 is just +# before the first join). +# +# The "== Thread" stuff is output from the computing threads. +# +gdb_test "b 105" ".*Breakpoint.*" "set 105 bp" + +pre_timeout +send_gdb "c\n" +gdb_expect { + -re ".*== Thread.*== Thread.*== Thread.*105.*$gdb_prompt $" { + pass "new threads created and ended" + set threads_exist 0 + } + -re ".*== Thread.*== Thread.*105.*$gdb_prompt $" { + pass "new threads created and ended" + set threads_exist 1 + } + -re ".*== Thread.*.*105.*$gdb_prompt $" { + pass "new threads created and ended" + set threads_exist 2 + } + -re ".*New thread.*New th.*New th.*105.*$gdb_prompt $" { + pass "new threads created" + set threads_exist 3 + } + -re ".*Breakpoint.*105.*$gdb_prompt $" { + set threads_exist 0 + fail "didn't see any threads" + } + -re ".*$gdb_prompt $" { + set threads_exist 0 + fail "didn't even hit bp" + } + timeout { + set threads_exist -1 + fail "timeout on continue" + } +} + +# Look at the threads again. We expect that some of +# the threads may have already finished execution. +# +send_gdb "info thread\n" +gdb_expect { + -re ".*4.*3.*2.* 1.*thread.*$gdb_prompt $" { set seen_threads 3 } + -re ".*3.*2.* 1.*thread.*$gdb_prompt $" { set seen_threads 2 } + -re ".*2.* 1.*thread.*$gdb_prompt $" { set seen_threads 1 } + -re ".* 1.*thread.*$gdb_prompt $" { set seen_threads 0 } + -re ".*$gdb_prompt $" { set seen_threads 0 } + timeout { + set seen_threads -10 + fail "timeout on second info thread" + } +} +post_timeout + +if { $seen_threads == $threads_exist } { + pass "saw all threads that existed" +} else { + if { $seen_threads > $threads_exist } { + fail "may have seen threads that didn't finish exiting yet" + } else { + fail "didn't see live threads" + } +} + +gdb_test "cle" ".*Deleted.*" "del bp at 105" + +# Check that threads are being consumed at the join call. +# We expect to join three times. If we ever see the bp at +# 111, we've gone too far. +# +gdb_test "b 106" ".*Breakpoint.*106.*" "set bp at 106" +gdb_test "b 111" ".*Breakpoint.*111.*" "set bp at 111" + +# This one is sure: we're already in the loop. +# +gdb_test "c" ".*Breakpoint.*106.*" "hit bp at 106 1st time, 2 left" + +# Did we go around the loop again? +# +send_gdb "c\n" +gdb_expect { + -re ".*Breakpoint.*111.*" { + fail "didn't join right 1" + gdb_test "cle" ".*" "" + } + -re ".*Breakpoint.*106.*" { + pass "hit bp at 106 2nd time, 1 left" + send_gdb "c\n" + gdb_expect { + -re ".*Breakpoint.*111.*" { + fail "didn't join right 2" + gdb_test "cle" ".*" "" + } + -re ".*Breakpoint.*106.*" { + pass "hit bp at 106 3rd time, 0 left" + gdb_test "cle" ".*" "" + gdb_test "c" ".*Breakpoint.*111.*" "" + gdb_test "cle" ".*" "" + } + timeout { fail "timeout going around the loop"} + } + } + timeout { fail "timeout getting to 106"} +} + +# Should only be one thread now. +# +pre_timeout +send_gdb "info thread\n" +gdb_expect { + -re ".*2 system thread.*1 sys.*$gdb_prompt $" { fail "Too many threads" } + -re ".*1 system th.*$gdb_prompt $" { pass "Just one thread" } + -re ".*$gdb_prompt $" { pass "One thread shown as no threads, ok" } + timeout { fail "timeout third info thread" } +} +post_timeout + +#============================= Begin pass 2 =========== +# +# Ok, go around again +# +gdb_test "c" ".*Breakpoint.*do_pass.*" "hit do_pass bp again 2" +gdb_test "b 105" ".*Breakpoint.*" "set 105 bp 2" + +pre_timeout +send_gdb "c\n" +gdb_expect { + -re ".*== Thread.*== Thread.*== Thread.*$gdb_prompt $" { + pass "new threads created and ended 2" + set threads_exist 0 + } + -re ".*== Thread.*== Thread.*$gdb_prompt $" { + pass "new threads created and ended 2" + set threads_exist 1 + } + -re ".*== Thread.*$gdb_prompt $" { + pass "new threads created and ended 2" + set threads_exist 2 + } + -re ".*New system thread.*New sys.*New.*105.*$gdb_prompt $" { + pass "new threads created 2" + set threads_exist 3 + } + timeout { + set threads_exist -1 + fail "timeout on continue 2" + } +} + +# Look at the threads again. We expect that some of +# the threads may have already finished execution. +# +send_gdb "info thread\n" +gdb_expect { + -re ".*4.*3.*2.* 1.*thread.*$gdb_prompt $" { set seen_threads 3 } + -re ".*3.*2.* 1.*thread.*$gdb_prompt $" { set seen_threads 2 } + -re ".*2.* 1.*thread.*$gdb_prompt $" { set seen_threads 1 } + -re ".* 1.*thread.*$gdb_prompt $" { set seen_threads 0 } + -re ".*$gdb_prompt $" { set seen_threads 0 } + timeout { + set seen_threads -10 + fail "timeout on second info thread 2" + } +} +post_timeout + +if { $seen_threads == $threads_exist } { + pass "saw all threads that existed" +} else { + if { $seen_threads > $threads_exist } { + fail "may have seen threads that didn't finish exiting yet 2" + } else { + fail "didn't see live threads 2" + } +} + +gdb_test "cle" ".*Deleted.*" "del bp at 105 2" + +# Check that threads are being consumed at the join call. +# We expect to join three times. If we ever see the bp at +# 111, we've gone too far. +# +gdb_test "b 106" ".*Breakpoint.*106.*" "set bp at 106 2" +gdb_test "b 111" ".*Breakpoint.*111.*" "set bp at 111 2" + +# This one is sure: we're already in the loop. +# +gdb_test "c" ".*Breakpoint.*106.*" "hit bp at 106 1st time, 2 left 2" + +# Did we go around the loop again? +# +send_gdb "c\n" +gdb_expect { + -re ".*Breakpoint.*111.*" { + fail "didn't join right 1, pass 2" + gdb_test "cle" ".*" "" + } + -re ".*Breakpoint.*106.*" { + pass "hit bp at 106 2nd time, 1 left, pass 2" + send_gdb "c\n" + gdb_expect { + -re ".*Breakpoint.*111.*" { + fail "didn't join right 2, pass 2" + gdb_test "cle" ".*" "" + } + -re ".*Breakpoint.*106.*" { + pass "hit bp at 106 3rd time, 0 left, pass 2" + gdb_test "cle" ".*" "" + gdb_test "c" ".*Breakpoint.*111.*" "" + gdb_test "cle" ".*" "" + } + timeout { fail "timeout going around loop, pass 2"} + } + } + timeout { fail "timeout continue to 106, pass 2"} +} + +# Should only be one thread now. +# +pre_timeout +send_gdb "info thread\n" +gdb_expect { + -re ".*2 system thread.*1 sys.*$gdb_prompt $" { fail "Too many threads, pass 2" } + -re ".*1 system thread.*$gdb_prompt $" { pass "Just one thread, pass 2" } + -re ".*$gdb_prompt $" { pass "One thread shown as no threads, ok, pass 2" } + timeout { fail "timeout last info thread, pass 2" } +} +post_timeout + +# Done! +# +gdb_exit + +set timeout $oldtimeout +set verbose $oldverbose + +# execute_anywhere "rm -f ${binfile}" +# +return 0 diff --git a/gdb/testsuite/gdb.hp/templ-hp.cc b/gdb/testsuite/gdb.hp/templ-hp.cc new file mode 100644 index 00000000000..25241dc6dbf --- /dev/null +++ b/gdb/testsuite/gdb.hp/templ-hp.cc @@ -0,0 +1,785 @@ +/* This test code is from Wendell Baker (wbaker@comet.berkeley.edu) */ + +#include + +int a_i; +char a_c; +double a_d; + +typedef void *Pix; + +int +f(int i) +{ return 0; } + +int +f(int i, char c) +{ return 0; } + +int +f(int i, char c, double d) +{ return 0; } + +int +f(int i, char c, double d, char *cs) +{ return 0; } + +int +f(int i, char c, double d, char *cs, void (*fig)(int, char)) +{ return 0; } + +int +f(int i, char c, double d, char *cs, void (*fig)(char, int)) +{ return 0; } + +class R { +public: + int i; +}; +class S { +public: + int i; +}; +class T { +public: + int i; +}; + +char g(char, const char, volatile char) +{ return 'c'; } +char g(R, char&, const char&, volatile char&) +{ return 'c'; } +char g(char*, const char*, volatile char*) +{ return 'c'; } +char g(S, char*&, const char*&, volatile char*&) +{ return 'c'; } + +signed char g(T,signed char, const signed char, volatile signed char) +{ return 'c'; } +signed char g(T, R, signed char&, const signed char&, volatile signed char&) +{ return 'c'; } +signed char g(T, signed char*, const signed char*, volatile signed char*) +{ return 'c'; } +signed char g(T, S, signed char*&, const signed char*&, volatile signed char*&) +{ return 'c'; } + +unsigned char g(unsigned char, const unsigned char, volatile unsigned char) +{ return 'c'; } +unsigned char g(R, unsigned char&, const unsigned char&, volatile unsigned char&) +{ return 'c'; } +unsigned char g(unsigned char*, const unsigned char*, volatile unsigned char*) +{ return 'c'; } +unsigned char g(S, unsigned char*&, const unsigned char*&, volatile unsigned char*&) +{ return 'c'; } + +short g(short, const short, volatile short) +{ return 0; } +short g(R, short&, const short&, volatile short&) +{ return 0; } +short g(short*, const short*, volatile short*) +{ return 0; } +short g(S, short*&, const short*&, volatile short*&) +{ return 0; } + +signed short g(T, signed short, const signed short, volatile signed short) +{ return 0; } +signed short g(T, R, signed short&, const signed short&, volatile signed short&) +{ return 0; } +signed short g(T, signed short*, const signed short*, volatile signed short*) +{ return 0; } +signed short g(T, S, double, signed short*&, const signed short*&, volatile signed short*&) +{ return 0; } + +unsigned short g(unsigned short, const unsigned short, volatile unsigned short) +{ return 0; } +unsigned short g(R, unsigned short&, const unsigned short&, volatile unsigned short&) +{ return 0; } +unsigned short g(unsigned short*, const unsigned short*, volatile unsigned short*) +{ return 0; } +unsigned short g(S, unsigned short*&, const unsigned short*&, volatile unsigned short*&) +{ return 0; } + +int g(int, const int, volatile int) +{ return 0; } +int g(R, int&, const int&, volatile int&) +{ return 0; } +int g(int*, const int*, volatile int*) +{ return 0; } +int g(S, int*&, const int*&, volatile int*&) +{ return 0; } + +signed int g(T, signed int, const signed int, volatile signed int) +{ return 0; } +signed int g(T, R, signed int&, const signed int&, volatile signed int&) +{ return 0; } +signed int g(T, signed int*, const signed int*, volatile signed int*) +{ return 0; } +signed int g(T, S, signed int*&, const signed int*&, volatile signed int*&) +{ return 0; } + +unsigned int g(unsigned int, const unsigned int, volatile unsigned int) +{ return 0; } +unsigned int g(R, unsigned int&, const unsigned int&, volatile unsigned int&) +{ return 0; } +unsigned int g(unsigned int*, const unsigned int*, volatile unsigned int*) +{ return 0; } +unsigned int g(S, unsigned int*&, const unsigned int*&, volatile unsigned int*&) +{ return 0; } + +long g(long, const long, volatile long) +{ return 0; } +long g(R, long&, const long&, volatile long&) +{ return 0; } +long g(long*, const long*, volatile long*) +{ return 0; } +long g(S, long*&, const long*&, volatile long*&) +{ return 0; } + +signed long g(T, signed long, const signed long, volatile signed long) +{ return 0; } +signed long g(T, R, signed long&, const signed long&, volatile signed long&) +{ return 0; } +signed long g(T, signed long*, const signed long*, volatile signed long*) +{ return 0; } +signed long g(T, S, signed long*&, const signed long*&, volatile signed long*&) +{ return 0; } + +unsigned long g(unsigned long, const unsigned long, volatile unsigned long) +{ return 0; } +unsigned long g(S, unsigned long&, const unsigned long&, volatile unsigned long&) +{ return 0; } +unsigned long g(unsigned long*, const unsigned long*, volatile unsigned long*) +{ return 0; } +unsigned long g(S, unsigned long*&, const unsigned long*&, volatile unsigned long*&) +{ return 0; } + +#ifdef __GNUC__ +long long g(long long, const long long, volatile long long) +{ return 0; } +long long g(S, long long&, const long long&, volatile long long&) +{ return 0; } +long long g(long long*, const long long*, volatile long long*) +{ return 0; } +long long g(R, long long*&, const long long*&, volatile long long*&) +{ return 0; } + +signed long long g(T, signed long long, const signed long long, volatile signed long long) +{ return 0; } +signed long long g(T, R, signed long long&, const signed long long&, volatile signed long long&) +{ return 0; } +signed long long g(T, signed long long*, const signed long long*, volatile signed long long*) +{ return 0; } +signed long long g(T, S, signed long long*&, const signed long long*&, volatile signed long long*&) +{ return 0; } + +unsigned long long g(unsigned long long, const unsigned long long, volatile unsigned long long) +{ return 0; } +unsigned long long g(R, unsigned long long*, const unsigned long long*, volatile unsigned long long*) +{ return 0; } +unsigned long long g(unsigned long long&, const unsigned long long&, volatile unsigned long long&) +{ return 0; } +unsigned long long g(S, unsigned long long*&, const unsigned long long*&, volatile unsigned long long*&) +{ return 0; } +#endif + +float g(float, const float, volatile float) +{ return 0; } +float g(char, float&, const float&, volatile float&) +{ return 0; } +float g(float*, const float*, volatile float*) +{ return 0; } +float g(char, float*&, const float*&, volatile float*&) +{ return 0; } + +double g(double, const double, volatile double) +{ return 0; } +double g(char, double&, const double&, volatile double&) +{ return 0; } +double g(double*, const double*, volatile double*) +{ return 0; } +double g(char, double*&, const double*&, volatile double*&) +{ return 0; } + +#ifdef __GNUC__ +long double g(long double, const long double, volatile long double) +{ return 0; } +long double g(char, long double&, const long double&, volatile long double&) +{ return 0; } +long double g(long double*, const long double*, volatile long double*) +{ return 0; } +long double g(char, long double*&, const long double*&, volatile long double*&) +{ return 0; } +#endif + +class c { +public: + c(int) {}; + int i; +}; + +class c g(c, const c, volatile c) +{ return 0; } +c g(char, c&, const c&, volatile c&) +{ return 0; } +c g(c*, const c*, volatile c*) +{ return 0; } +c g(char, c*&, const c*&, volatile c*&) +{ return 0; } + +/* +void h(char = 'a') +{ } +void h(char, signed char = 'a') +{ } +void h(unsigned char = 'a') +{ } +*/ +/* +void h(char = (char)'a') +{ } +void h(char, signed char = (signed char)'a') +{ } +void h(unsigned char = (unsigned char)'a') +{ } + + +void h(short = (short)43) +{ } +void h(char, signed short = (signed short)43) +{ } +void h(unsigned short = (unsigned short)43) +{ } + +void h(int = (int)43) +{ } +void h(char, signed int = (signed int)43) +{ } +void h(unsigned int = (unsigned int)43) +{ } + + +void h(long = (long)43) +{ } +void h(char, signed long = (signed long)43) +{ } +void h(unsigned long = (unsigned long)43) +{ } + +#ifdef __GNUC__ +void h(long long = 43) +{ } +void h(char, signed long long = 43) +{ } +void h(unsigned long long = 43) +{ } +#endif + +void h(float = 4.3e-10) +{ } +void h(double = 4.3) +{ } +#ifdef __GNUC__ +void h(long double = 4.33e33) +{ } +#endif +*/ +void printf(const char *format, ... ) +{ + // elipsis +} + +class T1 { +public: + static void* operator new(size_t); + static void operator delete(void *pointer); + + void operator=(const T1&); + T1& operator=(int); + + int operator==(int) const; + int operator==(const T1&) const; + int operator!=(int) const; + int operator!=(const T1&) const; + + int operator<=(int) const; + int operator<=(const T1&) const; + int operator<(int) const; + int operator<(const T1&) const; + int operator>=(int) const; + int operator>=(const T1&) const; + int operator>(int) const; + int operator>(const T1&) const; + + void operator+(int) const; + T1& operator+(const T1&) const; + void operator+=(int) const; + T1& operator+=(const T1&) const; + + T1& operator++() const; + + void operator-(int) const; + T1& operator-(const T1&) const; + void operator-=(int) const; + T1& operator-=(const T1&) const; + + T1& operator--() const; + + void operator*(int) const; + T1& operator*(const T1&) const; + void operator*=(int) const; + T1& operator*=(const T1&) const; + + void operator/(int) const; + T1& operator/(const T1&) const; + void operator/=(int) const; + T1& operator/=(const T1&) const; + + void operator%(int) const; + T1& operator%(const T1&) const; + void operator%=(int) const; + T1& operator%=(const T1&) const; + + void operator&&(int) const; + T1& operator&&(const T1&) const; + + void operator||(int) const; + T1& operator||(const T1&) const; + + void operator&(int) const; + T1& operator&(const T1&) const; + void operator&=(int) const; + T1& operator&=(const T1&) const; + + void operator|(int) const; + T1& operator|(const T1&) const; + void operator|=(int) const; + T1& operator|=(const T1&) const; + + void operator^(int) const; + T1& operator^(const T1&) const; + void operator^=(int) const; + T1& operator^=(const T1&) const; + + T1& operator!() const; + T1& operator~() const; +}; + +void* +T1::operator new(size_t) +{ return 0; } + +void +T1::operator delete(void *pointer) +{ } + +class T2 { +public: + T2(int i): integer(i) + { } + int integer; +}; + +int operator==(const T2&, const T2&) +{ return 0; } +int operator==(const T2&, char) +{ return 0; } +int operator!=(const T2&, const T2&) +{ return 0; } +int operator!=(const T2&, char) +{ return 0; } + +int operator<=(const T2&, const T2&) +{ return 0; } +int operator<=(const T2&, char) +{ return 0; } +int operator<(const T2&, const T2&) +{ return 0; } +int operator<(const T2&, char) +{ return 0; } +int operator>=(const T2&, const T2&) +{ return 0; } +int operator>=(const T2&, char) +{ return 0; } +int operator>(const T2&, const T2&) +{ return 0; } +int operator>(const T2&, char) +{ return 0; } + +T2 operator+(const T2 t, int i) +{ return t.integer + i; } +T2 operator+(const T2 a, const T2& b) +{ return a.integer + b.integer; } +T2& operator+=(T2& t, int i) +{ t.integer += i; return t; } +T2& operator+=(T2& a, const T2& b) +{ a.integer += b.integer; return a; } + +T2 operator-(const T2 t, int i) +{ return t.integer - i; } +T2 operator-(const T2 a, const T2& b) +{ return a.integer - b.integer; } +T2& operator-=(T2& t, int i) +{ t.integer -= i; return t; } +T2& operator-=(T2& a, const T2& b) +{ a.integer -= b.integer; return a; } + +T2 operator*(const T2 t, int i) +{ return t.integer * i; } +T2 operator*(const T2 a, const T2& b) +{ return a.integer * b.integer; } +T2& operator*=(T2& t, int i) +{ t.integer *= i; return t; } +T2& operator*=(T2& a, const T2& b) +{ a.integer *= b.integer; return a; } + +T2 operator/(const T2 t, int i) +{ return t.integer / i; } +T2 operator/(const T2 a, const T2& b) +{ return a.integer / b.integer; } +T2& operator/=(T2& t, int i) +{ t.integer /= i; return t; } +T2& operator/=(T2& a, const T2& b) +{ a.integer /= b.integer; return a; } + +T2 operator%(const T2 t, int i) +{ return t.integer % i; } +T2 operator%(const T2 a, const T2& b) +{ return a.integer % b.integer; } +T2& operator%=(T2& t, int i) +{ t.integer %= i; return t; } +T2& operator%=(T2& a, const T2& b) +{ a.integer %= b.integer; return a; } + +template +class T5 { +public: + T5(int); + T5(const T5&); + ~T5(); + static void* operator new(size_t); + static void operator delete(void *pointer); + int value(); + + static T X; + T x; + int val; +}; + +template +T5::T5(int v) +{ val = v; } + +template +T5::T5(const T5&) +{} + +template +T5::~T5() +{} + +template +void* +T5::operator new(size_t) +{ return 0; } + +template +void +T5::operator delete(void *pointer) +{ } + +template +int +T5::value() +{ return val; } + + +#if ! defined(__GNUC__) || defined(GCC_BUG) +template +T T5::X; +#endif + + + + +T5 t5c(1); +T5 t5i(2); +T5 t5fi1(3); +T5 t5fi2(4); + + + + + + +class x { +public: + int (*manage[5])(double, + void *(*malloc)(unsigned size), + void (*free)(void *pointer)); + int (*device[5])(int open(const char *, unsigned mode, unsigned perms, int extra = 0), + int *(*read)(int fd, void *place, unsigned size), + int *(*write)(int fd, void *place, unsigned size), + void (*close)(int fd)); +}; +T5 t5x(5); + +#if !defined(__GNUC__) || (__GNUC__ >= 2 && __GNUC_MINOR__ >= 6) +template class T5; +template class T5; +template class T5; +template class T5; +template class T5; +#endif + +class T7 { +public: + static int get(); + static void put(int); +}; + +int +T7::get() +{ return 1; } + +void +T7::put(int i) +{ + // nothing +} + +// More template kinds. GDB 4.16 didn't handle these, but +// Wildebeest does. Note: Assuming HP aCC is used to compile +// this file; with g++ or HP cfront or other compilers the +// demangling may not get done correctly. + +// Ordinary template, to be instantiated with different types +template +class Foo { +public: + int x; + T t; + T foo (int, T); +}; + + +template T Foo::foo (int i, T tt) +{ + return tt; +} + +// Template with int parameter + +template +class Bar { +public: + int x; + T t; + T bar (int, T); +}; + + +template T Bar::bar (int i, T tt) +{ + if (i < sz) + return tt; + else + return 0; +} + +// function template with int parameter +template int dummy (T tt, int i) +{ + return tt; +} + +// Template with partial specializations +template +class Spec { +public: + int x; + T1 spec (T2); +}; + +template +T1 Spec::spec (T2 t2) +{ + return 0; +} + +template +class Spec { +public: + int x; + T spec (T*); +}; + +template +T Spec::spec (T * tp) +{ + return *tp; +} + +// Template with char parameter +template +class Baz { +public: + int x; + T t; + T baz (int, T); +}; + +template T Baz::baz (int i, T tt) +{ + if (i < sz) + return tt; + else + return 0; +} + +// Template with char * parameter +template +class Qux { +public: + int x; + T t; + T qux (int, T); +}; + +template T Qux::qux (int i, T tt) +{ + if (sz[0] == 'q') + return tt; + else + return 0; +} + +// Template with a function pointer parameter +template +class Qux1 { +public: + int x; + T t; + T qux (int, T); +}; + +template T Qux1::qux (int i, T tt) +{ + if (f != 0) + return tt; + else + return 0; +} + +// Some functions to provide as arguments to template +int gf1 (int a) { + return a * 2 + 13; +} +int gf2 (int a) { + return a * 2 + 26; +} + +char string[3]; + + +// Template for nested instantiations + +template +class Garply { +public: + int x; + T t; + T garply (int, T); +}; + +template T Garply::garply (int i, T tt) +{ + if (i > x) + return tt; + else + { + x += i; + return tt; + } +} + + +int main() +{ + int i; +#ifdef usestubs + set_debug_traps(); + breakpoint(); +#endif + i = i + 1; + + // New tests added here + + Foo fint; + Foo fchar; + Foo fvpchar; + + Bar bint; + Bar 3)> bint2; + + Baz bazint; + Baz bazint2; + + Qux quxint2; + Qux quxint; + + Qux1 qux11; + + int x = fint.foo(33, 47); + char c = fchar.foo(33, 'x'); + volatile char * cp = fvpchar.foo(33, 0); + + int y = dummy (400, 600); + + int z = bint.bar(55, 66); + z += bint2.bar(55, 66); + + c = bazint2.baz(4, 'y'); + c = quxint2.qux(4, 'z'); + + y = bazint.baz(4,3); + y = quxint.qux(4, 22); + y += qux11.qux(4, 22); + + y *= gf1(y) - gf2(y); + + Spec sic; + Spec siip; + + sic.spec ('c'); + siip.spec (&x); + + Garply f; + Garply fc; + f.x = 13; + + Garply > nf; + nf.x = 31; + + x = f.garply (3, 4); + + fc = nf.garply (3, fc); + + y = x + fc.x; + + + return 0; + +} + + + + + + + + + + + + + diff --git a/gdb/testsuite/gdb.hp/templ-hp.exp b/gdb/testsuite/gdb.hp/templ-hp.exp new file mode 100644 index 00000000000..64ca53daf76 --- /dev/null +++ b/gdb/testsuite/gdb.hp/templ-hp.exp @@ -0,0 +1,381 @@ +# Copyright (C) 1992, 1996, 1997 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 + + + +# More tests for different kinds of template parameters, +# templates with partial specializations, nested templates, etc. +# These have been tested only with HP aCC. They probably won't +# work with other compilers because of differences in mangling +# schemes. +# Added by Satish Pai 1997-09-25 + + +set ws "\[\r\n\t \]+" + +if $tracelevel then { + strace $tracelevel +} + +set testfile "templ-hp" +set srcfile ${testfile}.cc +set binfile ${objdir}/${subdir}/${testfile} + + + +# Create and source the file that provides information about the compiler +# used to compile the test case. + +if [get_compiler_info ${binfile} "c++"] { + return -1; +} + +if {[skip_hp_tests $gcc_compiled]} then { continue } + + +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." + +} + +# +# Test printing of the types of templates. +# + +proc test_ptype_of_templates {} { + global gdb_prompt + + send_gdb "ptype T5\n" + gdb_expect { + -re "type = class T5 \\{\r\n\[ \t\]*public:\r\n\[ \t\]*static int X;\r\n\[ \t\]*int x;\r\n\[ \t\]*int val;\r\n\r\n\[ \t\]*T5\\(int\\);\r\n\[ \t\]*T5\\(class T5 const &\\);\r\n\[ \t\]*void ~T5\\(int\\);\r\n\[ \t\]*static void \\* new\\(unsigned int\\);\r\n\[ \t\]*static void delete\\(void \\*\\);\r\n\[ \t\]*int value\\(void\\);\r\n\[ \t\]*\\}\r\n$gdb_prompt $" { pass "ptype T5" } + -re ".*$gdb_prompt $" { fail "ptype T5" } + timeout { fail "ptype T5 (timeout)" } + } + + send_gdb "ptype t5i\n" + gdb_expect { + -re "type = class T5 \\{\r\n\[ \t\]*public:\r\n\[ \t\]*static int X;\r\n\[ \t\]*int x;\r\n\[ \t\]*int val;\r\n\r\n\[ \t\]*T5\\(int\\);\r\n\[ \t\]*T5\\(class T5 const &\\);\r\n\[ \t\]*void ~T5\\(int\\);\r\n\[ \t\]*static void \\* new\\(unsigned int\\);\r\n\[ \t\]*static void delete\\(void \\*\\);\r\n\[ \t\]*int value\\(void\\);\r\n\[ \t\]*\\}\r\n$gdb_prompt $" { pass "ptype t5i 1" } + -re "type = class T5 \{.*public:.*static int X;.*int x;.*int val;.*.*T5 \\(int\\);.*.*void ~T5 \\(int\\).*.*.*int value \\(void\\);.*\}.*$gdb_prompt $" { + pass "ptype t5i" + } + -re ".*$gdb_prompt $" { fail "ptype t5i" } + timeout { fail "ptype t5i (timeout)" } + } +} + +# +# Test breakpoint setting on template methods. +# + +proc test_template_breakpoints {} { + global gdb_prompt + global testfile + global srcdir + + send_gdb "break T5::T5\n" + gdb_expect { + -re "0. cancel.*\r\n.1. all.*\r\n.2. *.*\r\n.3. *.*\r\n> $" { + gdb_test "0" \ + "cancelled" \ + "constructor breakpoint" + } + -re ".0. cancel\r\n.1. all\r\n.2. T5::T5\\(T5 const &\\) at .*/templates.cc:.*\r\n.3. T5::T5\\(int\\) at .*/templates-hp.cc:.*\r\n> $" { + gdb_test "0" \ + "cancelled" \ + "constructor breakpoint" + } + -re ".*$gdb_prompt $" { fail "constructor breakpoint" } + default { fail "constructor breakpoint (timeout)" } + } + + gdb_test "break T5::~T5" \ + "Breakpoint.*at.* file .*${testfile}.cc, line.*" \ + "destructor breakpoint" + + gdb_test "break T5::value" \ + "Breakpoint.*at.* file .*${testfile}.cc, line.*" \ + "value method breakpoint" + + delete_breakpoints +} + +# +# Test calling of template methods. +# + +proc test_template_calls {} { + global gdb_prompt + + send_gdb "print t5i.value()\n" + gdb_expect { + -re ".* = 2\r\n$gdb_prompt $" { pass "print t5i.value()" } + -re "Cannot invoke functions on this machine.*$gdb_prompt $" { + fail "print t5i.value()" + } + -re ".*$gdb_prompt $" { fail "print t5i.value()" } + timeout { fail "print t5i.value() (timeout)" } + } +} + + +proc do_tests {} { + global prms_id + global bug_id + global subdir + global objdir + global srcdir + global binfile + global prompt + global supports_template_debugging + + set prms_id 0 + set bug_id 0 + + # Start with a fresh gdb. + + gdb_exit + gdb_start + gdb_reinitialize_dir $srcdir/$subdir + gdb_load $binfile + + source ${binfile}.ci + + if { !$supports_template_debugging } { + warning "compiler lacks debugging info for templates; tests suppressed." 0 + return + } + + test_ptype_of_templates + test_template_breakpoints + + if [ runto_main ] { + test_template_calls + } +} + +do_tests + + +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_main] then { + perror "couldn't run to breakpoint" + continue +} + +send_gdb "print fint\n" +gdb_expect { + -re "\\$\[0-9\]* = \\{x = 0, t = 0\\}\r\n$gdb_prompt $" { pass "print fint" } + -re "$gdb_prompt $" { fail "print fint" } + timeout { fail "(timeout) print fint" } +} + +send_gdb "print fvpchar\n" +gdb_expect { + -re "\\$\[0-9\]* = \\{x = 0, t = 0x0\\}\r\n$gdb_prompt $" { pass "print fvpchar" } + -re "$gdb_prompt $" { fail "print fvpchar" } + timeout { fail "(timeout) print fvpchar" } +} + +# Template Foo + +send_gdb "ptype Foo\n" +gdb_expect { + -re "type = template <(class |)T> (class |)Foo \\{\r\n\[ \t\]*public:\r\n\[ \t\]*int x;\r\n\[ \t\]*T t;\r\n\\}\r\ntemplate instantiations:\r\n\[ \t\]*(class |)Foo\r\n\[ \t\]*(class |)Foo\r\n\[ \t\]*(class |)Foo\r\n$gdb_prompt $" { pass "ptype Foo" } + -re "$gdb_prompt $" { fail "ptype Foo" } + timeout { fail "(timeout) ptype Foo" } +} + +# ptype Foo + +send_gdb "ptype fint\n" +gdb_expect { + -re "type = (class |)Foo \\{\r\n\[ \t\]*public:\r\n\[ \t\]*int x;\r\n\[ \t\]*int t;\r\n\r\n\[ \t\]*int foo\\(int, int\\);\r\n\\}\r\n$gdb_prompt $" { pass "ptype fint" } + -re "$gdb_prompt $" { fail "ptype fint" } + timeout { fail "(timeout) ptype fint" } +} + +# ptype Foo + +send_gdb "ptype fchar\n" +gdb_expect { + -re "type = (class |)Foo \\{\r\n\[ \t\]*public:\r\n\[ \t\]*int x;\r\n\[ \t\]*char t;\r\n\r\n\[ \t\]*char foo\\(int, char\\);\r\n\\}\r\n$gdb_prompt $" { pass "ptype fchar" } + -re "$gdb_prompt $" { fail "ptype fchar" } + timeout { fail "(timeout) ptype fchar" } +} + +# ptype Foo + +send_gdb "ptype fvpchar\n" +gdb_expect { + -re "type = (class |)Foo \\{\r\n\[ \t\]*public:\r\n\[ \t\]*int x;\r\n\[ \t\]*volatile char \\*t;\r\n\r\n\[ \t\]*volatile char \\* foo\\(int, volatile char \\*\\);\r\n\\}\r\n$gdb_prompt $" { pass "ptype fvpchar" } + -re "$gdb_prompt $" { fail "ptype fvpchar" } + timeout { fail "(timeout) ptype fvpchar" } +} + +# print a function from Foo + +send_gdb "print Foo::foo\n" +gdb_expect { + -re "\\$\[0-9\]* = \\{volatile char \\*\\((class |)Foo \\*, int, volatile char \\*\\)\\} $hex ::foo\\(int, volatile char \\*\\)>\r\n$gdb_prompt $" { pass "print Foo::foo" } + -re "$gdb_prompt $" { fail "print Foo::foo" } + timeout { fail "(timeout) print Foo::foo" } +} + +# Template Bar + +send_gdb "ptype Bar\n" +gdb_expect { + -re "type = template <(class |)T, (class |)sz> (class |)Bar \\{\r\n\[ \t\]*public:\r\n\[ \t\]*int x;\r\n\[ \t\]*T t;\r\n\\}\r\ntemplate instantiations:\r\n\[ \t\]*(class |)Bar\r\n\[ \t\]*(class |)Bar\r\n$gdb_prompt $" { pass "ptype Bar" } + -re "$gdb_prompt $" { fail "ptype Bar" } + timeout { fail "(timeout) ptype Bar" } +} + + +# ptype Bar + +send_gdb "ptype bint\n" +gdb_expect { + -re "type = (class |)Bar \\{\r\n\[ \t\]*public:\r\n\[ \t\]*int x;\r\n\[ \t\]*int t;\r\n\r\n\[ \t\]*int bar\\(int, int\\);\r\n\\}\r\n$gdb_prompt $" { pass "ptype bint" } + -re "$gdb_prompt $" { fail "ptype bint" } + timeout { fail "(timeout) ptype bint" } +} + +# ptype Bar3)> + +send_gdb "ptype bint2\n" +gdb_expect { + -re "type = (class |)Bar \\{\r\n\[ \t\]*public:\r\n\[ \t\]*int x;\r\n\[ \t\]*int t;\r\n\r\n\[ \t\]*int bar\\(int, int\\);\r\n\\}\r\n$gdb_prompt $" { pass "ptype bint2" } + -re "$gdb_prompt $" { fail "ptype bint2" } + timeout { fail "(timeout) ptype bint2" } +} + +# Template Baz + +send_gdb "ptype Baz\n" +gdb_expect { + -re "type = template <(class |)T, (class |)sz> (class |)Baz \\{\r\n\[ \t\]*public:\r\n\[ \t\]*int x;\r\n\[ \t\]*T t;\r\n\\}\r\ntemplate instantiations:\r\n\[ \t\]*(class |)Baz\r\n\[ \t\]*(class |)Baz\r\n$gdb_prompt $" { pass "ptype Baz" } + -re "$gdb_prompt $" { fail "ptype Baz" } + timeout { fail "(timeout) ptype Baz" } +} + + +# ptype Baz + +send_gdb "ptype bazint\n" +gdb_expect { + -re "type = (class |)Baz \\{\r\n\[ \t\]*public:\r\n\[ \t\]*int x;\r\n\[ \t\]*int t;\r\n\r\n\[ \t\]*int baz\\(int, int\\);\r\n\\}\r\n$gdb_prompt $" { pass "ptype bazint" } + -re "$gdb_prompt $" { fail "ptype bazint" } + timeout { fail "(timeout) ptype bazint" } +} + +# ptype Baz + +send_gdb "ptype bazint2\n" +gdb_expect { + -re "type = (class |)Baz \\{\r\n\[ \t\]*public:\r\n\[ \t\]*int x;\r\n\[ \t\]*char t;\r\n\r\n\[ \t\]*char baz\\(int, char\\);\r\n\\}\r\n$gdb_prompt $" { pass "ptype bazint2" } + -re "$gdb_prompt $" { fail "ptype bazint2" } + timeout { fail "(timeout) ptype bazint2" } +} + +# Template Qux + +send_gdb "ptype Qux\n" +gdb_expect { + -re "type = template <(class |)T, (class |)sz> (class |)Qux \\{\r\n\[ \t\]*public:\r\n\[ \t\]*int x;\r\n\[ \t\]*T t;\r\n\\}\r\ntemplate instantiations:\r\n\[ \t\]*(class |)Qux\r\n\[ \t\]*(class |)Qux\r\n$gdb_prompt $" { pass "ptype Qux" } + -re "$gdb_prompt $" { fail "ptype Qux" } + timeout { fail "(timeout) ptype Qux" } +} + +# pt Qux + +send_gdb "ptype quxint\n" +gdb_expect { + -re "type = class Qux \\{\r\n\[ \t\]*public:\r\n\[ \t\]*int x;\r\n\[ \t\]*int t;\r\n\r\n\[ \t\]*int qux\\(int, int\\);\r\n\\}\r\n$gdb_prompt $" { pass "ptype quxint" } + -re "$gdb_prompt $" { fail "ptype quxint" } + timeout { fail "(timeout) ptype quxint" } +} + +# pt Qux + +send_gdb "ptype quxint2\n" +gdb_expect { + -re "type = class Qux \\{\r\n\[ \t\]*public:\r\n\[ \t\]*int x;\r\n\[ \t\]*char t;\r\n\r\n\[ \t\]*char qux\\(int, char\\);\r\n\\}\r\n$gdb_prompt $" { pass "ptype quxint2" } + -re "$gdb_prompt $" { fail "ptype quxint2" } + timeout { fail "(timeout) ptype quxint2" } +} + +# Template Spec + +send_gdb "ptype Spec\n" +gdb_expect { + -re "type = template <(class |)T1, (class |)T2> (class |)Spec \\{\r\n\[ \t\]*public:\r\n\[ \t\]*int x;\r\n\\}\r\ntemplate instantiations:\r\n\[ \t\]*(class |)Spec\r\n\[ \t\]*(class |)Spec\r\n$gdb_prompt $" { pass "ptype Spec" } + -re "$gdb_prompt $" { fail "ptype Spec" } + timeout { fail "(timeout) ptype Spec" } +} + +# pt Spec + +send_gdb "ptype siip\n" +gdb_expect { + -re "type = class Spec \\{\r\n\[ \t\]*public:\r\n\[ \t\]*int x;\r\n\r\n\[ \t\]*int spec\\(int \\*\\);\r\n\\}\r\n$gdb_prompt $" { pass "ptype siip" } + -re "$gdb_prompt $" { fail "ptype siip" } + timeout { fail "(timeout) ptype siip" } +} + +# pt Garply + +send_gdb "ptype Garply\n" +gdb_expect { + -re "type = class Garply \\{\r\n\[ \t\]*public:\r\n\[ \t\]*int x;\r\n\[ \t\]*int t;\r\n\r\n\[ \t\]*int garply\\(int, int\\);\r\n\\}\r\n$gdb_prompt $" { pass "ptype Garply" } + -re "$gdb_prompt $" { fail "ptype Garply" } + timeout { fail "(timeout) ptype Garply" } +} + +# ptype of nested template name + +send_gdb "ptype Garply >\n" +gdb_expect { + -re "type = (class |)Garply > \\{\r\n\[ \t\]*public:\r\n\[ \t\]*int x;\r\n\[ \t\]*(class |)Garply t;\r\n\r\n\[ \t\]*(class |)Garply garply\\(int, (class |)Garply\\);\r\n\\}\r\n$gdb_prompt $" { pass "ptype Garply >" } + -re "$gdb_prompt $" { fail "ptype Garply >" } + timeout { fail "(timeout) ptype Garply >" } +} + +# print out a function from a nested template name + +send_gdb "print Garply >::garply\n" +gdb_expect { + -re "\\$\[0-9\]* = \\{(class |)Garply \\((class |)Garply > \\*, int, (class |)Garply\\)\\} $hex >::garply\\(int, (class |)Garply\\)>\r\n$gdb_prompt $" { pass "print Garply >::garply" } + -re ".*$gdb_prompt $" { fail "print Garply >::garply" } + timeout { fail "print Garply >::garply (timeout)" } +} + +# UNFORTUNATELY, "break Garply >::garply" doesn't yet work. + +#send_gdb "break Garply >::garply +#gdb_expect { +# -re "Breakpoint \[0-9\]* at $hex: file .*templates.cc, line.*\r\n$gdb_prompt $" { pass "break Garply >::garply" } +# -re ".*$gdb_prompt $" { fail "break Garply >::garply" } +# timeout { fail "break Garply >::garply (timeout)" } +#} diff --git a/gdb/testsuite/gdb.hp/thr-lib.c b/gdb/testsuite/gdb.hp/thr-lib.c new file mode 100644 index 00000000000..15cd16829e1 --- /dev/null +++ b/gdb/testsuite/gdb.hp/thr-lib.c @@ -0,0 +1,79 @@ +/* Thread local in a library. +*/ +#include "thr-lib.h" +/* + * #define NTHREADS 4 + * #define NUM_ELEMS 12 + */ + +extern void* adder( void * ); + +pthread_mutex_t mutex; /* mutex for protecting global data total */ + +int numbers[NUM_ELEMS] = {5, 4, 3, 2, 1, 6, 7, 8, 9, 10, 12, 11}; +int total = 0; + +int debugger_saw[NTHREADS][ELEMS_PER_THREAD]; /* [4][3] */ +int the_code_saw[NTHREADS][ELEMS_PER_THREAD]; + +int get_number(i) +int i; +{ + /* sleep to force context switch to another thread in non-MP system + * so that TLS symbols are used by multiple threads concurrently + * in some way. + */ + sleep(1); + return numbers[i]; +} + +main() +{ + pthread_t thread[NTHREADS]; + void *status; + int i, j, ret; + + printf("== Thread: Test started\n"); + + for( i = 0; i < NTHREADS; i++ ) { + for( j = 0; j < ELEMS_PER_THREAD; j++ ) { + debugger_saw[i][j] = 0; + the_code_saw[i][j] = 0; + } + } + + ret = pthread_mutex_init(&mutex, NULL); + if (ret != 0) { + printf("== Thread: pthread_mutex_init() error: %d\n", ret); + exit(1); + } + + for (i=0; i < NTHREADS; i++) { + ret = pthread_create( &thread[i], + NULL, + adder, + (void *) i); + if (ret != 0) { + printf("== Thread: pthread_create() error: %d\n", ret); + exit(1); + } + printf("== Thread: thread %d created\n", i); + } + + for (i=0; i < NTHREADS; i++) { + pthread_join( thread[i], &status); + } + + printf("== Thread: total = %d\n", total); /* Expect "78" */ + + for( i = 0; i < NTHREADS; i++ ) { + for( j = 0; j < ELEMS_PER_THREAD; j++ ) { + printf( "== Thread: the debugger saw %d, the program saw %d\n", + debugger_saw[i][j], + the_code_saw[i][j] ); + } + } + + printf("== Thread: Test ended\n"); + exit(0); +} diff --git a/gdb/testsuite/gdb.hp/thr-lib.exp b/gdb/testsuite/gdb.hp/thr-lib.exp new file mode 100644 index 00000000000..53bf4668749 --- /dev/null +++ b/gdb/testsuite/gdb.hp/thr-lib.exp @@ -0,0 +1,234 @@ +# thr-lib.exp -- Expect script to test thread-local storage in lib +# Copyright (C) 1992 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 + +# use this to debug: +# +#log_user 1 + +# Thread stuff is _slow_; prepare for long waits. +# +# Further, this test has some "null" lines designed +# to consume output from gdb that was too late to be +# matched (sequence is "gdb_test" sends; timeout and +# on to next send; result finally comes in; mismatch). +# +# The null command is 'gdb_test "p \$pc" ".*" ""' +# NOTE: this command undoes any up/down stuff! +# +proc pre_timeout {} { + global timeout + + set timeout [expr "$timeout + 100"] +} + +proc post_timeout {} { + global timeout + global oldtimeout + + set timeout $oldtimeout + gdb_test "p \$pc" ".*" "" +} + +if $tracelevel then { + strace $tracelevel +} + +if { ![istarget "hppa*-*-hpux10.30"] && ![istarget "hppa*-*-hpux11.*"] } { + verbose "HPUX thread test ignored for non-hppa or pre-HP/UX-10.30 targets." + return 0 +} + +set testfile thr-lib +set srcfile ${srcdir}/${subdir}/${testfile}.c +set libsrc ${srcdir}/${subdir}/${testfile}lib.c +set mainobj ${objdir}/${testfile}.o +set libobj ${objdir}/${testfile}lib.o +set libsl ${objdir}/${subdir}/${testfile}lib.sl +set binfile ${objdir}/${subdir}/${testfile} + +# To build the executable we need to do this: +# +# cc -c -Aa -g -D_HPUX_SOURCE -D_REENTRANT +DA1.0 ./gdb.hp/thr-lib.c +# cc -c -Aa -g -D_HPUX_SOURCE -D_REENTRANT +DA1.0 +z ./gdb.hp/thr-liblib.c +# ld -o thread_local_in_lib.lib.sl -b ./gdb.hp/thr-liblib.o +# ld -a archive /opt/langtools/lib/crt0.o /opt/langtools/lib/end.o \ +# > thr-lib.o ./gdb.hp/thr-liblib.sl \ +# > -o thr-lib -lpthread -lc +# +remote_exec build "$CC ${srcfile} -c -Aa -g -D_HPUX_SOURCE -D_REENTRANT +DA1.0" +remote_exec build "$CC ${libsrc} -c -Aa -g -D_HPUX_SOURCE -D_REENTRANT +DA1.0 +z" +remote_exec build "ld -o ${libsl} -b ${libobj}" +remote_exec build "ld -a archive /opt/langtools/lib/crt0.o /opt/langtools/lib/end.o ${mainobj} ${libsl} -lpthread -lc -o ${binfile}" + +gdb_exit +gdb_start +gdb_reinitialize_dir $srcdir/$subdir + +set oldtimeout $timeout +#set timeout [expr "$timeout + 200"] +set oldverbose $verbose + +gdb_load ${binfile} + +# Here we go: test various things. +# +gdb_test "b adder" ".*Cannot break on adder without a running program.*" "shared loc, needs to run" +gdb_test "b main" ".*" "" +gdb_test "run" ".*Breakpoint 1, main.*" "" + +# Set a bp to inspect the results +# +gdb_test "b 67" ".*Breakpoint 2.*" "" + +# get to a point where we can set the collection breakpoint. +# +gdb_test "tb adder" ".*Breakpoint 3.*line 47.*" "set bp in shared lib" +gdb_test "c" ".*Switched to.*adder.*" "run to shared lib rtn" + +# Check locations of things +# +gdb_test "i ad sum" ".*Symbol \"sum\" is a thread-local variable.*offset.*from the thread base register mpsfu_high.*" "find sum" +gdb_test "i add x" ".*Symbol \"x\" is a thread-local variable.*" "find x" + +# Set a breakpoint later on in "adder" and +# collect the thread local's value. +# +gdb_test "b 61" ".*Breakpoint 4.*61.*" "Set collection bp" + +# extra check for grins, expect to hit "adder" in thread 2 first +# but could be wrong... +# +gdb_test "info thread" ".*\\\* 2.*thread.*thread.*" "two threads" + +# Can't use "gdb_test", as it uses "$gdb_prompt $" in +# testing the result. Our new prompt is ">", with +# no trailing space, so we can't do this just by +# changing "prompt". +# +# Anyway, I couldn't get expect to see the ">" prompt, +# during the command addition, so I just punted. +# _You_ are welcome to try, if you want! +# +send_gdb "commands 4\n" +gdb_expect { + -re "(.*Type commands.*\"end\"\.\r\n\>)" { + pass "start commands" + } + -re ".*$gdb_prompt $" { + fail "start commands" + } +} + +# Assume we're in commands-input mode. (Self-debug stuff turned off) +# +send_gdb "silent\n" +#send_gdb "p id\n" +#send_gdb "p j\n" +#send_gdb "p x\[j\]\n" +send_gdb "set debugger_saw\[id\]\[j\] = x\[j\]\n" +send_gdb "continue\n" +send_gdb "end\n" + +gdb_expect { + -re ".*set.*cont.*$gdb_prompt $" { + pass "add commands" + } + -re ".*$gdb_prompt $" { + fail "add commands" + } +} + +# Check out of paranoia. +# +send_gdb "info break 4\n" +gdb_expect { + -re ".*breakpoint.*set debugger_saw.*continue.*$gdb_prompt $" { + pass "Commands added" + } + -re ".*$gdb_prompt $" { + fail "Commands not added." + } +} + +# We now expect to run through the whole application +# Since this'll run for while, set a generous timeout. +# +set timeout [expr "$timeout + 30"] +send_gdb "c\n" +gdb_expect { + -re ".*Program exited normally.*$gdb_prompt $" { + fail "program runaway" + } + -re ".*Breakpoint 2.*67.*$gdb_prompt $" { + pass "get to end" + } + -re ".*$gdb_prompt $" { + fail "No progress?" + } + timeout { fail "timeout" } +} +set timeout $oldtimeout + +gdb_test "p debugger_saw" ".*5, 1, 9.*4, 6, 10.*3, 7, 12.*2, 8, 11.*" "check results" + +# Often only one misses; let's get detailed! +# +gdb_test "p debugger_saw\[0\]\[0\]" ".*= 5.*" "1" +gdb_test "p debugger_saw\[0\]\[1\]" ".*= 1.*" "2" +gdb_test "p debugger_saw\[0\]\[2\]" ".*= 9.*" "3" +gdb_test "p debugger_saw\[1\]\[0\]" ".*= 4.*" "4" +gdb_test "p debugger_saw\[1\]\[1\]" ".*= 6.*" "5" +gdb_test "p debugger_saw\[1\]\[2\]" ".*= 10.*" "6" +gdb_test "p debugger_saw\[2\]\[0\]" ".*= 3.*" "7" +gdb_test "p debugger_saw\[2\]\[1\]" ".*= 7.*" "8" +gdb_test "p debugger_saw\[2\]\[2\]" ".*= 12.*" "9" +gdb_test "p debugger_saw\[3\]\[0\]" ".*= 2.*" "10" +gdb_test "p debugger_saw\[3\]\[1\]" ".*= 8.*" "11" +gdb_test "p debugger_saw\[3\]\[2\]" ".*= 11.*" "12" + +send_gdb "i th\n" +gdb_expect { + -re ".* 1.*system thread.* 2.*system thread.*$gdb_prompt $" { + fail "Too many threads left" + } + -re ".*\\\* 1.*system thread.*main.*$gdb_prompt $" { + pass "Expect only base thread" + } + -re ".*No stack.*$gdb_prompt $" { + fail "runaway" + } + -re ".*$gdb_prompt $" { + fail "Hunh?" + } + timeout { fail "timeout" } +} + +gdb_test "c" ".*exited normally.*" "run to completion" + +# Done! +# +gdb_exit + +set timeout $oldtimeout +set verbose $oldverbose + +# execute_anywhere "rm -f ${binfile}" +# +return 0 diff --git a/gdb/testsuite/gdb.hp/thr-lib.h b/gdb/testsuite/gdb.hp/thr-lib.h new file mode 100644 index 00000000000..c9395dfd0ca --- /dev/null +++ b/gdb/testsuite/gdb.hp/thr-lib.h @@ -0,0 +1,7 @@ +#include +#include + +#define NTHREADS 4 +#define NUM_ELEMS 12 + +#define ELEMS_PER_THREAD (NUM_ELEMS/NTHREADS) diff --git a/gdb/testsuite/gdb.hp/thr-liblib.c b/gdb/testsuite/gdb.hp/thr-liblib.c new file mode 100644 index 00000000000..a3effcc111f --- /dev/null +++ b/gdb/testsuite/gdb.hp/thr-liblib.c @@ -0,0 +1,92 @@ +#include + +/* Library code for thread local in lib test. +*/ +#include "thr-lib.h" + +extern pthread_mutex_t mutex; +extern int get_number(); +extern int total; +extern int the_code_saw[NTHREADS][ELEMS_PER_THREAD]; + +/* The debugger should see this without a declaration. + * + * extern int debugger_saw[NTHREADS][ELEMS_PER_THREAD]; + */ + +/* The actual thread locals. + */ +__thread int sum; +__thread int x[ ELEMS_PER_THREAD ]; /* [3] */ + +void sumup() +{ + int j; + + sum = 0; + for (j = 0; j < ELEMS_PER_THREAD; j++) { + sum += x[j]; + } + + if( sum == x[0] ) + /* It won't be "==", but this lets us set a breakpoint + * and look at the thread-local storage. + */ + sum++; + + x[0] = x[2]; /* Another no-op for debugger use */ +} + +void *adder( vid ) + void * vid; +{ + int id; + int i, j; + int ret; + + id = (int) vid; + + /* printf( "== Thread: Welcome to adder %d\n", id ); */ + + for (j = 0; j < ELEMS_PER_THREAD; j++) { + x[j] = 0; + } + + for (i = id, j = 0; i < NUM_ELEMS; i += NTHREADS, j++ ) { + + /* printf( "== Thread: id %d, i %d, j %d\n", id, i, j ); + fflush( stdout ); */ + + x[j] = get_number(i); /* {0,1,2,3} +0, +4, +8 */ + + /* Record for posterity; the debugger will gather + * the same data here, using "x[j]". + */ + the_code_saw[ id ][ j ] = x[j]; + + /* printf( "== Thread %d, sample %d, val %d, i %d\n", id, j, x[j],i ); + fflush( stdout ); */ + } + + sumup(); + /* printf("== Thread: adder %d contributes total %d\n", id, sum); */ + + /* protect global data */ + ret = pthread_mutex_lock(&mutex); + if (ret != 0) { + printf("== Thread: pthread_mutex_lock() error: %d\n", ret); + exit(1); + } + + total += sum; + + ret = pthread_mutex_unlock(&mutex); + if (ret != 0) { + printf("== Thread: pthread_mutex_unlock() error: %d\n", ret); + exit(1); + } + + if( NTHREADS != 4 || ELEMS_PER_THREAD != 3 || NUM_ELEMS != 12 ) { + printf( "** ERROR in test code **\n" ); + } +} diff --git a/gdb/testsuite/gdb.hp/thr-stg.exp b/gdb/testsuite/gdb.hp/thr-stg.exp new file mode 100644 index 00000000000..19d69ee9297 --- /dev/null +++ b/gdb/testsuite/gdb.hp/thr-stg.exp @@ -0,0 +1,255 @@ +# thread_local_stg.exp -- Expect script to test thread-local storage +# Copyright (C) 1992 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 + +# use this to debug: +# +#log_user 1 + +# Thread stuff is _slow_; prepare for long waits. +# +# Further, this test has some "null" lines designed +# to consume output from gdb that was too late to be +# matched (sequence is "gdb_test" sends; timeout and +# on to next send; result finally comes in; mismatch). +# +# The null command is 'gdb_test "p \$pc" ".*" ""' +# NOTE: this command undoes any up/down stuff! +# +proc pre_timeout {} { + global timeout + + set timeout [expr "$timeout + 100"] +} + +proc post_timeout {} { + global timeout + global oldtimeout + + set timeout $oldtimeout + gdb_test "p \$pc" ".*" "" +} + +if $tracelevel then { + strace $tracelevel +} + +if { ![istarget "hppa*-*-hpux10.30"] && ![istarget "hppa*-*-hpux11.*"] } { + verbose "HPUX thread test ignored for non-hppa or pre-HP/UX-10.30 targets." + return 0 +} + +set testfile start-stop +set srcfile ${srcdir}/${subdir}/${testfile}.c +set binfile ${objdir}/${subdir}/${testfile} + +if [get_compiler_info ${binfile}] { + return -1 +} + +# To build the executable we need to link against the thread library. +# +# cc -Ae -g -o start_stop -lpthread start_stop.c +# +#compile "${srcfile} -Ae -g -lpthread -o ${binfile}" + +if {$gcc_compiled == 0} { + set additional_flags "additional_flags=-Ae" +} else { + set additional_flags "" +} + +if { [gdb_compile "${srcdir}/${subdir}/${testfile}.c" "${binfile}.o" object [list debug $additional_flags]] != "" } { + gdb_suppress_entire_file "Testcase compile failed, so all tests in this file will automatically fail." +} +remote_exec build "ld /usr/ccs/lib/crt0.o ${binfile}.o -lcl -lpthread -lc /opt/langtools/lib/end.o -o ${binfile}" + +gdb_exit +gdb_start +gdb_reinitialize_dir $srcdir/$subdir + +gdb_load ${binfile} +if ![runto_main] then { + fail "Can't run to main" + return 0 +} + +set oldtimeout $timeout +#set timeout [expr "$timeout + 200"] +set oldverbose $verbose +#set verbose 40 + +gdb_test "b do_pass" ".*" "set do_pass bp" +gdb_test "c" ".*do_pass.*" "run to do_pass" +gdb_test "cle" ".*" "" + +# Set a breakpoint at the "spin" routine and +# collect the thread local's value. +# +gdb_test "b 67" ".*Breakpoint 3.*67.*" "Set bp" + +# Can't use "gdb_test", as it uses "$gdb_prompt $" in +# testing the result. Our new prompt is ">", with +# no trailing space, so we can't do this just by +# changing "prompt". +# +# Anyway, I couldn't get expect to see the ">" prompt, +# during the command addition, so I just punted. +# _You_ are welcome to try, if you want! +# +send_gdb "commands 3\n" +gdb_expect { + -re "(.*Type commands.*\"end\"\.\r\n\>)" { + pass "start commands" + } + -re ".*$gdb_prompt $" { + fail "start commands" + } +} + +# Assume we're in commands-input mode. +# +send_gdb "silent\n" +send_gdb "set val_debugger_saw\[me\] = a_thread_local\n" +send_gdb "continue\n" +send_gdb "end\n" + +gdb_expect { + -re ".*set.*cont.*$gdb_prompt $" { + pass "add commands" + } + -re ".*$gdb_prompt $" { + fail "add commands" + } +} + +# Check out of paranoia. +# +send_gdb "info break 3\n" +gdb_expect { + -re ".*breakpoint.*set val_debugger.*continue.*$gdb_prompt $" { + pass "Commands added" + } + -re ".*$gdb_prompt $" { + fail "Commands not added." + } +} + +# Set a bp to inspect the results +# +gdb_test "b 134" ".*Breakpoint 4.*" "" + +# We now expect to run through a whole pass, seeing +# specific results as noted below (actual gotten by +# running application with debugging print statements +# turned on. +# +# Since this'll run for while, set a generous timeout. +# +set timeout [expr "$timeout + 30"] +send_gdb "c\n" +gdb_expect { + -re ".*Program exited normally.*$gdb_prompt $" { + fail "program runaway" + } + -re ".*Pass 0 done.*Pass 1 done.*$gdb_prompt $" { + fail "program runaway 2" + } + -re ".*Pass 0 done.*Breakpoint 4.*134.*$gdb_prompt $" { + pass "get to end of first pass" + } + -re ".*$gdb_prompt $" { + fail "No progress?" + } + timeout { fail "timeout" } +} + +gdb_test "p val_debugger_saw" ".*0, 1, 3.*" "first pass" + +send_gdb "i th\n" +gdb_expect { + -re ".* 1.*system thread.* 2.*system thread.*$gdb_prompt $" { + fail "Too many threads left" + } + -re ".*\\\* 1 system thread.*$gdb_prompt $" { + pass "Expect only base thread" + } + -re ".*No stack.*$gdb_prompt $" { + fail "runaway" + } + -re ".*$gdb_prompt $" { + fail "Hunh?" + } + timeout { fail "timeout" } +} + +gdb_test "i b" ".*4.*breakpoint.*134.*hit.*1 time.*" "Expect 134 bp to exist" + +gdb_test "c" ".*Breakpoint 4.*134.*" "get to end of second pass" +gdb_test "p val_debugger_saw" ".*6, 10, 15.*" "second pass" + +gdb_test "c" ".*Breakpoint 4.*134.*" "get to end of third pass" +gdb_test "p val_debugger_saw" ".*21, 28, 36.*" "third pass" + +gdb_test "info bre 3" ".*already hit 9 times.*" "count of silent bp hits" + +# Start over and do some "info address" stuff +# +send_gdb "d\n" +gdb_expect { + -re ".*Delete all breakpoints.*$" { + send_gdb "y\n" + gdb_expect { + -re ".*$gdb_prompt $" { + pass "del bps" + } + } + } + -re ".*$gdb_prompt $" { fail "no question" } +} + +gdb_test "b spin" ".*Breakpoint 5.*" "" + +send_gdb "r\n" +gdb_expect { + -re ".*Start it from the beginning.*$" { + send_gdb "y\n" + gdb_expect { + -re ".*$gdb_prompt $" { pass "restart" } + } + } + -re ".*Starting program.*$gdb_prompt $" { + pass "restart after previous fails" + } + -re ".*$gdb_prompt $" { fail "Can't restart" } +} +gdb_test "i ad a_global" ".*a_global.*static storage at address.*" "i ad a_global" +gdb_test "i add me" ".*me.*local variable at frame offset.*" "i ad me" +gdb_test "i ad a_thread_local" ".*a_thread_local.*a thread-local variable at offset.*" "i ad a_thread_local" + +# Done! +# +gdb_exit + +set timeout $oldtimeout +set verbose $oldverbose + +# execute_anywhere "rm -f ${binfile}" +# +return 0 diff --git a/gdb/testsuite/gdb.hp/watch-cmd.exp b/gdb/testsuite/gdb.hp/watch-cmd.exp new file mode 100644 index 00000000000..968a524098f --- /dev/null +++ b/gdb/testsuite/gdb.hp/watch-cmd.exp @@ -0,0 +1,146 @@ +# Copyright (C) 1998 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 + +if $tracelevel then { + strace $tracelevel +} + +# +# test special commands +# +set prms_id 0 +set bug_id 0 + +set testfile "run-hp" +set srcfile ${testfile}.c +set binfile ${objdir}/${subdir}/${testfile} +if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {debug additional_flags=-DFAKEARGV}] != "" } { + gdb_suppress_entire_file "Testcase compile failed, so all tests in this file will automatically fail." + +} + +gdb_exit +gdb_start +delete_breakpoints +gdb_reinitialize_dir $srcdir/$subdir +gdb_load ${binfile} + + + +proc watchpoint_command_test {} { + global gdb_prompt + + if [target_info exists noargs] { + verbose "Skipping watchpoint_command_test because of noargs." + return + } + + if { ![runto factorial] } then { gdb_suppress_tests } + # Don't depend upon argument passing, since most simulators don't currently + # support it. Bash value variable to be what we want. + gdb_test "p value=6" "" "set value to 6 in watchpoint_command_test" + delete_breakpoints + + # Verify that we can create a watchpoint, and give it a commands + # list that continues the inferior. We set the watchpoint on a + # local variable, too, so that it self-deletes when the watched + # data goes out of scope. + # + # What should happen is: Each time the watchpoint triggers, it + # continues the inferior. Eventually, the watchpoint will self- + # delete, when the watched variable is out of scope. But by that + # time, the inferior should have exited. GDB shouldn't crash or + # anything untoward as a result of this. + # + send_gdb "watch local_var\n" + gdb_expect { + -re ".*\[Ww\]atchpoint (\[0-9\]*): local_var.*$gdb_prompt $"\ + { pass "watch local_var" + set wp_id $expect_out(1,string) + send_gdb "commands $wp_id\n" + gdb_expect { + -re "Type commands for when breakpoint $wp_id is hit, one per line.*>"\ + { pass "begin commands on watch"} + -re "$gdb_prompt $"\ + {fail "begin commands on watch"} + timeout {fail "(timeout) begin commands on watch"} + } + } + -re "$gdb_prompt $"\ + {fail "watch local_var"} + timeout {fail "(timeout) watch local_var"} + } +# set wp_id $expect_out(1,string) +# send_gdb "commands $wp_id\n" +# gdb_expect { +# -re "Type commands for when breakpoint $wp_id is hit, one per line.*>"\ +# {pass "begin commands on watch"} +# -re "$gdb_prompt $"\ +# {fail "begin commands on watch"} +# timeout {fail "(timeout) begin commands on watch"} +# } + send_gdb "print value\n" + gdb_expect { + -re ">"\ + {pass "add print command to watch"} + -re "$gdb_prompt $"\ + {fail "add print command to watch"} + timeout {fail "(timeout) add print command to watch"} + } + send_gdb "continue\n" + gdb_expect { + -re ">"\ + {pass "add continue command to watch"} + -re "$gdb_prompt $"\ + {fail "add continue command to watch"} + timeout {fail "(timeout) add continue command to watch"} + } + send_gdb "end\n" + gdb_expect { + -re "$gdb_prompt $"\ + {pass "begin commands on watch"} + timeout {fail "(timeout) begin commands on watch"} + } + send_gdb "continue\n" + gdb_expect { + -re "Continuing.*\[Ww\]atchpoint $wp_id deleted because the program has left the block in.*which its expression is valid.*in main.*$gdb_prompt $"\ + {pass "continue with watch"} + -re "$gdb_prompt $"\ + {fail "continue with watch"} + timeout {fail "(timeout) continue with watch"} + } + send_gdb "continue\n" + gdb_expect { + -re "Continuing.*$gdb_prompt $"\ + {pass "continue until exit"} + -re "$gdb_prompt $"\ + {fail "continue until exit"} + timeout {fail "(timeout) continue until exit"} + } +} + +watchpoint_command_test + + + + + + + + diff --git a/gdb/testsuite/gdb.hp/watch-hp.c b/gdb/testsuite/gdb.hp/watch-hp.c new file mode 100644 index 00000000000..7336fe2bec8 --- /dev/null +++ b/gdb/testsuite/gdb.hp/watch-hp.c @@ -0,0 +1,166 @@ +#include +/* + * Since using watchpoints can be very slow, we have to take some pains to + * ensure that we don't run too long with them enabled or we run the risk + * of having the test timeout. To help avoid this, we insert some marker + * functions in the execution stream so we can set breakpoints at known + * locations, without worrying about invalidating line numbers by changing + * this file. We use null bodied functions are markers since gdb does + * not support breakpoints at labeled text points at this time. + * + * One place we need is a marker for when we start executing our tests + * instructions rather than any process startup code, so we insert one + * right after entering main(). Another is right before we finish, before + * we start executing any process termination code. + * + * Another problem we have to guard against, at least for the test + * suite, is that we need to ensure that the line that causes the + * watchpoint to be hit is still the current line when gdb notices + * the hit. Depending upon the specific code generated by the compiler, + * the instruction after the one that triggers the hit may be part of + * the same line or part of the next line. Thus we ensure that there + * are always some instructions to execute on the same line after the + * code that should trigger the hit. + */ + +int count = -1; +int ival1 = -1; +int ival2 = -1; +int ival3 = -1; +int ival4 = -1; +int ival5 = -1; +char buf[10]; +struct foo +{ + int val; +}; +struct foo struct1, struct2, *ptr1, *ptr2; + +int doread = 0; + +void marker1 () +{ +} + +void marker2 () +{ +} + +void marker4 () +{ +} + +void marker5 () +{ +} + +void marker6 () +{ +} + +void recurser (x) + int x; +{ + int local_x; + + if (x > 0) + recurser (x-1); + local_x = x; +} + +void +func2 () +{ + int local_a; + static int static_b; + + ival5++; + local_a = ival5; + static_b = local_a; +} + +int +func1 () +{ + /* The point of this is that we will set a breakpoint at this call. + + Then, if DECR_PC_AFTER_BREAK equals the size of a function call + instruction (true on a sun3 if this is gcc-compiled--FIXME we + should use asm() to make it work for any compiler, present or + future), then we will end up branching to the location just after + the breakpoint. And we better not confuse that with hitting the + breakpoint. */ + func2 (); + return 73; +} + +int main () +{ + struct1.val = 1; + struct2.val = 2; + ptr1 = &struct1; + ptr2 = &struct2; + marker1 (); + func1 (); + for (count = 0; count < 4; count++) { + ival1 = count; + ival3 = count; ival4 = count; + } + ival1 = count; /* Outside loop */ + ival2 = count; + ival3 = count; ival4 = count; + marker2 (); + if (doread) + { + static char msg[] = "type stuff for buf now:"; + write (1, msg, sizeof (msg) - 1); + read (0, &buf[0], 5); + } + marker4 (); + + /* We have a watchpoint on ptr1->val. It should be triggered if + ptr1's value changes. */ + ptr1 = ptr2; + + /* This should not trigger the watchpoint. If it does, then we + used the wrong value chain to re-insert the watchpoints or we + are not evaluating the watchpoint expression correctly. */ + struct1.val = 5; + marker5 (); + + /* We have a watchpoint on ptr1->val. It should be triggered if + ptr1's value changes. */ + ptr1 = ptr2; + + /* This should not trigger the watchpoint. If it does, then we + used the wrong value chain to re-insert the watchpoints or we + are not evaluating the watchpoint expression correctly. */ + struct1.val = 5; + marker5 (); + + /* We're going to watch locals of func2, to see that out-of-scope + watchpoints are detected and properly deleted. + */ + marker6 (); + + /* This invocation is used for watches of a single + local variable. */ + func2 (); + + /* This invocation is used for watches of an expression + involving a local variable. */ + func2 (); + + /* This invocation is used for watches of a static + (non-stack-based) local variable. */ + func2 (); + + /* This invocation is used for watches of a local variable + when recursion happens. + */ + marker6 (); + recurser (2); + + marker6 (); + return 0; +} diff --git a/gdb/testsuite/gdb.hp/watch-hp.exp b/gdb/testsuite/gdb.hp/watch-hp.exp new file mode 100644 index 00000000000..e25441b1008 --- /dev/null +++ b/gdb/testsuite/gdb.hp/watch-hp.exp @@ -0,0 +1,779 @@ +# Copyright (C) 1992, 1994, 1997 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 Fred Fish. (fnf@cygnus.com) + +if $tracelevel then { + strace $tracelevel +} + +set prms_id 0 +set bug_id 0 + +set testfile "watch-hp" +set srcfile ${testfile}.c +set binfile ${objdir}/${subdir}/${testfile} +if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {debug}] != "" } { + gdb_suppress_entire_file "Testcase compile failed, so all tests in this file will automatically fail." +} + +# Prepare for watchpoint tests by setting up two breakpoints and one +# watchpoint. +# +# We use breakpoints at marker functions to get past all the startup code, +# so we can get to the watchpoints in a reasonable amount of time from a +# known starting point. +# +# For simplicity, so we always know how to reference specific breakpoints or +# watchpoints by number, we expect a particular ordering and numbering of +# each in the combined breakpoint/watchpoint table, as follows: +# +# Number What Where +# 1 Breakpoint marker1() +# 2 Breakpoint marker2() +# 3 Watchpoint ival3 + +proc initialize {} { + global gdb_prompt + global hex + global decimal + global srcfile + + if [gdb_test "break marker1" "Breakpoint 1 at $hex: file .*$srcfile, line $decimal.*" "set breakpoint at marker1" ] { + return 0; + } + + + if [gdb_test "break marker2" "Breakpoint 2 at $hex: file .*$srcfile, line $decimal.*" "set breakpoint at marker2" ] { + return 0; + } + + + if [gdb_test "info break" "1\[ \]*breakpoint.*marker1.*\r\n2\[ \]*breakpoint.*marker2.*" "info break in watchpoint.exp" ] { + return 0; + } + +# ??rehrauer: To fix DTS #CHFts23014, in which setting a watchpoint +# before running can cause the inferior to croak on HP-UX 10.30 and +# 11.0 for reasons as yet unknown, we've disabled the ability to set +# watches without a running inferior. Verify the restriction. +# + send_gdb "watch ival3\n" + gdb_expect { + -re ".*can't do that without a running program; try \"break main\", \"run\" first.*$gdb_prompt $" { + pass "set watchpoint on ival3" + } + -re ".*$gdb_prompt $" { fail "set watchpoint on ival3" } + timeout { fail "set watchpoint on ival3 (timeout)" } + } + + +# if [gdb_test "watch ival3" ".*\[Ww\]atchpoint 3: ival3" "set watchpoint on ival3" ] { +# return 0; +# } + + + # "info watch" is the same as "info break" + +# if [gdb_test "info watch" "1\[ \]*breakpoint.*marker1.*\r\n2\[ \]*breakpoint.*marker2.*\r\n3\[ \]*.*watchpoint.*ival3" "watchpoint found in watchpoint/breakpoint table" ] { +# return 0; +# } + + + # After installing the watchpoint, we disable it until we are ready + # to use it. This allows the test program to run at full speed until + # we get to the first marker function. + +# if [gdb_test "disable 3" "disable 3\[\r\n\]+" "disable watchpoint" ] { +# return 0; +# } + + + return 1 +} + +# +# Test simple watchpoint. +# + +proc test_simple_watchpoint {} { + global gdb_prompt + global hex + global decimal + + # Ensure that the watchpoint is disabled when we startup. + +# if [gdb_test "disable 3" "^disable 3\[\r\n\]+" "disable watchpoint in test_simple_watchpoint" ] { +# return 0; +# } + + + # Run until we get to the first marker function. + + gdb_run_cmd + set timeout 600 + gdb_expect { + -re "Breakpoint 1, marker1 .*$gdb_prompt $" { + pass "run to marker1 in test_simple_watchpoint" + } + -re ".*$gdb_prompt $" { + fail "run to marker1 in test_simple_watchpoint" + return + } + timeout { + fail "run to marker1 in test_simple_watchpoint (timeout)" + return + } + } +#************************ + +# ??rehrauer: To fix DTS #CHFts23014, in which setting a watchpoint +# before running can cause the inferior to croak on HP-UX 10.30 and +# 11.0 for reasons as yet unknown, we've disabled the ability to set +# watches without a running inferior. The following testpoints used +# to be in [initialize]. +# + send_gdb "watch ival3\n" + gdb_expect { + -re ".*\[Ww\]atchpoint 3: ival3\r\n$gdb_prompt $" { + pass "set watchpoint on ival3" + } + -re ".*$gdb_prompt $" { fail "set watchpoint on ival3" } + timeout { fail "set watchpoint on ival3 (timeout)" } + } + + # "info watch" is the same as "info break" + + send_gdb "info watch\n" + gdb_expect { + -re "1\[ \]*breakpoint.*marker1.*\r\n2\[ \]*breakpoint.*marker2.*\r\n3\[ \]*.*watchpoint.*ival3\r\n$gdb_prompt $" { + pass "watchpoint found in watchpoint/breakpoint table" + } + -re ".*$gdb_prompt $" { + fail "watchpoint found in watchpoint/breakpoint table" + } + timeout { + fail "watchpoint found in watchpoint/breakpoint table" + } + } + + # After installing the watchpoint, we disable it until we are ready + # to use it. This allows the test program to run at full speed until + # we get to the first marker function. + + send_gdb "disable 3\n" + gdb_expect { + -re "disable 3\[\r\n\]+$gdb_prompt $" { pass "disable watchpoint" } + -re ".*$gdb_prompt $" { fail "disable watchpoint" } + timeout { fail "disable watchpoint (timeout)" } + } +#****** + # After reaching the marker function, enable the watchpoint. + + if [gdb_test "enable 3" "^enable 3\[\r\n\]+" "enable watchpoint" ] { + return ; + } + + + gdb_test "break func1" "Breakpoint.*at.*" + gdb_test "set \$func1_breakpoint_number = \$bpnum" "" + + gdb_test "continue" "Continuing.*Breakpoint \[0-9\]*, func1.*" \ + "continue to breakpoint at func1" + + # Continue until the first change, from -1 to 0 + + send_gdb "cont\n" + gdb_expect { + -re "Continuing.*\[Ww\]atchpoint.*ival3.*Old value = -1.*New value = 0.*ival3 = count; ival4 = count;.*$gdb_prompt $" { + pass "watchpoint hit, first time" + } + -re "Continuing.*Breakpoint.*func1.*$gdb_prompt $" { + setup_xfail "m68*-*-*" 2597 + fail "thought it hit breakpoint at func1 twice" + gdb_test "delete \$func1_breakpoint_number" "" + gdb_test "continue" "\ +Continuing.*\[Ww\]atchpoint.*ival3.*Old value = -1.*New value = 0.*ival3 = count;" \ + "watchpoint hit, first time" + } + -re ".*$gdb_prompt $" { fail "watchpoint hit, first time" ; return } + timeout { fail "watchpoint hit, first time (timeout)" ; return } + eof { fail "watchpoint hit, first time (eof)" ; return } + } + + gdb_test "delete \$func1_breakpoint_number" "" + + # Continue until the next change, from 0 to 1. + gdb_test "cont" "Continuing.*\[Ww\]atchpoint.*ival3.*Old value = 0.*New value = 1.*ival3 = count; ival4 = count;.*" "watchpoint hit, second time" + + # Continue until the next change, from 1 to 2. + gdb_test "cont" "Continuing.*\[Ww\]atchpoint.*ival3.*Old value = 1.*New value = 2.*ival3 = count; ival4 = count;.*" "watchpoint hit, third time" + + # Continue until the next change, from 2 to 3. + gdb_test "cont" "Continuing.*\[Ww\]atchpoint.*ival3.*Old value = 2.*New value = 3.*ival3 = count; ival4 = count;.*" "watchpoint hit, fourth time" + + # Continue until the next change, from 3 to 4. + # Note that this one is outside the loop. + + gdb_test "cont" "Continuing.*\[Ww\]atchpoint.*ival3.*Old value = 3.*New value = 4.*ival3 = count; ival4 = count;.*" "watchpoint hit, fifth time" + + # Continue until we hit the finishing marker function. + # Make sure we hit no more watchpoints. + + gdb_test "cont" "Continuing.*Breakpoint.*marker2 \(\).*" \ + "continue to marker2" + + # Disable the watchpoint so we run at full speed until we exit. + + if [gdb_test "disable 3" "^disable 3\[\r\n\]+" "watchpoint disabled" ] { + return ; + } + + + # Run until process exits. + + if [target_info exists gdb,noresults] { return } + + gdb_test "cont" "Continuing.*Program exited normally.*" \ + "continue to exit in test_simple_watchpoint" +} + +# Test disabling watchpoints. + +proc test_disabling_watchpoints {} { + global gdb_prompt + global binfile + global srcfile + global decimal + global hex + + # Ensure that the watchpoint is disabled when we startup. + + if [gdb_test "disable 3" "^disable 3\[\r\n\]+" "disable watchpoint in test_disabling_watchpoints" ] { + return 0; + } + + + # Run until we get to the first marker function. + + gdb_run_cmd + set timeout 600 + gdb_expect { + -re "Breakpoint 1, marker1 .*$gdb_prompt $" { + pass "run to marker1 in test_disabling_watchpoints" + } + -re ".*$gdb_prompt $" { + fail "run to marker1 in test_disabling_watchpoints" + return + } + timeout { + fail "run to marker1 in test_disabling_watchpoints (timeout)" + return + } + } + + # After reaching the marker function, enable the watchpoint. + + if [gdb_test "enable 3" "^enable 3\[\r\n\]+" "watchpoint enabled" ] { + return ; + } + + + # Continue until the first change, from -1 to 0 + # Don't check the old value, because on VxWorks the variable value + # will not have been reinitialized. + gdb_test "cont" "Continuing.*\[Ww\]atchpoint.*ival3.*Old value = .*New value = 0.*ival3 = count; ival4 = count;.*" "watchpoint hit in test_disabling_watchpoints, first time" + + # Continue until the next change, from 0 to 1. + gdb_test "cont" "Continuing.*\[Ww\]atchpoint.*ival3.*Old value = 0.*New value = 1.*ival3 = count; ival4 = count;.*" "watchpoint hit in test_disabling_watchpoints, second time" + + # Disable the watchpoint but leave breakpoints + + if [gdb_test "disable 3" "^disable 3\[\r\n\]+" "disable watchpoint #2 in test_disabling_watchpoints" ] { + return 0; + } + + + # Check watchpoint list, looking for the entry that confirms the + # watchpoint is disabled. + gdb_test "info watchpoints" "3\[ \]*.*watchpoint\[ \]*keep\[ \]*n\[ \]*ival3\r\n.*" "watchpoint disabled in table" + + # Continue until we hit the finishing marker function. + # Make sure we hit no more watchpoints. + gdb_test "cont" "Continuing.*Breakpoint.*marker2 \\(\\).*" \ + "disabled watchpoint skipped" + + if [target_info exists gdb,noresults] { return } + + gdb_test "cont" "Continuing.*Program exited normally.*" \ + "continue to exit in test_disabling_watchpoints" +} + +# Test stepping and other mundane operations with watchpoints enabled +proc test_stepping {} { + global gdb_prompt + + if [runto marker1] then { + gdb_test "watch ival2" ".*\[Ww\]atchpoint \[0-9\]*: ival2" + + # Well, let's not be too mundane. It should be a *bit* of a challenge + gdb_test "break func2 if 0" "Breakpoint.*at.*" + gdb_test "p \$func2_breakpoint_number = \$bpnum" " = .*" + + # The HPPA has a problem here if it's not using hardware watchpoints + if {[ istarget "hppa*-*-*" ] && ![ istarget "hppa*-*-*bsd*" ]} then { + # Don't actually try doing the call, if we do we can't continue. + setup_xfail "*-*-*" + fail "calling function with watchpoint enabled" + } else { + # The problem is that GDB confuses stepping through the call + # dummy with hitting the breakpoint at the end of the call dummy. + # Will be fixed once all architectures define + # CALL_DUMMY_BREAKPOINT_OFFSET. + setup_xfail "*-*-*" + # This doesn't occur if the call dummy starts with a call, + # because we are out of the dummy by the first time the inferior + # stops. + clear_xfail "d10v*-*-*" + clear_xfail "m68*-*-*" + clear_xfail "i*86*-*-*" + clear_xfail "vax-*-*" + # The following architectures define CALL_DUMMY_BREAKPOINT_OFFSET. + clear_xfail "alpha-*-*" + clear_xfail "mips*-*-*" + clear_xfail "sparc-*-*" + clear_xfail "hppa*-*-*bsd*" + # It works with the generic inferior function calling code too. + clear_xfail "mn10200*-*-*" + clear_xfail "mn10300*-*-*" + gdb_test "p func1 ()" "= 73" \ + "calling function with watchpoint enabled" + } + + # + # "finish" brings us back to main. + # On some targets (e.g. alpha) gdb will stop from the finish in midline + # of the marker1 call. This is due to register restoring code on + # the alpha and might be caused by stack adjustment instructions + # on other targets. In this case we will step once more. + # + + send_gdb "finish\n" + gdb_expect { + -re "Run.*exit from.*marker1.* at" { } + default { fail "finish from marker1" ; return } + } + + gdb_expect { + -re "marker1 \\(\\);.*$gdb_prompt $" { + send_gdb "step\n" + exp_continue + } + -re "func1 \\(\\);.*$gdb_prompt $" { + pass "finish from marker1" + } + -re ".*$gdb_prompt $" { + fail "finish from marker1" + } + default { fail "finish from marker1" ; return } + } + + gdb_test "next" "for \\(count = 0.*" "next to `for' in watchpoint.exp" + + # Now test that "until" works. It's a bit tricky to test + # "until", because compilers don't always arrange the code + # exactly the same way, and we might get slightly different + # sequences of statements. But the following should be true + # (if not it is a compiler or a debugger bug): The user who + # does "until" at every statement of a loop should end up + # stepping through the loop once, and the debugger should not + # stop for any of the remaining iterations. + + gdb_test "until" "ival1 = count.*" "until to ival1 assignment" + gdb_test "until" "ival3 = count.*" "until to ival3 assignment" + send_gdb "until\n" + gdb_expect { + -re "(for \\(count = 0|\}).*$gdb_prompt $" { + gdb_test "until" "ival1 = count; /. Outside loop ./" \ + "until out of loop" + } + -re "ival1 = count; /. Outside loop ./.*$gdb_prompt $" { + pass "until out of loop" + } + -re ".*$gdb_prompt $" { + fail "until out of loop" + } + default { fail "until out of loop" ; return } + } + + gdb_test "step" "ival2 = count.*" "step to ival2 assignment" + } +} + +# Test stepping and other mundane operations with watchpoints enabled +proc test_watchpoint_triggered_in_syscall {} { + global gdb_prompt + + if [target_info exists gdb,noinferiorio] { + verbose "Skipping test_watchpoint_triggered_in_syscall due to noinferiorio" + return + } + # Run until we get to the first marker function. + set x 0 + set y 0 + set testname "Watch buffer passed to read syscall" + if [runto marker2] then { + gdb_test "watch buf\[0\]" ".*\[Ww\]atchpoint \[0-9\]*: buf\\\[0\\\]" + gdb_test "watch buf\[1\]" ".*\[Ww\]atchpoint \[0-9\]*: buf\\\[1\\\]" + gdb_test "watch buf\[2\]" ".*\[Ww\]atchpoint \[0-9\]*: buf\\\[2\\\]" + gdb_test "watch buf\[3\]" ".*\[Ww\]atchpoint \[0-9\]*: buf\\\[3\\\]" + gdb_test "watch buf\[4\]" ".*\[Ww\]atchpoint \[0-9\]*: buf\\\[4\\\]" + gdb_test "break marker4" ".*Breakpoint.*" + + gdb_test "set doread = 1" "" + + # If we send_gdb "123\n" before gdb has switched the tty, then it goes + # to gdb, not the inferior, and we lose. So that is why we have + # watchpoint.c prompt us, so we can wait for that prompt. + send_gdb "continue\n"; + gdb_expect { + -re "Continuing\\.\r\ntype stuff for buf now:" { + pass "continue to read" + } + default { + fail "continue to read"; + return ; + } + } + + send_gdb "123\n" + gdb_expect { + -re ".*\[Ww\]atchpoint.*buf\\\[0\\\].*Old value = 0.*New value = 49\[^\n\]*\n" { set x [expr $x+1] ; exp_continue } + -re ".*\[Ww\]atchpoint.*buf\\\[1\\\].*Old value = 0.*New value = 50\[^\n\]*\n" { set x [expr $x+1] ; exp_continue } + -re ".*\[Ww\]atchpoint.*buf\\\[2\\\].*Old value = 0.*New value = 51\[^\n\]*\n" { set x [expr $x+1] ; exp_continue } + -re ".*\[Ww\]atchpoint.*buf\\\[3\\\].*Old value = 0.*New value = 10\[^\n\]*\n" { set x [expr $x+1] ; exp_continue } + -re ".*$gdb_prompt $" { pass "sent 123" } + timeout { fail "sent 123 (timeout)" } + } + + # Examine the values in buf to see how many watchpoints we + # should have printed. + send_gdb "print buf\[0\]\n" + gdb_expect { + -re ".*= 49.*$gdb_prompt $" { set y [expr $y+1]; pass "print buf\[0\]"} + -re ".*= 0.*$gdb_prompt $" { pass "print buf\[0\]"} + -re ".*$gdb_prompt $" { fail "print buf\[0\]"} + default { fail "print buf\[0\]"} + } + send_gdb "print buf\[1\]\n" + gdb_expect { + -re ".*= 50.*$gdb_prompt $" { set y [expr $y+1]; pass "print buf\[1\]"} + -re ".*= 0.*$gdb_prompt $" { pass "print buf\[1\]"} + -re ".*$gdb_prompt $" { fail "print buf\[1\]"} + default { fail "print buf\[1\]"} + } + send_gdb "print buf\[2\]\n" + gdb_expect { + -re ".*= 51.*$gdb_prompt $" { set y [expr $y+1]; pass "print buf\[2\]"} + -re ".*= 0.*$gdb_prompt $" { pass "print buf\[2\]"} + -re ".*$gdb_prompt $" { fail "print buf\[2\]"} + default { fail "print buf\[2\]"} + } + send_gdb "print buf\[3\]\n" + gdb_expect { + -re ".*= 10.*$gdb_prompt $" { set y [expr $y+1]; pass "print buf\[3\]"} + -re ".*= 0.*$gdb_prompt $" { pass "print buf\[3\]"} + -re ".*$gdb_prompt $" { fail "print buf\[3\]" } + default { fail "print buf\[3\]" } + } + + # Did we find what we were looking for? If not, flunk it. + if [expr $x==$y] then { pass $testname } else { fail "$testname (only triggered $x watchpoints, expected $y)"} + + # Continue until we hit the finishing marker function. + # Make sure we hit no more watchpoints. + gdb_test "cont" "Continuing.*Breakpoint.*marker4 \\(\\).*" \ + "continue to marker4" + + # Disable everything so we can finish the program at full speed + gdb_test "disable" "" "disable in test_watchpoint_triggered_in_syscall" + + if [target_info exists gdb,noresults] { return } + + gdb_test "cont" "Continuing.*Program exited normally.*" \ + "continue to exit in test_watchpoint_triggered_in_syscall" + } +} + +# Do a simple test of of watching through a pointer when the pointer +# itself changes. Should add some more complicated stuff here. + +proc test_complex_watchpoint {} { + global gdb_prompt + + if [runto marker4] then { + gdb_test "watch ptr1->val" ".*\[Ww\]atchpoint \[0-9\]*: ptr1->val" + gdb_test "break marker5" ".*Breakpoint.*" + + gdb_test "cont" "Continuing.*\[Ww\]atchpoint.*ptr1->val.*Old value = 1.*New value = 2.*" "Test complex watchpoint" + + # Continue until we hit the marker5 function. + # Make sure we hit no more watchpoints. + + gdb_test "cont" "Continuing.*Breakpoint.*marker5 \\(\\).*" \ + "did not trigger wrong watchpoint" +#******************** + # Test watches of things declared locally in a function. + # In particular, test that a watch of stack-based things + # is deleted when the stack-based things go out of scope. + # + gdb_test "disable" "" "disable in test_complex_watchpoint" + gdb_test "break marker6" ".*Breakpoint.*" + gdb_test "cont" "Continuing.*Breakpoint.*marker6 \\(\\).*" \ + "continue to marker6" + gdb_test "break func2" ".*Breakpoint.*" + gdb_test "cont" "Continuing.*func2.*" + + # Test a watch of a single stack-based variable, whose scope + # is the function we're now in. This should auto-delete when + # execution exits the scope of the watchpoint. + # + gdb_test "watch local_a" ".*\[Ww\]atchpoint \[0-9\]*: local_a" "set local watch" + gdb_test "cont" "\[Ww\]atchpoint.*local_a.*" "trigger local watch" + gdb_test "cont" "Continuing.*Watchpoint .* deleted because the program has left the block in.*which its expression is valid.*" "self-delete local watch" + + # after func2 returned, gdb stopped and deleted the watchpoint + # we're now in main, let's get to func2 + gdb_test "cont" "Continuing.*func2.*" + + # We should be in "func2" again now. Test a watch of an + # expression which includes both a stack-based local and + # something whose scope is larger than this invocation + # of "func2". This should also auto-delete. + # + gdb_test "watch local_a + ival5" ".*\[Ww\]atchpoint \[0-9\]*: local_a . ival5" \ + "set partially local watch" + gdb_test "cont" "Continuing.*\[Ww\]atchpoint .*: local_a . ival5.*" \ + "trigger1 partially local watch" + gdb_test "cont" "Continuing.*\[Ww\]atchpoint .*: local_a . ival5.*" \ + "trigger2 partially local watch" + gdb_test "cont" "Continuing.*\[Ww\]atchpoint .* deleted because the program has left the block in.*which its expression is valid.*" \ + "self-delete partially local watch" + + # after func2 returned, gdb stopped and deleted the watchpoint + # we're now in main, let's get to func2 + gdb_test "cont" "Continuing.*func2.*" + + # We should be in "func2" again now. Test a watch of a + # static (non-stack-based) local. Since this has scope + # across any invocations of "func2", it should not auto- + # delete. + # + gdb_test "watch static_b" ".*\[Ww\]atchpoint \[0-9\]*: static_b" \ + "set static local watch" + gdb_test "cont" "Continuing.*\[Ww\]atchpoint .*: static_b.*" \ + "trigger static local watch" + gdb_test "cont" "Continuing.*marker6 \\(\\).*" \ + "continue after trigger static local watch" + gdb_test "info break" ".*watchpoint.*static_b.*" \ + "static local watch did not self-delete" + + # We should be in "recurser" now. Test a watch of a stack- + # based local. Symbols mentioned in a watchpoint are bound + # at watchpoint-creation. Thus, a watch of a stack-based + # local to a recursing function should be bound only to that + # one invocation, and should not trigger for other invocations. + # + gdb_test "tbreak recurser" ".*Breakpoint.*" + gdb_test "cont" "Continuing.*recurser.*" + gdb_test "watch local_x" ".*\[Ww\]atchpoint \[0-9\]*: local_x" \ + "set local watch in recursive call" + gdb_test "cont" "Continuing.*\[Ww\]atchpoint .*: local_x.*New value = 2.*" \ + "trigger local watch in recursive call" + gdb_test "cont" "Continuing.*\[Ww\]atchpoint .* deleted because the program has left the block in.*which its expression is valid.*" \ + "self-delete local watch in recursive call" + + + + +#****************** + # Disable everything so we can finish the program at full speed + gdb_test "disable" "" "disable in test_complex_watchpoint" + + if [target_info exists gdb,noresults] { return } + + + gdb_test "cont" "Continuing.*Program exited normally.*" \ + "continue to exit in test_complex_watchpoint" + } +} + +# Start with a fresh gdb. + +gdb_start +gdb_reinitialize_dir $srcdir/$subdir +gdb_load $binfile +set timeout 600 +verbose "Timeout now 600 sec.\n" + +if [initialize] then { + + test_simple_watchpoint + + # The IDT/sim monitor only has 8 (!) open files, of which it uses + # 4 (!). So we have to make sure one program exits before + # starting another one. + if [istarget "mips-idt-*"] then { + gdb_exit + gdb_start + gdb_reinitialize_dir $srcdir/$subdir + gdb_load $binfile + initialize + } + + test_disabling_watchpoints + + # See above. + if [istarget "mips-idt-*"] then { + gdb_exit + gdb_start + gdb_reinitialize_dir $srcdir/$subdir + gdb_load $binfile + initialize + } + + if ![target_info exists gdb,cannot_call_functions] { + test_stepping + + # See above. + if [istarget "mips-idt-*"] then { + gdb_exit + gdb_start + gdb_reinitialize_dir $srcdir/$subdir + gdb_load $binfile + initialize + } + } + + # Only enabled for some targets merely because it has not been tested + # elsewhere. + # On sparc-sun-sunos4.1.3, GDB was running all the way to the marker4 + # breakpoint before stopping for the watchpoint. I don't know why. + if {[istarget "hppa*-*-*"]} then { + test_watchpoint_triggered_in_syscall + } + + # See above. + if [istarget "mips-idt-*"] then { + gdb_exit + gdb_start + gdb_reinitialize_dir $srcdir/$subdir + gdb_load $binfile + initialize + } + + # Only enabled for some targets merely because it has not been tested + # elsewhere. + if {[istarget "hppa*-*-*"] || \ + [istarget "sparc*-*-sunos*"] || \ + [istarget "m32r-*-*"]} then { + test_complex_watchpoint +#*************** + } + + # Verify that a user can force GDB to use "slow" watchpoints. + # (This proves rather little on kernels that don't support + # fast watchpoints, but still...) + # + if ![runto_main] then { fail "watch tests suppressed" } + + send_gdb "set can-use-hw-watchpoints 0\n" + gdb_expect { + -re "$gdb_prompt $"\ + {pass "disable fast watches"} + timeout {fail "(timeout) disable fast watches"} + } + send_gdb "show can-use-hw-watchpoints\n" + gdb_expect { + -re "Debugger's willingness to use watchpoint hardware is 0.*$gdb_prompt $"\ + {pass "show disable fast watches"} + -re "$gdb_prompt $"\ + {fail "show disable fast watches"} + timeout {fail "(timeout) show disable fast watches"} + } + send_gdb "watch ival3 if count > 1\n" + gdb_expect { + -re "Watchpoint \[0-9\]*: ival3.*$gdb_prompt $"\ + {pass "set slow conditional watch"} + -re "$gdb_prompt $"\ + {fail "set slow conditional watch"} + timeout {fail "(timeout) set slow conditional watch"} + } + send_gdb "continue\n" + gdb_expect { + -re "Watchpoint \[0-9\]*: ival3.*Old value = 1.*New value = 2.*$gdb_prompt $"\ + {pass "trigger slow conditional watch"} + -re "$gdb_prompt $"\ + {fail "trigger slow conditional watch"} + timeout {fail "(timeout) trigger slow conditional watch"} + } + + # We've explicitly disabled hardware watches. Verify that GDB + # + # + send_gdb "rwatch ival3\n" + gdb_expect { + -re "Expression cannot be implemented with read/access watchpoint..*$gdb_prompt $"\ + {pass "rwatch disallowed when can-set-hw-watchpoints cleared"} + -re "$gdb_prompt $"\ + {fail "rwatch disallowed when can-set-hw-watchpoints cleared"} + timeout {fail "(timeout) rwatch disallowed when can-use-hw-watchpoints cleared"} + } + + # Read- and access watchpoints are unsupported on HP-UX. Verify + # that GDB gracefully responds to requests to create them. + # + if [istarget "hppa*-*-hpux*"] then { + send_gdb "set can-use-hw-watchpoints 1\n" + gdb_expect { + -re "$gdb_prompt $"\ + {pass "enable fast watches"} + timeout {fail "(timeout) enable fast watches"} + } + send_gdb "rwatch ival3\n" + gdb_expect { + -re "Target does not have this type of hardware watchpoint support.*$gdb_prompt $"\ + {pass "read watches disallowed"} + -re "$gdb_prompt $"\ + {fail "read watches disallowed"} + timeout {fail "(timeout) read watches disallowed"} + } + + send_gdb "awatch ival3\n" + gdb_expect { + -re "Target does not have this type of hardware watchpoint support.*$gdb_prompt $"\ + {pass "access watches disallowed"} + -re "$gdb_prompt $"\ + {fail "access watches disallowed"} + timeout {fail "(timeout) access watches disallowed"} + } + +#*************** + } +} diff --git a/gdb/testsuite/gdb.hp/xdb1.exp b/gdb/testsuite/gdb.hp/xdb1.exp new file mode 100644 index 00000000000..57e20daaab6 --- /dev/null +++ b/gdb/testsuite/gdb.hp/xdb1.exp @@ -0,0 +1,71 @@ +# Copyright (C) 1992, 1994, 1995 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 Fred Fish. (fnf@cygnus.com) + +if $tracelevel then { + strace $tracelevel + } + +global usestubs + +# +# test running programs +# +set prms_id 0 +set bug_id 0 + +set testfile "xdb" +set srcfile ${testfile}.c +set binfile ${objdir}/${subdir}/${testfile} +if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {debug}] != "" } { + gdb_suppress_entire_file "Testcase compile failed, so all tests in this file will automatically fail." +} + +global GDBFLAGS +set saved_gdbflags $GDBFLAGS + +set GDBFLAGS "$GDBFLAGS --xdb" + +gdb_exit +gdb_start +gdb_reinitialize_dir $srcdir/$subdir +gdb_load ${binfile} + +gdb_test "set pagination off" "" +gdb_test "show pagination" "State of pagination is off." +gdb_test "set pagination on" "" +gdb_test "show pagination" "State of pagination is on." + +gdb_test "txbreak callee" "Breakpoint.*at.*" +gdb_test "info break" "Num.*Type.*Disp.*Enb.*Address.*What\r\n.*breakpoint.*del.*y.*" + +gdb_test "xbreak callee" "Breakpoint.*at.*.*" +gdb_test "info break" "Num.*Type.*Disp.*Enb.*Address.*What\r\n.*breakpoint.*keep.*y.*" + +gdb_exit +set GDBFLAGS $saved_gdbflags +return 0 + + + + + + + diff --git a/gdb/testsuite/gdb.hp/xdb2.exp b/gdb/testsuite/gdb.hp/xdb2.exp new file mode 100644 index 00000000000..b138ee39bfc --- /dev/null +++ b/gdb/testsuite/gdb.hp/xdb2.exp @@ -0,0 +1,97 @@ +# Copyright (C) 1992, 1994, 1995 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 Fred Fish. (fnf@cygnus.com) + +if $tracelevel then { + strace $tracelevel + } + +global message + +# +# test running programs +# +set prms_id 0 +set bug_id 0 + +set testfile "xdb" +set binfile ${objdir}/${subdir}/${testfile} + +if { [gdb_compile "${srcdir}/${subdir}/xdb0.c" "${binfile}0.o" object {debug}] != "" } { + perror "Couldn't compile ${testfile}0.c to object" + return -1 +} + +if { [gdb_compile "${srcdir}/${subdir}/xdb1.c" "${binfile}1.o" object {debug}] != "" } { + perror "Couldn't compile ${testfile}1.c to object" + return -1 +} + +if { [gdb_compile "${binfile}0.o ${binfile}1.o" ${binfile} executable {debug}] != "" } { + perror "Couldn't link ${testfile}." + return -1 +} + +global GDBFLAGS +set saved_gdbflags $GDBFLAGS +set GDBFLAGS "$GDBFLAGS --xdb" + +gdb_exit +gdb_start +gdb_reinitialize_dir $srcdir/$subdir +gdb_load ${binfile} +gdb_test "break main" "" +gdb_test "run" "" +gdb_test "go +2" "Breakpoint.*at.*file.*xdb0\.c, line 12\.\r\nContinuing at.*\r\nmain \\(\\) at.*xdb0\.c:12\r\n12\[ \t\]+foo \\(x\\+\\+\\);" +gdb_test "go -2" "Note: breakpoint.*also set at pc.*\.\r\nBreakpoint.*at.*file.*xdb0\.c, line 10\.\r\nContinuing at.*\.\r\n\r\nBreakpoint.*, main \\(\\) at.*xdb0\.c:10.*" +gdb_test "go 16" "Breakpoint.*at.*file.*xdb0\.c, line 16\.\r\nContinuing at.*\.\r\nmain \\(\\) at.*xdb0\.c:16\r\n16\[ \t\]+foo \\(x\\+\\+\\);" + +send_gdb "go bar\n" + gdb_expect { + -re ".*Line 5 is not in .main.. Jump anyway.*y or n. $" { + send_gdb "y\n" + gdb_expect { + -re "$gdb_prompt $"\ + {pass "go bar"} + timeout {fail "(timeout) go bar"} + } + } + -re "Continuing at.*\.\r\nbar \\(x=0\\) at.*xdb1\.c:5" {} + timeout { perror "(timeout) go bar" ; return } + } + +# Verify that GDB responds gracefully to a "go" command without +# an argument. +# +gdb_test "go" "Usage: go " + +gdb_exit +gdb_start +gdb_reinitialize_dir $srcdir/$subdir +gdb_load ${binfile} + +gdb_test "break bar" "" +gdb_test "run" "" +gdb_test "backtrace full" ".*bar \\(x=0\\) at.*xdb1\.c:5\r\nNo locals\.\r\n.1.* in foo \\(x=1\\) at.*xdb0\.h:8\r\nNo locals\.\r\n.2.* in main \\(\\) at.*xdb0\.c:11\r\n.*x = 1" +gdb_test "bt 1 full" ".*bar \\(x=0\\) at.*xdb1\.c:5\r\nNo locals\.\r\n\\(More stack frames follow\.\.\.\\)" +gdb_test "bt full 2" ".*bar \\(x=0\\) at.*xdb1\.c:5\r\nNo locals\.\r\n.1.* in foo \\(x=1\\) at.*xdb0\.h:8\r\nNo locals\.\r\n\\(More stack frames follow\.\.\.\\)" + +set GDBFLAGS $saved_gdbflags +return 0 diff --git a/gdb/testsuite/gdb.hp/xdb3.exp b/gdb/testsuite/gdb.hp/xdb3.exp new file mode 100644 index 00000000000..ef6ba172f5d --- /dev/null +++ b/gdb/testsuite/gdb.hp/xdb3.exp @@ -0,0 +1,301 @@ +# Copyright (C) 1998 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 + + +if $tracelevel then { + strace $tracelevel +} + + +set testfile1 "average" +set testfile2 "sum" +set testfile "xdb-test" +set binfile1 ${objdir}/${subdir}/${testfile1} +set binfile2 ${objdir}/${subdir}/${testfile2} +set binfile ${objdir}/${subdir}/${testfile} + +if { [gdb_compile "${srcdir}/${subdir}/average.c" "${binfile1}.o" object {debug}] != "" } { + gdb_suppress_entire_file "Testcase compile failed, so all tests in this file will automatically fail." +} + +if { [gdb_compile "${srcdir}/${subdir}/sum.c" "${binfile2}.o" object {debug}] != "" } { + gdb_suppress_entire_file "Testcase compile failed, so all tests in this file will automatically fail." +} + +if { [gdb_compile "${binfile1}.o ${binfile2}.o" ${binfile} executable {debug}] != "" } { + gdb_suppress_entire_file "Testcase compile failed, so all tests in this file will automatically fail." +} + +proc xdb_reinitialize_dir { subdir } { + global gdb_prompt + + send_gdb "D\n" + gdb_expect { + -re "Reinitialize source path to empty.*y or n. " { + send_gdb "y\n" + gdb_expect { + -re "Source directories searched.*$gdb_prompt $" { + send_gdb "D $subdir\n" + gdb_expect { + -re "Source directories searched.*$gdb_prompt $" { + verbose "Dir set to $subdir" + } + -re ".*$gdb_prompt $" { + perror "Dir \"$subdir\" failed." + } + } + } + -re ".*$gdb_prompt $" { + perror "Dir \"$subdir\" failed." + } + } + } + -re ".*$gdb_prompt $" { + perror "Dir \"$subdir\" failed." + } + } +} + +# +#test_search +# +proc test_search { } { + gdb_test "set listsize 4" "" + gdb_test "list average.c:1" "1\[ \t\]+/. This is a sample .*" + gdb_test "/ print_average" "10\[ \t\]+void print_average\\(int list.*" + gdb_test "/ print_average" "12\[ \t\]+void print_average\\(list, low, high\\)" + gdb_test "/ print_average" "35\[ \t\]+print_average \\(my_list, first, last\\);" + gdb_test "? print_average" "12\[ \t\]+void print_average\\(list, low, high\\)" + gdb_test "? sum" "Expression not found" +} + +# +#test_viewing_loc +# +proc test_viewing_loc { } { + gdb_test "L" "No stack." + gdb_test "break main" "" + gdb_test "R" "" + gdb_test "L" "#0\[ \t\]+main \\(\\) at.*average.c:31\r\n31\[ \t\]+int first = 0;" +} + +# +#test_dir_list +# +proc test_dir_list { } { + gdb_test "ld" "Source directories searched: .*" +} + +# +#test_list_sources +# +proc test_list_sources { } { + gdb_test "lf" "Source files for which symbols have been read in:.*average\\.c,.*Source files for which symbols will be read in on demand:.*sum\\.c" +} + +# +#test_vlist +# +proc test_vlist { } { + gdb_test "v main" "27\[ \t\]+main \\(\\)\r\n28\[ \t\]+#endif\r\n29\[ \t\]+.\r\n30\[ \t\]+char c;" +} + +# +#test_va +# +proc test_va { } { + gdb_test "va main" "Dump of assembler code for function main:.*End of assembler dump\." +} + +# +#test_list_globals +# +proc test_list_globals { } { + gdb_test "lg" "All defined variables:\r\n\r\nFile globals:.*" +# gdb_test "lg" "All defined variables:\r\n\r\nFile globals:\r\nchar __buffer.512.;\r\nint __d_eh_catch_catch;\r\nint __d_eh_catch_throw;.*" +} + +# +#test_list_registers +# +proc test_list_registers { } { + gdb_test "lr" "\[ \t\]+flags:.*r18:.*pcsqt:.*ccr:.*\r\n\[ \t\]+r1:.*r19:.*eiem:.*cr12:.*" + gdb_test "lr r1" "r1 .*" +} + +# +#test_backtrace +# +proc test_backtrace { } { + gdb_test "t" "#0 main \\(\\) at.*average.c:31" + gdb_test "T" "#0 main \\(\\) at.*average.c:31\r\n\[ \t\]+c = 0.*\r\n\[ \t\]+first = 0\r\n\[ \t\]+last = 0" + + gdb_test "break sum" "" + gdb_test "cont" "" + + gdb_test "t" "#0 sum \\(list=0x.*, low=0, high=9\\) at.*sum\.c:11\r\n#1 0x.* in print_average \\(list=0x.*, low=0, high=9\\) at.*average\.c:17\r\n#2 0x.* in main \\(\\) at.*average\.c:35" + gdb_test "t 1" "#0 sum \\(list=0x.*, low=0, high=9\\) at.*sum\.c:11\r\n\\(More stack frames follow\.\.\.\\)" + gdb_test "T" "#0 sum \\(list=0x.*, low=0, high=9\\) at.*sum\.c:11\r\n\[ \t\]+i = 0\r\n\[ \t\]+s = 0\r\n#1 0x.* in print_average \\(list=0x.*, low=0, high=9\\) at.*average\.c:17\r\n\[ \t\]+total = 0\r\n\[ \t\]+num_elements = 0\r\n\[ \t\]+average = 0\r\n#2 0x.* in main \\(\\) at.*average\.c:35\r\n\[ \t\]+c = 0 '.000'\r\n\[ \t\]+first = 0\r\n\[ \t\]+last = 9" + gdb_test "T 1" "#0 sum \\(list=0x.*, low=0, high=9\\) at.*sum\.c:11\r\n\[ \t\]+i = 0\r\n\[ \t\]+s = 0\r\n\\(More stack frames follow\.\.\.\\)" + + gdb_test "V" "#0 sum \\(list=0x.*, low=0, high=9\\) at.*sum\.c:11\r\n\\11\[ \t\]+int i, s = 0;" + gdb_test "V 1" "#1 0x.* in print_average \\(list=0x.*, low=0, high=9\\) at.*average\.c:17\r\n17\[ \t\]+total = sum\\(list, low, high\\);" +} + +# +# test_go +# +proc test_go { } { + gdb_test "break main" "" + gdb_test "R" "" + + gdb_test "g +1" "Breakpoint.*at 0x.*: file.*average\.c, line 32\.\r\nContinuing at 0x.*\.\r\nmain \\(\\) at.*average\.c:32\r\n32\[ \t\]+int last = num-1;" + gdb_test "g 35" "Breakpoint.*at 0x.*: file.*average\.c, line 35\.\r\nContinuing at 0x.*\.\r\nmain \\(\\) at.*average\.c:35\r\n35\[ \t\]+print_average \\(my_list, first, last\\);" + +} + +# +#test_breakpoints +# +proc test_breakpoints { } { + global gdb_prompt + + gdb_test "sb" "" + gdb_test "lb" "Num.*Type.*Disp.*Enb.*Address.*What\r\n1\[ \r\]+breakpoint\[ \r\]+keep n.*in main at.*average\.c:31.*" + gdb_test "ab" "" + gdb_test "lb" "Num.*Type.*Disp.*Enb.*Address.*What\r\n1\[ \r\]+breakpoint\[ \r\]+keep y.*in main at.*average\.c:31.*" + gdb_test "ba sum" "Breakpoint.*at.*: file.*sum\.c, line 11\." + gdb_test "cont" "" + gdb_test "bx" "Breakpoint.*at.*: file.*sum.c, line 15\." + gdb_test "bx if (1)" "Breakpoint.*at.*: file.*sum.c, line 15\." + gdb_test "bx 1" "Breakpoint.*at.*: file.*average.c, line 22\." + gdb_test "bx 1 if (1)" "Breakpoint.*at.*: file.*average.c, line 22\." + gdb_test "bc 1 2" "Will ignore next 2 crossings of breakpoint 1\." + gdb_test "lb 1" "Num.*Type.*Disp.*Enb.*Address.*What\r\n1\[ \r\]+breakpoint\[ \r\]+keep y.*in main at.*average\.c:31\r\n.*breakpoint already hit 1 time\r\n.*ignore next 2 hits.*" + + send_gdb "db\n" + gdb_expect { + -re "Delete all breakpoints.*y or n. $" { + send_gdb "y\n" + exp_continue + } + -re "y\r\n$gdb_prompt $" {} + -re ".*$gdb_prompt $" { # This happens if there were no breakpoints + } + timeout { perror "Delete all breakpoints (timeout)" ; return } + } + send_gdb "lb\n" + gdb_expect { + -re "No breakpoints or watchpoints..*$gdb_prompt $" {} + -re ".*$gdb_prompt $" { perror "breakpoints not deleted" ; return } + timeout { perror "info breakpoints (timeout)" ; return } + } +gdb_test "xbreak" "Breakpoint.*at.*file.*sum.c, line 15." +gdb_test "xbreak print_average" "Breakpoint.*at.*file.*average.c, line 22." +gdb_test "xbreak if (1)" "Note: breakpoint.*also set at pc.*Breakpoint.*at.*file.*sum.c, line 15." +gdb_test "xbreak print_average if (1)" "Note: breakpoint.*also set at pc.*Breakpoint.*at.*file.*average.c, line 22." + + send_gdb "lb\n" + gdb_expect { + -re "Num Type Disp Enb Address What.*breakpoint keep y.*in sum at.*sum.c:15.*breakpoint keep y.*in print_average at.*average.c:22.*breakpoint keep y.*in sum at.*sum.c:15.*stop only if 1.*breakpoint keep y.*in print_average at.*average.c:22.*stop only if 1.*$gdb_prompt $" {pass "lb on xbreaks"} + -re ".*$gdb_prompt $" { fail "breakpoints not deleted"} + timeout { fail "info breakpoints (timeout)" } + } + +} + +# +# test_signals +# +proc test_signals { } { + gdb_test "handle SIGTERM nostop noprint" "" + gdb_test "z SIGTERM s" "Signal.*Stop.*Print.*Pass to program.*Description\r\nSIGTERM.*Yes.*Yes.*Yes.*Terminated" + gdb_test "z SIGTERM r" "Signal.*Stop.*Print.*Pass to program.*Description\r\nSIGTERM.*No.*No.*Yes.*Terminated" + gdb_test "z SIGTERM i" "Signal.*Stop.*Print.*Pass to program.*Description\r\nSIGTERM.*No.*No.*No.*Terminated" + gdb_test "z SIGTERM r" "Signal.*Stop.*Print.*Pass to program.*Description\r\nSIGTERM.*No.*Yes.*No.*Terminated" + gdb_test "z SIGTERM Q" "Signal.*Stop.*Print.*Pass to program.*Description\r\nSIGTERM.*No.*No.*No.*Terminated" + gdb_test "lz" "Signal.*Stop.*Print.*Pass to program.*Description\r\n\r\nSIGHUP.*Yes.*" +} + + + +# Start with a fresh gdb. +global GDBFLAGS +set saved_gdbflags $GDBFLAGS + +set GDBFLAGS "$GDBFLAGS --xdb" + +gdb_exit +gdb_start + +xdb_reinitialize_dir $srcdir/$subdir + +gdb_load ${binfile} +send_gdb "set width 0\n" +gdb_expect -re "$gdb_prompt $" +test_search +test_viewing_loc +test_dir_list +test_list_sources +test_vlist +test_va +gdb_test "l" "No arguments.\r\nc = 0.*\r\nfirst = 0\r\nlast = 0" +#test_list_globals +test_list_registers +test_backtrace + +# Start with a fresh gdb. + +gdb_exit +gdb_start +xdb_reinitialize_dir $srcdir/$subdir + +gdb_load ${binfile} +send_gdb "set width 0\n" +gdb_expect -re "$gdb_prompt $" +test_go + + +gdb_exit +gdb_start +xdb_reinitialize_dir $srcdir/$subdir + +gdb_load ${binfile} +send_gdb "set width 0\n" +gdb_expect -re "$gdb_prompt $" +gdb_test "break main" "" +gdb_test "R" "" +gdb_test "S" "32\[ \t\]+int last = num-1;" +test_breakpoints +test_signals +gdb_test "sm" "" +gdb_test "info set" ".*pagination: State of pagination is off.*" +gdb_test "am" "" +gdb_test "info set" ".*pagination: State of pagination is on.*" +gdb_exit + +set GDBFLAGS $saved_gdbflags + +return 0 + + + + + + -- 2.30.2