This is the mail archive of the gdb-patches@sourceware.org mailing list for the GDB project.


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]
Other format: [Raw text]

Re: [PATCH] New testsuite directory gdb.reverse, and tests


Hi Michael,

Thanks for your work.  :)

And I got a error when configure:
config.status: creating gdb.server/Makefile
config.status: creating gdb.java/Makefile
config.status: creating gdb.mi/Makefile
config.status: creating gdb.modula2/Makefile
config.status: creating gdb.objc/Makefile
config.status: creating gdb.opt/Makefile
config.status: creating gdb.pascal/Makefile
config.status: creating gdb.python/Makefile
config.status: creating gdb.reverse/Makefile
config.status: error: cannot find input file: gdb.reverse/Makefile.in

I think because your patch doesn't include it.


Thanks,
Hui

On Thu, Jun 25, 2009 at 04:49, Michael Snyder<msnyder@vmware.com> wrote:
> Here are some new tests to test reverse debugging.
> I've moved the test solib-reverse (submitted earlier) into this directory.
>
> Since most targets don't (yet) implement reverse debugging,
> these tests all return with no results unless you add the
> following to your board description file:
>
> ? ?set_board_info gdb,can_reverse 1
>
> In addition, since Process Record requires some special
> commands that will not be used by remote debug targets
> such as SID and Simics (eg. to start and stop recording),
> you'll also want to define the following for process record:
>
> ? ?set_board_info gdb,use_precord 1
>
> I hope that the Virtutech folk will try out these tests
> using Simics and let me know if any changes are required.
>
> OK, to commit?
>
>
> 2009-06-24 ?Michael Snyder ?<msnyder@vmware.com>
>
> ? ? ? ?* gdb.reverse: New directory.
> ? ? ? ?* gdb.reverse/break-reverse.c: New test.
> ? ? ? ?* gdb.reverse/break-reverse.exp: New test.
> ? ? ? ?* gdb.reverse/consecutive-reverse.c: New test.
> ? ? ? ?* gdb.reverse/consecutive-reverse.exp: New test.
> ? ? ? ?* gdb.reverse/finish-reverse.c: New test.
> ? ? ? ?* gdb.reverse/finish-reverse.exp: New test.
> ? ? ? ?* gdb.reverse/machinestate.c: New test.
> ? ? ? ?* gdb.reverse/machinestate1.c: New test.
> ? ? ? ?* gdb.reverse/machinestate.exp: New test.
> ? ? ? ?* gdb.reverse/Makefile.in: New file.
> ? ? ? ?* gdb.reverse/shr2.c: New test.
> ? ? ? ?* gdb.reverse/solib-reverse.c: New test.
> ? ? ? ?* gdb.reverse/solib-reverse.exp: New test.
> ? ? ? ?* gdb.reverse/step-reverse.c: New test.
> ? ? ? ?* gdb.reverse/step-reverse.exp: New test.
> ? ? ? ?* gdb.reverse/until-reverse.c: New test.
> ? ? ? ?* gdb.reverse/until-reverse1.c: New test.
> ? ? ? ?* gdb.reverse/until-reverse.exp: New test.
> ? ? ? ?* gdb.reverse/watch-reverse.c: New test.
> ? ? ? ?* gdb.reverse/watch-reverse.exp: New test.
> ? ? ? ?* configure.ac (AC_OUTPUT): Add gdb.reverse/Makefile.
> ? ? ? ?* configure: Regenerate.
>
> Index: configure
> ===================================================================
> RCS file: /cvs/src/src/gdb/testsuite/configure,v
> retrieving revision 1.29
> diff -u -p -r1.29 configure
> --- configure ? 19 Oct 2008 19:59:31 -0000 ? ? ?1.29
> +++ configure ? 24 Jun 2009 20:38:54 -0000
> @@ -3131,7 +3131,7 @@ done
>
>
>
> -
>
>
> ?ac_config_files="$ac_config_files Makefile gdb.ada/Makefile
> gdb.arch/Makefile gdb.asm/Makefile gdb.base/Makefile gdb.cp/Makefile
> gdb.disasm/Makefile gdb.dwarf2/Makefile gdb.fortran/Makefile
> gdb.server/Makefile gdb.java/Makefile gdb.mi/Makefile gdb.modula2/Makefile
> gdb.objc/Makefile gdb.opt/Makefile gdb.pascal/Makefile gdb.python/Makefile
> gdb.threads/Makefile gdb.trace/Makefile gdb.xml/Makefile"
> +
>
>
> ?ac_config_files="$ac_config_files Makefile gdb.ada/Makefile
> gdb.arch/Makefile gdb.asm/Makefile gdb.base/Makefile gdb.cp/Makefile
> gdb.disasm/Makefile gdb.dwarf2/Makefile gdb.fortran/Makefile
> gdb.server/Makefile gdb.java/Makefile gdb.mi/Makefile gdb.modula2/Makefile
> gdb.objc/Makefile gdb.opt/Makefile gdb.pascal/Makefile gdb.python/Makefile
> gdb.reverse/Makefile gdb.threads/Makefile gdb.trace/Makefile
> gdb.xml/Makefile"
> ?cat >confcache <<\_ACEOF
> ?# This file is a shell script that caches the results of configure
> ?# tests run on this system so they can be shared between configure
> @@ -3699,6 +3699,7 @@ do
> ? "gdb.opt/Makefile" ) CONFIG_FILES="$CONFIG_FILES gdb.opt/Makefile" ;;
> ? "gdb.pascal/Makefile" ) CONFIG_FILES="$CONFIG_FILES gdb.pascal/Makefile"
> ;;
> ? "gdb.python/Makefile" ) CONFIG_FILES="$CONFIG_FILES gdb.python/Makefile"
> ;;
> + ?"gdb.reverse/Makefile" ) CONFIG_FILES="$CONFIG_FILES
> gdb.reverse/Makefile" ;;
> ? "gdb.threads/Makefile" ) CONFIG_FILES="$CONFIG_FILES gdb.threads/Makefile"
> ;;
> ? "gdb.trace/Makefile" ) CONFIG_FILES="$CONFIG_FILES gdb.trace/Makefile" ;;
> ? "gdb.xml/Makefile" ) CONFIG_FILES="$CONFIG_FILES gdb.xml/Makefile" ;;
> Index: configure.ac
> ===================================================================
> RCS file: /cvs/src/src/gdb/testsuite/configure.ac,v
> retrieving revision 1.12
> diff -u -p -r1.12 configure.ac
> --- configure.ac ? ? ? ?19 Oct 2008 19:59:31 -0000 ? ? ?1.12
> +++ configure.ac ? ? ? ?24 Jun 2009 20:38:54 -0000
> @@ -117,5 +117,5 @@ AC_OUTPUT([Makefile \
> ? gdb.fortran/Makefile gdb.server/Makefile \
> ? gdb.java/Makefile gdb.mi/Makefile gdb.modula2/Makefile \
> ? gdb.objc/Makefile gdb.opt/Makefile gdb.pascal/Makefile \
> - ?gdb.python/Makefile \
> + ?gdb.python/Makefile gdb.reverse/Makefile \
> ? gdb.threads/Makefile gdb.trace/Makefile gdb.xml/Makefile])
> Index: gdb.reverse/break-reverse.c
> ===================================================================
> RCS file: gdb.reverse/break-reverse.c
> diff -N gdb.reverse/break-reverse.c
> --- /dev/null ? 1 Jan 1970 00:00:00 -0000
> +++ gdb.reverse/break-reverse.c 24 Jun 2009 20:38:54 -0000
> @@ -0,0 +1,37 @@
> +/* This testcase is part of GDB, the GNU debugger.
> +
> + ? Copyright 2008, 2009 Free Software Foundation, Inc.
> +
> + ? This program is free software; you can redistribute it and/or modify
> + ? it under the terms of the GNU General Public License as published by
> + ? the Free Software Foundation; either version 3 of the License, or
> + ? (at your option) any later version.
> +
> + ? This program is distributed in the hope that it will be useful,
> + ? but WITHOUT ANY WARRANTY; without even the implied warranty of
> + ? MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. ?See the
> + ? GNU General Public License for more details.
> +
> + ? You should have received a copy of the GNU General Public License
> + ? along with this program. ?If not, see <http://www.gnu.org/licenses/>.
> ?*/
> +
> +int xyz;
> +
> +int bar ()
> +{
> + ?xyz = 2; /* break in bar */
> + ?return 1;
> +}
> +
> +int foo ()
> +{
> + ?xyz = 1; /* break in foo */
> + ?return bar ();
> +}
> +
> +int main ()
> +{
> + ?xyz = 0; ? ? /* break in main */
> + ?foo ();
> + ?return (xyz == 2 ? 0 : 1);
> +} ? ? ? ? ? ? ?/* end of main */
> Index: gdb.reverse/break-reverse.exp
> ===================================================================
> RCS file: gdb.reverse/break-reverse.exp
> diff -N gdb.reverse/break-reverse.exp
> --- /dev/null ? 1 Jan 1970 00:00:00 -0000
> +++ gdb.reverse/break-reverse.exp ? ? ? 24 Jun 2009 20:38:54 -0000
> @@ -0,0 +1,89 @@
> +# ? Copyright 2008, 2009 Free Software Foundation, Inc.
> +
> +# This program is free software; you can redistribute it and/or modify
> +# it under the terms of the GNU General Public License as published by
> +# the Free Software Foundation; either version 3 of the License, or
> +# (at your option) any later version.
> +#
> +# This program is distributed in the hope that it will be useful,
> +# but WITHOUT ANY WARRANTY; without even the implied warranty of
> +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. ?See the
> +# GNU General Public License for more details.
> +#
> +# You should have received a copy of the GNU General Public License
> +# along with this program. ?If not, see <http://www.gnu.org/licenses/>.
> +
> +# This file was written by Michael Snyder (msnyder@vmware.com).
> +
> +#
> +# Test reverse debugging with breakpoints.
> +#
> +
> +if ![target_info exists gdb,can_reverse] {
> + ? ?return
> +}
> +
> +set testfile "break-reverse"
> +set srcfile ?${testfile}.c
> +
> +if { [prepare_for_testing $testfile.exp $testfile $srcfile] } {
> + ? ?return -1
> +}
> +
> +set foo_location ?[gdb_get_line_number "break in foo" ]
> +set bar_location ?[gdb_get_line_number "break in bar" ]
> +set main_location [gdb_get_line_number "break in main"]
> +set end_location ?[gdb_get_line_number "end of main" ?]
> +
> +runto main
> +
> +if [target_info exists gdb,use_precord] {
> + ? ?# Activate process record/replay
> + ? ?gdb_test "record" "" "Turn on process record"
> + ? ?# FIXME: command ought to acknowledge, so we can test if it succeeded.
> +}
> +
> +gdb_test "break foo" \
> + ? ?"Breakpoint $decimal at .* line $foo_location\." \
> + ? ?"set breakpoint on foo"
> +
> +gdb_test "break bar" \
> + ? ?"Breakpoint $decimal at .* line $bar_location\." \
> + ? ?"set breakpoint on bar"
> +
> +gdb_test "break $end_location" \
> + ? ?"Breakpoint $decimal at .* line $end_location\." \
> + ? ?set breakpoint at end of main"
> +
> +gdb_continue_to_breakpoint "foo" ".*/$srcfile:$foo_location.*"
> +gdb_continue_to_breakpoint "bar" ".*/$srcfile:$bar_location.*"
> +gdb_continue_to_breakpoint "end" ".*/$srcfile:$end_location.*"
> +
> +# FIXME 'set exec-dir' command should give some output so we can test.
> +gdb_test "set exec-direction reverse" "" "set reverse"
> +
> +gdb_continue_to_breakpoint "bar backward" ?".*/$srcfile:$bar_location.*"
> +gdb_continue_to_breakpoint "foo backward" ?".*/$srcfile:$foo_location.*"
> +
> +gdb_test_multiple "continue" "main backward" {
> + ? ?-re ".*Breakpoint $decimal,.*/$srcfile:$main_location.*$gdb_prompt $" {
> + ? ? ? pass "main backward"
> + ? ?}
> + ? ?-re "No more reverse-execution history.* break in main .*$gdb_prompt $"
> {
> + ? ? ? pass "main backward"
> + ? ?}
> +}
> +
> +gdb_test "set exec-direction forward" "" "set forward"
> +
> +gdb_continue_to_breakpoint "foo" ".*/$srcfile:$foo_location.*"
> +gdb_continue_to_breakpoint "bar" ".*/$srcfile:$bar_location.*"
> +
> +gdb_test_multiple "continue" "end of record log" {
> + ? ?-re ".*Breakpoint $decimal,.*/$srcfile:$end_location.*$gdb_prompt $" {
> + ? ? ? pass "end of record log"
> + ? ?}
> + ? ?-re "No more reverse-execution history.* end of main .*$gdb_prompt $" {
> + ? ? ? pass "end of record log"
> + ? ?}
> +}
> Index: gdb.reverse/consecutive-reverse.c
> ===================================================================
> RCS file: gdb.reverse/consecutive-reverse.c
> diff -N gdb.reverse/consecutive-reverse.c
> --- /dev/null ? 1 Jan 1970 00:00:00 -0000
> +++ gdb.reverse/consecutive-reverse.c ? 24 Jun 2009 20:38:54 -0000
> @@ -0,0 +1,37 @@
> +/* This testcase is part of GDB, the GNU debugger.
> +
> + ? Copyright 2008, 2009 Free Software Foundation, Inc.
> +
> + ? This program is free software; you can redistribute it and/or modify
> + ? it under the terms of the GNU General Public License as published by
> + ? the Free Software Foundation; either version 3 of the License, or
> + ? (at your option) any later version.
> +
> + ? This program is distributed in the hope that it will be useful,
> + ? but WITHOUT ANY WARRANTY; without even the implied warranty of
> + ? MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. ?See the
> + ? GNU General Public License for more details.
> +
> + ? You should have received a copy of the GNU General Public License
> + ? along with this program. ?If not, see <http://www.gnu.org/licenses/>.
> ?*/
> +
> +/*
> + ? Purpose of this test: ?to test breakpoints on consecutive instructions.
> +*/
> +
> +int a[7] = {1, 2, 3, 4, 5, 6, 7};
> +
> +/* assert: first line of foo has more than one instruction. */
> +int foo ()
> +{
> + ?return a[0] + a[1] + a[2] + a[3] + a[4] + a[5] + a[6];
> +}
> +
> +main()
> +{
> +#ifdef usestubs
> + ? ?set_debug_traps ();
> + ? ?breakpoint ();
> +#endif
> + ?foo ();
> +}
> Index: gdb.reverse/consecutive-reverse.exp
> ===================================================================
> RCS file: gdb.reverse/consecutive-reverse.exp
> diff -N gdb.reverse/consecutive-reverse.exp
> --- /dev/null ? 1 Jan 1970 00:00:00 -0000
> +++ gdb.reverse/consecutive-reverse.exp 24 Jun 2009 20:38:54 -0000
> @@ -0,0 +1,131 @@
> +# ? Copyright 2008, 2009 Free Software Foundation, Inc.
> +
> +# This program is free software; you can redistribute it and/or modify
> +# it under the terms of the GNU General Public License as published by
> +# the Free Software Foundation; either version 3 of the License, or
> +# (at your option) any later version.
> +#
> +# This program is distributed in the hope that it will be useful,
> +# but WITHOUT ANY WARRANTY; without even the implied warranty of
> +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. ?See the
> +# GNU General Public License for more details.
> +#
> +# You should have received a copy of the GNU General Public License
> +# along with this program. ?If not, see <http://www.gnu.org/licenses/>.
> +
> +# Please email any bugs, comments, and/or additions to this file to:
> +# bug-gdb@prep.ai.mit.edu
> +
> +# Based on a file written by Michael Snyder. (msnyder@redhat.com)
> +
> +#
> +# Test reverse debugging breakpoints at consecutive instruction addresses.
> +#
> +
> +if ![target_info exists gdb,can_reverse] {
> + ? ?return
> +}
> +
> +set testfile "consecutive-reverse"
> +set srcfile ${testfile}.c
> +
> +if { [prepare_for_testing $testfile.exp $testfile $srcfile] } {
> + ? ?return -1
> +}
> +
> +runto main
> +
> +if [target_info exists gdb,use_precord] {
> + ? ?# Activate process record/replay
> + ? ?gdb_test "record" "" "Turn on process record"
> + ? ?# FIXME: command ought to acknowledge, so we can test if it succeeded.
> +}
> +
> +gdb_breakpoint foo
> +gdb_test "continue" "Breakpoint $decimal, foo .*" \
> + ? ? ? "continue to breakpoint in foo"
> +
> +set foo1_addr 0
> +set foo2_addr 0
> +set stop_addr 0
> +
> +send_gdb "x /2i \$pc\n"
> +gdb_expect {
> + ? ?global hex
> + ? ?global foo1_addr
> + ? ?global foo2_addr
> + ? ?global gdb_prompt
> +
> + ? ?-re "($hex).*\[\r\n\]+($hex).*$gdb_prompt $" {
> + ? ? ? set foo1_addr $expect_out(1,string)
> + ? ? ? set foo2_addr $expect_out(2,string)
> + ? ? ? pass "get breakpoint address for foo"
> + ? ?}
> + ? ?-re ".*$gdb_prompt $" {
> + ? ? ? fail "get breakpoint address for foo"
> + ? ? ? return 0;
> + ? ?}
> + ? ?timeout {
> + ? ? ? fail "get breakpoint address for foo (timeout)"
> + ? ? ? return 0;
> + ? ?}
> +}
> +
> +gdb_test "break \*$foo2_addr" "Breakpoint $decimal at $foo2_addr: file .*"
> \
> + ? ? ? "set bp, 2nd instr"
> +
> +send_gdb "step\n"
> +gdb_expect {
> + ? ?-re "Breakpoint $decimal, ($hex) in foo.*$gdb_prompt $" {
> + ? ? ? set stop_addr $expect_out(1,string)
> + ? ? ? if [eval expr "$foo2_addr == $stop_addr"] then {
> + ? ? ? ? ? pass "stopped at bp, 2nd instr"
> + ? ? ? } else {
> + ? ? ? ? ? fail "stopped at bp, 2nd instr (wrong address)"
> + ? ? ? }
> + ? ?}
> + ? ?-re ".*$gdb_prompt $" {
> + ? ? ? fail "stopped at bp, 2nd instr"
> + ? ?}
> + ? ?timeout {
> + ? ? ? fail "stopped at bp, 2nd instr (timeout)"
> +
> + ? ?}
> +}
> +
> +###
> +###
> +###
> +
> +# Set reverse execution direction
> +# FIXME: command needs to acknowledge, so we can test if it succeeded.
> +
> +gdb_test "set exec-dir reverse" "" "set reverse execution"
> +
> +# Now step backward and hope to hit the first breakpoint.
> +
> +set test_msg "stopped at bp in reverse, 1st instr"
> +gdb_test_multiple "step" "$test_msg" {
> + ? ?-re "Breakpoint $decimal, ($hex) in foo.*$gdb_prompt $" {
> + ? ? ? set stop_addr $expect_out(1,string)
> + ? ? ? if [eval expr "$foo1_addr == $stop_addr"] then {
> + ? ? ? ? ? pass "$test_msg"
> + ? ? ? } else {
> + ? ? ? ? ? fail "$test_msg (wrong address)"
> + ? ? ? }
> + ? ?}
> + ? ?-re "Breakpoint $decimal, foo.*$gdb_prompt $" {
> + ? ? ? send_gdb "print \$pc == $foo1_addr\n"
> + ? ? ? gdb_expect {
> + ? ? ? ? ? -re "$decimal = 1\[\r\n\]+$gdb_prompt $" {
> + ? ? ? ? ? ? ? pass "$test_msg"
> + ? ? ? ? ? }
> + ? ? ? ? ? -re "$decimal = 0\[\r\n\]+$gdb_prompt $" {
> + ? ? ? ? ? ? ? fail "$test_msg (wrong address)"
> + ? ? ? ? ? }
> + ? ? ? }
> + ? ?}
> + ? ?-re ".*$gdb_prompt $" {
> + ? ? ? fail "$test_msg"
> + ? ?}
> +}
> Index: gdb.reverse/finish-reverse.c
> ===================================================================
> RCS file: gdb.reverse/finish-reverse.c
> diff -N gdb.reverse/finish-reverse.c
> --- /dev/null ? 1 Jan 1970 00:00:00 -0000
> +++ gdb.reverse/finish-reverse.c ? ? ? ?24 Jun 2009 20:38:54 -0000
> @@ -0,0 +1,127 @@
> +/* This testcase is part of GDB, the GNU debugger.
> +
> + ? Copyright 2008, 2009 Free Software Foundation, Inc.
> +
> + ? This program is free software; you can redistribute it and/or modify
> + ? it under the terms of the GNU General Public License as published by
> + ? the Free Software Foundation; either version 3 of the License, or
> + ? (at your option) any later version.
> +
> + ? This program is distributed in the hope that it will be useful,
> + ? but WITHOUT ANY WARRANTY; without even the implied warranty of
> + ? MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. ?See the
> + ? GNU General Public License for more details.
> +
> + ? You should have received a copy of the GNU General Public License
> + ? along with this program. ?If not, see <http://www.gnu.org/licenses/>.
> ?*/
> +
> +/* Test gdb's "return" command in reverse. ?*/
> +
> +int void_test = 0;
> +int main_test = 0;
> +
> +char ? ? ?char_returnval ? ? ?= '1';
> +short ? ? short_returnval ? ? = 1;
> +int ? ? ? int_returnval ? ? ? = 1;
> +long ? ? ?long_returnval ? ? ?= 1;
> +long long long_long_returnval = 1;
> +float ? ? float_returnval ? ? = 1;
> +double ? ?double_returnval ? ?= 1;
> +
> +union {
> + ?char ? ? ?char_testval;
> + ?short ? ? short_testval;
> + ?int ? ? ? int_testval;
> + ?long ? ? ?long_testval;
> + ?long long long_long_testval;
> + ?float ? ? float_testval;
> + ?double ? ?double_testval;
> + ?char ? ? ?ffff[80];
> +} testval;
> +
> +void void_func ()
> +{
> + ?void_test = 1; ? ? ? ? ? ? ? /* VOID FUNC */
> +}
> +
> +char char_func ()
> +{
> + ?return char_returnval; ? ? ? /* CHAR FUNC */
> +}
> +
> +short short_func ()
> +{
> + ?return short_returnval; ? ? ?/* SHORT FUNC */
> +}
> +
> +int int_func ()
> +{
> + ?return int_returnval; ? ? ? ? ? ? ? ?/* INT FUNC */
> +}
> +
> +long long_func ()
> +{
> + ?return long_returnval; ? ? ? /* LONG FUNC */
> +}
> +
> +long long long_long_func ()
> +{
> + ?return long_long_returnval; ?/* LONG LONG FUNC */
> +}
> +
> +float float_func ()
> +{
> + ?return float_returnval; ? ? ?/* FLOAT FUNC */
> +}
> +
> +double double_func ()
> +{
> + ?return double_returnval; ? ? /* DOUBLE FUNC */
> +}
> +
> +int main (int argc, char **argv)
> +{
> + ?char char_resultval;
> + ?short short_resultval;
> + ?int int_resultval;
> + ?long long_resultval;
> + ?long long long_long_resultval;
> + ?float float_resultval;
> + ?double double_resultval;
> + ?int i;
> +
> + ?/* A "test load" that will insure that the function really returns
> + ? ? a ${type} (as opposed to just a truncated or part of a ${type}). ?*/
> + ?for (i = 0; i < sizeof (testval.ffff); i++)
> + ? ?testval.ffff[i] = 0xff;
> +
> + ?void_func (); ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?/* call to void_func */
> + ?char_resultval ? ? ?= char_func (); ? ? ? ? ?/* void_checkpoint */
> + ?short_resultval ? ? = short_func (); ? ? ? ? /* char_checkpoint */
> + ?int_resultval ? ? ? = int_func (); ? ? ? ? ? /* short_checkpoint */
> + ?long_resultval ? ? ?= long_func (); ? ? ? ? ?/* int_checkpoint */
> + ?long_long_resultval = long_long_func (); ? ? /* long_checkpoint */
> +
> + ?/* On machines using IEEE floating point, the test pattern of all
> + ? ? 1-bits established above turns out to be a floating-point NaN
> + ? ? ("Not a Number"). ?According to the IEEE rules, NaN's aren't even
> + ? ? equal to themselves. ?This can lead to stupid conversations with
> + ? ? GDB like:
> +
> + ? ? ? (gdb) p testval.float_testval == testval.float_testval
> + ? ? ? $7 = 0
> + ? ? ? (gdb)
> +
> + ? ? This is the correct answer, but it's not the sort of thing
> + ? ? return2.exp wants to see. ?So to make things work the way they
> + ? ? ought, we'll set aside the `union' cleverness and initialize the
> + ? ? test values explicitly here. ?These values have interesting bits
> + ? ? throughout the value, so we'll still detect truncated values. ?*/
> +
> + ?testval.float_testval = 2.7182818284590452354;/* long_long_checkpoint */
> + ?float_resultval ? ? = float_func ();
> + ?testval.double_testval = 3.14159265358979323846; /* float_checkpoint */
> + ?double_resultval ? ?= double_func ();
> + ?main_test = 1; ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? /* double_checkpoint */
> + ?return 0;
> +}
> Index: gdb.reverse/finish-reverse.exp
> ===================================================================
> RCS file: gdb.reverse/finish-reverse.exp
> diff -N gdb.reverse/finish-reverse.exp
> --- /dev/null ? 1 Jan 1970 00:00:00 -0000
> +++ gdb.reverse/finish-reverse.exp ? ? ?24 Jun 2009 20:38:54 -0000
> @@ -0,0 +1,264 @@
> +# Copyright 2008, 2009 Free Software Foundation, Inc.
> +
> +# This program is free software; you can redistribute it and/or modify
> +# it under the terms of the GNU General Public License as published by
> +# the Free Software Foundation; either version 3 of the License, or
> +# (at your option) any later version.
> +#
> +# This program is distributed in the hope that it will be useful,
> +# but WITHOUT ANY WARRANTY; without even the implied warranty of
> +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. ?See the
> +# GNU General Public License for more details.
> +#
> +# You should have received a copy of the GNU General Public License
> +# along with this program. ?If not, see <http://www.gnu.org/licenses/>.
> +
> +# Please email any bugs, comments, and/or additions to this file to:
> +# bug-gdb@prep.ai.mit.edu
> +
> +#
> +# Test "reverse-finish" command
> +#
> +
> +if ![target_info exists gdb,can_reverse] {
> + ? ?return
> +}
> +
> +set testfile "finish-reverse"
> +set srcfile ${testfile}.c
> +
> +if { [prepare_for_testing $testfile.exp "$testfile" $srcfile] } {
> + ? ?return -1
> +}
> +
> +proc test_start_of_line { line_text test_msg } {
> + ? ?global gdb_prompt
> + ? ?global decimal
> + ? ?global hex
> +
> + ? ?send_gdb "info line\n"
> + ? ?gdb_expect {
> + ? ? ? -re "Line $decimal of .* starts at address ($hex) .*$gdb_prompt $" {
> + ? ? ? ? ? set line_begin $expect_out(1,string)
> + ? ? ? }
> + ? ? ? default {
> + ? ? ? ? ? fail "Get line address in test_start_of_line"
> + ? ? ? }
> + ? ?}
> + ? ?send_gdb "info reg pc\n"
> + ? ?gdb_expect {
> + ? ? ? -re ".*: ($hex)\r\n*$gdb_prompt $" {
> + ? ? ? ? ? set stop_pc $expect_out(1,string)
> + ? ? ? }
> + ? ? ? default {
> + ? ? ? ? ? fail"Get stop pc in test_start_of_line"
> + ? ? ? }
> + ? ?}
> + ? ?gdb_test "print $line_begin == $stop_pc" \
> + ? ? ? " = 1\[\r\n\]*" \
> + ? ? ? "test_start_of_line, $test_msg"
> +}
> +
> +runto main
> +
> +if [target_info exists gdb,use_precord] {
> + ? ?# Activate process record/replay
> + ? ?gdb_test "record" "" "Turn on process record"
> + ? ?# FIXME: command ought to acknowledge, so we can test if it succeeded.
> +}
> +
> +# Test finish from void func
> +
> +set breakloc [gdb_get_line_number "VOID FUNC" "$srcfile"]
> +gdb_test "break void_func" \
> + ? ?"Breakpoint $decimal at .*/$srcfile, line $breakloc\." \
> + ? ?"set breakpoint on void_func"
> +gdb_continue_to_breakpoint "void_func" ".*/$srcfile:$breakloc.*"
> +
> +set test_msg "finish from void_func"
> +gdb_test_multiple "finish" "$test_msg" {
> + ? ?-re " call to void_func .*$gdb_prompt $" {
> + ? ? ? send_gdb "step\n"
> + ? ? ? exp_continue
> + ? ?}
> + ? ?-re " void_checkpoint .*$gdb_prompt $" {
> + ? ? ? pass "$test_msg"
> + ? ?}
> +}
> +
> +# Test finish from char func
> +
> +set breakloc [gdb_get_line_number "CHAR FUNC" "$srcfile"]
> +gdb_test "break char_func" \
> + ? ?"Breakpoint $decimal at .*/$srcfile, line $breakloc\." \
> + ? ?"set breakpoint on char_func"
> +gdb_continue_to_breakpoint "char_func" ".*/$srcfile:$breakloc.*"
> +
> +set test_msg "finish from char_func"
> +gdb_test_multiple "finish" "$test_msg" {
> + ? ?-re " void_checkpoint .*$gdb_prompt $" {
> + ? ? ? send_gdb "step\n"
> + ? ? ? exp_continue
> + ? ?}
> + ? ?-re " char_checkpoint .*$gdb_prompt $" {
> + ? ? ? pass "$test_msg"
> + ? ?}
> +}
> +
> +# Test finish from short func
> +
> +set breakloc [gdb_get_line_number "SHORT FUNC" "$srcfile"]
> +gdb_test "break short_func" \
> + ? ?"Breakpoint $decimal at .* line $breakloc\." \
> + ? ?"set breakpoint on short_func"
> +gdb_continue_to_breakpoint "short_func" ".*/$srcfile:$breakloc.*"
> +
> +set test_msg "finish from short_func"
> +gdb_test_multiple "finish" "$test_msg" {
> + ? ?-re " char_checkpoint .*$gdb_prompt $" {
> + ? ? ? send_gdb "step\n"
> + ? ? ? exp_continue
> + ? ?}
> + ? ?-re " short_checkpoint .*$gdb_prompt $" {
> + ? ? ? pass "$test_msg"
> + ? ?}
> +}
> +
> +# Test finish from int func
> +
> +set breakloc [gdb_get_line_number "INT FUNC" "$srcfile"]
> +gdb_test "break int_func" \
> + ? ?"Breakpoint $decimal at .* line $breakloc\." \
> + ? ?"set breakpoint on int_func"
> +gdb_continue_to_breakpoint "int_func" ".*/$srcfile:$breakloc.*"
> +
> +set test_msg "finish from int_func"
> +gdb_test_multiple "finish" "$test_msg" {
> + ? ?-re " short_checkpoint .*$gdb_prompt $" {
> + ? ? ? send_gdb "step\n"
> + ? ? ? exp_continue
> + ? ?}
> + ? ?-re " int_checkpoint .*$gdb_prompt $" {
> + ? ? ? pass "$test_msg"
> + ? ?}
> +}
> +
> +# Test finish from long func
> +
> +set breakloc [gdb_get_line_number "LONG FUNC" "$srcfile"]
> +gdb_test "break long_func" \
> + ? ?"Breakpoint $decimal at .* line $breakloc\." \
> + ? ?"set breakpoint on long_func"
> +gdb_continue_to_breakpoint "long_func" ".*/$srcfile:$breakloc.*"
> +
> +set test_msg "finish from long_func"
> +gdb_test_multiple "finish" "$test_msg" {
> + ? ?-re " int_checkpoint .*$gdb_prompt $" {
> + ? ? ? send_gdb "step\n"
> + ? ? ? exp_continue
> + ? ?}
> + ? ?-re " long_checkpoint .*$gdb_prompt $" {
> + ? ? ? pass "$test_msg"
> + ? ?}
> +}
> +
> +# Test finish from long long func
> +
> +set breakloc [gdb_get_line_number "LONG LONG FUNC" "$srcfile"]
> +gdb_test "break long_long_func" \
> + ? ?"Breakpoint $decimal at .* line $breakloc\." \
> + ? ?"set breakpoint on long_long_func"
> +gdb_continue_to_breakpoint "long_long_func" ".*/$srcfile:$breakloc.*"
> +
> +set test_msg "finish from long_long_func"
> +gdb_test_multiple "finish" "$test_msg" {
> + ? ?-re " long_checkpoint .*$gdb_prompt $" {
> + ? ? ? send_gdb "step\n"
> + ? ? ? exp_continue
> + ? ?}
> + ? ?-re " long_long_checkpoint .*$gdb_prompt $" {
> + ? ? ? pass "$test_msg"
> + ? ?}
> +}
> +
> +
> +###
> +###
> +###
> +
> +# Now switch to reverse
> +gdb_test "set exec-dir reverse" "" "set reverse execution"
> +
> +# Test reverse finish from long long func
> +
> +set breakloc [gdb_get_line_number "LONG LONG FUNC" "$srcfile"]
> +gdb_continue_to_breakpoint "long_long_func" ".*/$srcfile:$breakloc.*"
> +
> +set test_msg "reverse finish from long_long_func"
> +gdb_test_multiple "finish" "$test_msg" {
> + ? ?-re ".* long_checkpoint.*$gdb_prompt $" {
> + ? ? ? test_start_of_line "long_checkpoint" "$test_msg"
> + ? ?}
> +}
> +
> +# Test reverse finish from long func
> +
> +set breakloc [gdb_get_line_number "LONG FUNC" "$srcfile"]
> +gdb_continue_to_breakpoint "long_func" ".*/$srcfile:$breakloc.*"
> +
> +set test_msg "reverse finish from long_func"
> +gdb_test_multiple "finish" "$test_msg" {
> + ? ?-re ".* int_checkpoint.*$gdb_prompt $" {
> + ? ? ? test_start_of_line "int_checkpoint" "$test_msg"
> + ? ?}
> +}
> +
> +# Test reverse finish from int func
> +
> +set breakloc [gdb_get_line_number "INT FUNC" "$srcfile"]
> +gdb_continue_to_breakpoint "int_func" ".*/$srcfile:$breakloc.*"
> +
> +set test_msg "reverse finish from int_func"
> +gdb_test_multiple "finish" "$test_msg" {
> + ? ?-re ".* short_checkpoint.*$gdb_prompt $" {
> + ? ? ? test_start_of_line "short_checkpoint" "$test_msg"
> + ? ?}
> +}
> +
> +# Test reverse finish from short func
> +
> +set breakloc [gdb_get_line_number "SHORT FUNC" "$srcfile"]
> +gdb_continue_to_breakpoint "short_func" ".*/$srcfile:$breakloc.*"
> +
> +set test_msg "reverse finish from short_func"
> +gdb_test_multiple "finish" "$test_msg" {
> + ? ?-re ".* char_checkpoint.*$gdb_prompt $" {
> + ? ? ? test_start_of_line "char_checkpoint" "$test_msg"
> + ? ?}
> +}
> +
> +# Test reverse finish from char func
> +
> +set breakloc [gdb_get_line_number "CHAR FUNC" "$srcfile"]
> +gdb_continue_to_breakpoint "char_func" ".*/$srcfile:$breakloc.*"
> +
> +set test_msg "reverse finish from char_func"
> +gdb_test_multiple "finish" "$test_msg" {
> + ? ?-re ".* void_checkpoint.*$gdb_prompt $" {
> + ? ? ? test_start_of_line "void_checkpoint" "$test_msg"
> + ? ?}
> +}
> +
> +# Test reverse finish from void func
> +
> +set breakloc [gdb_get_line_number "VOID FUNC" "$srcfile"]
> +gdb_continue_to_breakpoint "void_func" ".*/$srcfile:$breakloc.*"
> +
> +set test_msg "reverse finish from void_func"
> +gdb_test_multiple "finish" "$test_msg" {
> + ? ?-re ".* call to void_func.*$gdb_prompt $" {
> + ? ? ? test_start_of_line "call to void_func" "$test_msg"
> + ? ?}
> +}
> +
> +return 0
> Index: gdb.reverse/machinestate.c
> ===================================================================
> RCS file: gdb.reverse/machinestate.c
> diff -N gdb.reverse/machinestate.c
> --- /dev/null ? 1 Jan 1970 00:00:00 -0000
> +++ gdb.reverse/machinestate.c ?24 Jun 2009 20:38:54 -0000
> @@ -0,0 +1,101 @@
> +/* This testcase is part of GDB, the GNU debugger.
> +
> + ? Copyright 2008, 2009 Free Software Foundation, Inc.
> +
> + ? This program is free software; you can redistribute it and/or modify
> + ? it under the terms of the GNU General Public License as published by
> + ? the Free Software Foundation; either version 3 of the License, or
> + ? (at your option) any later version.
> +
> + ? This program is distributed in the hope that it will be useful,
> + ? but WITHOUT ANY WARRANTY; without even the implied warranty of
> + ? MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. ?See the
> + ? GNU General Public License for more details.
> +
> + ? You should have received a copy of the GNU General Public License
> + ? along with this program. ?If not, see <http://www.gnu.org/licenses/>.
> ?*/
> +
> +/*
> + * Test restoration of machine state
> + */
> +
> +extern void hide (int);
> +
> +/* Test register variable
> + ? Requires -- compiler honors 'register'. ?*/
> +
> +void
> +register_state (void)
> +{
> + ?register int a = 0;
> +
> + ?hide (a); ? ?/* External function to defeat optimization. ?*/
> + ?a++; ? ? ? ? /* register_state: set breakpoint here */
> + ?hide (a); ? ?/* register post-change */
> +}
> +
> +/* Test auto variable (whatever that means). ?*/
> +
> +void
> +auto_state (void)
> +{
> + ?auto int a = 0;
> +
> + ?hide (a); ? ?/* External function to defeat optimization. ?*/
> + ?a++; ? ? ? ? /* auto_state: set breakpoint here */
> + ?hide (a); ? ?/* auto post-change */
> +}
> +
> +/* Test function-static variable. ?*/
> +
> +void
> +function_static_state (void)
> +{
> + ?static int a = 0;
> +
> + ?hide (a); ? ?/* External function to defeat optimization. ?*/
> + ?a++; ? ? ? ? /* function_static_state: set breakpoint here */
> + ?hide (a); ? ?/* function static post-change */
> +}
> +
> +/* Test module-static variable. ?*/
> +
> +static int astatic;
> +
> +void
> +module_static_state (void)
> +{
> + ?astatic = 0;
> +
> + ?hide (astatic); ? ? ?/* External function to defeat optimization. ?*/
> + ?astatic++; ? ? ? ? ? /* module_static_state: set breakpoint here */
> + ?hide (astatic); ? ? ?/* module static post-change */
> +}
> +
> +/* Test module-global variable. ?*/
> +
> +int aglobal;
> +
> +void
> +module_global_state (void)
> +{
> + ?aglobal = 0;
> +
> + ?hide (aglobal); ? ? ?/* External function to defeat optimization. ?*/
> + ?aglobal++; ? ? ? ? ? /* module_global_state: set breakpoint here */
> + ?hide (aglobal); ? ? ?/* module global post-change */
> +}
> +
> +/* main test driver */
> +
> +int
> +main (int argc, char **argv)
> +{
> + ?register_state (); ? /* begin main */
> + ?auto_state ();
> + ?function_static_state ();
> + ?module_static_state ();
> + ?module_global_state ();
> +
> + ?return 0; ? ? ? ? ? ?/* end main */
> +}
> Index: gdb.reverse/machinestate.exp
> ===================================================================
> RCS file: gdb.reverse/machinestate.exp
> diff -N gdb.reverse/machinestate.exp
> --- /dev/null ? 1 Jan 1970 00:00:00 -0000
> +++ gdb.reverse/machinestate.exp ? ? ? ?24 Jun 2009 20:38:54 -0000
> @@ -0,0 +1,233 @@
> +# Copyright 2008, 2009 Free Software Foundation, Inc.
> +
> +# This program is free software; you can redistribute it and/or modify
> +# it under the terms of the GNU General Public License as published by
> +# the Free Software Foundation; either version 3 of the License, or
> +# (at your option) any later version.
> +#
> +# This program is distributed in the hope that it will be useful,
> +# but WITHOUT ANY WARRANTY; without even the implied warranty of
> +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. ?See the
> +# GNU General Public License for more details.
> +#
> +# You should have received a copy of the GNU General Public License
> +# along with this program. ?If not, see <http://www.gnu.org/licenses/>.
> +
> +# Please email any bugs, comments, and/or additions to this file to:
> +# bug-gdb@prep.ai.mit.edu
> +
> +#
> +# This test tests the restoration of various kinds of machine state
> +# to their original values by reverse execution. ?We will execute
> +# the program forward while it changes various types of data, and
> +# then execute it backward to see if their values get restored.
> +#
> +# The types of machine state (data) that are tested are:
> +# ? register variable
> +# ? auto variable
> +# ? function static variable
> +# ? module static variable
> +# ? module global variable
> +#
> +# TODO:
> +# various, possibly including...
> +# ? .bss variable, .data variable, ...
> +# ? shared library variable
> +# ? heap variable (pointer)...
> +# ? overlay variables...
> +# ? Test forward replay
> +#
> +
> +if ![target_info exists gdb,can_reverse] {
> + ? ?return
> +}
> +
> +set testfile "machinestate"
> +set srcfile ?${testfile}.c
> +set srcfile1 ${testfile}1.c
> +
> +if { [prepare_for_testing $testfile.exp $testfile {machinestate.c
> machinestate1.c} ] } {
> + ? ?return -1
> +}
> +
> +set newline "\[\r\n\]+"
> +
> +set beginmain [gdb_get_line_number " begin main " $srcfile]
> +set endmain ? [gdb_get_line_number " end main " ? $srcfile]
> +
> +# Test begins
> +
> +runto main
> +
> +if [target_info exists gdb,use_precord] {
> + ? ?# Activate process record/replay
> + ? ?gdb_test "record" "" "Turn on process record"
> + ? ?# FIXME: command ought to acknowledge, so we can test if it succeeded.
> +}
> +
> +# Proceed to end of main
> +
> +gdb_test "break $endmain" \
> + ? ?"Breakpoint.* file .*/$srcfile, line $endmain.*" ""
> +gdb_continue_to_breakpoint "end of main" ".*/$srcfile:$endmain.*"
> +
> +###
> +###
> +###
> +
> +# Now run backward to each of several points where data is changed.
> +#
> +
> +# Module global variable, reverse
> +
> +set breakloc [gdb_get_line_number \
> + ? ? ? ? ? ? ? ? "module_global_state: set breakpoint here" $srcfile]
> +
> +gdb_test "tbreak $breakloc" ".*/$srcfile, line $breakloc.*" ""
> +gdb_test "reverse-continue" ".*/$srcfile:$breakloc.*" "reverse to
> $breakloc"
> +
> +gdb_test "print aglobal" ".* = 0$newline" ?"module global
> reverse-breakpoint"
> +gdb_test "step" ? ? ? ? ?".* module global post-change .*" ""
> +gdb_test "print aglobal" ".* = 1$newline" ?"module global forward past bp"
> +gdb_test "reverse-step" ?".*$newline$breakloc.*" ""
> +gdb_test "print aglobal" ".* = 0$newline" ?"module global reverse-step to
> bp"
> +
> +
> +# Module static variable, reverse
> +
> +set breakloc [gdb_get_line_number \
> + ? ? ? ? ? ? ? ? "module_static_state: set breakpoint here" $srcfile]
> +
> +gdb_test "tbreak $breakloc" ".*/$srcfile, line $breakloc.*" ""
> +gdb_test "reverse-continue" ".*/$srcfile:$breakloc.*" "reverse to
> $breakloc"
> +
> +gdb_test "print astatic" ".* = 0$newline" ?"module static
> reverse-breakpoint"
> +gdb_test "step" ? ? ? ? ?".* module static post-change .*" ""
> +gdb_test "print astatic" ".* = 1$newline" ?"module static forward"
> +gdb_test "reverse-step" ?".*$newline$breakloc.*" ""
> +gdb_test "print astatic" ".* = 0$newline" ?"module static reverse-step"
> +
> +# Function static variable, reverse
> +
> +set breakloc [gdb_get_line_number \
> + ? ? ? ? ? ? ? ? "function_static_state: set breakpoint here" $srcfile]
> +
> +gdb_test "tbreak $breakloc" ".*/$srcfile, line $breakloc.*" ""
> +gdb_test "reverse-continue" ".*/$srcfile:$breakloc.*" "reverse to
> $breakloc"
> +
> +gdb_test "print a" ? ? ?".* = 0$newline" ?"function static
> reverse-breakpoint"
> +gdb_test "step" ? ? ? ? ".* function static post-change .*" ""
> +gdb_test "print a" ? ? ?".* = 1$newline" ?"function static forward"
> +gdb_test "reverse-step" ".*$newline$breakloc.*" ""
> +gdb_test "print a" ? ? ?".* = 0$newline" ?"function static reverse-step"
> +
> +# Auto variable, reverse
> +
> +set breakloc [gdb_get_line_number \
> + ? ? ? ? ? ? ? ? "auto_state: set breakpoint here" $srcfile]
> +
> +gdb_test "tbreak $breakloc" ".*/$srcfile, line $breakloc.*" ""
> +gdb_test "reverse-continue" ".*/$srcfile:$breakloc.*" "reverse to
> $breakloc"
> +
> +gdb_test "print a" ? ? ?".* = 0$newline" ?"auto var reverse-breakpoint"
> +gdb_test "step" ? ? ? ? ".* auto post-change .*" ""
> +gdb_test "print a" ? ? ?".* = 1$newline" ?"auto var forward"
> +gdb_test "reverse-step" ".*$newline$breakloc.*" ""
> +gdb_test "print a" ? ? ?".* = 0$newline" ?"auto var reverse-step"
> +
> +# Register variable, reverse
> +
> +set breakloc [gdb_get_line_number \
> + ? ? ? ? ? ? ? ? "register_state: set breakpoint here" $srcfile]
> +
> +gdb_test "tbreak $breakloc" ".*/$srcfile, line $breakloc.*" ""
> +gdb_test "reverse-continue" ".*/$srcfile:$breakloc.*" "reverse to
> $breakloc"
> +
> +gdb_test "print a" ? ? ?".* = 0$newline" ?"register var reverse-breakpoint"
> +gdb_test "step" ? ? ? ? ".* register post-change .*" ""
> +gdb_test "print a" ? ? ?".* = 1$newline" ?"register var step post-change"
> +gdb_test "reverse-step" ".*$newline$breakloc.*" ""
> +gdb_test "print a" ? ? ?".* = 0$newline" ?"register var reverse step-to"
> +
> +# Proceed to beginning of main
> +
> +gdb_test "tbreak $beginmain" ".*/$srcfile, line $beginmain.*" ""
> +gdb_test "reverse-continue" ?".*/$srcfile:$beginmain.*" "reverse to main"
> +
> +# Now repeat tests while replaying forward.
> +
> +# Register variable, forward
> +
> +set breakloc [gdb_get_line_number \
> + ? ? ? ? ? ? ? ? "register_state: set breakpoint here" $srcfile]
> +
> +gdb_test "tbreak $breakloc" ".*/$srcfile, line $breakloc.*" ""
> +gdb_test "continue" ? ? ? ? ".*/$srcfile:$breakloc.*" "forward to
> $breakloc"
> +
> +gdb_test "print a" ? ? ?".* = 0$newline" ?"register var forward-breakpoint"
> +gdb_test "reverse-step" ".*hide.*" ""
> +gdb_test "step" ? ? ? ? ".*$newline$breakloc.*" ""
> +gdb_test "print a" ? ? ?".* = 0$newline" ?"register var forward step-to"
> +gdb_test "step" ? ? ? ? ".* register post-change .*" ""
> +gdb_test "print a" ? ? ?".* = 1$newline" ?"register var step post-change"
> +
> +# Auto variable, forward
> +
> +set breakloc [gdb_get_line_number \
> + ? ? ? ? ? ? ? ? "auto_state: set breakpoint here" $srcfile]
> +
> +gdb_test "tbreak $breakloc" ".*/$srcfile, line $breakloc.*" ""
> +gdb_test "continue" ? ? ? ? ".*/$srcfile:$breakloc.*" "forward to
> $breakloc"
> +
> +gdb_test "print a" ? ? ?".* = 0$newline" ?"auto var forward-breakpoint"
> +gdb_test "reverse-step" ".*hide.*" ""
> +gdb_test "step" ? ? ? ? ".*$newline$breakloc.*" ""
> +gdb_test "print a" ? ? ?".* = 0$newline" ?"auto var forward step-to"
> +gdb_test "step" ? ? ? ? ".* auto post-change .*" ""
> +gdb_test "print a" ? ? ?".* = 1$newline" ?"auto var step post-change"
> +
> +# Function static variable, forward
> +
> +set breakloc [gdb_get_line_number \
> + ? ? ? ? ? ? ? ? "function_static_state: set breakpoint here" $srcfile]
> +
> +gdb_test "tbreak $breakloc" ".*/$srcfile, line $breakloc.*" ""
> +gdb_test "continue" ? ? ? ? ".*/$srcfile:$breakloc.*" "forward to
> $breakloc"
> +
> +gdb_test "print a" ? ? ?".* = 0$newline" ?"function static
> forward-breakpoint"
> +gdb_test "reverse-step" ".*hide.*" ""
> +gdb_test "step" ? ? ? ? ".*$newline$breakloc.*" ""
> +gdb_test "print a" ? ? ?".* = 0$newline" ?"function static forward step-to"
> +gdb_test "step" ? ? ? ? ".* function static post-change .*" ""
> +gdb_test "print a" ? ? ?".* = 1$newline" ?"function static step
> post-change"
> +
> +# Module static variable, forward
> +
> +set breakloc [gdb_get_line_number \
> + ? ? ? ? ? ? ? ? "module_static_state: set breakpoint here" $srcfile]
> +
> +gdb_test "tbreak $breakloc" ".*/$srcfile, line $breakloc.*" ""
> +gdb_test "continue" ? ? ? ? ".*/$srcfile:$breakloc.*" "forward to
> $breakloc"
> +
> +gdb_test "print astatic" ".* = 0$newline" ?"module static
> forward-breakpoint"
> +gdb_test "reverse-step" ?".*hide.*" ""
> +gdb_test "step" ? ? ? ? ?".*$newline$breakloc.*" ""
> +gdb_test "print astatic" ".* = 0$newline" ?"module static forward step-to"
> +gdb_test "step" ? ? ? ? ?".* module static post-change .*" ""
> +gdb_test "print astatic" ".* = 1$newline" ?"module static step post-change"
> +
> +# Module global variable, forward
> +
> +set breakloc [gdb_get_line_number \
> + ? ? ? ? ? ? ? ? "module_global_state: set breakpoint here" $srcfile]
> +
> +gdb_test "tbreak $breakloc" ".*/$srcfile, line $breakloc.*" ""
> +gdb_test "continue" ? ? ? ? ".*/$srcfile:$breakloc.*" "forward to
> $breakloc"
> +
> +gdb_test "print aglobal" ".* = 0$newline" ?"module global
> forward-breakpoint"
> +gdb_test "reverse-step" ?".*hide.*" ""
> +gdb_test "step" ? ? ? ? ?".*$newline$breakloc.*" ""
> +gdb_test "print aglobal" ".* = 0$newline" ?"module global forward step-to"
> +gdb_test "step" ? ? ? ? ?".* module global post-change .*" ""
> +gdb_test "print aglobal" ".* = 1$newline" ?"module global step post-change"
> +
> Index: gdb.reverse/machinestate1.c
> ===================================================================
> RCS file: gdb.reverse/machinestate1.c
> diff -N gdb.reverse/machinestate1.c
> --- /dev/null ? 1 Jan 1970 00:00:00 -0000
> +++ gdb.reverse/machinestate1.c 24 Jun 2009 20:38:54 -0000
> @@ -0,0 +1,25 @@
> +/* This testcase is part of GDB, the GNU debugger.
> +
> + ? Copyright 2008 Free Software Foundation, Inc.
> +
> + ? This program is free software; you can redistribute it and/or modify
> + ? it under the terms of the GNU General Public License as published by
> + ? the Free Software Foundation; either version 3 of the License, or
> + ? (at your option) any later version.
> +
> + ? This program is distributed in the hope that it will be useful,
> + ? but WITHOUT ANY WARRANTY; without even the implied warranty of
> + ? MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. ?See the
> + ? GNU General Public License for more details.
> +
> + ? You should have received a copy of the GNU General Public License
> + ? along with this program. ?If not, see <http://www.gnu.org/licenses/>.
> ?*/
> +
> +/*
> + * Aux function for machine state test.
> + */
> +
> +void
> +hide (int x)
> +{
> +}
> Index: gdb.reverse/shr2.c
> ===================================================================
> RCS file: gdb.reverse/shr2.c
> diff -N gdb.reverse/shr2.c
> --- /dev/null ? 1 Jan 1970 00:00:00 -0000
> +++ gdb.reverse/shr2.c ?24 Jun 2009 20:38:54 -0000
> @@ -0,0 +1,34 @@
> +/* This testcase is part of GDB, the GNU debugger.
> +
> + ? Copyright 2009 Free Software Foundation, Inc.
> +
> + ? This program is free software; you can redistribute it and/or modify
> + ? it under the terms of the GNU General Public License as published by
> + ? the Free Software Foundation; either version 3 of the License, or
> + ? (at your option) any later version.
> +
> + ? This program is distributed in the hope that it will be useful,
> + ? but WITHOUT ANY WARRANTY; without even the implied warranty of
> + ? MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. ?See the
> + ? GNU General Public License for more details.
> +
> + ? You should have received a copy of the GNU General Public License
> + ? along with this program. ?If not, see <http://www.gnu.org/licenses/>.
> ?*/
> +
> +#ifdef PROTOTYPES
> +int shr2(int x)
> +#else
> +int shr2(x) int x;
> +#endif
> +{
> + ?return 2*x;
> +}
> +
> +#ifdef PROTOTYPES
> +int shr2_local(int x)
> +#else
> +int shr2_local(x) int x;
> +#endif
> +{
> + ?return 2*x;
> +}
> Index: gdb.reverse/solib-reverse.c
> ===================================================================
> RCS file: gdb.reverse/solib-reverse.c
> diff -N gdb.reverse/solib-reverse.c
> --- /dev/null ? 1 Jan 1970 00:00:00 -0000
> +++ gdb.reverse/solib-reverse.c 24 Jun 2009 20:38:54 -0000
> @@ -0,0 +1,43 @@
> +/* This testcase is part of GDB, the GNU debugger.
> +
> + ? Copyright 2009 Free Software Foundation, Inc.
> +
> + ? This program is free software; you can redistribute it and/or modify
> + ? it under the terms of the GNU General Public License as published by
> + ? the Free Software Foundation; either version 3 of the License, or
> + ? (at your option) any later version.
> +
> + ? This program is distributed in the hope that it will be useful,
> + ? but WITHOUT ANY WARRANTY; without even the implied warranty of
> + ? MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. ?See the
> + ? GNU General Public License for more details.
> +
> + ? You should have received a copy of the GNU General Public License
> + ? along with this program. ?If not, see <http://www.gnu.org/licenses/>.
> ?*/
> +
> +/* Test reverse debugging of shared libraries. ?*/
> +
> +#include <stdio.h>
> +
> +/* Shared library function */
> +extern int shr2(int);
> +
> +int main ()
> +{
> + ?char* cptr = "String 1";
> + ?int b[2] = {5,8};
> +
> + ?b[0] = shr2(12); ? ? ? ? ? ? /* begin part two */
> + ?b[1] = shr2(17); ? ? ? ? ? ? /* middle part two */
> +
> + ?b[0] = 6; ? b[1] = 9; ? ? ? ? ? ? ? ?/* generic statement, end part two
> */
> + ?printf ("message 1\n"); ? ? ?/* printf one */
> + ?printf ("message 2\n"); ? ? ?/* printf two */
> + ?printf ("message 3\n"); ? ? ?/* printf three */
> + ?sleep (0); ? ? ? ? ? ? ? ? ? /* sleep one */
> + ?sleep (0); ? ? ? ? ? ? ? ? ? /* sleep two */
> + ?sleep (0); ? ? ? ? ? ? ? ? ? /* sleep three */
> +
> + ?return 0; ? ? ? ? ? ? ? ? ? ?/* end part one */
> +}
> +
> Index: gdb.reverse/solib-reverse.exp
> ===================================================================
> RCS file: gdb.reverse/solib-reverse.exp
> diff -N gdb.reverse/solib-reverse.exp
> --- /dev/null ? 1 Jan 1970 00:00:00 -0000
> +++ gdb.reverse/solib-reverse.exp ? ? ? 24 Jun 2009 20:38:54 -0000
> @@ -0,0 +1,127 @@
> +# Copyright 2009
> +# Free Software Foundation, Inc.
> +
> +# This program is free software; you can redistribute it and/or modify
> +# it under the terms of the GNU General Public License as published by
> +# the Free Software Foundation; either version 3 of the License, or
> +# (at your option) any later version.
> +#
> +# This program is distributed in the hope that it will be useful,
> +# but WITHOUT ANY WARRANTY; without even the implied warranty of
> +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. ?See the
> +# GNU General Public License for more details.
> +#
> +# You should have received a copy of the GNU General Public License
> +# along with this program. ?If not, see <http://www.gnu.org/licenses/>.
> +
> +# This file was written by Michael Snyder (msnyder@vmware.com).
> +
> +#
> +# Test reverse debugging with shared libraries.
> +#
> +
> +if ![target_info exists gdb,can_reverse] {
> + ? ?return
> +}
> +
> +set testfile "solib-reverse"
> +set srcfile ?${testfile}.c
> +set libfile ?"shr2"
> +set libsrc ? ${libfile}.c
> +set library ?${objdir}/${subdir}/${libfile}.sl
> +set binfile ?${objdir}/${subdir}/${testfile}
> +
> +if [get_compiler_info ${binfile}] {
> + ? ?return -1
> +}
> +
> +if { [gdb_compile_shlib ${srcdir}/${subdir}/${libsrc} ${library} "debug"]
> != "" } {
> + ? ?untested "Could not compile shared library."
> + ? ?return -1
> +}
> +
> +set exec_opts [list debug shlib=${library}]
> +
> +if { [gdb_compile ${srcdir}/${subdir}/${srcfile} ${binfile} executable
> $exec_opts] != "" } {
> + ? ?untested "Could not compile $binfile."
> + ? ?return -1
> +}
> +
> +# Start with a fresh gdb.
> +
> +gdb_exit
> +gdb_start
> +gdb_reinitialize_dir $srcdir/$subdir
> +gdb_load ${binfile}
> +
> +
> +runto main
> +
> +if [target_info exists gdb,use_precord] {
> + ? ?# Activate process record/replay
> + ? ?gdb_test "record" "" "Turn on process record"
> + ? ?# FIXME: command ought to acknowledge, so we can test if it succeeded.
> +}
> +
> +#
> +# Test reverse-step over undebuggable solib functions.
> +#
> +
> +# Run forward past some solib function calls.
> +
> +set end_part_one [gdb_get_line_number " end part one" "$srcfile"]
> +set end_part_two [gdb_get_line_number " end part two" "$srcfile"]
> +gdb_test "until $end_part_one" " end part one.*" "run until end part one"
> +
> +gdb_test "reverse-step" " sleep three .*" "reverse-step third sleep"
> +gdb_test "reverse-step" " sleep two .*" ? "reverse-step second sleep"
> +gdb_test "reverse-step" " sleep one .*" ? \
> + ? ? ? ? ? ? ? ? ? "reverse-step first sleep, dynsym resolve"
> +
> +gdb_test "reverse-step" " printf three .*" "reverse-step third printf"
> +gdb_test "reverse-step" " printf two .*" ? "reverse-step second printf"
> +gdb_test "reverse-step" " printf one .*" ? \
> + ? ? ? ? ? ? ? ? ? "reverse-step first printf, dynsym resolve"
> +gdb_test "reverse-step" " generic statement.*" "reverse-step generic"
> +
> +
> +#
> +# Test reverse-next over undebuggable solib functions.
> +#
> +
> +# Run forward again...
> +
> +gdb_test "until $end_part_one" " end part one.*" "forward to end part one"
> +
> +gdb_test "reverse-next" " sleep three .*" "reverse-next third sleep"
> +gdb_test "reverse-next" " sleep two .*" ? "reverse-next second sleep"
> +gdb_test "reverse-next" " sleep one .*" ? \
> + ? ? ? ? ? ? ? ? ? "reverse-next first sleep, dynsym resolve"
> +
> +gdb_test "reverse-next" " printf three .*" "reverse-next third printf"
> +gdb_test "reverse-next" " printf two .*" ? "reverse-next second printf"
> +gdb_test "reverse-next" " printf one .*" ? \
> + ? ? ? ? ? ? ? ? ? "reverse-next first printf, dynsym resolve"
> +gdb_test "reverse-next" " generic statement.*" "reverse-next generic"
> +
> +
> +#
> +# Test reverse-step into debuggable solib function
> +#
> +
> +gdb_test "reverse-step" "${libsrc}.*" "reverse-step into solib function
> one"
> +gdb_test "reverse-step" "return 2.x.*" "reverse-step within solib function
> one"
> +gdb_test "reverse-step" " middle part two.*" "reverse-step back to main
> one"
> +
> +gdb_test "reverse-step" "${libsrc}.*" "reverse-step into solib function
> two"
> +gdb_test "reverse-step" "return 2.x.*" "reverse-step within solib function
> two"
> +gdb_test "reverse-step" " begin part two.*" "reverse-step back to main two"
> +
> +#
> +# Test reverse-next over debuggable solib function
> +#
> +
> +gdb_test "until $end_part_two" " end part two.*" "run until end part two"
> +
> +gdb_test "reverse-next" " middle part two.*" "reverse-next over solib
> function one"
> +gdb_test "reverse-next" " begin part two.*" "reverse-next over solib
> function two"
> Index: gdb.reverse/step-reverse.c
> ===================================================================
> RCS file: gdb.reverse/step-reverse.c
> diff -N gdb.reverse/step-reverse.c
> --- /dev/null ? 1 Jan 1970 00:00:00 -0000
> +++ gdb.reverse/step-reverse.c ?24 Jun 2009 20:38:54 -0000
> @@ -0,0 +1,78 @@
> +/* This testcase is part of GDB, the GNU debugger.
> +
> + ? Copyright 2008, 2009 Free Software Foundation, Inc.
> +
> + ? This program is free software; you can redistribute it and/or modify
> + ? it under the terms of the GNU General Public License as published by
> + ? the Free Software Foundation; either version 3 of the License, or
> + ? (at your option) any later version.
> +
> + ? This program is distributed in the hope that it will be useful,
> + ? but WITHOUT ANY WARRANTY; without even the implied warranty of
> + ? MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. ?See the
> + ? GNU General Public License for more details.
> +
> + ? You should have received a copy of the GNU General Public License
> + ? along with this program. ?If not, see <http://www.gnu.org/licenses/>.
> ?*/
> +
> +#include <stdlib.h>
> +#include <string.h>
> +
> +/* Test various kinds of stepping.
> +*/
> +int myglob = 0;
> +
> +int callee() { ? ? ? ? /* ENTER CALLEE */
> + ?myglob++; return 0; ?/* ARRIVED IN CALLEE */
> +} ? ? ? ? ? ? ? ? ? ? ?/* RETURN FROM CALLEE */
> +
> +/* A structure which, we hope, will need to be passed using memcpy. ?*/
> +struct rhomboidal {
> + ?int rather_large[100];
> +};
> +
> +void
> +large_struct_by_value (struct rhomboidal r)
> +{
> + ?myglob += r.rather_large[42]; /* step-test.exp: arrive here 1 */
> +}
> +
> +int main () {
> + ? int w,x,y,z;
> + ? int a[10], b[10];
> +
> + ? /* Test "next" and "step" */
> + ? w = 0; ? ? ?/* BREAK AT MAIN */
> + ? x = 1; ? ? ?/* NEXT TEST 1 */
> + ? y = 2; ? ? ?/* STEP TEST 1 */
> + ? z = 3; ? ? ?/* REVERSE NEXT TEST 1 */
> + ? w = w + 2; ?/* NEXT TEST 2 */
> + ? x = x + 3; ?/* REVERSE STEP TEST 1 */
> + ? y = y + 4;
> + ? z = z + 5; ?/* STEP TEST 2 */
> +
> + ? /* Test that "next" goes over a call */
> + ? callee(); ? /* NEXT OVER THIS CALL */
> +
> + ? /* Test that "step" doesn't */
> + ? callee(); ? /* STEP INTO THIS CALL */
> +
> + ? /* Test "stepi" */
> + ? a[5] = a[3] - a[4]; /* FINISH TEST */
> + ? callee(); ? /* STEPI TEST */
> +
> + ? /* Test "nexti" */
> + ? callee(); ? /* NEXTI TEST */
> +
> + ? y = w + z;
> +
> + ? {
> + ? ? struct rhomboidal r;
> + ? ? memset (r.rather_large, 0, sizeof (r.rather_large));
> + ? ? r.rather_large[42] = 10;
> + ? ? large_struct_by_value (r); ?/* step-test.exp: large struct by value */
> + ? }
> +
> + ? exit (0);
> +}
> +
> Index: gdb.reverse/step-reverse.exp
> ===================================================================
> RCS file: gdb.reverse/step-reverse.exp
> diff -N gdb.reverse/step-reverse.exp
> --- /dev/null ? 1 Jan 1970 00:00:00 -0000
> +++ gdb.reverse/step-reverse.exp ? ? ? ?24 Jun 2009 20:38:54 -0000
> @@ -0,0 +1,250 @@
> +# Copyright 2008, 2009 Free Software Foundation, Inc.
> +
> +# This program is free software; you can redistribute it and/or modify
> +# it under the terms of the GNU General Public License as published by
> +# the Free Software Foundation; either version 3 of the License, or
> +# (at your option) any later version.
> +#
> +# This program is distributed in the hope that it will be useful,
> +# but WITHOUT ANY WARRANTY; without even the implied warranty of
> +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. ?See the
> +# GNU General Public License for more details.
> +#
> +# You should have received a copy of the GNU General Public License
> +# along with this program. ?If not, see <http://www.gnu.org/licenses/>. ?*/
> +# step-reverse.exp -- Expect script to test reverse stepping in gdb.
> +# Lots of code borrowed from "step-test.exp".
> +
> +#
> +# Test step and next in reverse
> +#
> +
> +if ![target_info exists gdb,can_reverse] {
> + ? ?return
> +}
> +
> +set testfile "step-reverse"
> +set srcfile ?${testfile}.c
> +
> +if { [prepare_for_testing $testfile.exp $testfile $srcfile] } {
> + ? ?return -1
> +}
> +
> +runto main
> +
> +if [target_info exists gdb,use_precord] {
> + ? ?# Activate process record/replay
> + ? ?gdb_test "record" "" "Turn on process record"
> + ? ?# FIXME: command ought to acknowledge, so we can test if it succeeded.
> +}
> +
> +# plain vanilla step/next (no count)
> +
> +gdb_test "next" ".*NEXT TEST 1.*" "next test 1"
> +gdb_test "step" ".*STEP TEST 1.*" "step test 1"
> +
> +# step/next with count
> +
> +gdb_test "next 2" ".*NEXT TEST 2.*" "next test 2"
> +gdb_test "step 3" ".*STEP TEST 2.*" "step test 2"
> +
> +# step over call
> +
> +gdb_test "step" ".*NEXT OVER THIS CALL.*" "step up to call"
> +gdb_test "next" ".*STEP INTO THIS CALL.*" "next over call"
> +
> +# step into call
> +
> +gdb_test "step" ".*ARRIVED IN CALLEE.*" "step into call"
> +
> +# finish out of call
> +
> +set test_message "finish out of fn call"
> +gdb_test_multiple "finish" "$test_message" {
> + ? ?-re "FINISH TEST.*$gdb_prompt $" {
> + ? ? ? pass "$test_message"
> + ? ?}
> + ? ?-re "STEP INTO THIS CALL.*$gdb_prompt $" {
> + ? ? ? send_gdb "step\n"
> + ? ? ? exp_continue
> + ? ?}
> +}
> +
> +# stepi over flat code (no calls)
> +
> +set test_message "simple stepi"
> +gdb_test_multiple "stepi" "$test_message" {
> + ? ?-re "STEPI TEST.*$gdb_prompt $" {
> + ? ? ? pass "$test_message"
> + ? ?}
> + ? ?-re "FINISH TEST.*$gdb_prompt $" {
> + ? ? ? send_gdb "stepi\n"
> + ? ? ? exp_continue
> + ? ?}
> + ? ?-re "NEXTI TEST.*$gdb_prompt $" {
> + ? ? ? fail "$test_message (too far)"
> + ? ?}
> +}
> +
> +# stepi into a function call
> +
> +set test_message "stepi into function call"
> +gdb_test_multiple "stepi" "$test_message" {
> + ? ?-re "ARRIVED IN CALLEE.*$gdb_prompt $" {
> + ? ? ? pass "$test_message"
> + ? ?}
> + ? ?-re "NEXTI TEST.*$gdb_prompt $" {
> + ? ? ? fail "$test_message (too far)"
> + ? ?}
> + ? ?-re "RETURN FROM CALLEE.*$gdb_prompt $" {
> + ? ? ? fail "$test_message (too far)"
> + ? ?}
> + ? ?-re "ENTER CALLEE.*$gdb_prompt $" {
> + ? ? ? send_gdb "stepi\n"
> + ? ? ? exp_continue
> + ? ?}
> +}
> +
> +# stepi thru return of a function call
> +
> +set test_message "stepi back from function call"
> +gdb_test_multiple "stepi" "$test_message" {
> + ? ?-re "NEXTI TEST.*$gdb_prompt $" {
> + ? ? ? pass "$test_message"
> + ? ?}
> + ? ?-re "ARRIVED IN CALLEE.*$gdb_prompt $" {
> + ? ? ? send_gdb "stepi\n"
> + ? ? ? exp_continue
> + ? ?}
> + ? ?-re "RETURN FROM CALLEE.*$gdb_prompt $" {
> + ? ? ? send_gdb "stepi\n"
> + ? ? ? exp_continue
> + ? ?}
> + ? ?-re "STEPI TEST.*$gdb_prompt $" {
> + ? ? ? send_gdb "stepi\n"
> + ? ? ? exp_continue
> + ? ?}
> + ? ?-re "ENTER CALLEE.*$gdb_prompt $" {
> + ? ? ? fail "$test_message (too far)"
> + ? ?}
> +}
> +
> +###
> +###
> +###
> +
> +# Set reverse execution direction
> +# FIXME: command needs to acknowledge, so we can test if it succeeded.
> +
> +gdb_test "set exec-dir reverse" "" "set reverse execution"
> +
> +# stepi backward thru return and into a function
> +
> +set stepi_location ?[gdb_get_line_number "ARRIVED IN CALLEE" "$srcfile"]
> +set test_message "reverse stepi thru function return"
> +gdb_test_multiple "stepi" "$test_message" {
> + ? ?-re "NEXTI TEST.*$gdb_prompt $" {
> + ? ? ? fail "$test_message (start statement)"
> + ? ?}
> + ? ?-re "RETURN FROM CALLEE.*$gdb_prompt $" {
> + ? ? ? send_gdb "stepi\n"
> + ? ? ? exp_continue
> + ? ?}
> + ? ?-re "$hex\[ \t\]*$stepi_location.*ARRIVED IN CALLEE.*$gdb_prompt $" {
> + ? ? ? send_gdb "stepi\n"
> + ? ? ? exp_continue
> + ? ?}
> + ? ?-re "ARRIVED IN CALLEE.*$gdb_prompt $" {
> + ? ? ? pass "$test_message"
> + ? ?}
> + ? ?-re "ENTER CALLEE.*$gdb_prompt $" {
> + ? ? ? fail "$test_message (too far)"
> + ? ?}
> + ? ?-re "STEPI TEST.*$gdb_prompt $" {
> + ? ? ? fail "$test_message (too far)"
> + ? ?}
> +}
> +
> +# stepi backward out of a function call
> +
> +set stepi_location ?[gdb_get_line_number "FINISH TEST" "$srcfile"]
> +set test_message "reverse stepi from a function call"
> +gdb_test_multiple "stepi" "$test_message" {
> + ? ?-re "ARRIVED IN CALLEE.*$gdb_prompt $" {
> + ? ? ? fail "$test_message (start statement)"
> + ? ?}
> + ? ?-re "ENTER CALLEE.*$gdb_prompt $" {
> + ? ? ? send_gdb "stepi\n"
> + ? ? ? exp_continue
> + ? ?}
> + ? ?-re "${hex}\[ \t\]*$stepi_location.*STEPI TEST.*$gdb_prompt $" {
> + ? ? ? send_gdb "stepi\n"
> + ? ? ? exp_continue
> + ? ?}
> + ? ?-re "STEPI TEST.*$gdb_prompt $" {
> + ? ? ? pass "$test_message"
> + ? ?}
> + ? ?-re "STEP INTO THIS CALL.*$gdb_prompt $" {
> + ? ? ? fail "$test_message (too far)"
> + ? ?}
> +}
> +
> +# stepi backward over flat code (no calls)
> +
> +set stepi_location ?[gdb_get_line_number "FINISH TEST" "$srcfile"]
> +set test_message "simple reverse stepi"
> +gdb_test_multiple "stepi" "$test_message" {
> + ? ?-re "STEPI TEST.*$gdb_prompt $" {
> + ? ? ? fail "$test_message (start statement)"
> + ? ?}
> + ? ?-re "$hex\[ \t\]*$stepi_location.* FINISH TEST.*$gdb_prompt $" {
> + ? ? ? send_gdb "stepi\n"
> + ? ? ? exp_continue
> + ? ?}
> + ? ?-re "$stepi_location.* FINISH TEST.*$gdb_prompt $" {
> + ? ? ? pass "$test_message"
> + ? ?}
> + ? ?-re "STEP INTO THIS CALL.*$gdb_prompt $" {
> + ? ? ? fail "$test_message (too far)"
> + ? ?}
> +}
> +
> +# step backward into function (thru return)
> +
> +set test_message "reverse step into fn call"
> +gdb_test_multiple "step" "$test_message" {
> + ? ?-re "RETURN FROM CALLEE.*$gdb_prompt $" {
> + ? ? ? send_gdb "step\n"
> + ? ? ? exp_continue
> + ? ?}
> + ? ?-re "ARRIVED IN CALLEE.*$gdb_prompt $" {
> + ? ? ? pass "$test_message"
> + ? ?}
> +}
> +
> +# step backward out of called function (thru call)
> +
> +gdb_test "step" ".*STEP INTO THIS CALL.*" "reverse step out of called fn"
> +
> +# next backward over call
> +
> +gdb_test "next" ".*NEXT OVER THIS CALL.*" "reverse next over call"
> +
> +# step/next backward with count
> +
> +gdb_test "step 3" ".*REVERSE STEP TEST 1.*" "reverse step test 1"
> +gdb_test "next 2" ".*REVERSE NEXT TEST 1.*" "reverse next test 1"
> +
> +# step/next backward without count
> +
> +gdb_test "step" ".*STEP TEST 1.*" "reverse step test 2"
> +gdb_test "next" ".*NEXT TEST 1.*" "reverse next test 2"
> +
> +
> +
> +# Finish test by running forward to the end.
> +# FIXME return to this later...
> +# gdb_test "set exec-dir forward" "" "set forward execution"
> +# gdb_continue_to_end "step-reverse.exp"
> +
> +return 0
> Index: gdb.reverse/until-reverse.c
> ===================================================================
> RCS file: gdb.reverse/until-reverse.c
> diff -N gdb.reverse/until-reverse.c
> --- /dev/null ? 1 Jan 1970 00:00:00 -0000
> +++ gdb.reverse/until-reverse.c 24 Jun 2009 20:38:54 -0000
> @@ -0,0 +1,149 @@
> +/* This testcase is part of GDB, the GNU debugger.
> +
> + ? Copyright 2008, 2009
> + ? Free Software Foundation, Inc.
> +
> + ? This program is free software; you can redistribute it and/or modify
> + ? it under the terms of the GNU General Public License as published by
> + ? the Free Software Foundation; either version 3 of the License, or
> + ? (at your option) any later version.
> +
> + ? This program is distributed in the hope that it will be useful,
> + ? but WITHOUT ANY WARRANTY; without even the implied warranty of
> + ? MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. ?See the
> + ? GNU General Public License for more details.
> +
> + ? You should have received a copy of the GNU General Public License
> + ? along with this program. ?If not, see <http://www.gnu.org/licenses/>.
> +
> + ? Please email any bugs, comments, and/or additions to this file to:
> + ? bug-gdb@prep.ai.mit.edu ?*/
> +
> +#ifdef vxworks
> +
> +# ?include <stdio.h>
> +
> +/* VxWorks does not supply atoi. ?*/
> +static int
> +atoi (z)
> + ? ? char *z;
> +{
> + ?int i = 0;
> +
> + ?while (*z >= '0' && *z <= '9')
> + ? ?i = i * 10 + (*z++ - '0');
> + ?return i;
> +}
> +
> +/* I don't know of any way to pass an array to VxWorks. ?This function
> + ? can be called directly from gdb. ?*/
> +
> +vxmain (arg)
> +char *arg;
> +{
> + ?char *argv[2];
> +
> + ?argv[0] = "";
> + ?argv[1] = arg;
> + ?main (2, argv, (char **) 0);
> +}
> +
> +#else /* ! vxworks */
> +# ?include <stdio.h>
> +# ?include <stdlib.h>
> +#endif /* ! vxworks */
> +
> +#ifdef PROTOTYPES
> +extern int marker1 (void);
> +extern int marker2 (int a);
> +extern void marker3 (char *a, char *b);
> +extern void marker4 (long d);
> +#else
> +extern int marker1 ();
> +extern int marker2 ();
> +extern void marker3 ();
> +extern void marker4 ();
> +#endif
> +
> +/*
> + * ? ? This simple classical example of recursion is useful for
> + * ? ? testing stack backtraces and such.
> + */
> +
> +#ifdef PROTOTYPES
> +int factorial(int);
> +
> +int
> +main (int argc, char **argv, char **envp)
> +#else
> +int
> +main (argc, argv, envp)
> +int argc;
> +char *argv[], **envp;
> +#endif
> +{
> +#ifdef usestubs
> + ? ?set_debug_traps(); ?/* set breakpoint 5 here */
> + ? ?breakpoint();
> +#endif
> + ? ?if (argc == 12345) { ?/* an unlikely value < 2^16, in case uninited */
> /* set breakpoint 6 here */
> + ? ? ? fprintf (stderr, "usage: ?factorial <number>\n");
> + ? ? ? return 1;
> + ? ?}
> + ? ?printf ("%d\n", factorial (atoi ("6"))); ?/* set breakpoint 1 here */
> + ? ?/* set breakpoint 12 here */
> + ? ?marker1 (); ?/* set breakpoint 11 here */
> + ? ?marker2 (43); /* set breakpoint 20 here */
> + ? ?marker3 ("stack", "trace"); /* set breakpoint 21 here */
> + ? ?marker4 (177601976L);
> + ? ?/* We're used by a test that requires malloc, so make sure it is
> + ? ? ? in the executable. ?*/
> + ? ?(void)malloc (1);
> +
> + ? ?argc = (argc == 12345); /* This is silly, but we can step off of it */
> /* set breakpoint 2 here */
> + ? ?return argc; ?/* set breakpoint 10 here */
> +} /* set breakpoint 10a here */
> +
> +#ifdef PROTOTYPES
> +int factorial (int value)
> +#else
> +int factorial (value)
> +int value;
> +#endif
> +{
> + ?if (value > 1) { ?/* set breakpoint 7 here */
> + ? ? ? value *= factorial (value - 1);
> + ? ?}
> + ? ?return (value); /* set breakpoint 19 here */
> +}
> +
> +#ifdef PROTOTYPES
> +int multi_line_if_conditional (int a, int b, int c)
> +#else
> +int multi_line_if_conditional (a, b, c)
> + ?int a, b, c;
> +#endif
> +{
> + ?if (a ? ?/* set breakpoint 3 here */
> + ? ? ?&& b
> + ? ? ?&& c)
> + ? ?return 0;
> + ?else
> + ? ?return 1;
> +}
> +
> +#ifdef PROTOTYPES
> +int multi_line_while_conditional (int a, int b, int c)
> +#else
> +int multi_line_while_conditional (a, b, c)
> + ?int a, b, c;
> +#endif
> +{
> + ?while (a /* set breakpoint 4 here */
> + ? ? ?&& b
> + ? ? ?&& c)
> + ? ?{
> + ? ? ?a--, b--, c--;
> + ? ?}
> + ?return 0;
> +}
> Index: gdb.reverse/until-reverse.exp
> ===================================================================
> RCS file: gdb.reverse/until-reverse.exp
> diff -N gdb.reverse/until-reverse.exp
> --- /dev/null ? 1 Jan 1970 00:00:00 -0000
> +++ gdb.reverse/until-reverse.exp ? ? ? 24 Jun 2009 20:38:54 -0000
> @@ -0,0 +1,133 @@
> +# Copyright 2008, 2009 Free Software Foundation, Inc.
> +
> +# This program is free software; you can redistribute it and/or modify
> +# it under the terms of the GNU General Public License as published by
> +# the Free Software Foundation; either version 3 of the License, or
> +# (at your option) any later version.
> +#
> +# This program is distributed in the hope that it will be useful,
> +# but WITHOUT ANY WARRANTY; without even the implied warranty of
> +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. ?See the
> +# GNU General Public License for more details.
> +#
> +# You should have received a copy of the GNU General Public License
> +# along with this program. ?If not, see <http://www.gnu.org/licenses/>. ?*/
> +
> +# Please email any bugs, comments, and/or additions to this file to:
> +# bug-gdb@prep.ai.mit.edu
> +
> +#
> +# Test 'until' and 'advance' in reverse.
> +#
> +
> +if ![target_info exists gdb,can_reverse] {
> + ? ?return
> +}
> +
> +set testfile "until-reverse"
> +set srcfile ${testfile}.c
> +set srcfile1 ${testfile}1.c
> +
> +if { [prepare_for_testing $testfile.exp $testfile {until-reverse.c
> until-reverse1.c} ] } {
> + ? ?return -1
> +}
> +
> +set bp_location1 ?[gdb_get_line_number "set breakpoint 1 here"]
> +set bp_location7 ?[gdb_get_line_number "set breakpoint 7 here"]
> +set bp_location9 ?[gdb_get_line_number "set breakpoint 9 here" "$srcfile1"]
> +set bp_location19 [gdb_get_line_number "set breakpoint 19 here"]
> +set bp_location20 [gdb_get_line_number "set breakpoint 20 here"]
> +set bp_location21 [gdb_get_line_number "set breakpoint 21 here"]
> +
> +runto main
> +
> +if [target_info exists gdb,use_precord] {
> + ? ?# Activate process record/replay
> + ? ?gdb_test "record" "" "Turn on process record"
> + ? ?# FIXME: command ought to acknowledge, so we can test if it succeeded.
> +}
> +
> +# Verify that plain vanilla "until <location>" works.
> +#
> +gdb_test "until $bp_location1" \
> + ? ?"main .* at .*:$bp_location1.*" \
> + ? ?"until line number"
> +
> +# Advance up to factorial, outer invocation
> +#
> +gdb_test "advance factorial" \
> + ? ?"factorial .value=6..*$srcfile:$bp_location7.*" \
> + ? ?"advance to factorial"
> +
> +# At this point, 'until' should continue the inferior up to when all the
> +# inner invocations of factorial() are completed and we are back at this
> +# frame.
> +#
> +gdb_test "until $bp_location19" \
> + ? ?"factorial .value=720.*${srcfile}:$bp_location19.*" \
> + ? ?"until factorial, recursive function"
> +
> +# Finish out to main scope
> +#
> +gdb_test "finish" \
> + ? ?" in main .*$srcfile:$bp_location1.*" \
> + ? ?"finish to main"
> +
> +# Advance to a function called by main (marker2)
> +#
> +gdb_test "advance marker2" \
> + ? ?"marker2 .a=43.*$srcfile1:$bp_location9.*" \
> + ? ?"advance to marker2"
> +
> +# Now issue an until with another function, not called by the current
> +# frame, as argument. This should not work, i.e. the program should
> +# stop at main, the caller, where we put the 'guard' breakpoint.
> +#
> +set test_msg "until func, not called by current frame"
> +gdb_test_multiple "until marker3" "$test_msg" {
> + ? ?-re "main .*at .*${srcfile}:$bp_location20.*$gdb_prompt $" {
> + ? ? ? pass "$test_msg"
> + ? ?}
> + ? ?-re "main .*at .*${srcfile}:$bp_location21.*$gdb_prompt $" {
> + ? ? ? pass "$test_msg"
> + ? ?}
> +}
> +
> +###
> +###
> +###
> +
> +# Set reverse execution direction
> +# FIXME: command needs to acknowledge, so we can test if it succeeded.
> +
> +gdb_test "set exec-dir reverse" "" "set reverse execution"
> +
> +#
> +# We should now be at main, after the return from marker2.
> +# "Advance" backward into marker2.
> +#
> +
> +gdb_test "advance marker2" \
> + ? ?"marker2 .a=43.*$srcfile1:$bp_location9.*" \
> + ? ?"reverse-advance to marker2"
> +
> +# Finish out to main scope (backward)
> +
> +gdb_test "finish" \
> + ? ?" in main .*$srcfile:$bp_location20.*" \
> + ? ?"reverse-finish from marker2"
> +
> +# Advance backward to last line of factorial (outer invocation)
> +
> +gdb_test "advance $bp_location19" \
> + ? ?"factorial .value=720.*${srcfile}:$bp_location19.*" \
> + ? ?"reverse-advance to final return of factorial"
> +
> +# Now do "until" across the recursive calls,
> +# ending up in the same frame where we are now.
> +
> +gdb_test "until $bp_location7" \
> + ? ?"factorial .value=6..*$srcfile:$bp_location7.*" \
> + ? ?"reverse-until to entry of factorial"
> +
> +
> Index: gdb.reverse/until-reverse1.c
> ===================================================================
> RCS file: gdb.reverse/until-reverse1.c
> diff -N gdb.reverse/until-reverse1.c
> --- /dev/null ? 1 Jan 1970 00:00:00 -0000
> +++ gdb.reverse/until-reverse1.c ? ? ? ?24 Jun 2009 20:38:54 -0000
> @@ -0,0 +1,52 @@
> +/* This testcase is part of GDB, the GNU debugger.
> +
> + ? Copyright 1992, 1993, 1994, 1995, 1999, 2002, 2003, 2007, 2008
> + ? Free Software Foundation, Inc.
> +
> + ? This program is free software; you can redistribute it and/or modify
> + ? it under the terms of the GNU General Public License as published by
> + ? the Free Software Foundation; either version 3 of the License, or
> + ? (at your option) any later version.
> +
> + ? This program is distributed in the hope that it will be useful,
> + ? but WITHOUT ANY WARRANTY; without even the implied warranty of
> + ? MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. ?See the
> + ? GNU General Public License for more details.
> +
> + ? You should have received a copy of the GNU General Public License
> + ? along with this program. ?If not, see <http://www.gnu.org/licenses/>.
> +
> + ? Please email any bugs, comments, and/or additions to this file to:
> + ? bug-gdb@prep.ai.mit.edu ?*/
> +
> +/* The code for this file was extracted from the gdb testsuite
> + ? testcase "break.c". */
> +
> +/* The following functions do nothing useful. ?They are included
> + ? simply as places to try setting breakpoints at. ?They are
> + ? explicitly "one-line functions" to verify that this case works
> + ? (some versions of gcc have or have had problems with this).
> +
> + ? These functions are in a separate source file to prevent an
> + ? optimizing compiler from inlining them and optimizing them away. */
> +
> +#ifdef PROTOTYPES
> +int marker1 (void) { return (0); } ? ? /* set breakpoint 15 here */
> +int marker2 (int a) { return (1); } ? ?/* set breakpoint 8 here */
> +void marker3 (char *a, char *b) {} ? ? /* set breakpoint 17 here */
> +void marker4 (long d) {} ? ? ? ? ? ? ? /* set breakpoint 14 here */
> +#else
> +int marker1 () { return (0); } ? ? ? ? /* set breakpoint 16 here */
> +int marker2 (a) int a; { return (1); } /* set breakpoint 9 here */
> +void marker3 (a, b) char *a, *b; {} ? ?/* set breakpoint 18 here */
> +void marker4 (d) long d; {} ? ? ? ? ? ?/* set breakpoint 13 here */
> +#endif
> +
> +/* A structure we use for field name completion tests. ?*/
> +struct some_struct
> +{
> + ?int a_field;
> + ?int b_field;
> +};
> +
> +struct some_struct values[50];
> Index: gdb.reverse/watch-reverse.c
> ===================================================================
> RCS file: gdb.reverse/watch-reverse.c
> diff -N gdb.reverse/watch-reverse.c
> --- /dev/null ? 1 Jan 1970 00:00:00 -0000
> +++ gdb.reverse/watch-reverse.c 24 Jun 2009 20:38:54 -0000
> @@ -0,0 +1,222 @@
> +/* This testcase is part of GDB, the GNU debugger.
> +
> + ? Copyright 2008, 2009
> + ? Free Software Foundation, Inc.
> +
> + ? This program is free software; you can redistribute it and/or modify
> + ? it under the terms of the GNU General Public License as published by
> + ? the Free Software Foundation; either version 3 of the License, or
> + ? (at your option) any later version.
> +
> + ? This program is distributed in the hope that it will be useful,
> + ? but WITHOUT ANY WARRANTY; without even the implied warranty of
> + ? MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. ?See the
> + ? GNU General Public License for more details.
> +
> + ? You should have received a copy of the GNU General Public License
> + ? along with this program. ?If not, see <http://www.gnu.org/licenses/>.
> +
> + ? Please email any bugs, comments, and/or additions to this file to:
> + ? bug-gdb@prep.ai.mit.edu ?*/
> +
> +#include <stdio.h>
> +#include <unistd.h>
> +/*
> + * ? ? 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;
> +
> +char *global_ptr;
> +
> +void marker1 ()
> +{
> +}
> +
> +void marker2 ()
> +{
> +}
> +
> +void marker4 ()
> +{
> +}
> +
> +void marker5 ()
> +{
> +}
> +
> +void marker6 ()
> +{
> +}
> +
> +#ifdef PROTOTYPES
> +void recurser (int ?x)
> +#else
> +void recurser (x) int ?x;
> +#endif
> +{
> + ?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;
> +}
> +
> +void
> +func3 ()
> +{
> + ?int x;
> + ?int y;
> +
> + ?x = 0;
> + ?x = 1; ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? /* second x assignment */
> + ?y = 1;
> + ?y = 2;
> +}
> +
> +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;
> +}
> +
> +void
> +func4 ()
> +{
> + ?buf[0] = 3;
> + ?global_ptr = buf;
> + ?buf[0] = 7;
> +}
> +
> +int main ()
> +{
> +#ifdef usestubs
> + ?set_debug_traps();
> + ?breakpoint();
> +#endif
> + ?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 ();
> +
> + ?func3 ();
> +
> + ?func4 ();
> +
> + ?return 0;
> +}
> Index: gdb.reverse/watch-reverse.exp
> ===================================================================
> RCS file: gdb.reverse/watch-reverse.exp
> diff -N gdb.reverse/watch-reverse.exp
> --- /dev/null ? 1 Jan 1970 00:00:00 -0000
> +++ gdb.reverse/watch-reverse.exp ? ? ? 24 Jun 2009 20:38:54 -0000
> @@ -0,0 +1,131 @@
> +# Copyright 2008, 2009 Free Software Foundation, Inc.
> +
> +# This program is free software; you can redistribute it and/or modify
> +# it under the terms of the GNU General Public License as published by
> +# the Free Software Foundation; either version 3 of the License, or
> +# (at your option) any later version.
> +#
> +# This program is distributed in the hope that it will be useful,
> +# but WITHOUT ANY WARRANTY; without even the implied warranty of
> +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. ?See the
> +# GNU General Public License for more details.
> +#
> +# You should have received a copy of the GNU General Public License
> +# along with this program. ?If not, see <http://www.gnu.org/licenses/>.
> +
> +# Please email any bugs, comments, and/or additions to this file to:
> +# bug-gdb@prep.ai.mit.edu
> +
> +# Based on a file written by Fred Fish. (fnf@cygnus.com)
> +
> +#
> +# Test reverse debugging with watchpoints
> +#
> +
> +if ![target_info exists gdb,can_reverse] {
> + ? ?return
> +}
> +
> +set testfile "watch-reverse"
> +set srcfile ${testfile}.c
> +set binfile ${objdir}/${subdir}/${testfile}
> +
> +if { [prepare_for_testing $testfile.exp $testfile $srcfile] } {
> + ? ?return -1
> +}
> +
> +runto main
> +
> +if [target_info exists gdb,use_precord] {
> + ? ?# Activate process record/replay
> + ? ?gdb_test "record" "" "Turn on process record"
> + ? ?# FIXME: command ought to acknowledge, so we can test if it succeeded.
> +}
> +
> +# Only software watchpoints can be used in reverse
> +gdb_test "set can-use-hw-watchpoints 0" "" ""
> +
> +gdb_test "break marker1" \
> + ? ?"Breakpoint $decimal at $hex: file .*$srcfile, line $decimal.*" \
> + ? ?"set breakpoint at marker1"
> +
> +gdb_test "break marker2" \
> + ? ?"Breakpoint $decimal at $hex: file .*$srcfile, line $decimal.*" \
> + ? ?"set breakpoint at marker2"
> +
> +gdb_continue_to_breakpoint "marker1" ".*/$srcfile:.*"
> +
> +gdb_test "watch ival3" \
> + ? ?".*\[Ww\]atchpoint $decimal: ival3.*" \
> + ? ?"set watchpoint on ival3"
> +
> +# Continue until first change, from -1 to 0
> +
> +gdb_test "continue" \
> + ? ?".*\[Ww\]atchpoint.*ival3.*Old value = -1.*New value = 0.*ival3 =
> count; ival4 = count;.*" \
> + ? ?"watchpoint hit, first time"
> +
> +# Continue until the next change, from 0 to 1.
> +gdb_test "continue" \
> + ? ?".*\[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 "continue" \
> + ? ?".*\[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 "continue" \
> + ? ?".*\[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 "continue" \
> + ? ?".*\[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_continue_to_breakpoint "marker2" ".*/$srcfile:.*"
> +
> +###
> +###
> +###
> +
> +# FIXME 'set exec-dir' command should give some output so we can test.
> +gdb_test "set exec-direction reverse" "" "set reverse"
> +
> +# Reverse until the previous change, from 4 to 3
> +# Note that this one is outside the loop
> +
> +gdb_test "continue" \
> + ? ?".*\[Ww\]atchpoint.*ival3.*Old value = 4.*New value = 3.*ival3 = count;
> ival4 = count;.*" \
> + ? ?"watchpoint hit in reverse, first time"
> +
> +# Reverse until the previous change, from 3 to 2.
> +gdb_test "continue" \
> + ? ?".*\[Ww\]atchpoint.*ival3.*Old value = 3.*New value = 2.*ival3 = count;
> ival4 = count;.*" \
> + ? ?"watchpoint hit in reverse, second time"
> +
> +# Reverse until the previous change, from 2 to 1.
> +gdb_test "continue" \
> + ? ?".*\[Ww\]atchpoint.*ival3.*Old value = 2.*New value = 1.*ival3 = count;
> ival4 = count;.*" \
> + ? ?"watchpoint hit in reverse, third time"
> +
> +# Reverse until the previous change, from 1 to 0.
> +gdb_test "continue" \
> + ? ?".*\[Ww\]atchpoint.*ival3.*Old value = 1.*New value = 0.*ival3 = count;
> ival4 = count;.*" \
> + ? ?"watchpoint hit in reverse, fourth time"
> +
> +# Reverse until first change, from 0 to -1
> +
> +gdb_test "continue" \
> + ? ?".*\[Ww\]atchpoint.*ival3.*Old value = 0.*New value = -1.*ival3 =
> count; ival4 = count;.*" \
> + ? ?"watchpoint hit in reverse, fifth time"
> +
> +
> +return 0
>
>


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]