gdb_exit
if [mi_gdb_start] {
- continue
+ return
}
mi_delete_breakpoints
gdb_exit
if [mi_gdb_start] {
- continue
+ return
}
mi_delete_breakpoints
gdb_exit
if [mi_gdb_start] {
- continue
+ return
}
mi_delete_breakpoints
if ![runto_main] then {
perror "couldn't run to breakpoint"
- continue
+ return
}
gdb_test "next" "return 0;" "continuing after dummy()"
if ![runto_main] then {
perror "couldn't run to breakpoint"
- continue
+ return
}
#
if ![runto_main] then {
perror "couldn't run to breakpoint"
- continue
+ return
}
# First, print the array without the indexes
if ![runto_main] then {
perror "couldn't run to breakpoint"
- continue
+ return
}
gdb_test "next" "return 0;" "continuing after dummy()"
#
if ![runto_main] then {
perror "couldn't run to breakpoint"
- continue
+ return
}
gdb_test "break baz" ".*" ""
# This test only works on GNU/Linux.
if { ![isnative] || [is_remote host] || [use_gdb_stub]
|| ![istarget *-linux*] || [skip_shlib_tests]} {
- continue
+ return
}
load_lib prelink-support.exp
if ![runto_main] then {
perror "couldn't run to breakpoint"
- continue
+ return
}
# Run to the breakpoint at return.
"unknown" "ada" "modula-2" "pascal" "fortran"
}
if {[lsearch -exact $skip_langs $lang] >= 0} {
- continue
+ return
}
gdb_test_no_output "set language $lang"
if [target_info exists gdb,nosignals] {
verbose "Skipping because of nosignals."
- continue
+ return
}
# This test requires sending ^C to interrupt the running target.
if [target_info exists gdb,nosignals] {
verbose "Skipping branch-to-self.exp because of nosignals."
- continue
+ return
}
standard_testfile
# This test only works on GNU/Linux.
if { ![isnative] || [is_remote host] || [use_gdb_stub]
|| ![istarget *-linux*] || [skip_shlib_tests]} {
- continue
+ return
}
load_lib prelink-support.exp
# test.
if [target_info exists gdb,cannot_call_functions] {
unsupported "this target can not call functions"
- continue
+ return
}
# Create and source the file that provides information about the compiler
if ![runto_main] then {
perror "couldn't run to breakpoint"
- continue
+ return
}
get_debug_format
# test.
if [target_info exists gdb,cannot_call_functions] {
unsupported "this target can not call functions"
- continue
+ return
}
set skip_float_test [gdb_skip_float_test]
if ![runto_main] then {
perror "couldn't run to breakpoint"
- continue
+ return
}
if [target_info exists gdb,cannot_call_functions] {
unsupported "this target can not call functions"
- continue
+ return
}
standard_testfile .c
if [target_info exists gdb,nosignals] {
verbose "Skipping call-signal-resume.exp because of nosignals."
- continue
+ return
}
# test.
if [target_info exists gdb,cannot_call_functions] {
unsupported "this target can not call functions"
- continue
+ return
}
proc get_dummy_frame_number { } {
# test.
if [target_info exists gdb,cannot_call_functions] {
unsupported "this target can not call functions"
- continue
+ return
}
if ![runto_main] then {
perror "couldn't run to breakpoint"
- continue
+ return
}
set prev_timeout $timeout
# test.
if [target_info exists gdb,cannot_call_functions] {
unsupported "this target can not call functions"
- continue
+ return
}
# Start with a fresh gdb.
# test.
if [target_info exists gdb,cannot_call_functions] {
unsupported "this target can not call functions"
- continue
+ return
}
set skip_float_test [gdb_skip_float_test]
if {[target_info exists gdb,cannot_call_functions]} {
unsupported "this target can not call functions"
- continue
+ return
}
standard_testfile .c
# Until "catch fork" is implemented on other targets...
#
if { ![istarget "*-*-linux*"] && ![istarget "*-*-openbsd*"] } then {
- continue
+ return
}
# Reusing foll-fork.c since it's a simple forking program.
if [target_info exists gdb,nosignals] {
verbose "Skipping catch-signal-fork.exp because of nosignals."
- continue
+ return
}
standard_testfile
if [target_info exists gdb,nosignals] {
verbose "Skipping catch-signal.exp because of nosignals."
- continue
+ return
}
standard_testfile
# other targets...
#
if {![istarget "*-*-linux*"]} then {
- continue
+ return
}
# Checkpoint support is currently implemented in the Linux native
# target, so only works with "target native".
if { [target_info gdb_protocol] != "" } {
- continue
+ return
}
# Must name the source file explicitly, otherwise when driven by
if ![runto_main] then {
perror "couldn't run to breakpoint"
- continue
+ return
}
gdb_test "print (2 ? 3 : 4)" "\[0-9\]* = 3" \
if ![runto_main] then {
perror "couldn't run to breakpoint"
- continue
+ return
}
set is_stmt [is_stmt_addresses $srcfile]
#
if ![runto_main] then {
perror "couldn't run to breakpoint"
- continue
+ return
}
get_debug_format
#
if ![runto_main] then {
perror "couldn't run to breakpoint"
- continue
+ return
}
# test vars and pointers
if [target_info exists gdb,cannot_call_functions] {
unsupported "this target can not call functions"
- continue
+ return
}
# We need to up this because this can be really slow on some boards.
if ![runto_main] then {
perror "couldn't run to breakpoint"
- continue
+ return
}
set sizeof_long [get_sizeof "long" 4]
# This test exercises disassemble /s with optimized and inlined code.
if { ![is_amd64_regs_target] } {
- continue
+ return
}
standard_testfile .S
if ![runto_main] then {
perror "could not run to main"
- continue
+ return
}
gdb_test "break call_me if param.e == 1" \
if ![runto_main] then {
perror "couldn't run to breakpoint"
- continue
+ return
}
gdb_test_no_output "set variable x=14" "set variable x=14"
if ![runto_main] then {
perror "couldn't run to breakpoint"
- continue
+ return
}
gdb_continue_to_end
if { [target_info exists gdb,nosignals] } {
verbose "Skipping exitsignal.exp because of nosignals."
- continue
+ return
}
standard_testfile segv.c
if ![runto_main] then {
perror "couldn't run to breakpoint"
- continue
+ return
}
proc test_expr { args } {
if [target_info exists gdb,nofileio] {
verbose "Skipping fileio.exp because of no fileio capabilities."
- continue
+ return
}
if ![runto_main] then {
perror "couldn't run to breakpoint"
- continue
+ return
}
gdb_test "break stop" "Breakpoint .*$srcfile.*"
if ![runto_main] then {
perror "couldn't run to breakpoint"
- continue
+ return
}
# Test "info float".
if ![runto_main] then {
perror "couldn't run to breakpoint"
- continue
+ return
}
# Run to the breakpoint at return.
if ![runto_main] then {
perror "couldn't run to breakpoint"
- continue
+ return
}
# Run to the breakpoint at return.
# required for follow-exec-mode testing.
if { [target_info exists gdb_protocol]
&& [target_info gdb_protocol] == "remote" } {
- continue
+ return
}
# Until "catch exec" is implemented on other targets...
#
if {![istarget "*-linux*"]} then {
- continue
+ return
}
standard_testfile foll-exec-mode.c
# Until "catch exec" is implemented on other targets...
#
if { ![istarget "*-linux*"] } then {
- continue
+ return
}
standard_testfile foll-exec.c
clean_restart ${binfile}
if ![runto abort {allow-pending}] then {
- continue
+ return
}
# See http://sources.redhat.com/gdb/bugs/1250
if ![runto_main] then {
perror "couldn't run to breakpoint"
- continue
+ return
}
gdb_test "print /x bar" "{x__0 = 0x0, y__0 = 0x0, z__1 = 0x0}"
if [target_info exists gdb,cannot_call_functions] {
unsupported "can not call functions"
- continue
+ return
}
if {[prepare_for_testing "failed to prepare" $testfile $srcfile debug]} {
#
if { ![istarget "*-*-linux*"] } then {
unsupported "inferior-died.exp"
- continue
+ return
}
if { ![support_displaced_stepping] } {
if [target_info exists gdb,nosignals] {
verbose "Skipping interrupt-daemon-attach.exp because of nosignals."
- continue
+ return
}
# This test requires sending ^C to interrupt the running target.
if [target_info exists gdb,nointerrupts] {
verbose "Skipping interrupt.exp because of nointerrupts."
- continue
+ return
}
if [target_info exists gdb,noinferiorio] {
if [target_info exists gdb,nosignals] {
verbose "Skipping kill-after-signal.exp because of nosignals."
- continue
+ return
}
if [prepare_for_testing "failed to prepare" ${testfile}] {
if ![runto_main] then {
perror "couldn't run to breakpoint"
- continue
+ return
}
proc evaluate { vars ops } {
#
if ![runto_main] then {
perror "couldn't run to breakpoint"
- continue
+ return
}
gdb_test "break marker1" ".*" ""
# other targets...
#
if { ![istarget "*-*-linux*"] } then {
- continue
+ return
}
clean_restart "${testcase}"
if ![runto_main] {
perror "could not run to main"
- continue
+ return
}
set bp_location [gdb_get_line_number "STOP" "${testcase}.c"]
clean_restart "${testcase}"
if ![runto_main] {
perror "could not run to main"
- continue
+ return
}
set bp_location [gdb_get_line_number "STOP" "${testcase}.c"]
clean_restart "${testcase}"
if ![runto_main] {
perror "could not run to main"
- continue
+ return
}
set bp_location [gdb_get_line_number "STOP" "${testcase}.c"]
if ![runto_main] then {
perror "couldn't run to breakpoint"
- continue
+ return
}
if ![runto_main] then {
perror "couldn't run to breakpoint"
- continue
+ return
}
gdb_test "print x = 45" "$decimal = 45" "set a global"
global gdb_spawn_id
if ![istarget *-linux*] {
- continue
+ return
}
# In remote mode we cannot use the 'set args' command, and this
# test requires it.
if { [target_info exists gdb_protocol] } then {
if { [target_info gdb_protocol] == "remote" } then {
- continue
+ return
}
}
if ![runto_main] then {
perror "couldn't run to breakpoint"
- continue
+ return
}
gdb_test "next " "more_code.*;" "continuing after dummy()"
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
-if { [skip_cplus_tests] } { continue }
+if { [skip_cplus_tests] } { return }
standard_testfile .c
if ![runto_main] then {
perror "couldn't run to breakpoint"
- continue
+ return
}
proc find_breakpoint_pc { sym } {
if [target_info exists gdb,cannot_call_functions] {
unsupported "this target can not call functions"
- continue
+ return
}
# We need to up this because this can be really slow on some boards.
if [target_info exists gdb,nosignals] {
verbose "Skipping catch-signal.exp because of nosignals."
- continue
+ return
}
# This test requires sending ^C to interrupt the running target.
if ![runto_main] then {
perror "couldn't run to breakpoint"
- continue
+ return
}
gdb_test "break fun_three" \
if ![runto_main] then {
perror "couldn't run to breakpoint"
- continue
+ return
}
#
if [target_info exists gdb,nosignals] {
verbose "Skipping relativedebug.exp because of nosignals."
- continue
+ return
}
standard_testfile .c
if [target_info exists gdb,nosignals] {
verbose "Skipping savedregs.exp because of nosignals."
- continue
+ return
}
if ![runto_main] then {
perror "couldn't run to breakpoint"
- continue
+ return
}
# Determine expected output for unsigned long variables,
if [target_info exists gdb,nosignals] {
verbose "Skipping sigall.exp because of nosignals."
- continue
+ return
}
standard_testfile
if [target_info exists gdb,nosignals] {
verbose "Skipping sigaltstack.exp because of nosignals."
- continue
+ return
}
if [target_info exists gdb,nosignals] {
verbose "Skipping sigbpt.exp because of nosignals."
- continue
+ return
}
if [target_info exists gdb,nosignals] {
verbose "Skipping sigchld.exp because of nosignals."
- continue
+ return
}
standard_testfile .c
if [target_info exists gdb,nosignals] {
verbose "Skipping siginfo-addr.exp because of nosignals."
- continue
+ return
}
standard_testfile
if [target_info exists gdb,nosignals] {
verbose "Skipping siginfo-infcall.exp because of nosignals."
- continue
+ return
}
standard_testfile .c
if [target_info exists gdb,nosignals] {
verbose "Skipping siginfo-obj.exp because of nosignals."
- continue
+ return
}
if { ![supports_get_siginfo_type] } {
if [target_info exists gdb,nosignals] {
verbose "Skipping siginfo-thread.exp because of nosignals."
- continue
+ return
}
if { ![supports_get_siginfo_type] } {
if [target_info exists gdb,nosignals] {
verbose "Skipping siginfo.exp because of nosignals."
- continue
+ return
}
if [target_info exists gdb,nosignals] {
verbose "Skipping signals.exp because of nosignals."
- continue
+ return
}
if [target_info exists gdb,nosignals] {
verbose "Skipping signull.exp because of nosignals."
- continue
+ return
}
if [target_info exists gdb,nosignals] {
verbose "Skipping sigrepeat.exp because of nosignals."
- continue
+ return
}
if [target_info exists gdb,nosignals] {
verbose "Skipping sigstep.exp because of nosignals."
- continue
+ return
}
if [target_info exists gdb,nosignals] {
verbose "Skipping $subdir/$gdb_test_file_name.exp because of nosignals."
- continue
+ return
}
# The testfile relies on "run" from the command line, so only works
# with "target native".
if { [target_info gdb_protocol] != "" } {
- continue
+ return
}
gdb_exit
if ![runto_main] then {
perror "couldn't run to breakpoint"
- continue
+ return
}
#
# This only works on GNU/Linux.
if { ![isnative] || [is_remote host] || ![istarget *-linux*]
|| [skip_shlib_tests]} {
- continue
+ return
}
set test "skip-solib"
if ![runto_main] then {
perror "couldn't run to breakpoint"
- continue
+ return
}
#
if [target_info exists gdb,cannot_call_functions] {
unsupported "this target can not call functions"
- continue
+ return
}
standard_testfile .c
}
if ![runto_main] then {
- continue
+ return
}
# Functions.
if [target_info exists gdb,nosignals] {
verbose "Skipping unwindonsignal.exp because of nosignals."
- continue
+ return
}
# test.
if [target_info exists gdb,cannot_call_functions] {
unsupported "this target can not call functions"
- continue
+ return
}
standard_testfile
if ![runto test] then {
perror "couldn't run to breakpoint"
- continue
+ return
}
gdb_test_stdio "print find_max1(5,1,2,3,4,5)" \
#
if ![runto_main] then {
perror "couldn't run to breakpoint"
- continue
+ return
}
get_debug_format
if ![runto_main] then {
perror "couldn't run to breakpoint"
- continue
+ return
}
#
# about the field or baseclass being ambiguous is emitted at the right
# times.
-if { [skip_cplus_tests] } { continue }
+if { [skip_cplus_tests] } { return }
standard_testfile .cc
if ![runto_main] then {
perror "couldn't run to breakpoint"
- continue
+ return
}
# Run to a breakpoint after the variables have been initialized so we
# This file is part of the gdb testsuite.
-if {[skip_cplus_tests]} { continue }
+if {[skip_cplus_tests]} { return }
standard_testfile .cc anon-ns2.cc
if {![runto_main]} {
perror "couldn't run to breakpoint"
- continue
+ return
}
set ans {(anonymous namespace)}
# This file was written by Sue Kimura (sue_kimura@hp.com)
# Rewritten by Michael Chastain (mec.gnu@mindspring.com)
-if { [skip_stl_tests] } { continue }
+if { [skip_stl_tests] } { return }
standard_testfile .cc
if ![runto_main] then {
perror "couldn't run to breakpoint"
- continue
+ return
}
# Set breakpoint on template function
#
-if { [skip_cplus_tests] } { continue }
+if { [skip_cplus_tests] } { return }
standard_testfile .cc casts03.cc
if ![runto_main] then {
perror "couldn't run to breakpoint"
- continue
+ return
}
# Prevent symbol on address 0x0 being printed.
if ![runto_main] then {
perror "couldn't run to breakpoint"
- continue
+ return
}
# Prevent symbol on address 0x0 being printed.
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
-if { [skip_cplus_tests] } { continue }
+if { [skip_cplus_tests] } { return }
standard_testfile .cc
if ![runto_main] then {
perror "couldn't run to main"
- continue
+ return
}
get_debug_format
# This file is part of the gdb testsuite.
-if {[skip_cplus_tests]} { continue }
+if {[skip_cplus_tests]} { return }
standard_testfile .cc
if {![runto_main]} {
perror "couldn't run to breakpoint"
- continue
+ return
}
# "x" sometimes isn't available due to
if ![runto_main] then {
perror "couldn't run to breakpoint main"
- continue
+ return
}
gdb_breakpoint [gdb_get_line_number "end of main"]
standard_testfile .cc
-if {[skip_cplus_tests]} { continue }
+if {[skip_cplus_tests]} { return }
if {[prepare_for_testing "failed to prepare" $testfile $srcfile {debug c++}] } {
return -1
if {![runto_main]} {
perror "could not run to main"
- continue
+ return
}
gdb_breakpoint [gdb_get_line_number "break here"]
# Call to template instantiations.
-if { [skip_cplus_tests] } { continue }
+if { [skip_cplus_tests] } { return }
standard_testfile cttiadd.cc cttiadd1.cc cttiadd2.cc cttiadd3.cc
if ![runto_main] then {
perror "couldn't run to breakpoint"
- continue
+ return
}
gdb_breakpoint [gdb_get_line_number "marker add1"]
# TODO: this needs more work before actually deploying it.
# So bail out here.
-if { [ test_compiler_info gcc-*] } then { continue }
+if { [ test_compiler_info gcc-*] } then { return }
gdb_test_multiple "print add<int>(2,2)" "print add<int>(2,2)" {
-re "\\$\[0-9\]+ = 4\r\n$gdb_prompt $" {
# Start program.
-if { [skip_cplus_tests] } { continue }
+if { [skip_cplus_tests] } { return }
load_lib "cp-support.exp"
if ![runto 'marker1'] then {
perror "couldn't run to marker1"
- continue
+ return
}
# Check inheritance of typedefs again, but this time with an active block.
# Now run to N::Derived::doit and get the type of "value_type"
if {![runto "N::Derived::doit"]} {
perror "couldn't run to N::Derived::doit"
- continue
+ return
}
gdb_test "ptype value_type" "type = int"
# Test that the disassembler correctly demangles C++ function names in
# it's header line.
-if {[skip_cplus_tests]} { continue }
+if {[skip_cplus_tests]} { return }
standard_testfile .cc
if ![runto_main] then {
perror "couldn't run to breakpoint"
- continue
+ return
}
proc check_disassembly_header { request expected } {
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
-if { [skip_cplus_tests] } { continue }
+if { [skip_cplus_tests] } { return }
standard_testfile .cc
if ![runto_main] then {
perror "couldn't run to main"
- continue
+ return
}
gdb_breakpoint [gdb_get_line_number "Break here"]
set ws "\[\r\n\t \]+"
set nl "\[\r\n\]+"
-if { [skip_stl_tests] } { continue }
+if { [skip_stl_tests] } { return }
standard_testfile .cc
}
if { !$ok } {
- continue
+ return
}
set name "info breakpoints (after inferior run)"
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
-if { [skip_cplus_tests] } { continue }
+if { [skip_cplus_tests] } { return }
standard_testfile .cc
if ![runto_main] then {
perror "couldn't run to main"
- continue
+ return
}
gdb_breakpoint [gdb_get_line_number "stop inside C"]
if ![runto_main] then {
perror "couldn't run to breakpoint main"
- continue
+ return
}
# Test that function calls done through function pointers
set ws "\[\r\n\t \]*"
set nl "\[\r\n\]+"
-if { [skip_cplus_tests] } { continue }
+if { [skip_cplus_tests] } { return }
#
# test running programs
if ![runto_main] then {
perror "couldn't run to main"
- continue
+ return
}
# See http://sources.redhat.com/gdb/bugs/1355
# This test is largely based of gdb.base/callfuncs.exp.
-if { [skip_cplus_tests] } { continue }
+if { [skip_cplus_tests] } { return }
if [target_info exists gdb,nosignals] {
verbose "Skipping gdb2495.exp because of nosignals."
- continue
+ return
}
standard_testfile .cc
# test.
if [target_info exists gdb,cannot_call_functions] {
unsupported "this target can not call functions"
- continue
+ return
}
if {[prepare_for_testing "failed to prepare" $testfile $srcfile {debug c++}]} {
if ![runto_main] then {
perror "couldn't run to main"
- continue
+ return
}
# See http://sourceware.org/gdb/bugs/2495
# Restart the inferior back at main.
if ![runto_main] then {
perror "couldn't run to main"
- continue
+ return
}
# Test expressions which assume an implicit "this" with a qualified
# name.
-if {[skip_cplus_tests]} { continue }
+if {[skip_cplus_tests]} { return }
standard_testfile .cc
# Run to D::f.
if {![runto_main]} {
perror "couldn't run to main"
- continue
+ return
}
gdb_breakpoint "D::f"
# This file is part of the gdb testsuite.
# It tests various aspects of iostream that have caused problems for gdb.
-if { [skip_cplus_tests] } { continue }
+if { [skip_cplus_tests] } { return }
standard_testfile .cc
if ![runto_main] {
perror "couldn't run to breakpoint"
- continue
+ return
}
# PR 18417
if ![runto_main] then {
perror "couldn't run to breakpoint main"
- continue
+ return
}
# Test that koenig lookup finds correct function
# test running programs
#
-if { [skip_cplus_tests] } { continue }
+if { [skip_cplus_tests] } { return }
standard_testfile .cc
#
if ![runto_main] then {
perror "couldn't run to breakpoint"
- continue
+ return
}
if ![runto 'marker1'] then {
perror "couldn't run to marker1"
- continue
+ return
}
gdb_test "up" ".*foobar.*" "up from marker1"
# This file is part of the gdb testsuite
-if { [skip_cplus_tests] } { continue }
+if { [skip_cplus_tests] } { return }
#
# test running programs
if ![runto_main] then {
perror "couldn't run to breakpoint"
- continue
+ return
}
# First, run to after we've constructed all the gnu_obj_N's:
# This file is part of the gdb testsuite
-if { [skip_cplus_tests] } { continue }
+if { [skip_cplus_tests] } { return }
#
# test running programs
if ![runto_main] then {
perror "couldn't run to breakpoint"
- continue
+ return
}
get_debug_format
# passed in registers. This test passes so many structures it is
# hoped that some will need to be placed onto the stack.
-if { [skip_cplus_tests] } { continue }
+if { [skip_cplus_tests] } { return }
standard_testfile .cc
if ![runto_main] {
perror "couldn't run to breakpoint"
- continue
+ return
}
gdb_breakpoint [gdb_get_line_number "break-here"]
# Test that breakpoints on C++ constructors work, despite the
# fact that gcc generates several versions of constructor function.
-if { [skip_cplus_tests] } { continue }
+if { [skip_cplus_tests] } { return }
standard_testfile .cc
if ![runto_main] then {
perror "couldn't run to breakpoint"
- continue
+ return
}
# Set a breakpoint with multiple locations
set vhn "\\$\[0-9\]+"
-if { [skip_cplus_tests] } { continue }
+if { [skip_cplus_tests] } { return }
standard_testfile .cc
if ![runto_main] then {
perror "couldn't run to breakpoint"
- continue
+ return
}
gdb_breakpoint [gdb_get_line_number "Breakpoint 1 here"]
lappend result [list "${method_name}($params)" $expect]
}
-if {[skip_cplus_tests]} { continue }
+if {[skip_cplus_tests]} { return }
# Tests for c++/12266 et al
standard_testfile .cc
if {![runto_main]} {
perror "couldn't run to breakpoint"
- continue
+ return
}
array set typedefs {
# test running programs
#
-if { [skip_cplus_tests] } { continue }
+if { [skip_cplus_tests] } { return }
standard_testfile .cc
#
if ![runto_main] then {
perror "couldn't run to breakpoint"
- continue
+ return
}
gdb_test "break A::foo" \
# This tests setting a break in an ambiguous c++ method with
# current_language set to c.
-if { [skip_cplus_tests] } { continue }
+if { [skip_cplus_tests] } { return }
standard_testfile .cc
if {![runto_main]} {
perror "couldn't run to breakpoint"
- continue
+ return
}
proc test_break { lang } {
# Do not run in environments which do not support C++.
if {[skip_cplus_tests]} {
- continue
+ return
}
# This test can only be run on x86-like targets which support DWARF.
if ![runto_main] then {
perror "couldn't run to breakpoint main"
- continue
+ return
}
gdb_test "print C::x" "= 5"
-if { [skip_cplus_tests] } { continue }
+if { [skip_cplus_tests] } { return }
standard_testfile .cc namespace1.cc
#
if ![runto_main] then {
perror "couldn't run to breakpoint"
- continue
+ return
}
if ![runto 'marker1'] then {
perror "couldn't run to marker1"
- continue
+ return
}
gdb_test "up" ".*main.*" "up from marker1"
if ![runto "C::D::marker2"] then {
perror "couldn't run to marker2"
- continue
+ return
}
gdb_test "print c" "\\$\[0-9\].* = 1"
# along with this program. If not, see <http://www.gnu.org/licenses/>.
-if { [skip_cplus_tests] } { continue }
+if { [skip_cplus_tests] } { return }
standard_testfile .cc
if ![runto_main] then {
perror "couldn't run to main"
- continue
+ return
}
if {![skip_unwinder_tests]} {
}
if {[skip_cplus_tests]} {
- continue
+ return
}
standard_testfile .cc nsalias-dw.S
if ![runto_main] then {
perror "couldn't run to breakpoint main"
- continue
+ return
}
############################################
if ![runto_main] then {
perror "couldn't run to breakpoint main"
- continue
+ return
}
gdb_test "print x" "\\$\[0-9\].* = 11"
############################################
if ![runto_main] then {
perror "couldn't run to breakpoint main"
- continue
+ return
}
gdb_test "print ab" "No symbol .* in current context." \
############################################
if ![runto_main] then {
perror "couldn't run to breakpoint main"
- continue
+ return
}
with_test_prefix "main scope" {
if ![runto_main] then {
perror "couldn't run to breakpoint main"
- continue
+ return
}
############################################
if ![runto_main] then {
perror "couldn't run to breakpoint main"
- continue
+ return
}
# Test global operator
if ![runto_main] then {
perror "couldn't run to breakpoint main"
- continue
+ return
}
gdb_breakpoint [gdb_get_line_number "end of main"]
# test running programs
#
-if { [skip_cplus_tests] } { continue }
+if { [skip_cplus_tests] } { return }
standard_testfile .cc
#
if {![runto_main]} {
perror "couldn't run to breakpoint"
- continue
+ return
}
# When I ask gdb to set a breakpoint on an overloaded function,
gdb_test "break ${class}::hibob if (a_param == 3)" "Breakpoint (\[0-9\]).*"
}
-if { [skip_cplus_tests] } { continue }
+if { [skip_cplus_tests] } { return }
# Test for c++/11734
standard_testfile ovsrch1.cc ovsrch2.cc ovsrch3.cc ovsrch4.cc
if {![runto_main]} {
perror "couldn't run to breakpoint"
- continue
+ return
}
# Break in A::stop_here and run tests.
if {[skip_cplus_tests]} {
untested "c++ test skipped"
- continue
+ return
}
standard_testfile .cc
if {[skip_cplus_tests]} {
untested "c++ test skipped"
- continue
+ return
}
# The program source is generated in the output directory.
# This file is part of the gdb testsuite.
-if { [skip_cplus_tests] } { continue }
+if { [skip_cplus_tests] } { return }
#
# test running programs
if ![runto_main] then {
perror "couldn't run to breakpoint"
- continue
+ return
}
gdb_test_multiple "break myClass::performBlocking" "break myClass::performBlocking" {
# This file is part of the gdb testsuite.
-if { [skip_cplus_tests] } { continue }
+if { [skip_cplus_tests] } { return }
#
# test running programs
if ![runto_main] then {
perror "couldn't run to breakpoint"
- continue
+ return
}
gdb_test "next" ".*return 0;" "step past initialization"
# This file is part of the gdb testsuite
-if { [skip_cplus_tests] } { continue }
+if { [skip_cplus_tests] } { return }
#
# test running programs
if ![runto_main] then {
perror "couldn't run to breakpoint"
- continue
+ return
}
# First, run to after we've constructed the object:
set nl "\[\r\n\]+"
-if { [skip_cplus_tests] } { continue }
+if { [skip_cplus_tests] } { return }
load_lib "cp-support.exp"
if ![runto_main] then {
perror "couldn't run to breakpoint"
- continue
+ return
}
# set a breakpoint at the return stmt
set nl "\[\r\n\]+"
-if { [skip_cplus_tests] } { continue }
+if { [skip_cplus_tests] } { return }
load_lib "cp-support.exp"
if ![runto_main] then {
perror "couldn't run to breakpoint"
- continue
+ return
}
gdb_test "print b" ".*same as static member.*"
# This file is part of the gdb testsuite.
-if { [skip_cplus_tests] } { continue }
+if { [skip_cplus_tests] } { return }
standard_testfile .cc
if ![runto_main] then {
perror "couldn't run to breakpoint"
- continue
+ return
}
gdb_breakpoint [gdb_get_line_number "set breakpoint here"]
# This file is part of the gdb testsuite
-if { [skip_cplus_tests] } { continue }
+if { [skip_cplus_tests] } { return }
#
# test running programs
if ![runto_main] then {
perror "couldn't run to breakpoint"
- continue
+ return
}
# First, run to after we've constructed the object:
# test running programs
#
-if { [skip_cplus_tests] } { continue }
+if { [skip_cplus_tests] } { return }
standard_testfile .cc
#
if ![runto_main] then {
perror "couldn't run to breakpoint"
- continue
+ return
}
if ![runto 'marker1'] then {
perror "couldn't run to marker1"
- continue
+ return
}
gdb_test "up" ".*main.*" "up from marker1 1"
#
if ![runto_main] then {
perror "couldn't run to breakpoint"
- continue
+ return
}
if ![runto 'marker1'] then {
perror "couldn't run to marker1"
- continue
+ return
}
gdb_test "up" ".*main.*" "up from marker1 2"
if ![runto 'f'] then {
perror "couldn't run to f"
- continue
+ return
}
gdb_test "up" ".main2.*" "up from f"
# (involving templates, in particular) where this problem triggers
# because GDB and GCC have different ideas what a class is called.
-if { [skip_cplus_tests] } { continue }
+if { [skip_cplus_tests] } { return }
#
# test running programs
if ![runto_main] then {
perror "couldn't run to breakpoint"
- continue
+ return
}
# First, run to after we've constructed the object:
standard_testfile .cc
-if {[skip_cplus_tests]} { continue }
+if {[skip_cplus_tests]} { return }
if {[prepare_for_testing ${testfile}.exp $testfile $srcfile \
{debug c++ additional_flags="-std=gnu++11"}] } {
if {![runto_main]} {
perror "could not run to main"
- continue
+ return
}
gdb_breakpoint [gdb_get_line_number "break here"]
# Tests for reference types with short type variables in GDB, based on
# gdb.cp/ref-types.exp.
-if { [skip_cplus_tests] } { continue }
+if { [skip_cplus_tests] } { return }
standard_testfile .cc
if {![runto 'f']} then {
perror "couldn't run to f"
- continue
+ return
}
gdb_test "up" ".main2.*" "up from f"
# Derived from gdb.linespec/ls-errs.exp.
if {[skip_cplus_tests]} {
- continue
+ return
}
standard_testfile .cc
if ![runto_main] then {
perror "couldn't run to breakpoint main"
- continue
+ return
}
############################################
if ![runto_main] then {
perror "couldn't run to breakpoint main"
- continue
+ return
}
gdb_breakpoint [gdb_get_line_number "end of main"]
}
}
-if {[skip_cplus_tests]} { continue }
+if {[skip_cplus_tests]} { return }
# Tests for c++/12750
standard_testfile .cc
if {![runto_main]} {
perror "couldn't run to breakpoint"
- continue
+ return
}
set ans {(anonymous namespace)}
# This file is part of the gdb testsuite.
if {[skip_cplus_tests]} {
- continue
+ return
}
standard_testfile .cc
# This file is part of the gdb testsuite
-if { [skip_stl_tests] } { continue }
+if { [skip_stl_tests] } { return }
#
# test running programs
if ![runto_main] then {
perror "couldn't run to breakpoint"
- continue
+ return
}
gdb_breakpoint [gdb_get_line_number "marker 1-throw"]
# source file "userdef.cc"
#
-if { [skip_stl_tests] } { continue }
+if { [skip_stl_tests] } { return }
standard_testfile .cc
if ![runto_main] then {
perror "couldn't run to breakpoint"
- continue
+ return
}
gdb_test "break marker1" \
# Test expressions in which variable names shadow tag names.
-if {[skip_cplus_tests]} { continue }
+if {[skip_cplus_tests]} { return }
standard_testfile var-tag.cc var-tag-2.cc var-tag-3.cc var-tag-4.cc
# Run to main and test again.
if {![runto_main]} {
perror "couldn't run to main"
- continue
+ return
}
with_test_prefix "in main" {
# This file is part of the gdb testsuite.
-if { [skip_cplus_tests] } { continue }
+if { [skip_cplus_tests] } { return }
standard_testfile .cc
if {![runto_main]} then {
perror "couldn't run to breakpoint"
- continue
+ return
}
gdb_breakpoint [gdb_get_line_number "breakpoint 1"]
# Make sure printing virtual base class data member works correctly (PR16841)
-if { [skip_cplus_tests] } { continue }
+if { [skip_cplus_tests] } { return }
standard_testfile .cc
if {![runto_main]} then {
perror "couldn't run to main"
- continue
+ return
}
# From a list of nested scopes, generate all possible ways of accessing something
set nl "\[\r\n\]+"
-if { [skip_cplus_tests] } { continue }
+if { [skip_cplus_tests] } { return }
load_lib "cp-support.exp"
if ![runto_main] then {
perror "couldn't run to breakpoint"
- continue
+ return
}
# set a breakpoint at the return stmt
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
-if { [skip_cplus_tests] || [skip_hw_watchpoint_tests]} { continue }
+if { [skip_cplus_tests] || [skip_hw_watchpoint_tests]} { return }
standard_testfile .cc
if ![runto_main] then {
perror "couldn't run to main"
- continue
+ return
}
gdb_test "watch watchme\[3\]" "atchpoint .*: watchme.*" "set watchpoint"
if ![runto MAIN__] then {
perror "couldn't run to breakpoint MAIN__"
- continue
+ return
}
gdb_breakpoint [gdb_get_line_number "stop-here-out" \
}
if ![runto_main] then {
- continue
+ return
}
set srcline [gdb_get_line_number "stepi line" $csrcfile]
# The referenced value is a global array whose location is a DW_OP_addr.
if [skip_cplus_tests] {
- continue
+ return
}
load_lib dwarf.exp
# The referenced value is a DW_AT_const_value.
if [skip_cplus_tests] {
- continue
+ return
}
load_lib dwarf.exp
# The referenced value is a global variable whose location is a DW_OP_addr.
if [skip_cplus_tests] {
- continue
+ return
}
load_lib dwarf.exp
# The referenced value is a global struct whose location is a DW_OP_addr.
if [skip_cplus_tests] {
- continue
+ return
}
load_lib dwarf.exp
# this case -flto.
if [skip_cplus_tests] {
- continue
+ return
}
load_lib dwarf.exp
if { ![runto f] } {
perror "Could not run to breakpoint `f'."
- continue
+ return
}
gdb_test "watch x" ".*\[Ww\]atchpoint 2: x" "watch x"
if {![fortran_runto_main]} {
perror "Could not run to main."
- continue
+ return
}
gdb_test "until 21" {21.*print.*}
if {![fortran_runto_main]} {
perror "Could not run to main."
- continue
+ return
}
# Convenience proc to setup for KFAIL
if ![runto sub_] then {
perror "couldn't run to breakpoint sub_"
- continue
+ return
}
gdb_breakpoint [gdb_get_line_number "return"]
if {![fortran_runto_main]} {
perror "Could not run to main."
- continue
+ return
}
gdb_breakpoint [gdb_get_line_number "Break here"]
if { ![fortran_runto_main] } {
perror "Could not run to main."
- continue
+ return
}
# Go to foo.
if {![fortran_runto_main]} {
perror "Could not run to main."
- continue
+ return
}
gdb_breakpoint [gdb_get_line_number "Break here"]
if ![fortran_runto_main] {
perror "Couldn't run to main"
- continue
+ return
}
gdb_breakpoint [gdb_get_line_number "break-here"]
if ![fortran_runto_main] then {
perror "couldn't run to main"
- continue
+ return
}
gdb_breakpoint [gdb_get_line_number "stop-here-out"]
if ![fortran_runto_main] then {
perror "Couldn't run to main"
- continue
+ return
}
# Depending on the compiler being used, the type names can be printed differently.
if ![fortran_runto_main] then {
perror "couldn't run to main"
- continue
+ return
}
gdb_breakpoint [gdb_get_line_number "bp"]
if {![runto [gdb_get_line_number "post_init"]]} then {
perror "couldn't run to breakpoint post_init"
- continue
+ return
}
# Test homogeneous derived type.
if ![fortran_runto_main] then {
perror "couldn't run to main"
- continue
+ return
}
# Depending on the compiler being used, the type names can be printed differently.
if {![runto [gdb_get_line_number "post_init"]]} then {
perror "couldn't run to breakpoint post_init"
- continue
+ return
}
# Use inspired by gdb.base/callfuncs.exp.
load_lib "fortran.exp"
load_lib "sym-info-cmds.exp"
-if { [skip_fortran_tests] } { continue }
+if { [skip_fortran_tests] } { return }
standard_testfile info-types.f90 info-types-2.f90
if { ![fortran_runto_main] } {
perror "Could not run to main."
- continue
+ return
}
# Avoid libc symbols.
load_lib "fortran.exp"
load_lib "sym-info-cmds.exp"
-if { [skip_fortran_tests] } { continue }
+if { [skip_fortran_tests] } { return }
standard_testfile info-types.f90 info-types-2.f90
if { ![fortran_runto_main] } {
perror "Could not run to main."
- continue
+ return
}
set integer4 [fortran_int4]
load_lib "fortran.exp"
-if { [skip_fortran_tests] } { continue }
+if { [skip_fortran_tests] } { return }
standard_testfile .f90
if { ![fortran_runto_main] } {
perror "Could not run to main."
- continue
+ return
}
gdb_breakpoint [gdb_get_line_number "stop-here"]
if ![fortran_runto_main] then {
perror "couldn't run to main"
- continue
+ return
}
gdb_breakpoint $srclibfile:[gdb_get_line_number "i-is-2-in-lib" $srclibfile]
if { ![fortran_runto_main] } {
perror "Could not run to main."
- continue
+ return
}
gdb_breakpoint [gdb_get_line_number "stop-here"]
load_lib "fortran.exp"
-if { [skip_fortran_tests] } { continue }
+if { [skip_fortran_tests] } { return }
standard_testfile .f90
if { ![fortran_runto_main] } {
perror "Could not run to main."
- continue
+ return
}
gdb_breakpoint [gdb_get_line_number "stop-here"]
if ![fortran_runto_main] then {
perror "couldn't run to main"
- continue
+ return
}
# Avoid libc symbols.
if ![fortran_runto_main] {
perror "Couldn't run to main"
- continue
+ return
}
# Depending on the compiler being used, the type names can be printed differently.
if ![fortran_runto_main] then {
perror "couldn't run to main"
- continue
+ return
}
# Depending on the compiler being used, the type names can be printed
# Break on a contained function and run to it.
if {![runto ${src_prefix}[gdb_get_line_number "pre_init"]]} then {
perror "couldn't run to breakpoint pre_init"
- continue
+ return
}
# Call a contained function.
load_lib "fortran.exp"
if { [skip_fortran_tests] } {
- continue
+ return
}
standard_testfile .f90
if ![fortran_runto_main] then {
perror "couldn't run to main"
- continue
+ return
}
set integer4 [fortran_int4]
if {![runto [gdb_get_line_number "post_truth_table_init"]]} then {
perror "couldn't run to breakpoint post_truth_table_init"
- continue
+ return
}
# Non-zero value to use as the function call count base. Using zero is avoided
if ![fortran_runto_main] then {
perror "couldn't run to main"
- continue
+ return
}
# Avoid libc symbols, in particular the 'array' type.
if ![fortran_runto_main] then {
perror "couldn't run to main"
- continue
+ return
}
gdb_breakpoint [gdb_get_line_number "vla2-allocated"]
gdb_continue_to_breakpoint "vla2-allocated, second time"
}
if [mi_gdb_start] {
- continue
+ return
}
mi_delete_breakpoints
# GDB could have crashed.
mi_gdb_exit
if [mi_gdb_start] {
- continue
+ return
}
mi_delete_breakpoints
mi_gdb_reinitialize_dir $srcdir/$subdir
gdb_exit
if [mi_gdb_start] {
- continue
+ return
}
proc do_test {count} {
}
if [mi_gdb_start] {
- continue
+ return
}
if ![can_spawn_for_attach] {
- continue
+ return
}
set string_re {(?:[^\\"]|\\.)*}
gdb_exit
if [mi_gdb_start] {
- continue
+ return
}
# Try the "-list-thread-groups --available". This command can generate
gdb_exit
if [mi_gdb_start] {
- continue
+ return
}
mi_gdb_load ${binfile}
gdb_exit
if [mi_gdb_start] {
- continue
+ return
}
standard_testfile basics.c
gdb_exit
if [mi_gdb_start separate-inferior-tty] {
- continue
+ return
}
standard_testfile basics.c
gdb_exit
if [mi_gdb_start] {
- continue
+ return
}
mi_gdb_reinitialize_dir $srcdir/$subdir
mi_gdb_load ${binfile}
# Test the -catch-throw, -catch-rethrow, and -catch-catch MI commands.
-if { [skip_cplus_tests] } { continue }
+if { [skip_cplus_tests] } { return }
load_lib mi-support.exp
set MIFLAGS "-i=mi"
global main_lineno
if {[mi_gdb_start]} {
- continue
+ return
}
mi_delete_breakpoints
gdb_exit
if [mi_gdb_start] {
- continue
+ return
}
standard_testfile
with_test_prefix "$variant" {
gdb_exit
if [mi_gdb_start] {
- continue
+ return
}
set options {debug}
gdb_exit
if [mi_gdb_start separate-inferior-tty] {
- continue
+ return
}
standard_testfile
gdb_exit
if {[mi_gdb_start]} {
- continue
+ return
}
mi_gdb_test "-interpreter-exec console \"set editing on\"" \
gdb_exit
if [mi_gdb_start] {
- continue
+ return
}
standard_testfile basics.c
gdb_exit
if [mi_gdb_start] {
- continue
+ return
}
mi_delete_breakpoints
mi_gdb_reinitialize_dir $srcdir/$subdir
gdb_exit
if [mi_gdb_start] {
- continue
+ return
}
standard_testfile basics.c
gdb_exit
if [mi_gdb_start] {
- continue
+ return
}
standard_testfile
gdb_exit
if [mi_gdb_start] {
- continue
+ return
}
mi_gdb_test "show architecture" \
gdb_exit
if [mi_gdb_start] {
- continue
+ return
}
# First, verify that the debugger correctly advertises support
gdb_exit
if [mi_gdb_start] {
- continue
+ return
}
standard_testfile basics.c
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
-if { [skip_cplus_tests] } { continue }
+if { [skip_cplus_tests] } { return }
load_lib mi-support.exp
set MIFLAGS "-i=mi"
gdb_exit
if [mi_gdb_start] {
- continue
+ return
}
standard_testfile .cc
gdb_exit
if [mi_gdb_start] {
- continue
+ return
}
# First, verify that the debugger correctly advertises support
# file with a Windows-style logical drive names and C++.
if {[skip_cplus_tests]} {
- continue
+ return
}
load_lib mi-support.exp
gdb_exit
if [mi_gdb_start $args] {
- continue
+ return
}
set start 1
mi_detect_async
if { [mi_runto_main] < 0 } {
- continue
+ return
}
mi_create_breakpoint break_at_me "breakpoint at marker" \
mi_detect_async
if { [mi_runto_main] < 0 } {
- continue
+ return
}
# Check that register and stack info don't end up stale after resuming
mi_detect_async
if { [mi_runto_main] < 0 } {
- continue
+ return
}
mi_create_breakpoint thread_function \
mi_detect_async
if { [mi_runto_main] < 0 } {
- continue
+ return
}
# Keep this in sync with THREADS in the $srcfile.
mi_detect_async
if { [mi_runto_main] < 0 } {
- continue
+ return
}
mi_create_breakpoint thread_execler \
gdb_exit
if {[mi_gdb_start]} {
- continue
+ return
}
# This procedure tests the various thread commands in MI.
gdb_exit
if [mi_gdb_start] {
- continue
+ return
}
standard_testfile .S
gdb_exit
if [mi_gdb_start] {
- continue
+ return
}
standard_testfile basics.c
gdb_exit
if [mi_gdb_start] {
- continue
+ return
}
standard_testfile basics.c
gdb_exit
if [mi_gdb_start] {
- continue
+ return
}
standard_testfile solib-main.c solib-lib.c
gdb_exit
if [mi_gdb_start] {
- continue
+ return
}
standard_testfile
if [target_info exists gdb,nosignals] {
verbose "Skipping mi-syn-frame.exp because of nosignals."
- continue
+ return
}
load_lib mi-support.exp
if [target_info exists gdb,nointerrupts] {
verbose "Skipping mi-threads-interrupt.exp because of nointerrupts."
- continue
+ return
}
load_lib mi-support.exp
gdb_exit
if {[mi_gdb_start]} {
- continue
+ return
}
# Load the binary in gdb...
gdb_exit
if [mi_gdb_start] {
- continue
+ return
}
gdb_exit
if [mi_gdb_start] {
- continue
+ return
}
standard_testfile until.c
gdb_exit
if [mi_gdb_start] {
- continue
+ return
}
standard_testfile var-cmd.c
gdb_exit
if [mi_gdb_start] {
- continue
+ return
}
standard_testfile array.f90
gdb_exit
if [mi_gdb_start] {
- continue
+ return
}
standard_testfile
gdb_exit
if [mi_gdb_start] {
- continue
+ return
}
standard_testfile var-cmd.c
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
-if { [skip_cplus_tests] } { continue }
+if { [skip_cplus_tests] } { return }
load_lib mi-support.exp
set MIFLAGS "-i=mi"
gdb_exit
if [mi_gdb_start] {
- continue
+ return
}
standard_testfile .cc
gdb_exit
if [mi_gdb_start] {
- continue
+ return
}
standard_testfile var-cmd.c
gdb_exit
if [mi_gdb_start] {
- continue
+ return
}
standard_testfile var-cmd.c
gdb_exit
if [mi_gdb_start] {
- continue
+ return
}
standard_testfile
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
-if { [skip_cplus_tests] } { continue }
+if { [skip_cplus_tests] } { return }
load_lib mi-support.exp
set MIFLAGS "-i=mi"
gdb_exit
if [mi_gdb_start] {
- continue
+ return
}
standard_testfile .cc
gdb_exit
if [mi_gdb_start] {
- continue
+ return
}
standard_testfile vla.c
gdb_exit
if [mi_gdb_start] {
- continue
+ return
}
standard_testfile vla.f90
mi_detect_async
if { [mi_runto_main] < 0 } {
- continue
+ return
}
# Set a watchpoint.
gdb_exit
if [mi_gdb_start] {
- continue
+ return
}
standard_testfile .s
set MIFLAGS "-i=mi2"
if {[mi_gdb_start]} {
- continue
+ return
}
standard_testfile
gdb_exit
if [mi_gdb_start] {
- continue
+ return
}
# Check console 'set prompt' does not affect the MI output.
gdb_exit
if [mi_gdb_start] {
- continue
+ return
}
standard_testfile var-cmd.c
if ![runto here] then {
perror "couldn't run to breakpoint 'here'"
- continue
+ return
}
gdb_test "set lang modula-2" ".*does not match.*" "switch to modula-2"
if ![runto foo] then {
perror "couldn't run to breakpoint foo"
- continue
+ return
}
gdb_test "set lang modula-2" ".*does not match.*" "switch to modula-2"
# along with this program. If not, see <http://www.gnu.org/licenses/>.
if ![target_can_use_run_cmd] {
- continue
+ return
}
# Until "catch exec" is implemented on other targets...
#
if {![istarget "*-linux*"]} then {
- continue
+ return
}
set testfile "bkpt-multi-exec"
if ![runto f] then {
perror "couldn't run to f"
- continue
+ return
}
gdb_test_no_output "set print frame-arguments all"
# CLI output sent to MI's console.
with_test_prefix "mi" {
if [mi_gdb_start] {
- continue
+ return
}
mi_gdb_load ${binfile}
mi_runto_main
gdb_exit
if [mi_gdb_start] {
- continue
+ return
}
standard_testfile py-framefilter-mi.c
clean_restart
# Skip all tests if Python scripting is not enabled.
-if { [skip_python_tests] } { continue }
+if { [skip_python_tests] } { return }
# Skip this test if the tracemalloc module is not available.
if { ![gdb_py_module_available "tracemalloc"] } {
unsupported "tracemalloc module not available"
- continue
+ return
}
set pyfile [gdb_remote_download host ${srcdir}/${subdir}/${testfile}.py]
gdb_exit
if {[mi_gdb_start]} {
- continue
+ return
}
if {[lsearch -exact [mi_get_features] python] < 0} {
gdb_exit
if [mi_gdb_start] {
- continue
+ return
}
standard_testfile
return -1
}
-if { [mi_skip_python_tests] } { continue }
+if { [mi_skip_python_tests] } { return }
set remote_python_file [gdb_remote_download host ${srcdir}/${subdir}/${pyfile}]
gdb_exit
if [mi_gdb_start] {
- continue
+ return
}
standard_testfile
return -1
}
-if { [mi_skip_python_tests] } { continue }
+if { [mi_skip_python_tests] } { return }
# Make the -gdb.py script available to gdb, it is automagically loaded by gdb.
# Care is taken to put it in the same directory as the binary so that
gdb_exit
if [mi_gdb_start] {
- continue
+ return
}
standard_testfile py-prettyprint.c
}
if [mi_gdb_start] {
- continue
+ return
}
mi_delete_breakpoints
mi_gdb_reinitialize_dir $srcdir/$subdir
if ![runto_main] then {
untested "could not run to main"
- continue
+ return
}
gdb_test_no_output "record"
if ![runto_main] then {
untested "could not run to main"
- continue
+ return
}
gdb_test_no_output "record"
load_lib rust-support.exp
if {[skip_rust_tests]} {
- continue
+ return
}
standard_testfile .rs
# Rust compiler. This serves as a smoke test.
load_lib "rust-support.exp"
-if {[skip_rust_tests]} { continue }
+if {[skip_rust_tests]} { return }
gdb_start
if {![set_lang_rust]} {
warning "Rust expression tests suppressed."
- continue
+ return
}
gdb_test "print 9__97" " = 997"
load_lib rust-support.exp
if {[skip_rust_tests]} {
- continue
+ return
}
standard_testfile .rs
load_lib rust-support.exp
if {[skip_rust_tests]} {
- continue
+ return
}
standard_testfile .rs
load_lib rust-support.exp
if {[skip_rust_tests]} {
- continue
+ return
}
standard_testfile .rs
load_lib rust-support.exp
if {[skip_rust_tests]} {
- continue
+ return
}
standard_testfile .rs
load_lib gdb-python.exp
load_lib rust-support.exp
if {[skip_rust_tests]} {
- continue
+ return
}
standard_testfile .rs
return -1
}
-if { [skip_python_tests] } { continue }
+if { [skip_python_tests] } { return }
set remote_python_file [gdb_remote_download host \
${srcdir}/${subdir}/${testfile}.py]
load_lib rust-support.exp
if {[skip_rust_tests]} {
- continue
+ return
}
set v [split [rust_compiler_version] .]
load_lib rust-support.exp
if {[skip_rust_tests]} {
- continue
+ return
}
save_vars { env(TERM) } {
load_lib rust-support.exp
if {[skip_rust_tests]} {
- continue
+ return
}
standard_testfile .rs
load_lib gdb-python.exp
if {[skip_python_tests]} {
- continue
+ return
}
gdb_test "python print(gdb.lookup_type('simple::HiBob'))" "simple::HiBob"
load_lib rust-support.exp
if {[skip_rust_tests]} {
- continue
+ return
}
standard_testfile .rs
load_lib rust-support.exp
if {[skip_rust_tests]} {
- continue
+ return
}
# Non-ASCII identifiers were allowed starting in 1.53.
load_lib rust-support.exp
if {[skip_rust_tests]} {
- continue
+ return
}
standard_testfile .rs
load_lib rust-support.exp
if {[skip_rust_tests]} {
- continue
+ return
}
standard_testfile .rs
load_lib rust-support.exp
if {[skip_rust_tests]} {
- continue
+ return
}
standard_testfile .rs
# This test is only for extended remote targets.
if {[target_info gdb_protocol] != "extended-remote"} {
- continue
+ return
}
# This test also makes use of 'detach-on-fork' which is not supported
# on all platforms.
if { ![istarget "*-*-linux*"] && ![istarget "*-*-openbsd*"] } then {
- continue
+ return
}
# And we need to be able to reconnect to gdbserver.
if [target_info exists gdb,nointerrupts] {
verbose "Skipping reconnect-ctrl-c.exp because of nointerrupts."
- continue
+ return
}
standard_testfile
if ![runto_main] then {
perror "couldn't run to breakpoint"
- continue
+ return
}
get_debug_format
# This test only works on Linux
if { ![isnative] || [is_remote host] || [use_gdb_stub]
|| ![istarget *-linux*] } {
- continue
+ return
}
standard_testfile
# This test only works on Linux
if { ![isnative] || [is_remote host] || [use_gdb_stub]
|| ![istarget *-linux*] } {
- continue
+ return
}
standard_testfile
# This test only works on Linux
if { ![isnative] || [is_remote host] || [use_gdb_stub]
|| ![istarget *-linux*] } {
- continue
+ return
}
standard_testfile
# This test only works for native processes on GNU/Linux.
if {[target_info gdb_protocol] != "" || ![istarget *-linux*]} {
- continue
+ return
}
# Test relies on checking gdb debug output. Do not run if gdb debug is
# inferiors have terminated, and this test requires that.
if { [target_info exists gdb_protocol]
&& [target_info gdb_protocol] == "remote" } {
- continue
+ return
}
standard_testfile
# test.
if [target_info exists gdb,cannot_call_functions] {
unsupported "this target can not call functions"
- continue
+ return
}
proc get_dummy_frame_number { } {
}
if ![runto_main] {
- continue
+ return
}
# Set a thread-specific breakpoint that the wrong thread trips on
# test.
if [target_info exists gdb,cannot_call_functions] {
unsupported "this target can not call functions"
- continue
+ return
}
clean_restart ${binfile}
# threads).
if [target_info exists gdb,no_thread_names] {
- continue
+ return
}
standard_testfile
}
if ![runto "all_threads_ready"] {
- continue
+ return
}
gdb_test "info threads" \
# Test relies on checking gdb debug output. Do not run if gdb debug is
# enabled as any debug will be redirected to the log.
if [gdb_debug_enabled] {
- continue
+ return
}
standard_testfile
}
if ![runto_main] {
- continue
+ return
}
# Make sure it's GDB's decr_pc logic that's being tested, not the
clean_restart $executable
if ![runto_main] {
- continue
+ return
}
gdb_test_no_output "set displaced-stepping $displaced"
# test.
if [target_info exists gdb,cannot_call_functions] {
unsupported "this target can not call functions"
- continue
+ return
}
clean_restart ${binfile}
gdb_exit
if [mi_gdb_start] {
- continue
+ return
}
mi_gdb_reinitialize_dir $srcdir/$subdir
}
gdb_exit
if [mi_gdb_start] {
- continue
+ return
}
mi_gdb_reinitialize_dir $srcdir/$subdir
# Only x86 and x86_64 targets are supported for now.
if { ![istarget "x86_64-*"] && ![istarget "i?86-*"] } {
- continue
+ return
}
proc compile_stap_bin {exec_name {arg ""}} {
if { ![runto_main] } {
perror "Could not run to `main'."
- continue
+ return
}
gdb_breakpoint [gdb_get_line_number "end-here"]
clean_restart $executable
if { ![runto_main] } {
perror "Could not run to `main'."
- continue
+ return
}
if { ![gdb_target_supports_trace] } {
projects / binutils-gdb.git / commitdiff