-# Copyright (C) 1992, 1994, 1995, 1997, 1999 Free Software Foundation, Inc.
+# Copyright 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000
+# Free Software Foundation, Inc.
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
set gdb_prompt "\[(\]gdb\[)\]"
}
+# Needed for some tests under Cygwin.
+global EXEEXT
+global env
+
+if ![info exists env(EXEEXT)] {
+ set EXEEXT ""
+} else {
+ set EXEEXT $env(EXEEXT)
+}
+
### Only procedures should come after this point.
#
if [target_info exists use_gdb_stub] {
if [target_info exists gdb,do_reload_on_run] {
- # According to Stu, this will always work.
- gdb_load "";
+ # Specifying no file, defaults to the executable
+ # currently being debugged.
+ if { [gdb_load ""] < 0 } {
+ return;
+ }
send_gdb "continue\n";
gdb_expect 60 {
-re "Continu\[^\r\n\]*\[\r\n\]" {}
set start "start";
}
send_gdb "jump *$start\n"
- gdb_expect 30 {
- -re "Continuing at \[^\r\n\]*\[\r\n\]" {
- if ![target_info exists gdb_stub] {
- return;
- }
- }
- -re "No symbol \"start\" in current.*$gdb_prompt $" {
- send_gdb "jump *_start\n";
- exp_continue;
- }
- -re "No symbol \"_start\" in current.*$gdb_prompt $" {
- perror "Can't find start symbol to run in gdb_run";
+ set start_attempt 1;
+ while { $start_attempt } {
+ # Cap (re)start attempts at three to ensure that this loop
+ # always eventually fails. Don't worry about trying to be
+ # clever and not send a command when it has failed.
+ if [expr $start_attempt > 3] {
+ perror "Jump to start() failed (retry count exceeded)";
return;
}
- -re "Line.* Jump anyway.*y or n. $" {
- send_gdb "y\n"
- exp_continue;
- }
- -re "No symbol.*context.*$gdb_prompt $" {}
- -re "The program is not being run.*$gdb_prompt $" {
- gdb_load "";
- send_gdb "jump *$start\n";
- exp_continue;
+ set start_attempt [expr $start_attempt + 1];
+ gdb_expect 30 {
+ -re "Continuing at \[^\r\n\]*\[\r\n\]" {
+ set start_attempt 0;
+ }
+ -re "No symbol \"_start\" in current.*$gdb_prompt $" {
+ perror "Can't find start symbol to run in gdb_run";
+ return;
+ }
+ -re "No symbol \"start\" in current.*$gdb_prompt $" {
+ send_gdb "jump *_start\n";
+ }
+ -re "No symbol.*context.*$gdb_prompt $" {
+ set start_attempt 0;
+ }
+ -re "Line.* Jump anyway.*y or n. $" {
+ send_gdb "y\n"
+ }
+ -re "The program is not being run.*$gdb_prompt $" {
+ if { [gdb_load ""] < 0 } {
+ return;
+ }
+ send_gdb "jump *$start\n";
+ }
+ timeout {
+ perror "Jump to start() failed (timeout)";
+ return
+ }
}
- timeout { perror "Jump to start() failed (timeout)"; return }
}
if [target_info exists gdb_stub] {
gdb_expect 60 {
}
-# gdb_test COMMAND PATTERN MESSAGE -- send a command to gdb; test the result.
+### Continue, and expect to hit a breakpoint.
+### Report a pass or fail, depending on whether it seems to have
+### worked. Use NAME as part of the test name; each call to
+### continue_to_breakpoint should use a NAME which is unique within
+### that test file.
+proc gdb_continue_to_breakpoint {name} {
+ global gdb_prompt
+ set full_name "continue to breakpoint: $name"
+
+ send_gdb "continue\n"
+ gdb_expect {
+ -re "Breakpoint .* at .*\r\n$gdb_prompt $" {
+ pass $full_name
+ }
+ -re ".*$gdb_prompt $" {
+ fail $full_name
+ }
+ timeout {
+ fail "$full_name (timeout)"
+ }
+ }
+}
+
+
+
+# gdb_test COMMAND PATTERN MESSAGE QUESTION RESPONSE
+# Send a command to gdb; test the result.
#
# COMMAND is the command to execute, send to GDB with send_gdb. If
# this is the null string no command is sent.
# omitted, then the pass/fail messages use the command string as the
# message. (If this is the empty string, then sometimes we don't
# call pass or fail at all; I don't understand this at all.)
+# QUESTION is a question GDB may ask in response to COMMAND, like
+# "are you sure?"
+# RESPONSE is the response to send if QUESTION appears.
#
# Returns:
# 1 if the test failed,
# we need to set -notransfer expect option so that
# command output is not lost for pattern matching
# - guo
- gdb_expect -notransfer 2 {
- -re "\[\r\n\]" { }
- timeout { }
+ gdb_expect 2 {
+ -notransfer -re "\[\r\n\]" { verbose "partial: match" 3 }
+ timeout { verbose "partial: timeout" 3 }
}
set string [string range "$string" [expr $foo + 1] end];
} else {
}
}
- if [info exists timeout] {
- set tmt $timeout;
+ if [target_info exists gdb,timeout] {
+ set tmt [target_info gdb,timeout];
} else {
- global timeout;
if [info exists timeout] {
set tmt $timeout;
} else {
- set tmt 60;
+ global timeout;
+ if [info exists timeout] {
+ set tmt $timeout;
+ } else {
+ set tmt 60;
+ }
}
}
gdb_expect $tmt {
}
fail "$errmsg"
return -1
+ }
+ -re "EXIT code \[0-9\r\n\]+Program exited normally.*$gdb_prompt $" {
+ if ![string match "" $message] then {
+ set errmsg "$message: the program exited"
+ } else {
+ set errmsg "$command: the program exited"
+ }
+ fail "$errmsg"
+ return -1
}
-re "The program is not being run.*$gdb_prompt $" {
if ![string match "" $message] then {
if {![istarget "hppa*-*-hpux*"]} {
if { [llength $args] > 0 } {
if {$args == "c++"} {
- if { [gdb_compile "${srcdir}/${subdir}/compiler.cc" "${binfile}.ci" preprocess {}] != "" } {
+ if { [gdb_compile "${srcdir}/lib/compiler.cc" "${binfile}.ci" preprocess {}] != "" } {
perror "Couldn't make ${binfile}.ci file"
return 1;
}
}
} else {
- if { [gdb_compile "${srcdir}/${subdir}/compiler.c" "${binfile}.ci" preprocess {}] != "" } {
+ if { [gdb_compile "${srcdir}/lib/compiler.c" "${binfile}.ci" preprocess {}] != "" } {
perror "Couldn't make ${binfile}.ci file"
return 1;
}
if { [llength $args] > 0 } {
if {$args == "c++"} {
if { [eval gdb_preprocess \
- [list "${srcdir}/${subdir}/compiler.cc" "${binfile}.ci"] \
+ [list "${srcdir}/lib/compiler.cc" "${binfile}.ci"] \
$args] != "" } {
perror "Couldn't make ${binfile}.ci file"
return 1;
}
} elseif { $args != "f77" } {
if { [eval gdb_preprocess \
- [list "${srcdir}/${subdir}/compiler.c" "${binfile}.ci"] \
+ [list "${srcdir}/lib/compiler.c" "${binfile}.ci"] \
$args] != "" } {
perror "Couldn't make ${binfile}.ci file"
return 1;
return $result;
}
+set gdb_wrapper_initialized 0
+
+proc gdb_wrapper_init { args } {
+ global gdb_wrapper_initialized;
+ global gdb_wrapper_file;
+ global gdb_wrapper_flags;
+
+ if { $gdb_wrapper_initialized == 1 } { return; }
+
+ if {[target_info exists needs_status_wrapper] && \
+ [target_info needs_status_wrapper] != "0" && \
+ ![info exists gdb_wrapper_file]} {
+ set result [build_wrapper "testglue.o"];
+ if { $result != "" } {
+ set gdb_wrapper_file [lindex $result 0];
+ set gdb_wrapper_flags [lindex $result 1];
+ } else {
+ warning "Status wrapper failed to build."
+ }
+ }
+ set gdb_wrapper_initialized 1
+}
+
proc gdb_compile {source dest type options} {
global GDB_TESTCASE_OPTIONS;
+ global gdb_wrapper_file;
+ global gdb_wrapper_flags;
+ global gdb_wrapper_initialized;
if [target_info exists gdb_stub] {
set options2 { "additional_flags=-Dusestubs" }
verbose "options are $options"
verbose "source is $source $dest $type $options"
+ if { $gdb_wrapper_initialized == 0 } { gdb_wrapper_init }
+
+ if {[target_info exists needs_status_wrapper] && \
+ [target_info needs_status_wrapper] != "0" && \
+ [info exists gdb_wrapper_file]} {
+ lappend options "libs=${gdb_wrapper_file}"
+ lappend options "ldflags=${gdb_wrapper_flags}"
+ }
+
set result [target_compile $source $dest $type $options];
regsub "\[\r\n\]*$" "$result" "" result;
regsub "^\[\r\n\]*" "$result" "" result;
#
proc gdb_expect { args } {
- # allow -notransfer expect flag specification,
- # used by gdb_test routine for multi-line commands.
- # packed with gtimeout when fed to remote_expect routine,
- # which is a hack but due to what looks like a res and orig
- # parsing problem in remote_expect routine (dejagnu/lib/remote.exp):
- # what's fed into res is not removed from orig.
- # - guo
- if { [lindex $args 0] == "-notransfer" } {
- set notransfer -notransfer;
- set args [lrange $args 1 end];
- } else {
- set notransfer "";
- }
-
if { [llength $args] == 2 && [lindex $args 0] != "-re" } {
set gtimeout [lindex $args 0];
set expcode [list [lindex $args 1]];
}
}
set code [catch \
- {uplevel remote_expect host "$gtimeout $notransfer" $expcode} string];
+ {uplevel remote_expect host $gtimeout $expcode} string];
if [info exists old_val] {
set remote_suppress_flag $old_val;
} else {
}
}
+# gdb_expect_list MESSAGE SENTINEL LIST -- expect a sequence of outputs
#
# Check for long sequence of output by parts.
-# TEST: is the test message.
+# MESSAGE: is the test message to be printed with the test success/fail.
# SENTINEL: Is the terminal pattern indicating that output has finished.
# LIST: is the sequence of outputs to match.
# If the sentinel is recognized early, it is considered an error.
#
-proc gdb_expect_list {test sentinal list} {
+# Returns:
+# 1 if the test failed,
+# 0 if the test passes,
+# -1 if there was an internal error.
+#
+proc gdb_expect_list {test sentinel list} {
global gdb_prompt
+ global suppress_flag
set index 0
set ok 1
+ if { $suppress_flag } {
+ set ok 0
+ }
while { ${index} < [llength ${list}] } {
set pattern [lindex ${list} ${index}]
set index [expr ${index} + 1]
if { ${index} == [llength ${list}] } {
if { ${ok} } {
gdb_expect {
- -re "${pattern}${sentinal}" {
- pass "${test}, pattern ${index} + sentinal"
+ -re "${pattern}${sentinel}" {
+ pass "${test}, pattern ${index} + sentinel"
+ }
+ -re "${sentinel}" {
+ fail "${test}, pattern ${index} + sentinel"
+ set ok 0
}
timeout {
- fail "${test}, pattern ${index} + sentinal (timeout)"
+ fail "${test}, pattern ${index} + sentinel (timeout)"
set ok 0
}
}
} else {
- fail "${test}, pattern ${index} + sentinal"
+ unresolved "${test}, pattern ${index} + sentinel"
}
} else {
if { ${ok} } {
-re "${pattern}" {
pass "${test}, pattern ${index}"
}
- -re "${sentinal}" {
+ -re "${sentinel}" {
fail "${test}, pattern ${index}"
set ok 0
}
}
}
} else {
- fail "${test}, pattern ${index}"
+ unresolved "${test}, pattern ${index}"
}
}
}
+ if { ${ok} } {
+ return 0
+ } else {
+ return 1
+ }
}
#
}
}
+# Return true if FORMAT matches the debug format the current test was
+# compiled with. FORMAT is a shell-style globbing pattern; it can use
+# `*', `[...]', and so on.
+#
+# This function depends on variables set by `get_debug_format', above.
+
+proc test_debug_format {format} {
+ global debug_format
+
+ return [expr [string match $format $debug_format] != 0]
+}
+
# Like setup_xfail, but takes the name of a debug format (DWARF 1,
# COFF, stabs, etc). If that format matches the format that the
# current test was compiled with, then the next test is expected to
# fail for any target. Returns 1 if the next test or set of tests is
# expected to fail, 0 otherwise (or if it is unknown). Must have
# previously called get_debug_format.
-
proc setup_xfail_format { format } {
- global debug_format
+ set ret [test_debug_format $format];
- if [string match $debug_format $format] then {
+ if {$ret} then {
setup_xfail "*-*-*"
- return 1;
}
- return 0
-}
+ return $ret;
+}
proc gdb_step_for_stub { } {
global gdb_prompt;
# Don't bother to check the output of the program, that may be
# extremely tough for some remote systems.
gdb_test "continue"\
- "Continuing.\[\r\n0-9\]+Program exited normally\\..*"\
+ "Continuing.\[\r\n0-9\]+(... EXIT code 0\[\r\n\]+|)Program exited normally\\..*"\
"continue until exit at $mssg"
}
}
}
}
+# Print a message and return true if a test should be skipped
+# due to lack of floating point suport.
+
+proc gdb_skip_float_test { msg } {
+ if [target_info exists gdb,skip_float_tests] {
+ verbose "Skipping test '$msg': no float tests.";
+ return 1;
+ }
+ return 0;
+}
+
+# Print a message and return true if a test should be skipped
+# due to lack of stdio support.
+
+proc gdb_skip_stdio_test { msg } {
+ if [target_info exists gdb,noinferiorio] {
+ verbose "Skipping test '$msg': no inferior i/o.";
+ return 1;
+ }
+ return 0;
+}
+
+proc gdb_skip_bogus_test { msg } {
+ return 0;
+}
+
projects / deliverable / binutils-gdb.git / blobdiff