# Start the inferior
if ![runto_main] then {
- fail "cannot run to main, testcase aborted"
return 0
}
clean_restart ${testfile}
if ![runto_main] then {
- fail "cannot run to main, testcase aborted"
return 0
}
set sp "\[ \t\]*"
if ![runto_main] then {
- fail "cannot run to main, testcase aborted"
return 0
}
# - continue, the program exits.
if ![runto_main] then {
- fail "cannot run to main, testcase aborted"
return 0
}
####################################
if ![runto_main] then {
- fail "cannot run to main, testcase aborted"
return 0
}
# - continue, the program exits.
if ![runto_main] then {
- fail "cannot run to main, testcase aborted"
return 0
}
# the program.
if ![runto_main] then {
- fail "cannot run to main, testcase aborted"
return 0
}
############################################
if ![runto_main] then {
- fail "cannot run to main, testcase aborted"
return 0
}
set bp_location [gdb_get_line_number "STOP" ${testdir}/some_c.c]
if ![runto "some_c.c:$bp_location"] then {
- fail "can't run to some_c.c STOP location"
return
}
clean_restart ${testfile}
if ![runto_main] then {
- fail "cannot run to main, testcase aborted"
return 0
}
clean_restart ${testfile}
if ![runto_main] then {
- fail "cannot run to main, testcase aborted"
return 0
}
# - continue, the program exits.
if {[mi_runto_main] < 0} {
- fail "cannot run to main, testcase aborted"
return 0
}
clean_restart ${testfile}
if ![runto_main] then {
- fail "cannot run to main, testcase aborted"
return 0
}
with_test_prefix "scenario 1" {
if {[mi_runto_main] < 0} {
- fail "cannot run to main, testcase aborted"
return 0
}
}
with_test_prefix "scenario 2" {
mi_delete_breakpoints
if {[mi_runto_main] < 0} {
- fail "cannot run to main, testcase aborted"
return 0
}
}
clean_restart ${testfile}
if ![runto_main] then {
- fail "cannot run to main, testcase aborted"
return 0
}
with_test_prefix "scenario 1" {
if {[mi_runto_main] < 0} {
- fail "cannot run to main, testcase aborted"
return 0
}
}
with_test_prefix "scenario 2" {
mi_delete_breakpoints
if {[mi_runto_main] < 0} {
- fail "cannot run to main, testcase aborted"
return 0
}
}
mi_clean_restart $binfile
if {[mi_runto_main] < 0} {
- fail "cannot run to main, testcase aborted"
return 0
}
clean_restart ${testfile}
if ![runto_main] then {
- fail "cannot run to main, testcase aborted"
return 0
}
mi_clean_restart $binfile
if {[mi_runto_main] < 0} {
- fail "cannot run to main, testcase aborted"
return 0
}
mi_clean_restart $binfile
if {[mi_runto_main] < 0} {
- fail "cannot run to main, testcase aborted"
return 0
}
mi_clean_restart $binfile
if {[mi_runto_main] < 0} {
- fail "cannot run to main, testcase aborted"
return 0
}
mi_clean_restart $binfile
if {[mi_runto_main] < 0} {
- fail "cannot run to main, testcase aborted"
return 0
}
mi_clean_restart $binfile
if {[mi_runto_main] < 0} {
- fail "cannot run to main, testcase aborted"
return 0
}
mi_gdb_test "-gdb-set debug-file-directory \"\"" ".*"
if ![mi_runto "task_switch.break_me"] then {
- fail "cannot run to main, testcase aborted"
return 0
}
####################################
if ![mi_runto "task_switch.break_me"] then {
- fail "cannot run to main, testcase aborted"
return 0
}
mi_clean_restart $binfile
if {[mi_runto_main] < 0} {
- fail "cannot run to main, testcase aborted"
return 0
}
mi_clean_restart $binfile
if {[mi_runto_main] < 0} {
- fail "cannot run to main, testcase aborted"
return 0
}
mi_clean_restart $binfile
if {[mi_runto_main] < 0} {
- fail "cannot run to main, testcase aborted"
return 0
}
mi_clean_restart $binfile
if {[mi_runto_main] < 0} {
- fail "cannot run to main, testcase aborted"
return 0
}
}
if ![runto_main] {
- untested "could not run to main"
return -1
}
}
if {![runto_main]} {
- untested "could not run to main"
return -1
}
}
if ![runto_main] {
- untested "could not run to main"
return -1
}
}
if ![runto_main] {
- untested "could not run to main"
return -1
}
# Restart to execute the async tag fault test.
with_test_prefix "async" {
if ![runto_main] {
- untested "could not run to main"
return -1
}
}
if ![runto_main] {
- untested "could not run to main"
return -1
}
}
if ![runto_main] {
- untested "could not run to main"
return -1
}
}
if ![runto_main] {
- untested "could not run to main"
return -1
}
}
if ![runto_main] {
- untested "could not run to main"
return -1
}
# of the previous tests, this makes sure that it doesn't affect
# this series of tests.
if ![runto_main] then {
- fail "can't run to main"
return 0
}
# Run to `main' where we begin our tests.
if ![runto_main] then {
- untested "could not run to main"
return -1
}
#
if ![runto_main] then {
- fail "can't run to main"
return 0
}
}
if ![runto_main] {
- untested "could not run to main"
return -1
}
clean_restart ${binfile}
if ![runto_main] then {
- fail "can't run to main"
return 0
}
gdb_test "show displaced-stepping" ".* displaced stepping .* is on.*"
if ![runto_main] then {
- fail "can't run to main"
return 0
}
gdb_test "show displaced-stepping" ".* displaced stepping .* is on.*"
if ![runto_main] then {
- fail "can't run to main"
return 0
}
clean_restart ${binfile}
if ![runto_main] then {
- fail "can't run to main"
return 0
}
}
if ![runto_main] {
- untested "could not run to main"
return -1
}
# Get things started.
if ![runto_main] then {
- fail "can't run to main"
return 0
}
clean_restart ${binfile}
if ![runto_main] then {
- fail "can't run to main"
return 0
}
clean_restart ${binfile}
if ![runto_main] then {
- fail "can't run to main"
return 0
}
proc test_probe { probe_name } {
with_test_prefix "probe: ${probe_name}" {
if { ![runto "-pstap $probe_name"] } {
- fail "run to probe $probe_name"
return
}
proc goto_probe { probe_name } {
if { ![runto "-pstap $probe_name"] } {
- fail "run to probe $probe_name"
return
}
}
clean_restart ${binfile}
if ![runto_main] then {
- fail "can't run to main"
return 0
}
}
if ![runto_main] {
- fail "can't run to main"
return 0
}
}
if ![runto_main] {
- fail "can't run to main"
return 0
}
}
if ![runto_main] {
- untested "could not run to main"
return -1
}
gdb_test_no_output "set displaced-stepping off"
if ![runto_main] then {
- fail "can't run to main"
return 0
}
}
if ![runto_main] {
- untested "could not run to main"
return -1
}
}
if ![runto_main] {
- fail "can't run to main"
return -1
}
#
if ![runto_main] then {
- fail "can't run to main"
return 0
}
#
if ![runto_main] then {
- fail "can't run to main"
return 0
}
gdb_reinitialize_dir $srcdir/$subdir
gdb_load ${binfile}
if ![runto_main] then {
- fail "can't run to main"
return 0
}
}
if ![runto_main] {
- fail "can't run to main to check for trace support"
return -1
}
clean_restart ${executable}
if ![runto_main] {
- fail "can't run to main for ftrace tests"
return 0
}
#
if ![runto_main] then {
- fail "can't run to main"
return 0
}
#
if ![runto_main] then {
- fail "can't run to main"
return 0
}
clean_restart ${binfile}
if ![runto_main] then {
- fail "can't run to main"
return 0
}
}
if ![runto_main] then {
- fail "run to main"
return
}
}
if ![runto_main] {
- untested "could not run to main"
return -1
}
clean_restart ${binfile}
if ![runto_main] then {
- fail "can't run to main"
return 0
}
gdb_test "show displaced-stepping" ".* displaced stepping .* is on.*"
if ![runto_main] then {
- fail "can't run to main"
return 0
}
}
if ![runto_main] then {
- untested "could not run to main"
return -1
}
}
if ![runto_main] then {
- fail "can't run to main"
return 0
}
}
if ![runto_main] {
- untested "could not run to main"
return -1
}
}
if ![runto_main] {
- untested "could not run to main"
return -1
}
}
if ![runto_main] {
- untested "could not run to main"
return -1
}
}
if ![runto_main] {
- untested "could not run to main"
return -1
}
set parameters "print pass stop"
with_test_prefix "$parameters" {
if ![runto_main] {
- fail "could not run to main"
return -1
}
set parameters "print pass nostop"
with_test_prefix "$parameters" {
if ![runto_main] {
- fail "could not run to main"
return -1
}
set parameters "print nopass stop"
with_test_prefix "$parameters" {
if ![runto_main] {
- fail "could not run to main"
return -1
}
set parameters "noprint pass nostop"
with_test_prefix "$parameters" {
if ![runto_main] {
- fail "could not run to main"
return -1
}
}
if ![runto_main] {
- untested "could not run to main"
return -1
}
}
if ![runto_main] {
- untested "could not run to main"
return -1
}
#
if ![runto_main] then {
- fail "can't run to main"
return 0
}
clean_restart ${binfile}
if ![runto_main] then {
- fail "can't run to main"
return 0
}
clean_restart ${binfile}
if ![runto_main] then {
- fail "can't run to main"
return 0
}
# We need to start the inferior to place the breakpoints in the memory at all.
if ![runto_main] {
- untested start
return -1
}
#
if ![runto_main] then {
- fail "can't run to main"
return 0
}
gdb_compile ${objfiles} ${binfile} executable ${options}
clean_restart ${testname}
if ![runto_main] then {
- fail "running test program, MIPS16 thunk tests aborted"
return
}
}
if ![runto_main] then {
- fail "can't run to main"
return 0
}
set test "core at last insn in foo"
if ![runto_main] then {
- fail "can't run to main"
return 0
}
gdb_breakpoint "*$foo_last"
set test "core at nullified insn"
if ![runto_main] then {
- fail "can't run to main"
return 0
}
gdb_breakpoint "*$foo_last"
gdb_load ${binfile}
if { ![runto_main] } then {
- fail "run to main"
return
}
clean_restart $binfile
if ![runto_main] then {
- fail "could not run to main"
return -1
}
#
if ![runto_main] then {
- fail "can't run to main"
return 0
}
clean_restart $binfile
if ![runto_main] then {
- fail "could not run to main"
return -1
}
# Run to `main' where we begin our tests.
if ![runto_main] then {
- fail "can't run to main"
return 0
}
global decimal hex
if ![runto_main] then {
- untested "could not run to main"
return -1
}
global gdb_prompt inferior_exited_re srcfile srcfile2
if ![runto_main] then {
- untested "could not run to main"
return -1
}
}
if ![runto_main] then {
- fail "can't run to main"
return 0
}
}
if ![runto_main] then {
- fail "can't run to main"
return 0
}
}
if { ![runto_main] } {
- untested "failed to runto main"
return -1
}
}
if ![runto_main] then {
- fail "can't run to main"
return 0
}
}
if ![runto_main] then {
- fail "can't run to main"
return 0
}
}
if ![runto_main] then {
- fail "can't run to main"
return 0
}
}
if ![runto_main] {
- untested "could not run to main"
return -1
}
}
if ![runto_main] then {
- untested "could not run to main"
return -1
}
}
if ![runto_main] then {
- untested "could not run to main"
return 0
}
}
if ![runto_main] then {
- untested "could not run to main"
return -1
}
#
if ![runto_main] then {
- untested "ARM prologue tests"
return -1
}
}
if ![runto_main] then {
- untested "could not run to main"
return -1
}
gdb_load ${binfile}
if ![runto_main] then {
- untested "could not run to main"
return -1
}
# Run to `main' where we begin our tests.
if ![runto_main] then {
- fail "can't run to main"
return 0
}
# Run to `main' where we begin our tests.
if ![runto_main] then {
- fail "can't run to main"
return 0
}
}
if { ![runto_main] } {
- unsupported "could not run to main"
return -1
}
}
if { ![runto_main] } {
- unsupported "could not run to main"
return -1
}
}
if { ![runto_main] } {
- unsupported "could not run to main"
return -1
}
#
if ![runto_main] then {
- fail "can't run to main"
return 0
}
global lineno
if ![runto test] {
- fail "can't run to test"
return
}
global lineno
if ![runto test] {
- fail "can't run to test"
return
}
global lineno
if ![runto test] {
- fail "can't run to test"
return
}
global lineno
if ![runto test] {
- fail "can't run to test"
return
}
global lineno
if ![runto test] {
- fail "can't run to test"
return
}
}
if ![runto_main] then {
- fail "can't run to main"
return 0
}
# Because runto_main doesn't know how to handle the prompt with annotations,
# run to main before we set the annotation level.
if ![runto_main] then {
- fail "can't run to main"
return 1
}
gdb_reinitialize_dir $srcdir/$subdir
gdb_load ${binfile}
if { ![runto_main] } then {
- fail "run to main"
return
}
clean_restart ${testfile}
if {![runto_main]} {
- unsupported "failed to run to main"
return -1
}
}
if { ![runto_main] } then {
- fail "run to main"
return
}
clean_restart "$filelink"
if ![runto_main] {
- untested "could not run to main"
return -1
}
clean_restart "$dirlink/$filelink"
if ![runto_main] {
- untested "could not run to main"
return -1
}
}
if ![runto_main] {
- fail "can't run to main"
return 0
}
clean_restart $binfile
if ![runto setup_done] then {
- fail "can't run to setup_done"
return 0
}
clean_restart $binfile
if { ![runto_main] } {
- fail "could not run to main"
return
}
# Check which target this board connects to. If testing with a native
# target board, this should cause the native target to auto connect.
if ![runto_main] then {
- fail "can't run to main"
return 0
}
}
if ![runto_main] then {
- fail "can't run to main"
return 0
}
set print_core_line [gdb_get_line_number "ABORT;"]
}
if ![runto_main] then {
- fail "can't run to main"
return 0
}
}
if ![runto_main] then {
- fail "can't run to main"
return 0
}
set print_core_line [gdb_get_line_number "Dump core"]
delete_breakpoints
if ![runto_main] then {
- fail "can't run to main"
return
}
set GDBFLAGS $saved_gdbflags
if ![runto start] {
- fail "can't run to start"
return
}
set GDBFLAGS $saved_gdbflags
if ![runto_main] then {
- fail "can't run to main"
return
}
# inappropriately. (There are no calls to those system functions
# in this test program.)
#
-if ![runto_main] then { fail "break tests suppressed" }
+if ![runto_main] then {
+ return
+}
gdb_test "catch fork" "Catchpoint \[0-9\]+ \\(fork\\)" \
"set catch fork, never expected to trigger"
# Verify that a "silent" breakpoint can be set, and that GDB is indeed
# "silent" about its triggering.
#
-if ![runto_main] then { fail "break tests suppressed" }
+if ![runto_main] then {
+ return
+}
gdb_test_multiple "break $bp_location1" \
"set to-be-silent break bp_location1" {
# Verify that GDB responds gracefully to a "finish" command with
# arguments.
#
-if ![runto_main] then { fail "break tests suppressed" }
+if ![runto_main] then {
+ return
+}
send_gdb "finish 123\n"
gdb_expect {
# We need to start the inferior to place the breakpoints in the memory at all.
if ![runto_main] {
- untested start
return -1
}
# Check we can run to main. If this works this time then we just
# assume that it will work later on (when we repeatedly restart GDB).
if ![runto_main] then {
- untested "run to main"
return -1
}
# Check we can run to main. If this works this time then we just
# assume that it will work later on (when we repeatedly restart GDB).
if ![runto_main] then {
- untested $testfile
return -1
}
with_test_prefix $bt_cmd {
if ![runto_main] then {
- fail "can't run to main"
return 0
}
clean_restart ${binfile}
if { ![runto_main] } {
- fail "can't run to main"
return 0
}
clean_restart ${binfile}
if { ![runto_main] } {
- fail "can't run to main"
return 0
}
}
if {![runto_main]} {
- untested "could not run to main"
return -1
}
proc catch_follow_exec { } {
if { ![runto_main] } {
- untested "could not run to main"
return -1
}
clean_restart $testfile
if ![runto_main] {
- untested "could not run to main"
return -1
}
}
if ![runto_main] {
- fail "can't run to main to make the tests"
return -1
}
gdb_load_shlib $binfile2
if {![runto_main]} {
- fail "can't run to main"
return
}
}
if ![runto_main] then {
- fail "can't run to main"
return -1
}
# Check target supports catch syscall or not.
if ![runto_main] then {
- fail "can't run to main"
return
}
proc runto_or_return {function} {
if { ![runto factorial] } {
- fail "cannot run to $function"
return -code return
}
}
# Now get past startup code.
if ![runto_main] then {
- fail "can't run to main"
return 0
}
}
if { ![runto_main] } then {
- fail "can't run to main"
return 0
}
}
if ![runto_main] then {
- fail "can't run to main"
return 0
}
# deletes the breakpoints.
with_test_prefix "with continue 1" {
if {![runto_main]} {
- fail "could not run to main"
return -1
}
# Repeat with a condition that evaluates to false.
with_test_prefix "with continue 2" {
if {![runto_main]} {
- fail "could not run to main"
return -1
}
# Repeat with a condition that contains junk at the end.
with_test_prefix "with junk" {
if {![runto_main]} {
- fail "could not run to main"
return -1
}
}
if ![runto_main] then {
- fail "can't run to main"
return 0
}
}
if ![runto_main] then {
- fail "can't run to main"
return 0
}
gdb_test_no_output "set breakpoint always-inserted $breakpoint_always_inserted"
if ![runto_main] {
- fail "run to main"
return -1
}
}
if ![runto_main] {
- fail "can't run to main"
return
}
}
if { ![runto_main] } {
- untested "could not run to main"
return -1
}
}
if { ![runto_main] } {
- untested "could not run to main"
return -1
}
clean_restart $binfile
if ![runto_main] then {
- fail "can't run to main"
return
}
gdb_load_shlib $libobj2
if ![runto_main] {
- untested "could not run to main"
return -1
}
}
if ![runto_main] {
- fail "run to main"
return -1
}
gdb_test "p a" { = \{1, 2\}}
if ![runto_main] then {
- fail "can't run to main"
return 0
}
set bp_location1 [gdb_get_line_number "set breakpoint 1 here"]
set bp_location11 [gdb_get_line_number "set breakpoint 11 here"]
-if ![runto_main] then { fail "define tests suppressed" }
+if ![runto_main] then {
+ return
+}
# Verify that GDB allows a user to define their very own commands.
#
}
if ![runto_main] {
- fail "couldn't run to main"
return
}
}
if ![runto_main] then {
- fail "can't run to main"
return 0
}
# Ok, on to real life
#
if ![runto_main] then {
- fail "could not run to main - other tests will fail."
- continue
+ return
}
# Disable hardware watchpoints if necessary.
clean_restart $binfile
if ![runto_main] {
- fail "can't run to main"
return -1
}
gdb_test_no_output "set disconnected-dprintf ${disconnected_dprintf}"
if ![runto_main] {
- fail "can't run to main"
return -1
}
}
if ![runto_main] {
- fail "can't run to main"
return -1
}
}
if ![runto_main] {
- fail "can't run to main"
return -1
}
# Since test:progress-counter is disabled we can run to the second
# instance of the test:two-locations probe.
- if {![runto "-probe-dtrace test:two-locations"]} {
- fail "run to the first test:two-locations probe point"
- }
- if {![runto "-probe-dtrace test:two-locations"]} {
- fail "run to the second test:two-locations probe point"
- }
+ runto "-probe-dtrace test:two-locations"]
+ runto "-probe-dtrace test:two-locations"]
# Go back to the breakpoint on main() and enable the
# test:progress-counter probe. Set a breakpoint on it and see
clean_restart ${binfile}
if ![runto_main] then {
- fail "can't run to main"
return 0
}
set bp_location15 [gdb_get_line_number "set breakpoint 15 here" $srcfile2]
set bp_location17 [gdb_get_line_number "set breakpoint 17 here" $srcfile2]
-if ![runto_main] then { fail "enable/disable break tests suppressed" }
+if ![runto_main] then {
+ return
+}
# Verify that we can set a breakpoint (the location is irrelevant),
# then enable it (yes, it's already enabled by default), then hit it.
# Verify that we can set a breakpoint to be self-deleting after the
# first time it triggers.
if ![runto_main] then {
- fail "enable/disable break tests suppressed"
+ return
}
set bp [break_at "marker3" " line $bp_location17"]
"info break marker4"
if ![runto_main] then {
- fail "enable/disable break tests suppressed"
+ return
}
# Test enable count by stopping at a location until it is disabled
# a flavor of enablement/disablement, after all.)
if ![runto_main] then {
- fail "enable/disable break tests suppressed"
+ return
}
with_test_prefix "ignore count" {
# Verify that we can specify both an ignore count and an auto-delete.
if ![runto_main] then {
- fail "enable/disable break tests suppressed"
+ return
}
with_test_prefix "ignore count and auto-delete" {
# the bp is encountered.
if ![runto_main] then {
- fail "enable/disable break tests suppressed"
+ return
}
with_test_prefix "disabled breakpoint ignore count" {
# (Also verify that GDB gracefully handles the case where the inferior
# isn't stopped at a breakpoint.)
#
-if ![runto_main] then { fail "enable/disable break tests suppressed" }
+if ![runto_main] then {
+ return
+}
gdb_test "break $bp_location1" \
"Breakpoint \[0-9\]*.*, line $bp_location1.*" \
# Verify that GDB correctly handles the "enable/disable" command
# with arguments, that include multiple locations.
#
-if ![runto_main] then { fail "enable/disable break tests suppressed" }
+if ![runto_main] then {
+ return
+}
set b1 0
set b2 0
set bp_location [gdb_get_line_number "START"]
if ![runto "endianity.c:$bp_location" ] then {
- fail "couldn't run to start"
return -1
}
}
if ![runto_main] {
- untested "could not run to main"
return -1
}
# Start the program running, and stop at main.
#
if ![runto_main] then {
- fail "couldn't run ${testfile}"
return
}
clean_restart ${exec1}
if ![runto_main] then {
- fail "couldn't run to main"
return -1
}
clean_restart ${exec2}
if ![runto_main] then {
- fail "couldn't run to main"
return -1
}
gdb_test_no_output "set breakpoint always-inserted $always_inserted"
if ![runto_main] then {
- fail "couldn't run to main"
return -1
}
proc test { prefix body } {
with_test_prefix $prefix {
if ![runto_main] {
- fail "can't run to main"
return 0
}
uplevel 1 $body
proc finish_pretty { } {
if ![runto foo] {
- fail "can't run to foo"
return
}
gdb_test_no_output "set print pretty" \
proc finish_abbreviation { abbrev } {
if { ! [ runto "int_func" ] } then {
- fail "running to int_func"
return -1
}
global decimal
if {![runto "int_func"]} {
- untested "couldn't run to main"
return
}
gdb_test_no_output "set print finish off"
global gdb_prompt skip_float_test
if { ! [ runto_main ] } then {
- untested "couldn't run to main"
return -1
}
gdb_load_shlib ${lib_sl}
if ![runto_main] then {
- fail "can't run to main"
return 1
}
# Start the program running, and stop at main.
#
if ![runto_main] then {
- fail "couldn't run ${testfile}"
return
}
# Start the program running, and stop at main.
#
if ![runto_main] then {
- fail "couldn't run ${testfile}"
return
}
# Start the program running, and stop at main.
#
if ![runto_main] then {
- fail "couldn't run ${testfile}"
return
}
# Start the program running, and stop at main.
#
if ![runto_main] then {
- fail "couldn't run ${testfile}"
return
}
# Start the program running, and stop at main.
#
if ![runto_main] then {
- fail "couldn't run ${testfile} (2nd try)"
return
}
# Start the program running, and stop at main.
#
if ![runto_main] then {
- fail "couldn't run ${testfile} (3rd try)"
return
}
# Start the program running, and stop at main.
#
if ![runto_main] then {
- fail "couldn't run ${testfile} (4th try)"
return
}
# Start the program running, and stop at main.
#
if ![runto_main] then {
- fail "couldn't run ${testfile} (5th try)"
return
}
clean_restart $::testfile
if { ![runto_main] } {
- fail "could not run to main"
return 0
}
}
if ![runto_main] then {
- fail "can't run to main"
return 0
}
gdb_test_no_output "maint set dwarf unwinder $dwarf_unwinder"
if ![runto_main] then {
- fail "can't run to main"
return 0
}
}
if ![runto setup_done] then {
- fail "can't run to setup_done"
return 0
}
}
if ![runto_main] {
- fail "can't run to main"
return 0
}
}
if { ![runto_main] } {
- untested "could not run to main"
return -1
}
"set buffer exceeding arguments"
if { ! [ runto_main ] } then {
- untested "could not run to main"
return -1
}
# The binary is stripped of debug info, but not minsyms.
if ![runto break_here] {
- fail "can't run to break_here"
return -1
}
# The binary is stripped of debug info, but not minsyms.
if ![runto break_here] {
- fail "can't run to break_here"
return -1
}
}
if { ! [ runto_main ] } then {
- untested "couldn't run to main"
return -1
}
}
if ![runto_main] then {
- fail "can't run to main"
return 1
}
if { ![runto_main] } then {
- fail "run to main"
return
}
}
if { ![runto_main] } then {
- fail "run to main"
return
}
gdb_load_shlib $libobj
if ![runto_main] then {
- fail "can't run to main"
return 0
}
gdb_load_shlib ${lib_so}
if ![runto_main] then {
- fail "can't run to main"
return 1
}
gdb_load_shlib ${lib_so}
if ![runto_main] then {
- fail "can't run to main"
return 1
}
clean_restart ${binfile}
if { ![runto_main] } {
- fail "runto main"
return -1
}
gdb_test_no_output "set auto-solib-add off"
if ![runto_main] then {
- fail "can't run to main"
return 0
}
gdb_load_shlib $lib_so
if ![runto_main] then {
- fail "can't run to main"
return -1
}
}
if ![runto_main] {
- fail "can't run to main"
return -1
}
}
if ![runto_main] {
- untested ${test}.exp
return -1
}
set srcfile break.c
set srcfile1 break1.c
-if ![runto_main] then { fail "break tests suppressed" }
+if ![runto_main] then {
+ return
+}
+
delete_breakpoints
#
#***********
-if ![runto_main] then { fail "break tests suppressed" }
+if ![runto_main] then {
+ return
+}
# Verify that GDB responds gracefully when asked to set a breakpoint
# on a nonexistent source line.
# Verify that a "silent" breakpoint can be set, and that GDB is indeed
# "silent" about its triggering.
#
-if ![runto_main] then { fail "break tests suppressed" }
+if ![runto_main] then {
+ return
+}
gdb_test_multiple "hbreak $bp_location1" \
"set to-be-silent hardware break bp_location1" {
return -1
}
-if ![runto_main] then { fail "break tests suppressed" }
+if ![runto_main] then {
+ return
+}
+
delete_breakpoints
#
clean_restart $binfile
if ![runto_main] then {
- fail "can't run to main"
return -code return
}
set timeout 30
if { ! [ runto_main ] } then {
- untested "couldn't run to main"
return -1
}
}
if ![runto_main] {
- fail "can't run to main"
return -1
}
clean_restart $binfile
if {![runto_main]} {
- untested "could not run to main"
return -1
}
}
if ![runto_main] then {
- fail "couldn't run to main"
return -1
}
# Advance to main
if { ![runto_main] } then {
- fail "can't run to main"
return 0
}
gdb_test_no_output "set args $inferior_args"
if { ![runto_main] } {
- fail "could not run to main"
return -1
}
gdb_test "inferior" "\[Current inferior is 1 \[<null>\] (.*)\]" "inferior not running"
if { ![runto_main] } {
- untested "could not run to main"
return
}
clean_restart $executable
if ![runto_main] then {
- fail "can't run to main"
return 0
}
}
if ![runto_main] then {
- fail "can't run to main"
return 0
}
}
if ![runto_main] {
- untested "could not run to main"
return -1
}
}
if ![runto_main] then {
- fail "cannot run to main"
return -1
}
}
if { ! [ runto_main ] } then {
- untested "could not run to main"
return -1
}
}
if { ![runto_main] } {
- fail "can't run to main"
return -1
}
"info program after next"
if { ![runto_main] } then {
- fail "can't restart program"
return -1
}
}
if ![runto_main] then {
- fail "can't run to main"
return 0
}
}
if ![runto setup_done] then {
- fail "can't run to setup_done"
return 0
}
}
if ![runto_main] {
- untested $testfile.exp
return -1
}
if { [skip_python_tests] } { continue }
if ![runto_main] then {
- fail "can't run to main"
return 0
}
}
if ![runto_main] then {
- fail "run to main"
return -1
}
gdb_test "set follow-fork-mode child" ".*"
if ![runto "daemon_main"] {
- fail "can't run to daemon_main function"
return
}
gdb_test_no_output "set interactive-mode off"
if ![runto_main] {
- fail "can't run to main"
return -1
}
gdb_test_no_output "set follow-fork-mode ${follow-fork-mode}"
if { ![runto_main] } {
- fail "can't run to main"
return -1
}
}
if { ![runto_main] } {
- fail "can't run to main"
return
}
}
if { ![runto_main] } {
- fail "can't run to main"
return
}
clean_restart $binfile
if {![runto_main]} {
- fail "can't run to main"
return
}
clean_restart $binfile_dl2
if {![runto_main]} {
- untested "could not run to main"
return -1
}
}
if ![runto_main] then {
- fail "can't run to main"
return 0
}
if {![runto_main]} {
- fail "label tests suppressed"
return -1
}
}
if { ![runto_main] } then {
- unsupported "runto main"
return
}
}
if ![runto_main] {
- untested "could not run to main"
return -1
}
}
if ![runto_main] {
- fail "can't run to main"
return -1
}
clean_restart ${binfile}
if ![runto_main] then {
- fail "can't run to main"
return 0
}
clean_restart $binfile
if ![runto_main] then {
- fail "can't run to main"
return
}
}
if ![runto_main] {
- fail "can't run to main"
return -1
}
}
if { ![runto_main] } then {
- fail "run to main"
return
}
clean_restart ${binfile}
if { ![runto known_types] } then {
- fail "run to known_types"
return
}
clean_restart ${binfile}
if ![runto_main] then {
- fail "can't run to main"
return 0
}
# Start the program running.
if {! [runto_main]} {
- fail "macro tests suppressed: couldn't run to main"
return 0
}
}
if ![runto_main] then {
- untested "maint info sections"
return -1
}
gdb_test "maintenance show target-async" "Controlling the inferior in asynchronous mode is off\\."
if { ![runto_main] } {
- fail "can't run to main"
return
}
# Start the test.
if {![runto_main]} {
- fail "couldn't run to main"
return
}
# Advance to main.
if { ![runto_main] } then {
- fail "can't run to main"
return 0
}
}
if ![runto_main] then {
- fail "can't run to main"
return 0
}
clean_restart $testfile
if ![runto_main] {
- untested "could not run to main"
return -1
}
}
if ![runto_main] {
- fail "can't run to main"
return
}
test_break "before run"
if ![runto_main] {
- fail "can't run to main"
return
}
clean_restart $testfile
if ![runto_main] {
- untested "could not run to main"
return -1
}
# Test that we can continue working normally.
if ![runto_main] {
- fail "could not run to main"
+ return
}
}
global gdb_prompt
if { ! [ runto_main ] } then {
- untested "could not run to main"
return -1
}
global gdb_prompt
if { ! [ runto_main ] } then {
- untested "could not run to main"
return -1
}
clean_restart $binfile
if ![runto_main] {
- fail "cannot run to main"
return
}
clean_restart $binfile
if ![runto_main] {
- fail "cannot run to main"
return
}
#
if ![runto_main] then {
- fail "can't run to main"
return 0
}
clean_restart $binfile
if ![runto_main] then {
- fail "can't run to main"
return 0
}
clean_restart $binfile
if ![runto_main] then {
- fail "can't run to main"
return 0
}
clean_restart $binfile
if ![runto_main] then {
- fail "can't run to main"
return 0
}
clean_restart ${binfile}
if ![runto_main] {
- fail "can't run to main"
return
}
clean_restart ${testname}
if ![runto_main] {
- untested pr10179
return -1
}
clean_restart ${binfile}
if ![runto_main] then {
- fail "can't run to main"
return 0
}
}
if ![runto_main] {
- untested $testfile.exp
return -1
}
}
if ![runto_main] {
- untested $testfile.exp
return -1
}
gdb_load_shlib $libobj2
if ![runto_main] {
- untested "could not run to main"
return -1
}
gdb_load ${binfile}
if ![runto_main] then {
- fail "can't run to main"
return 0
}
if {$appear_how == "run"} {
if ![runto_main] then {
- fail "can't run to main"
return
}
} elseif {$appear_how == "attach" || $appear_how == "attach-nofile"} {
}
if ![runto_main] {
- fail "can't run to main"
return -1
}
}
if ![runto_main] {
- untested "could not run to main"
return -1
}
}
if ![runto_main] then {
- fail "can't run to main"
return 0
}
# Part THREE: Check the upload behavour
#
if ![runto_main] then {
- fail "cannot run to main"
return
}
global gdb_prompt skip_float_test
if { ! [ runto_main ] } then {
- untested "couldn't run to main"
return -1
}
}
if { ![runto_main] } {
- untested "could not run to main"
return
}
}
if ![runto_main] {
- untested "could not run to main"
return -1
}
# Delete all breakpoints so that the "runto_main" breakpoint above
# Now start a new debugger session...
clean_restart $testfile
if ![runto_main] {
- fail "cannot restart program"
return -1
}
# Delete all breakpoints so that the "runto_main" breakpoint above
# Advance to main
if ![runto_main] then {
- fail "can't run to main"
return 0
}
set srcfile1 break1.c
if ![runto_main] then {
- fail "couldn't run to main"
return
}
# inappropriately. (There are no calls to those system functions
# in this test program.)
#
-if ![runto_main] then { fail "sepdebug tests suppressed" }
+if ![runto_main] then {
+ return
+}
gdb_test "catch fork" "Catchpoint \[0-9\]+ \\(fork\\)" \
"set catch fork, never expected to trigger"
# Verify that a "silent" breakpoint can be set, and that GDB is indeed
# "silent" about its triggering.
#
-if ![runto_main] then { fail "sepdebug tests suppressed" }
+if ![runto_main] then {
+ return
+}
gdb_test_multiple "break $bp_location1" \
"set to-be-silent break bp_location1" {
# Verify that GDB responds gracefully to a "finish" command with
# arguments.
#
-if ![runto_main] then { fail "sepdebug tests suppressed" }
+if ![runto_main] then {
+ return
+}
gdb_test "finish 123" \
"The \"finish\" command does not take any arguments.*" \
gdb_test_no_output "set cwd ~/" "set inferior cwd to ~/ dir"
if { ![runto_main] } {
- untested "could not run to main"
return -1
}
gdb_test_no_output "set cwd $tmpdir" "set inferior cwd to temp dir"
if { ![runto_main] } {
- untested "could not run to main"
return -1
}
with_test_prefix "running with set cwd" {
if { ![runto_main] } {
- untested "could not run to main"
return -1
}
}
with_test_prefix "running without set cwd" {
if { ![runto_main] } {
- untested "could not run to main"
return -1
}
}
}
if ![runto_main] then {
- fail "can't run to main"
return 0
}
clean_restart $::binfile
if ![runto_main] then {
- fail "can't run to main"
return
}
clean_restart $::binfile
if ![runto_main] then {
- fail "can't run to main"
return
}
gdb_breakpoint "bar"
if { ![runto "bar"] } {
- fail "failed to run to bar"
return -1
}
# Load up the shared objects
if ![runto_main] then {
- fail "can't run to main"
return 0
}
# Advance to main
if ![runto_main] then {
- fail "can't run to main"
return 0
}
#
if ![runto_main] then {
- fail "can't run to main"
return 0
}
# Advance to main
if ![runto_main] then {
- fail "can't run to main"
return 0
}
# Advance to main
if ![runto_main] then {
- fail "can't run to main"
return 0
}
# Advance to main
if ![runto_main] then {
- fail "can't run to main"
return 0
}
# Advance to main
if ![runto_main] then {
- fail "can't run to main"
return 0
}
# Advance to main
if ![runto_main] then {
- fail "can't run to main"
return 0
}
clean_restart $binfile
if { ! [ runto_main ] } then {
- untested "failed to compile"
return -1
}
}
if ![runto_main] then {
- untested "could not run to main"
return -1
}
#
if ![runto_main] then {
- fail "can't run to main"
return 0
}
# Advance to main
if ![runto_main] then {
- fail "can't run to main"
return 0
}
set srcfile1 skip1.c
if ![runto_main] {
- fail "can't run to main"
return
}
gdb_test "bt" "\\s*\\#0\\s+main.*" "again back to main"
if ![runto_main] {
- fail "can't run to main"
return
}
}
if ![runto_main] {
- fail "can't run to main"
return
}
}
if ![runto_main] {
- fail "can't run to main"
return
}
"Num\\s+Enb\\s+Glob\\s+File\\s+RE\\s+Function\\s*" \
"1\\s+y\\s+n\\s+${srcfile_lib}\\s+n\\s+<none>\\s*"]
- if ![runto_main] { fail "skip tests suppressed" }
+ if ![runto_main] {
+ return
+ }
#
# We shouldn't step into square(), since we skipped skip-solib-lib.c.
"Function multiply will be skipped when stepping\\." \
"skip function"
- if ![runto_main] { fail "skip tests suppressed" }
+ if ![runto_main] {
+ return
+ }
#
# Our first step should take us into square.
gdb_test "skip -rfu foo.* xyzzy" "Invalid argument: xyzzy"
if ![runto_main] {
- fail "can't run to main"
return
}
# right over it and go to the second line of main().
if ![runto_main] {
- fail "can't run to main"
return
}
"info skip (delete 1)"
if ![runto_main] {
- fail "can't run to main"
return
}
"info skip shows entry as disabled"
if ![runto_main] {
- fail "can't run to main"
return
}
"info skip shows entry as enabled"
if ![runto_main] {
- fail "can't run to main"
return
}
with_test_prefix "step using -fi" {
if ![runto_main] {
- fail "can't run to main"
return
}
with_test_prefix "step using -gfi" {
if ![runto_main] {
- fail "can't run to main"
return
}
with_test_prefix "step using -fu for baz" {
if ![runto_main] {
- fail "can't run to main"
return
}
with_test_prefix "step using -rfu for baz" {
if ![runto_main] {
- fail "can't run to main"
return
}
with_test_prefix "step using -fi + -fu" {
gdb_test_no_output "skip delete"
- if ![runto test_skip_file_and_function no-message] {
- fail "can't run to test_skip_file_and_function"
+ if ![runto test_skip_file_and_function] {
return
}
global binfile
clean_restart "${binfile}"
if ![runto_main] {
- fail "can't run to main"
return
}
}
if ![runto_main] {
- fail "can't run to main"
return
}
# This program implicitly loads SOM shared libraries.
#
-if ![runto_main] then { fail "implicit solibs tests suppressed" }
+if ![runto_main] then {
+ return
+}
# Verify that we can step over the first shlib call.
#
}
if ![runto_main] {
- fail "can't run to main"
return
}
gdb_load_shlib $libobj
if ![runto_main] then {
- fail "can't run to main"
return 0
}
clean_restart $executable
if ![runto_main] then {
- fail "can't run to main"
return 0
}
clean_restart $testfile
if { ![runto_main] } {
- fail "can't run to main"
return
}
delete_breakpoints
if ![runto_main] then {
- fail "can't run to main"
return 0
}
clean_restart $testfile
if { ![runto_main] } {
- fail "can't run to main"
return
}
"\r\nSource directories searched: \\\$cdir\[:;\]\\\$cwd"
if ![runto_main] then {
- fail "can't run to main"
return 0
}
}
if ![runto_main] then {
- fail "can't run to main"
return 0
}
}
if ![runto_main] {
- fail "can't run to main"
return 0
}
}
if ![runto_main] then {
- fail "can't run to main"
return 0
}
clean_restart ${binfile}
if ![runto_main] then {
- fail "can't run to main"
return 0
}
}
if { ![runto_main] } then {
- fail "can't run to main"
return -1
}
}
if ![runto_main] then {
- fail "can't run to main"
return 0
}
}
if { ![runto_main] } {
- untested "failed to run to main"
return -1
}
}
if ![runto_main] then {
- fail "can't run to main"
return 0
}
}
if ![runto_main] {
- fail "can't run to main"
return -1
}
clean_restart $binfile
if ![runto_main] {
- fail "couldn't run to main"
- untested "stepping over breakpoint with displaced=$displaced"
return -1
}
clean_restart $testfile
if { ![runto_main] } then {
- fail "run to main ($syscall)"
return -1
}
set testfile "step-over-fork"
clean_restart $testfile
if { ![runto_main] } then {
- fail "run to main"
return -1
}
clean_restart ${binfile}
if ![runto_main] then {
- fail "can't run to main"
return 0
}
-re ".*(Program received|$inferior_exited_re).*$gdb_prompt $" {
# Oops... We ran to the end of the program... Better reset
if {![runto_main]} then {
- fail "$test (Can't run to main)"
return 0
}
if {![runto step-test.c:45]} {
- fail "$test (Can't run to line 45)"
return 0
}
fail "$test"
}
if ![runto_main] then {
- fail "can't run to main"
return 0
}
}
if ![runto_main] {
- untested "could not run to main"
return -1
}
}
if { ![runto_main] } {
- untested "could not run to main"
return
}
}
if {![runto_main]} {
- fail "style tests failed"
return
}
set readnow [readnow]
if {![runto_main]} {
- fail "style tests failed"
return
}
gdb_load_shlib ${lib_so}
if ![runto_main] then {
- fail "can't run to main"
return
}
}
if ![runto_main] then {
- fail "can't run to main"
continue
}
}
if {![runto_main]} {
- untested "could not run to main"
return -1
}
gdb_load_shlib $lib1
if ![runto_main] {
- fail "can't run to main"
return -1
}
}
if { ![runto_main] } {
- untested "could not run to main"
return
}
"test info terminal pre-execution"
if ![runto break_here] then {
- fail "can't run to break_here"
return 0
}
gdb_load_shlib ${libobj}
if ![runto_main] then {
- fail "can't run to main"
return 0
}
}
if ![runto_main] {
- fail "can't run to main"
return -1
}
}
if ![runto_main] {
- fail "can't run to main"
return 0
}
set bp_location21 [gdb_get_line_number "set breakpoint 21 here"]
if ![runto_main] then {
- fail "can't run to main"
return 0
}
}
if { ![runto_main] } {
- fail "can't run to main"
return 0
}
}
if ![runto done] {
- fail "couldn't run to done"
return
}
}
if ![runto f1] {
- fail "can't run to f1"
return
}
clean_restart ${testfile}
if { ![runto_main] } then {
- fail "run to main"
return
}
}
if ![runto_main] then {
- fail "can't run to main"
return
}
}
if ![runto_main] then {
- fail "can't run to main"
return
}
}
if ![runto_main] then {
- fail "can't run to main"
return
}
}
if ![runto_main] then {
- fail "can't run to main"
return
}
}
if { ![runto_main] } then {
- fail "run to main"
return
}
clean_restart ${testfile}
if { ![runto_main] } then {
- fail "run to main ($teststr)"
return
}
clean_restart ${binfile}
if { ![runto_main] } then {
- fail "run to main"
return
}
}
if ![runto_main] {
- untested "can't run to main"
return -1
}
}
if ![runto_main] then {
- fail "can't run to main"
return 0
}
}
if { ![runto_main] } then {
- fail "run to main"
return
}
clean_restart $binfile
if { ![runto_main] } then {
- fail "run to main"
return
}
}
if ![runto_main] {
- untested "could not run to main"
return -1
}
# (This proves rather little on kernels that don't support
# fast watchpoints, but still...)
#
- if ![runto_main] then { fail "watch tests suppressed" }
+ if ![runto_main] then {
+ return
+ }
gdb_test_no_output "set can-use-hw-watchpoints 0" "disable fast watches"
}
if ![runto_main] then {
- fail "can't run to main"
return 0
}
clean_restart $binfile
if ![runto_main] {
- fail "cannot run to main"
return
}
}
if ![runto_main] {
- untested "failed to run to main"
return -1
}
}
if ![runto_main] {
- untested "failed to run to main"
return -1
}
}
if ![runto_main] {
- untested "failed to run to main"
return -1
}
}
if ![runto_main] {
- untested "failed to run to main"
return -1
}
}
if ![runto_main] {
- untested "failed to run to main"
return -1
}
}
if ![runto_main] {
- untested "failed to run to main"
return -1
}
}
if ![runto_main] {
- untested "failed to run to main"
return -1
}
}
clean_restart $testfile
if ![runto_main] {
- untested "failed to run to main"
return -1
}
if ![runto_main] {
- untested "failed to run to main"
return -1
}
# make sure record-btrace can be enabled after re-run
clean_restart $testfile
if ![runto_main] {
- untested "failed to run to main"
return -1
}
gdb_test_no_output "record btrace" "enable after restart"
if ![runto_main] {
- untested "failed to run to main"
return -1
}
gdb_test_no_output "record btrace" "enable after re-run"
}
if ![runto_main] {
- untested "failed to run to main"
return -1
}
}
if ![runto_main] {
- untested "failed to run to main"
return -1
}
# make sure we can handle incomplete trace with respect to indentation
if ![runto_main] {
- untested "failed to run to main"
return -1
}
# navigate to the fib in line 24 above
}
if ![runto_main] {
- untested "failed to run to main"
return -1
}
}
if ![runto_main] {
- untested "failed to run to main"
return -1
}
with_test_prefix "inferior 1" {
if ![runto_main] {
- untested "failed to run to main"
return -1
}
}
gdb_test "inferior 2" "Switching to inferior 2.*"
if ![runto_main] {
- untested "inferior 2: failed to run to main"
return -1
}
gdb_test "inferior 3" "Switching to inferior 3.*"
if ![runto_main] {
- untested "inferior 3: failed to run to main"
return -1
}
clean_restart $testfile
if ![runto_main] {
- untested "failed to run to main"
return -1
}
}
if ![runto_main] {
- untested "failed to run to main"
return -1
}
}
if ![runto_main] {
- untested "failed to run to main"
return -1
}
}
if ![runto_main] {
- untested "failed to run to main"
return -1
}
}
if ![runto_main] {
- untested "failed to run to main"
return -1
}
}
if ![runto_main] {
- untested "failed to run to main"
return -1
}
return -1
}
if ![runto_main] {
- untested "failed to run to main"
return -1
}
}
if ![runto_main] {
- untested "failed to run to main"
return -1
}
}
if ![runto_main] {
- untested "failed to run to main"
return -1
}
}
if ![runto_main] {
- untested "failed to run to main"
return -1
}
return -1
}
if ![runto_main] {
- untested "failed to run to main"
return -1
}
}
if ![runto_main] {
- untested "failed to run to main"
return -1
}
}
if ![runto test] {
- untested "failed to run to main"
return -1
}
}
if ![runto_main] {
- untested "failed to run to main"
return -1
}
}
if {![runto_main]} {
- untested "could not run to main"
return -1
}
}
if {![runto_main]} {
- untested "could not run to main"
return -1
}
}
if {![runto_main]} {
- untested "could not run to main"
return -1
}
}
if {![runto_main]} {
- untested "could not run to main"
return -1
}
}
if {![runto_main]} {
- untested "could not run to main"
return -1
}
}
if {![runto_main]} {
- untested "could not run to main"
return -1
}
}
if {![runto_main]} {
- untested "could not run to main"
return -1
}
}
if {![runto_main]} {
- untested "could not run to main"
return -1
}
clean_restart ${binfile}
if ![runto_main] then {
- fail "can't run to main"
return 0
}
}
if ![runto_main] {
- untested abstract-origin
return -1
}
}
if {![runto_main]} {
- untested "could not run to main"
return -1
}
global gdb_prompt
if ![runto_main] {
- fail "couldn't run to main"
return
}
}
if {![runto_main]} {
- untested "could not run to main"
return -1
}
}
if ![runto_main] {
- untested destrprint
return -1
}
}
if ![runto 'marker'] then {
- fail "run to marker"
return -1
}
gdb_load_shlib $binfile_lib
if ![runto_main] {
- fail "can't run to main"
return 0
}
clean_restart $binfile
if ![runto_main] then {
- fail "can't run to main"
return
}
}
if ![runto_main] then {
- fail "couldn't run to breakpoint"
return
}
set bp_location [gdb_get_line_number "set multi-line breakpoint here" $hdrfile]
if { ![runto_main] } {
- fail "can't run to main for multi_line_foo tests."
return 0
}
set bp_location [gdb_get_line_number "set multi-line breakpoint here"]
if { ![runto_main] } {
- fail "can't run to main for multi_line_foo tests."
return 0
}
}
if {![runto_main]} {
- untested "failed to run to main"
return -1
}
}
if {![runto_main]} {
- untested "failed to run to main"
return -1
}
}
if ![runto_main] then {
- fail "can't run to main"
return
}
}
if ![runto_main] then {
- fail "can't run to main"
return
}
}
if {![runto_main]} {
- untested "couldn't run to main"
return -1
}
# Set it up at a breakpoint so we can play with the variable values.
#
if {![runto_main]} {
- untested "couldn't run to breakpoint"
return -1
}
if {![runto 'marker1']} {
- untested "couldn't run to marker1"
return -1
}
clean_restart $testfile
if ![runto_main] {
- untested "could not run to main"
return 0
}
# Delete all breakpoints so that the "runto_main" breakpoint above
}
if {![runto_main]} {
- fail "can't run to main"
return 0
}
}
if ![runto_main] {
- untested "could not run to main"
return -1
}
with_test_prefix $prefix {
if ![runto_main] {
- fail "can't run to main"
return
}
clean_restart ${executable}
if ![runto_main] {
- fail "can't run to main pass 2"
return
}
}
if ![runto_main] {
- untested "could not run to main"
return -1
}
}
if ![runto_main] {
- untested typeid
return -1
}
}
if ![runto_main] then {
- fail "can't run to main"
return 0
}
do_test_wide_char $lang "u16" "u32" "wchar"
}
if ![runto_main] then {
- fail "cannot run to main."
continue
}
gdb_test_no_output "set auto-solib-add off"
if { ![runto_main] } {
- fail "cannot run to main."
return -1
}
clean_restart ${binfile}
-runto main message
+runto main
gdb_load_shlib ${lib_so}
if ![runto_main] then {
- fail "can't run to main"
return
}
}
if { ![runto_main] } {
- fail "can't run to main"
return
}
}
if { ![runto_main] } {
- fail "can't run to main"
return
}
}
if { ![runto_main] } {
- fail "can't run to main"
return
}
}
if ![fortran_runto_main] {
- untested "could not run to main"
return -1
}
}
if ![fortran_runto_main] {
- untested "could not run to main"
return -1
}
}
if ![fortran_runto_main] {
- untested "could not run to main"
return -1
}
clean_restart ${binfile}
if ![fortran_runto_main] {
- untested "could not run to main"
return -1
}
}
if ![fortran_runto_main] {
- untested "could not run to main"
return -1
}
}
if ![fortran_runto_main] then {
- untested "couldn't run to main"
return -1
}
set string_func [find_mangled_name "string_func"]
if ![fortran_runto_main] {
- untested "could not run to main"
return -1
}
}
if ![fortran_runto_main] {
- untested "could not run to main"
return -1
}
}
if ![fortran_runto_main] {
- untested "could not run to main"
return -1
}
}
if ![fortran_runto_main] {
- fail "run to main"
return -1
}
}
if ![fortran_runto_main] {
- untested "could not run to main"
return -1
}
}
if ![fortran_runto_main] {
- untested "could not run to main"
return -1
}
if ![fortran_runto_main] {
- untested "could not run to main"
return -1
}
clean_restart ${binfile}
if ![runto_main] {
- untested "could not run to main"
return -1
}
}
if ![fortran_runto_main] {
- untested "could not run to main"
return -1
}
}
if { ![fortran_runto_main] } {
- fail "could not run to main"
return -1
}
}
if ![fortran_runto_main] {
- untested "could not run to main"
return -1
}
}
if {![fortran_runto_main]} then {
- untested "could not run to main"
return -1
}
}
if {![fortran_runto_main]} then {
- untested "couldn't run to main"
return -1
}
}
if ![fortran_runto_main] {
- untested "could not run to main"
return -1
}
}
if ![fortran_runto_main] {
- untested "could not run to main"
return -1
}
}
if ![fortran_runto_main] {
- untested "could not run to main"
return -1
}
}
if ![fortran_runto_main] {
- untested "could not run to main"
return -1
}
# handled correctly when using as VLA's
if ![fortran_runto_main] {
- untested "could not run to main"
return -1
}
}
if ![fortran_runto_main] {
- untested "could not run to main"
return -1
}
}
if ![fortran_runto_main] {
- untested "could not run to main"
return -1
}
}
if ![fortran_runto_main] {
- untested "could not run to main"
return -1
}
}
if ![fortran_runto_main] {
- untested "could not run to main"
return -1
}
}
if ![fortran_runto_main] {
- untested "could not run to main"
return -1
}
}
if ![fortran_runto_main] {
- untested "could not run to main"
return -1
}
}
if ![fortran_runto_main] {
- untested "could not run to main"
return -1
}
}
if ![fortran_runto_main] {
- untested "could not run to main"
return -1
}
}
if ![fortran_runto_main] {
- untested "could not run to main"
return -1
}
}
if ![fortran_runto_main] {
- untested "could not run to main"
return -1
}
}
if ![fortran_runto_main] {
- fail "run to main"
return
}
set bp_location2 [gdb_get_line_number "set breakpoint 2 here"]
if { [go_runto_main] < 0 } {
- untested "could not run to main"
return -1
}
set bp_location1 [gdb_get_line_number "set breakpoint 1 here"]
if { [go_runto_main] < 0 } {
- untested "could not run to main"
return -1
}
}
if { [go_runto_main] < 0 } {
- untested "could not run to main"
return -1
}
set bp_location1 [gdb_get_line_number "set breakpoint 1 here"]
if { [go_runto_main] < 0 } {
- untested "could not run to main"
return -1
}
set bp_location2 [gdb_get_line_number "set breakpoint 2 here"]
if { [go_runto_main] < 0 } {
- untested "could not run to main"
return -1
}
}
if { [go_runto_main] < 0 } {
- untested "could not run to main"
return -1
}
set bp_location2 {main.T.Bar}
if { [go_runto_main] < 0 } {
- untested "could not run to main"
return -1
}
clean_restart $testfile
if { [go_runto_main] < 0 } {
- untested methods
return -1
}
}
if { [go_runto_main] < 0 } {
- untested "could not run to main"
return -1
}
}
if { [go_runto_main] < 0 } {
- untested "could not run to main"
return -1
}
}
if { [go_runto_main] < 0 } {
- untested "could not run to main"
return -1
}
clean_restart ${testfile}
if ![gdb_guile_runto_main] {
- fail "cannot run to main."
return 0
}
delete_breakpoints
if { [skip_guile_tests] } { continue }
if ![gdb_guile_runto_main] {
- fail "can't run to main"
return
}
if { [skip_guile_tests] } { continue }
if ![runto_main] {
- fail "can't run to main"
return
}
# The following tests require execution.
if ![gdb_guile_runto_main] {
- fail "can't run to main"
return
}
if { [skip_guile_tests] } { continue }
if ![gdb_guile_runto_main] {
- fail "can't run to main"
return
}
clean_restart ${exefile}
if ![gdb_guile_runto_main ] {
- fail "can't run to main"
return
}
# The following tests require execution.
if ![gdb_guile_runto_main] {
- fail "can't run to main"
return
}
}
if ![runto_main] {
- fail "can't run to main"
return 0
}
gdb_test_no_output "set max-completions unlimited"
if {![runto_main]} {
- fail "can't run to main"
return 0
}
}
if ![runto_main] {
- fail "can't run to main"
return 0
}
mi_clean_restart $binfile
if {[mi_runto_main] < 0} {
- untested "could not run to main"
return -1
}
mi_gdb_load $binfile
if { [mi_runto_main] < 0 } {
- fail "can't run to main"
return
}
}
if { ![runto_main] } then {
- fail "can't run to main"
return -1
}
# Start the program running, and stop at main.
#
if ![runto_main] then {
- perror "Couldn't run ${binfile1}"
return
}
# Inferior 1 stops at f1.
if ![runto f1] then {
- fail "can't run to f1"
return 0
}
# Inferior 2 stops at f2.
if ![runto f2] then {
- fail "can't run to f2"
return 0
}
clean_restart ${from_exec}
if ![runto all_started] then {
- fail "couldn't run to all_started"
return -1
}
clean_restart ${exec1}
if ![runto_main] then {
- fail "starting inferior 1"
+ return
}
# Add and start inferior 2
gdb_load ${binfile2}
if ![runto_main] then {
- fail "starting inferior 2"
+ return
}
# Check we do have two inferiors loaded.
# Run the steady inferior to a breakpoint, and let it stay stopped
# there.
- if ![runto all_started message] then {
- untested "setup failed"
+ if ![runto all_started] then {
return 0
}
foreach_with_prefix iter {1 2} {
delete_breakpoints
- if ![runto all_started message] {
+ if ![runto all_started] {
return 0
}
# Run to main and delete breakpoints.
proc my_runto_main {} {
if ![runto_main] {
- fail "run to main"
return 0
} else {
# Delete breakpoints otherwise GDB would try to step over
"load binary"
if {![runto_main]} {
- fail "couldn't run to main."
return
}
}
if {![runto_main]} {
- fail "starting inferior 1"
return -1
}
"add the second inferior"
gdb_test "inferior 2" ".*Switching to inferior 2.*"
if {![runto_main]} {
- fail "starting inferior 2"
return -1
}
gdb_test "print duration=10" "= 10"
gdb_load ${binfile}
if ![runto_main] then {
- fail "starting inferior 2"
return
}
gdb_test_no_output "set detach-on-fork off"
if ![runto "child_function"] {
- fail "can't run to child_function"
return
}
}
if { ![runto start_sequence] } then {
- fail "run to start_sequence"
return
}
# Start with a clean state.
delete_breakpoints
if {![runto_main]} {
- untested "could not run to main"
return -1
}
clean_restart $binfile
if {![runto_main]} {
- untested "could not run to main"
continue
}
clean_restart $binfile
if {![runto_main]} {
- untested "could not run to main"
continue
}
clean_restart $binfile
if {![runto_main]} {
- untested "could not run to main"
continue
}
clean_restart $binfile
if {![runto_main]} {
- untested "could not run to main"
continue
}
clean_restart $binfile
if ![runto_main] {
- fail "can't run to main"
return -1
}
clean_restart $binfile
if ![runto_main] {
- fail "can't run to main"
return -1
}
return 0
global SKIP_STEP_COUNT SKIP_DIRECTIVE_COUNT
if ![runto_main] {
- fail "can't run to main"
return -1
}
clean_restart $binfile
if ![runto_main] {
- fail "can't run to main"
return -1
}
return 0
clean_restart $binfile
if ![runto_main] {
- fail "can't run to main"
return -1
}
return 0
clean_restart $binfile
if ![runto_main] {
- fail "can't run to main"
return -1
}
if { [skip_python_tests] } { continue }
if ![runto_main] then {
- fail "can't run to main"
return 0
}
}
if ![runto_main] {
- fail "couldn't run to main."
return 0
}
gdb_test_no_output "set print pretty on"
if { ![runto_main] } {
- fail "failed to run to main"
return
}
if { [skip_python_tests] } { continue }
if ![runto_main ] then {
- fail "can't run to main"
return -1
}
if { [skip_python_tests] } { continue }
if ![runto_main] then {
- fail "can't run to main"
return 0
}
clean_restart "${testfile}"
if ![runto_main] {
- perror "could not run to main"
- continue
+ return
}
# The following will create a breakpoint Python wrapper whose construction will
gdb_test "python print (gdb.breakpoints())" "\\(\\)"
if ![runto_main] then {
- fail "cannot run to main."
return 0
}
clean_restart ${testfile}
if ![runto_main] then {
- fail "cannot run to main."
return 0
}
clean_restart ${testfile}
if ![runto_main] then {
- fail "cannot run to main."
return 0
}
clean_restart ${testfile}
if ![runto_main] then {
- fail "cannot run to main."
return 0
}
clean_restart ${testfile}
if ![runto_main] then {
- fail "cannot run to main."
return 0
}
}
if ![runto_main] then {
- fail "cannot run to main."
return 0
}
gdb_test_no_output "set can-use-hw-watchpoints 0" ""
}
if ![runto_main] then {
- fail "cannot run to main."
return 0
}
delete_breakpoints
gdb_test_no_output "set can-use-hw-watchpoints 0" ""
}
if ![runto_main] then {
- fail "cannot run to main."
return 0
}
delete_breakpoints
clean_restart ${testfile}
if ![runto_main] then {
- fail "cannot run to main."
return 0
}
delete_breakpoints
clean_restart ${testfile}
if ![runto_main] then {
- fail "cannot run to main."
return 0
}
set two_location_re "Breakpoint $decimal at $hex:.*2 locations."
if ![runto_main] then {
- fail "cannot run to main."
return 0
}
}
if ![runto_main] then {
- fail "cannot run to main."
return 0
}
clean_restart ${testfile}
if ![runto_main] then {
- fail "cannot run to main."
return 0
}
clean_restart ${testfile}
if ![runto_main] then {
- fail "cannot run to main."
return 0
}
delete_breakpoints
if { [skip_python_tests] } { continue }
if ![runto_main] then {
- fail "cannot run to main."
return 0
}
gdb_load_shlib ${lib_sl}
if ![runto_main] then {
- fail "cannot run to main."
return 0
}
set cond_line [gdb_get_line_number "Condition Break."]
if ![runto_main] then {
- fail "cannot run to main."
return 0
}
"import python scripts, 3"
if ![runto call_longjmp_1] then {
- perror "couldn't run to breakpoint call_longjmp"
- continue
+ return
}
gdb_test "python finishbp = SimpleFinishBreakpoint(gdb.newest_frame())" \
if ![runto_main] then {
- fail "cannot run to main."
return 0
}
"import python scripts, 5"
if ![runto_main] then {
- fail "cannot run to main."
return 0
}
"import python scripts, 6"
if ![runto_main] then {
- fail "cannot run to main."
return 0
}
#
if ![runto "test_exec_exit"] then {
- fail "cannot run to test_exec_exit."
return 0
}
#
if ![runto "test_exec_exit"] then {
- fail "cannot run to test_exec_exit."
return 0
}
if { [skip_python_tests] } { continue }
if ![runto_main] then {
- fail "cannot run to main."
return 0
}
if { [skip_python_tests] } { continue }
if ![runto_main] then {
- fail "can't run to function f"
return 0
}
# The following tests require execution.
if ![runto_main] then {
- fail "can't run to main"
return 0
}
# The following tests require execution.
if ![runto_main] then {
- fail "can't run to main"
return 0
}
# The following tests require execution.
if ![runto_main] then {
- fail "can't run to main"
return 0
}
if { [skip_python_tests] } { continue }
if ![runto_main] then {
- fail "can't run to main"
return 0
}
}
if ![runto_main] {
- fail "can't run to main"
return 0
}
if { [skip_python_tests] } { continue }
if ![runto_main] then {
- fail "can't run to main"
return 0
}
if { [skip_python_tests] } { continue }
if ![runto_main ] then {
- fail "can't run to main"
return -1
}
${srcdir}/${subdir}/${testfile}.py]
if ![runto_main ] {
- fail "can't run to main"
return -1
}
clean_restart ${testfile}
set run_to_here [gdb_get_line_number {break to inspect} ${testfile}.c ]
- if ![runto ${testfile}.c:$run_to_here message] {
+ if ![runto ${testfile}.c:$run_to_here] {
return 0
}
"Verify set of random attribute in progspace"
if {![runto_main]} {
- fail "can't run to main"
return
}
if { [skip_python_tests] } { continue }
if ![runto_main] then {
- fail "can't run to main"
return 0
}
}
if { ![runto_main] } {
- untested "failed to run to main"
return -1
}
}
if ![runto_main ] then {
- fail "can't run to main"
return -1
}
}
if ![runto_main ] then {
- fail "can't run to main"
return -1
}
# The following tests require execution.
if ![runto_main] then {
- fail "can't run to main"
return 0
}
if {[skip_python_tests]} { continue }
if {![runto_main]} {
- untested "couldn't run to main"
return -1
}
# The following tests require execution.
if ![runto_main] then {
- fail "can't run to main"
return 0
}
"True" "lookup_static_symbol for global var"
if ![runto_main] then {
- fail "can't run to main"
return 0
}
"10" "print value of anon"
if ![runto_main] then {
- fail "can't run to main"
return 0
}
# Start with a fresh gdb.
clean_restart ${binfile}
if ![runto_main] then {
- fail "cannot run to main."
return 0
}
if { [skip_python_tests] } { continue }
if ![runto_main] then {
- fail "can't run to main"
return 0
}
# The following tests require execution.
if ![runto_main] then {
- fail "can't run to main"
return 0
}
set pyfile [gdb_remote_download host ${srcdir}/${subdir}/${testfile}.py]
if ![runto_main ] then {
- fail "can't run to main"
return -1
}
if { [skip_python_tests] } { continue }
if ![runto_main] then {
- fail "can't run to main"
return 0
}
# The following tests require execution.
if ![runto_main] then {
- fail "can't run to main"
return 0
}
# The following tests require execution.
if ![runto_main] then {
- fail "can't run to main"
return 0
}
# The following tests require execution.
if ![runto_main] then {
- fail "can't run to main"
return 0
}
# The following tests require execution.
if ![runto_main] then {
- fail "can't run to main"
return 0
}
# The following tests require execution.
if ![runto_main] then {
- fail "can't run to main"
return 0
}
}
if ![runto_main] then {
- fail "can't run to main"
return 0
}
return -1
}
if { ![runto_main] } then {
- fail "run to main"
return
}
}
if ![runto_main] then {
- fail "can't run to main"
return 0
}
}
if { ![runto_main] } {
- untested "failed to run to main"
return -1
}
clean_restart ${binfile}
if ![runto_main] then {
- fail "can't run to main"
return 0
}
proc do_test {version} {
if ![runto_main] {
- fail "can't run to main $version"
return -1
}
gdb_test "rb test" "" "set breakpoints $version"
}
if ![runto_main] {
- fail "cannot run to main"
return -1
}
gdb_load $binfile
if ![runto_main] {
- fail "cannot run to main"
return -1
}
}
clean_restart $binfile
if {![runto "all_started"]} {
- fail "could not run to all_started"
return
}
}
if { ![runto_main] } {
- untested "could not run to main"
return -1
}
}
if ![runto_main] {
- untested "could not run to main"
return -1
}
}
if ![runto_main] {
- untested "could not run to main"
return -1
}
}
if {[runto_main] <= 0} {
- untested "could not run to main"
return -1
}
clean_restart ${binfile}
if ![runto_main] then {
- fail "can't run to main"
return 0
}
set GDBFLAGS $saved_gdbflags
if ![runto_main] then {
- fail "can't run to main"
return 0
}
clean_restart ${binfile}
if ![runto_main] then {
- fail "can't run to main"
return 0
}
gdb_load ${binfile}
if ![runto_main] then {
- fail "can't run to main"
return 0
}
gdb_test_no_output "set displaced on"
if ![runto_main] then {
- fail "can't run to main"
return 0
}
set GDBFLAGS $saved_gdbflags
if ![runto_main] then {
- fail "can't run to main"
return 0
}
set timeout 30
if { ! [ runto_main ] } then {
- untested "could not run to main"
return -1
}
clean_restart ${binfile}
if { ![runto_main] } {
- fail "can't run to main"
return 0
}
}
if {![runto_main]} {
- fail "can't run to main"
return -1
}
gdb_test_no_output "set displaced-stepping $displaced"
if ![runto all_started] {
- fail "couldn't run to all_started"
return
}
set break_line [gdb_get_line_number "set breakpoint here"]
clean_restart ${binfile}
if { ![runto_main] } {
- fail "can't run to main"
return 0
}
}
if { ![runto_main] } then {
- fail "run to main"
return
}
gdb_test_no_output "set can-use-hw-watchpoints 1" ""
if ![runto_main] then {
- fail "can't run to main"
return
}
clean_restart "${binfile}"
if ![runto_main] then {
- fail "can't run to main"
return 0
}
}
if ![runto_main] then {
- fail "can't run to main"
return 0
}
}
if ![runto_main] {
- fail "can't run to main"
return -1
}
}
if {![runto_main]} {
- untested "could not run to main"
return -1
}
clean_restart ${binfile}
if ![runto_main] then {
- fail "can't run to main"
return 0
}
clean_restart ${binfile}
if ![runto_main] {
- fail "can't run to main"
return -1
}
clean_restart ${binfile}
if ![runto_main] {
- fail "can't run to main"
return -1
}
clean_restart ${binfile}
if ![runto_main] {
- fail "can't run to main"
return -1
}
set GDBFLAGS $saved_gdbflags
if ![runto_main] then {
- fail "can't run to main"
return 0
}
clean_restart ${binfile}
if ![runto_main] {
- fail "can't run to main"
return 0
}
clean_restart $executable
if ![runto_main] then {
- fail "can't run to main"
return 0
}
clean_restart ${binfile}
if ![runto_main] then {
- fail "can't run to main"
return 0
}
clean_restart ${binfile}
if ![runto_main] then {
- fail "can't run to main"
return 0
}
clean_restart ${binfile}
if ![runto_main] then {
- fail "can't run to main"
return 0
}
clean_restart ${binfile}
if ![runto "thread_function"] then {
- fail "can't run to thread_function"
return 0
}
clean_restart ${binfile}
if ![runto_main] then {
- fail "can't run to main"
return 0
}
}
if ![runto_main] then {
- fail "can't run to main"
return 0
}
global gdb_prompt
if ![runto_main] {
- untested "could not run to main"
return -1
}
clean_restart ${binfile}
if { ![runto_main] } {
- fail "can't run to main"
return 0
}
clean_restart ${binfile}
if ![runto_main] then {
- fail "can't run to main"
return 1
}
# The initial thread may log a 'New Thread' message, but we don't
# check for it.
if ![runto_main] then {
- fail "can't run to main $enabled_string"
return 1
}
#
if ![runto_main] then {
- fail "can't run to main"
return 0
}
clean_restart ${binfile}
if ![runto_main] {
- fail "can't run to main"
return -1
}
}
if ![runto_main] {
- fail "can't run to main"
return -1
}
clean_restart ${binfile}
if ![runto_main] then {
- fail "can't run to main"
return 0
}
gdb_load_shlib ${binfile_lib}
if ![runto_main] then {
- fail "can't run to main"
return 0
}
gdb_load_shlib ${binfile_lib}
if ![runto_main] then {
- fail "can't run to main"
return 0
}
}
if ![runto_main] then {
- fail "can't run to main"
return 0
}
clean_restart $binfile
if ![runto_main] then {
- fail "can't run to main"
return 0
}
clean_restart $binfile
if ![runto_main] then {
- fail "can't run to main"
return 0
}
#
if ![runto_main] then {
- fail "can't run to main"
return 0
}
#
if ![runto_main] then {
- fail "can't run to main"
return 0
}
# Run to `main' where we begin our tests.
if ![runto_main] then {
- fail "failed to run to main"
return 0
}
clean_restart $testfile
if ![runto_main] {
- fail "can't run to main to check for trace support"
return -1
}
gdb_breakpoint "main"
gdb_run_cmd
if {[gdb_test "" "Breakpoint .*"] != 0} {
- fail "can't run to main"
return -1
}
}
if ![runto_main] {
- fail "can't run to main to check for trace support"
return -1
}
gdb_load_shlib $lib_sl2
if ![runto_main] {
- fail "can't run to main to check for trace support"
return -1
}
clean_restart ${testfile}
if ![runto_main] {
- fail "can't run to main"
return -1
}
gdb_test_no_output "delete break 1"
clean_restart ${testfile}
if ![runto_main] {
- fail "can't run to main"
return -1
}
}
if { ![runto_main] } {
- fail "can't run to main to check for trace support"
return -1
}
clean_restart $testfile
if { ![runto_main] } {
- fail "can't run to main"
return 1
}
clean_restart $testfile
if { ![runto_main] } {
- fail "can't run to main"
return 1
}
clean_restart $testfile
if { ![runto_main] } {
- fail "can't run to main"
return 1
}
}
if ![runto_main] {
- fail "can't run to main to check for trace support"
return -1
}
# Start with a fresh gdb.
clean_restart ${executable}
if ![runto_main] {
- fail "can't run to main"
return -1
}
# Start with a fresh gdb.
clean_restart ${executable}
if ![runto_main] {
- fail "can't run to main"
return -1
}
clean_restart ${testfile}
if ![runto_main] {
- fail "can't run to main"
return -1
}
load_lib "trace-support.exp"
if ![runto_main] {
- fail "can't run to main to check for trace support"
return -1
}
clean_restart ${testfile}
if ![runto_main] {
- fail "can't run to main to check for trace support"
return -1
}
clean_restart ${executable}
if ![runto_main] {
- fail "can't run to main to check for trace support"
return -1
}
}
if ![runto_main] {
- fail "can't run to main to check for trace support"
return -1
}
clean_restart ${executable}
if ![runto_main] {
- fail "can't run to main for ftrace tests"
return 0
}
"collect gdb_struct1_test" "^$"
gdb_run_cmd
if {[gdb_test "" "Breakpoint ${decimal}, main.*"] != 0} {
- fail "can't run to main"
return -1
}
}
if ![runto_main] {
- fail "can't run to main to check for trace support"
return -1
}
}
if ![runto_main] {
- fail "can't run to main to check for trace support"
return -1
}
clean_restart $executable
if ![runto_main] {
- fail "can't run to main to check for trace support"
return -1
}
gdb_load_shlib $lib_sl1
gdb_load_shlib $lib_sl2
if ![runto_main] then {
- fail "can't run to main"
return 0
}
# Create tracepoints on marker and main, and leave them in the
gdb_load_shlib $lib_sl2
if ![runto_main] {
- fail "can't run to main to check for trace support"
return -1
}
clean_restart $testfile
if ![runto_main] {
- fail "can't run to main to check for trace support"
return -1
}
clean_restart $testfile
if ![runto_main] then {
- fail "can't run to main"
return 0
}
clean_restart $testfile
if ![runto_main] {
- fail "can't run to main to check for trace support"
return -1
}
with_test_prefix "after tstart" {
if ![runto_main] {
- fail "can't run to main, target may have died unexpectedly"
return -1
}
}
gdb_load_shlib $lib_sl2
if ![runto_main] {
- fail "can't run to main to check for trace support"
return -1
}
# Start with a fresh gdb.
clean_restart $executable
if ![runto_main] {
- fail "can't run to main"
return -1
}
# Start with a fresh gdb.
clean_restart $executable
if ![runto_main] {
- fail "can't run to main"
return -1
}
# Start with a fresh gdb.
clean_restart $executable
if ![runto_main] {
- fail "can't run to main"
return -1
}
# Start with a fresh gdb.
clean_restart $executable
if ![runto_main] {
- fail "can't run to main"
return -1
}
# Start with a fresh gdb.
clean_restart $executable
if ![runto_main] {
- fail "can't run to main"
return -1
}
}
if ![runto_main] {
- fail "can't run to main to check for trace support"
return -1
}
}
if ![runto_main] {
- fail "can't run to main to check for trace support"
return -1
}
}
if ![runto_main] {
- fail "can't run to main to check for trace support"
return -1
}
clean_restart ${executable}
if ![runto_main] {
- fail "can't run to main for ftrace tests"
return 0
}
}
if ![runto_main] {
- fail "can't run to main to check for trace support"
return -1
}
# Start with a fresh gdb.
clean_restart ${testfile}
if ![runto_main] {
- fail "can't run to main"
return -1
}
gdb_breakpoint "end" qualified
}
if ![runto_main] {
- fail "can't run to main to check for trace support"
return -1
}
# Start with a fresh gdb.
clean_restart ${testfile}
if ![runto_main] {
- fail "can't run to main"
return -1
}
}
if ![runto_main] {
- fail "can't run to main to check for trace support"
return -1
}
# Start with a fresh gdb.
clean_restart ${executable}
if ![runto_main] {
- fail "can't run to main"
return -1
}
# Start with a fresh gdb.
clean_restart ${executable}
if ![runto_main] {
- fail "can't run to main"
return -1
}
# Start with a fresh gdb.
clean_restart ${executable}
if ![runto_main] {
- fail "can't run to main"
return -1
}
clean_restart $executable
gdb_load_shlib $libipa
if ![runto_main] {
- fail "can't run to main"
return -1
}
clean_restart $executable
gdb_load_shlib $libipa
if ![runto_main] {
- fail "can't run to main"
return -1
}
clean_restart $executable
gdb_load_shlib $libipa
if ![runto_main] {
- fail "can't run to main"
return -1
}
clean_restart $executable
gdb_load_shlib $libipa
if ![runto_main] {
- fail "can't run to main"
return -1
}
clean_restart $executable
gdb_load_shlib $libipa
if ![runto_main] {
- fail "can't run to main"
return -1
}
clean_restart $executable
gdb_load_shlib $libipa
if ![runto_main] {
- fail "can't run to main to check for trace support"
return -1
}
if { ![gdb_target_supports_trace] } then {
}
if ![runto_main] {
- fail "can't run to main to check for trace support"
return -1
}
# Start with a fresh gdb.
clean_restart ${executable}
if ![runto_main] {
- fail "can't run to main"
return -1
}
# Start with a fresh gdb.
clean_restart ${executable}
if ![runto_main] {
- fail "can't run to main"
return -1
}
# Start with a fresh gdb.
clean_restart ${executable}
if ![runto_main] {
- fail "can't run to main"
return -1
}
# Start with a fresh gdb.
clean_restart ${executable}
if ![runto_main] {
- fail "can't run to main"
return -1
}
# Start with a fresh gdb.
clean_restart ${executable}
if ![runto_main] {
- fail "can't run to main"
return -1
}
# Start with a fresh gdb.
clean_restart ${executable}
if ![runto_main] {
- fail "can't run to main"
return -1
}
clean_restart ${executable}
if ![runto_main] {
- fail "can't run to main for ftrace tests"
return 0
}
}
if ![runto_main] {
- fail "can't run to main to check for trace support"
return -1
}
}
if ![runto_main] {
- fail "can't run to main to check for trace support"
return -1
}
clean_restart ${executable}
if ![runto_main] {
- fail "can't run to main for ftrace tests"
return 0
}
clean_restart ${executable}
if ![runto_main] {
- fail "can't run to main for ftrace tests"
return 0
}
clean_restart ${testfile}
if ![runto_main] {
- fail "can't run to main to check for trace support"
return -1
}
set expected 0
if ![runto_main] {
- fail "can't run to main."
return -1
}
clean_restart ${testfile}
if ![runto_main] {
- fail "can't run to main to check for trace support"
return -1
}
# Make sure inferior is running in all-stop mode.
gdb_test_no_output "set non-stop 0"
if ![runto_main] {
- fail "can't run to main"
return -1
}
# Start with a fresh gdb.
clean_restart ${executable}
if ![runto_main] {
- fail "can't run to main"
return -1
}
clean_restart ${executable}
if ![runto_main] {
- fail "can't run to main for ftrace tests"
return 0
}
}
if ![runto_main] {
- fail "can't run to main to check for trace support"
return -1
}
clean_restart ${testfile}
if ![runto_main] {
- fail "can't run to main to check for trace support"
return -1
}
}
if ![runto_main] {
- fail "can't run to main to check for trace support"
return -1
}
clean_restart ${binfile}
if ![runto_main] then {
- fail "can't run to main"
return
}
gdb_breakpoint "main"
gdb_run_cmd
if {[gdb_test "" "Breakpoint .*"] != 0} {
- fail "can't run to main"
return -1
}
}
if { ![runto_main] } {
- untested "could not run to main"
return -1
}
if {$execution} {
if ![runto_main] then {
- fail "can't run to main"
return 0
}
}
}
if ![runto_main] then {
- fail "can't run to main"
return 0
}
# Run to `main' where we begin our tests.
if ![runto_main] then {
- untested "could not run to main"
return -1
}
clean_restart $dst
if { ! [runto "GNAT_Debug_Info_Test"] } {
- fail "failed to run to GNAT_Debug_Info_Test"
return 0
}
proc gdb_guile_runto_main { } {
if ![runto_main] {
- fail "can't run to main"
return 0
}
# If you don't want that, use gdb_start_cmd.
proc runto_main { } {
- return [runto main no-message qualified]
+ return [runto main qualified]
}
### Continue, and expect to hit a breakpoint.
projects / binutils-gdb.git / commitdiff