gdb/testsuite/gdb.trace/limits.exp - binutils-gdb - Git at Google

 # Copyright 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 [istarget "m68k-*-elf"] then {
     pass "Test not supported on this target"
     return;
 }

 load_lib "trace-support.exp"

 if $tracelevel then {
 	strace $tracelevel
 }

 set prms_id 0
 set bug_id 0

 set testfile "limits"
 set srcfile ${testfile}.c
 set binfile $objdir/$subdir/$testfile

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

 # Tests:
 # 1) Meet and exceed artificial limit on number of tracepoints
 # 2) Meet and exceed artificial limit on number of memranges
 # 3) Meet and exceed artificial limit on bytes  of bytecode data
 # [NOTE: number four is moved out into its own separate test module.]
 # 4) Meet and exceed artificial limit on bytes  of trace buffer storage
 #    (circular and non-circular modes).  However note that a more
 #    thorough test of the circular mode can be made separately.

 set cr "\[\r\n\]+"

 proc gdb_tracepoint_limit_test { } {
     global gdb_prompt
     global cr

     # Make sure we're in a sane starting state.
     gdb_test "tstop" "" ""
     gdb_test "tfind none" "" ""
     gdb_delete_tracepoints

     # Set three tracepoints
     gdb_test "trace foo" \
 	    "Tracepoint \[0-9\]+ at .*" \
 	    "tracepoint limit test: set first tracepoint"

     gdb_test "trace bar" \
 	    "Tracepoint \[0-9\]+ at .*" \
 	    "tracepoint limit test: set second tracepoint"

     gdb_test "trace baz" \
 	    "Tracepoint \[0-9\]+ at .*" \
 	    "tracepoint limit test: set third tracepoint"

     # Set secret artificial tracepoint limit to four
     gdb_test "maint packet QTLimit:tp:4" \
 	    "received: .OK." \
 	    "tracepoint limit test: set limit to four"

     # Now sending three tracepoints should succeed.
     send_gdb "tstart\n"
     gdb_expect {
 	-re "$cr$gdb_prompt" {
 	    pass "tracepoint limit test: send fewer than limit"
 	}
 	default {
 	    fail "tracepoint limit test: send fewer than limit"
 	}
     }

     # Set secret artificial tracepoint limit to three
     gdb_test "maint packet QTLimit:tp:3" \
 	    "received: .OK." \
 	    "tracepoint limit test: set limit to three"

     # Now sending three tracepoints should still succeed.
     send_gdb "tstart\n"
     gdb_expect {
 	-re "$cr$gdb_prompt" {
 	    pass "tracepoint limit test: send equal to limit"
 	}
 	default {
 	    fail "tracepoint limit test: send equal to limit"
 	}
     }

     # Set secret artificial tracepoint limit to two
     gdb_test "maint packet QTLimit:tp:2" \
 	    "received: .OK." \
 	    "tracepoint limit test: set limit to two"

     # Now sending three tracepoints should fail.
     gdb_test "tstart" \
 	    ".*\[Ee\]rror.*" \
 	    "tracepoint limit test: send more than limit"

     # Clean up:
     gdb_test "tstop" "" ""
     gdb_test "maint packet QTLimit:tp:FFFFFFFF" "" ""
 }

 proc gdb_memrange_limit_test { } {
     global gdb_prompt
     global cr

     # Make sure we're in a sane starting state.
     gdb_test "tstop" "" ""
     gdb_test "tfind none" "" ""
     gdb_delete_tracepoints

     # Set three tracepoints, and make 'em collect memranges
     gdb_test "trace foo" \
 	    "Tracepoint \[0-9\]+ at .*" \
 	    "memrange limit test: set first tracepoint"

     gdb_trace_setactions "memrange limit test: set first actions" \
 	    "" \
 	    "collect \$arg" "^$"

     gdb_test "trace bar" \
 	    "Tracepoint \[0-9\]+ at .*" \
 	    "memrange limit test: set second tracepoint"

     gdb_trace_setactions "memrange limit test: set second actions" \
 	    "" \
 	    "collect \$arg" "^$"

     gdb_test "trace baz" \
 	    "Tracepoint \[0-9\]+ at .*" \
 	    "memrange limit test: set third tracepoint"

     gdb_trace_setactions "memrange limit test: set third actions" \
 	    "" \
 	    "collect \$arg" "^$"

     # Set secret artificial memrange limit to four
     gdb_test "maint packet QTLimit:memrange:4" \
 	    "received: .OK." \
 	    "memrange limit test: set limit to four"

     # Now sending three memranges should still succeed.
     send_gdb "tstart\n"
     gdb_expect {
 	-re "$cr$gdb_prompt" {
 	    pass "memrange limit test: send fewer than limit"
 	}
 	default {
 	    fail "memrange limit test: send fewer than limit"
 	}
     }

     # Set secret artificial memrange limit to three
     gdb_test "maint packet QTLimit:memrange:3" \
 	    "received: .OK." \
 	    "memrange limit test: set limit to three"

     # Now sending three memranges should still succeed.
     send_gdb "tstart\n"
     gdb_expect {
 	-re "$cr$gdb_prompt" {
 	    pass "memrange limit test: send equal to limit"
 	}
 	default {
 	    fail "memrange limit test: send equal to limit"
 	}
     }

     # Set secret artificial memrange limit to two
     gdb_test "maint packet QTLimit:memrange:2" \
 	    "received: .OK." \
 	    "memrange limit test: set limit to two"

     # Now sending three memranges should fail.
     gdb_test "tstart" \
 	    ".*\[Ee\]rror.*" \
 	    "memrange limit test: send more than limit"

     # Clean up:
     gdb_test "tstop" "" ""
     gdb_test "maint packet QTLimit:memrange:FFFFFFFF" "" ""
 }


 proc gdb_bytecode_limit_test { } {
     global gdb_prompt
     global cr

     # Make sure we're in a sane starting state.
     gdb_test "tstop" "" ""
     gdb_test "tfind none" "" ""
     gdb_delete_tracepoints

     # Set three tracepoints
     gdb_test "trace foo" \
 	    "Tracepoint \[0-9\]+ at .*" \
 	    "bytecode limit test: set first tracepoint"

     gdb_trace_setactions "bytecode limit test: set first actions" \
 	    "" \
 	    "collect x + n" "^$"

     gdb_test "trace bar" \
 	    "Tracepoint \[0-9\]+ at .*" \
 	    "bytecode limit test: set second tracepoint"

     gdb_trace_setactions "bytecode limit test: set second actions" \
 	    "" \
 	    "collect y + n" "^$"

     gdb_test "trace baz" \
 	    "Tracepoint \[0-9\]+ at .*" \
 	    "bytecode limit test: set third tracepoint"

     gdb_trace_setactions "bytecode limit test: set third actions" \
 	    "" \
 	    "collect z + n" "^$"

     # Set secret artificial bytecode limit to a large number
     gdb_test "maint packet QTLimit:bytecode:400" \
 	    "received: .OK." \
 	    "bytecode limit test: set limit to large"

     # Now sending three bytecodes should still succeed.
     send_gdb "tstart\n"
     gdb_expect {
 	-re "$cr$gdb_prompt" {
 	    pass "bytecode limit test: send fewer than limit"
 	}
 	default {
 	    fail "bytecode limit test: send fewer than limit"
 	}
     }

     # Set secret artificial bytecode limit to a small number
     gdb_test "maint packet QTLimit:bytecode:40" \
 	    "received: .OK." \
 	    "bytecode limit test: set limit to small"

     # Now sending three bytecodes should fail.
     gdb_test "tstart" \
 	    ".*\[Ee\]rror.*" \
 	    "bytecode limit test: send more than limit"


     # Clean up:
     gdb_test "tstop" "" ""
     gdb_test "maint packet QTLimit:bytecode:FFFFFFFF" "" ""
 }

 proc gdb_trace_limits_tests { } {
     global gdb_prompt

     # We generously give ourselves one "pass" if we successfully
     # detect that this test cannot be run on this target!

     if { ![gdb_target_supports_trace] } then {
 	pass "Current target does not supporst trace"
 	return 1;
     }

     if [gdb_test "maint packet QTLimit:tp:ffffffff" \
 	    "received: .OK." ""] then {
 	pass "This test cannot be run on this target"
 	return 1;
     }

     if [gdb_test "maint packet QTLimit:memrange:ffffffff" \
 	    "received: .OK." ""] then {
 	pass "This test cannot be run on this target"
 	return 1;
     }

     if [gdb_test "maint packet QTLimit:bytecode:ffffffff" \
 	    "received: .OK." ""] then {
 	pass "This test cannot be run on this target"
 	return;
     }

     gdb_tracepoint_limit_test
     gdb_memrange_limit_test
     gdb_bytecode_limit_test
 }

 # Start with a fresh gdb.

 gdb_exit
 gdb_start
 gdb_reinitialize_dir $srcdir/$subdir
 gdb_load $binfile

 if [target_info exists gdb_stub] {
     gdb_step_for_stub;
 }
 # Body of test encased in a proc so we can return prematurely.
 gdb_trace_limits_tests
	# Copyright 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 [istarget "m68k-*-elf"] then {
	pass "Test not supported on this target"
	return;
	}

	load_lib "trace-support.exp"

	if $tracelevel then {
	strace $tracelevel
	}

	set prms_id 0
	set bug_id 0

	set testfile "limits"
	set srcfile ${testfile}.c
	set binfile $objdir/$subdir/$testfile

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

	# Tests:
	# 1) Meet and exceed artificial limit on number of tracepoints
	# 2) Meet and exceed artificial limit on number of memranges
	# 3) Meet and exceed artificial limit on bytes of bytecode data
	# [NOTE: number four is moved out into its own separate test module.]
	# 4) Meet and exceed artificial limit on bytes of trace buffer storage
	# (circular and non-circular modes). However note that a more
	# thorough test of the circular mode can be made separately.

	set cr "\[\r\n\]+"

	proc gdb_tracepoint_limit_test { } {
	global gdb_prompt
	global cr

	# Make sure we're in a sane starting state.
	gdb_test "tstop" "" ""
	gdb_test "tfind none" "" ""
	gdb_delete_tracepoints

	# Set three tracepoints
	gdb_test "trace foo" \
	"Tracepoint \[0-9\]+ at .*" \
	"tracepoint limit test: set first tracepoint"

	gdb_test "trace bar" \
	"Tracepoint \[0-9\]+ at .*" \
	"tracepoint limit test: set second tracepoint"

	gdb_test "trace baz" \
	"Tracepoint \[0-9\]+ at .*" \
	"tracepoint limit test: set third tracepoint"

	# Set secret artificial tracepoint limit to four
	gdb_test "maint packet QTLimit:tp:4" \
	"received: .OK." \
	"tracepoint limit test: set limit to four"

	# Now sending three tracepoints should succeed.
	send_gdb "tstart\n"
	gdb_expect {
	-re "$cr$gdb_prompt" {
	pass "tracepoint limit test: send fewer than limit"
	}
	default {
	fail "tracepoint limit test: send fewer than limit"
	}
	}

	# Set secret artificial tracepoint limit to three
	gdb_test "maint packet QTLimit:tp:3" \
	"received: .OK." \
	"tracepoint limit test: set limit to three"

	# Now sending three tracepoints should still succeed.
	send_gdb "tstart\n"
	gdb_expect {
	-re "$cr$gdb_prompt" {
	pass "tracepoint limit test: send equal to limit"
	}
	default {
	fail "tracepoint limit test: send equal to limit"
	}
	}

	# Set secret artificial tracepoint limit to two
	gdb_test "maint packet QTLimit:tp:2" \
	"received: .OK." \
	"tracepoint limit test: set limit to two"

	# Now sending three tracepoints should fail.
	gdb_test "tstart" \
	".\[Ee\]rror." \
	"tracepoint limit test: send more than limit"

	# Clean up:
	gdb_test "tstop" "" ""
	gdb_test "maint packet QTLimit:tp:FFFFFFFF" "" ""
	}

	proc gdb_memrange_limit_test { } {
	global gdb_prompt
	global cr

	# Make sure we're in a sane starting state.
	gdb_test "tstop" "" ""
	gdb_test "tfind none" "" ""
	gdb_delete_tracepoints

	# Set three tracepoints, and make 'em collect memranges
	gdb_test "trace foo" \
	"Tracepoint \[0-9\]+ at .*" \
	"memrange limit test: set first tracepoint"

	gdb_trace_setactions "memrange limit test: set first actions" \
	"" \
	"collect \$arg" "^$"

	gdb_test "trace bar" \
	"Tracepoint \[0-9\]+ at .*" \
	"memrange limit test: set second tracepoint"

	gdb_trace_setactions "memrange limit test: set second actions" \
	"" \
	"collect \$arg" "^$"

	gdb_test "trace baz" \
	"Tracepoint \[0-9\]+ at .*" \
	"memrange limit test: set third tracepoint"

	gdb_trace_setactions "memrange limit test: set third actions" \
	"" \
	"collect \$arg" "^$"

	# Set secret artificial memrange limit to four
	gdb_test "maint packet QTLimit:memrange:4" \
	"received: .OK." \
	"memrange limit test: set limit to four"

	# Now sending three memranges should still succeed.
	send_gdb "tstart\n"
	gdb_expect {
	-re "$cr$gdb_prompt" {
	pass "memrange limit test: send fewer than limit"
	}
	default {
	fail "memrange limit test: send fewer than limit"
	}
	}

	# Set secret artificial memrange limit to three
	gdb_test "maint packet QTLimit:memrange:3" \
	"received: .OK." \
	"memrange limit test: set limit to three"

	# Now sending three memranges should still succeed.
	send_gdb "tstart\n"
	gdb_expect {
	-re "$cr$gdb_prompt" {
	pass "memrange limit test: send equal to limit"
	}
	default {
	fail "memrange limit test: send equal to limit"
	}
	}

	# Set secret artificial memrange limit to two
	gdb_test "maint packet QTLimit:memrange:2" \
	"received: .OK." \
	"memrange limit test: set limit to two"

	# Now sending three memranges should fail.
	gdb_test "tstart" \
	".\[Ee\]rror." \
	"memrange limit test: send more than limit"

	# Clean up:
	gdb_test "tstop" "" ""
	gdb_test "maint packet QTLimit:memrange:FFFFFFFF" "" ""
	}


	proc gdb_bytecode_limit_test { } {
	global gdb_prompt
	global cr

	# Make sure we're in a sane starting state.
	gdb_test "tstop" "" ""
	gdb_test "tfind none" "" ""
	gdb_delete_tracepoints

	# Set three tracepoints
	gdb_test "trace foo" \
	"Tracepoint \[0-9\]+ at .*" \
	"bytecode limit test: set first tracepoint"

	gdb_trace_setactions "bytecode limit test: set first actions" \
	"" \
	"collect x + n" "^$"

	gdb_test "trace bar" \
	"Tracepoint \[0-9\]+ at .*" \
	"bytecode limit test: set second tracepoint"

	gdb_trace_setactions "bytecode limit test: set second actions" \
	"" \
	"collect y + n" "^$"

	gdb_test "trace baz" \
	"Tracepoint \[0-9\]+ at .*" \
	"bytecode limit test: set third tracepoint"

	gdb_trace_setactions "bytecode limit test: set third actions" \
	"" \
	"collect z + n" "^$"

	# Set secret artificial bytecode limit to a large number
	gdb_test "maint packet QTLimit:bytecode:400" \
	"received: .OK." \
	"bytecode limit test: set limit to large"

	# Now sending three bytecodes should still succeed.
	send_gdb "tstart\n"
	gdb_expect {
	-re "$cr$gdb_prompt" {
	pass "bytecode limit test: send fewer than limit"
	}
	default {
	fail "bytecode limit test: send fewer than limit"
	}
	}

	# Set secret artificial bytecode limit to a small number
	gdb_test "maint packet QTLimit:bytecode:40" \
	"received: .OK." \
	"bytecode limit test: set limit to small"

	# Now sending three bytecodes should fail.
	gdb_test "tstart" \
	".\[Ee\]rror." \
	"bytecode limit test: send more than limit"


	# Clean up:
	gdb_test "tstop" "" ""
	gdb_test "maint packet QTLimit:bytecode:FFFFFFFF" "" ""
	}

	proc gdb_trace_limits_tests { } {
	global gdb_prompt

	# We generously give ourselves one "pass" if we successfully
	# detect that this test cannot be run on this target!

	if { ![gdb_target_supports_trace] } then {
	pass "Current target does not supporst trace"
	return 1;
	}

	if [gdb_test "maint packet QTLimit:tp:ffffffff" \
	"received: .OK." ""] then {
	pass "This test cannot be run on this target"
	return 1;
	}

	if [gdb_test "maint packet QTLimit:memrange:ffffffff" \
	"received: .OK." ""] then {
	pass "This test cannot be run on this target"
	return 1;
	}

	if [gdb_test "maint packet QTLimit:bytecode:ffffffff" \
	"received: .OK." ""] then {
	pass "This test cannot be run on this target"
	return;
	}

	gdb_tracepoint_limit_test
	gdb_memrange_limit_test
	gdb_bytecode_limit_test
	}

	# Start with a fresh gdb.

	gdb_exit
	gdb_start
	gdb_reinitialize_dir $srcdir/$subdir
	gdb_load $binfile

	if [target_info exists gdb_stub] {
	gdb_step_for_stub;
	}
	# Body of test encased in a proc so we can return prematurely.
	gdb_trace_limits_tests