228 lines
7.3 KiB
Text
228 lines
7.3 KiB
Text
|
# Copyright 2015-2022 Free Software Foundation, Inc.
|
||
|
|
|
||
|
|
# This program is free software; you can redistribute it and/or modify
|
||
|
|
# it under the terms of the GNU General Public License as published by
|
||
|
|
# the Free Software Foundation; either version 3 of the License, or
|
||
|
|
# (at your option) any later version.
|
||
|
|
#
|
||
|
|
# This program is distributed in the hope that it will be useful,
|
||
|
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||
|
|
# GNU General Public License for more details.
|
||
|
|
#
|
||
|
|
# You should have received a copy of the GNU General Public License
|
||
|
|
# along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||
|
|
|
||
|
|
# Generic/oft used support routines for testing GDB's compile feature.
|
||
|
|
|
||
|
|
# Return 1 if we should skip tests of the "compile" feature.
|
||
|
|
# This must be invoked after the inferior has been started.
|
||
|
|
|
||
|
|
proc skip_compile_feature_tests {} {
|
||
|
|
global gdb_prompt
|
||
|
|
|
||
|
|
set result 0
|
||
|
|
gdb_test_multiple "compile code -- ;" "check for working compile command" {
|
||
|
|
"Could not load libcc1.*\r\n$gdb_prompt $" {
|
||
|
|
set result 1
|
||
|
|
}
|
||
|
|
-re "Command not supported on this host\\..*\r\n$gdb_prompt $" {
|
||
|
|
set result 1
|
||
|
|
}
|
||
|
|
-re "\r\n$gdb_prompt $" {
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return $result
|
||
|
|
}
|
||
|
|
|
||
|
|
# This namespace provides some convenience functions for running
|
||
|
|
# "compile code" and "compile print" tests.
|
||
|
|
#
|
||
|
|
# Exported functions are defined inline below.
|
||
|
|
#
|
||
|
|
# General usage:
|
||
|
|
#
|
||
|
|
# Start a new session, noting that the variable "var" will be used for
|
||
|
|
# "compile code" expressions. This variable /must/ exist in the stopped
|
||
|
|
# location.
|
||
|
|
#
|
||
|
|
# CompileExpression::new "var"
|
||
|
|
#
|
||
|
|
# Test the implicit expression "foo;" with result/value 3.
|
||
|
|
# CompileExpression::test "foo" 3
|
||
|
|
# ---> Runs the following tests (name of tests ignored for illustration)
|
||
|
|
# gdb_test_no_output "compile code var = foo"
|
||
|
|
# gdb_test "p var" "= 3"
|
||
|
|
# gdb_test "compile print foo;" "= 3"
|
||
|
|
#
|
||
|
|
# Test the explicit expression "a = function (3); var = a;" with the result 21.
|
||
|
|
# CompileExpression::test "a = function (3); var = a;" 21 -explicit
|
||
|
|
# ---> Runs the following tests (name of tests ignored for illustration)
|
||
|
|
# gdb_test_no_output "compile code a = function (3); var = a;"
|
||
|
|
# gdb_test "p var" "= 21"
|
||
|
|
#
|
||
|
|
# Additional option flags may be passed to test to control the behavior
|
||
|
|
# of the test harness:
|
||
|
|
#
|
||
|
|
# Pass -explicit to specify that the test uses an explicit expression,
|
||
|
|
# one which sets the value of the variable (see above). Only the code test
|
||
|
|
# will be run.
|
||
|
|
#
|
||
|
|
# Pass -value and/or -print to indicate that the value and/or print steps
|
||
|
|
# will optionally fail. Specify "xfail" or "kfail" to indicate how
|
||
|
|
# particular step will fail. These may be followed by any accepted DejaGNU
|
||
|
|
# parameters such as architecture and bug#. [See examples below.]
|
||
|
|
#
|
||
|
|
# To specify that the compile (and consequently print and value tests) is
|
||
|
|
# expected to kfail/xfail, use -kfail or -xfail with any appropriate
|
||
|
|
# DejaGNU parameters. Both options override -print and -value.
|
||
|
|
# [-xfail is given precedence over -kfail should both be given.]
|
||
|
|
#
|
||
|
|
# -value is used when a "code" test is run, specifying that the "compile
|
||
|
|
# code" and "print VAR" steps will fail in the prescribed manner.
|
||
|
|
# [If the print step generates a PASS, the test is considered invalidly
|
||
|
|
# written. VAR's value should /always/ be invalidated before a test is
|
||
|
|
# run.]
|
||
|
|
#
|
||
|
|
# -print is used to specify that an expression will fail in the prescribed
|
||
|
|
# manner when "print" test is executed.
|
||
|
|
#
|
||
|
|
# Pass "-name NAME" to set an optional test name. If not specified,
|
||
|
|
# the harness will use test names such as "compile code EXPR" and
|
||
|
|
# "result of compile code EXPR".
|
||
|
|
#
|
||
|
|
# Pass "-noprint" or "-nocode" to suppress print or code tests, respectively,
|
||
|
|
# This is useful when the expression being tested modifies the object
|
||
|
|
# being tested, e.g., "a++".
|
||
|
|
#
|
||
|
|
# These options must be passed LAST to CompileExpression::test.
|
||
|
|
#
|
||
|
|
# Examples:
|
||
|
|
#
|
||
|
|
# Both "code" and "print" tests are expected to xfail:
|
||
|
|
# CompileExpression add_imp "foo" 3 -compile {xfail *-*-*} -print {xfail *-*-*}
|
||
|
|
#
|
||
|
|
# The "print $VARIABLE" portion of the "code" test is expected to kfail
|
||
|
|
# (the actual "compile code" GDB command will succeed), but the "print"
|
||
|
|
# test should pass:
|
||
|
|
# CompileExpression add_imp "foo" 3 -value {kfail *-*-* gdb/1234}
|
||
|
|
|
||
|
|
namespace eval ::CompileExpression {
|
||
|
|
|
||
|
|
# The variable name to check testing results. This variable
|
||
|
|
# must be in scope when tests are run.
|
||
|
|
variable varName_ {}
|
||
|
|
|
||
|
|
# Start a new expression list. VARNAME is the name of the variable
|
||
|
|
# that will be printed to check if the result of the test was
|
||
|
|
# successful.
|
||
|
|
proc new {varname} {
|
||
|
|
variable varName_
|
||
|
|
|
||
|
|
set varName_ $varname
|
||
|
|
}
|
||
|
|
|
||
|
|
# Test an expression.
|
||
|
|
#
|
||
|
|
# See the preamble for a list of valid optional arguments.
|
||
|
|
#
|
||
|
|
# Implicit expressions will be sent to GDB in the form
|
||
|
|
# "$varName = $EXP". "p $varName" will be used to decide the pass
|
||
|
|
# or fail status of the test.
|
||
|
|
#
|
||
|
|
# Explicit expressions will be sent to GDB as-is and tested using only
|
||
|
|
# "compile code". The expression should set the value of the variable
|
||
|
|
# $varName, which is then printed to determine whether the test passed
|
||
|
|
# or failed.
|
||
|
|
#
|
||
|
|
# Unlike explicit expressions, implicit expressions are tested with both
|
||
|
|
# "compile print" and "compile code".
|
||
|
|
|
||
|
|
proc test {exp result args} {
|
||
|
|
parse_args {{value {"" ""}} {print {"" ""}} {name ""}
|
||
|
|
{noprint} {nocode} {explicit} {xfail {"" ""}} {kfail {"" ""}}}
|
||
|
|
|
||
|
|
if {[lindex $xfail 0] != ""} {
|
||
|
|
set l "xfail $xfail"
|
||
|
|
} elseif {[lindex $kfail 0] != ""} {
|
||
|
|
set l "kfail $kfail"
|
||
|
|
} else {
|
||
|
|
set l ""
|
||
|
|
set compile {"" ""}
|
||
|
|
}
|
||
|
|
if {$l != ""} {
|
||
|
|
set compile $l
|
||
|
|
set print $l
|
||
|
|
set value $l
|
||
|
|
}
|
||
|
|
|
||
|
|
if {!$nocode} {
|
||
|
|
do_test_ code $exp $result $explicit $name \
|
||
|
|
[list $compile $value $print]
|
||
|
|
}
|
||
|
|
if {!$noprint} {
|
||
|
|
do_test_ print $exp $result $explicit $name \
|
||
|
|
[list $compile $value $print]
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
# Run a compile test for CMD ("print" or "code").
|
||
|
|
|
||
|
|
proc do_test_ {cmd exp result is_explicit tst fail_list} {
|
||
|
|
variable varName_
|
||
|
|
|
||
|
|
if {![string match $cmd "code"]
|
||
|
|
&& ![string match $cmd "print"]} {
|
||
|
|
error "invalid command, $cmd; should be \"print\" or \"compile\""
|
||
|
|
}
|
||
|
|
|
||
|
|
# Get expected result of test. Will be "" if test is
|
||
|
|
# expected to PASS.
|
||
|
|
lassign $fail_list fail_compile fail_value fail_print
|
||
|
|
|
||
|
|
# Set a test name if one hasn't been provided.
|
||
|
|
if {$tst == ""} {
|
||
|
|
set tst "compile $cmd $exp"
|
||
|
|
}
|
||
|
|
|
||
|
|
if {[string match $cmd "print"]} {
|
||
|
|
if {!$is_explicit} {
|
||
|
|
eval setup_failures_ $fail_print
|
||
|
|
gdb_test "compile print $exp" $result $tst
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
if {$is_explicit} {
|
||
|
|
set command "compile code $exp"
|
||
|
|
} else {
|
||
|
|
set command "compile code $varName_ = $exp"
|
||
|
|
}
|
||
|
|
eval setup_failures_ $fail_compile
|
||
|
|
gdb_test_no_output $command $tst
|
||
|
|
eval setup_failures_ $fail_value
|
||
|
|
gdb_test "p $varName_" "= $result" "result of $tst"
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
# A convenience proc used to set up xfail and kfail tests.
|
||
|
|
# HOW is either xfail or kfail (case is ignored). ARGS is any
|
||
|
|
# optional architecture, bug number, or other string to pass to
|
||
|
|
# respective DejaGNU setup_$how routines.
|
||
|
|
|
||
|
|
proc setup_failures_ {how args} {
|
||
|
|
switch -nocase $how {
|
||
|
|
xfail {
|
||
|
|
eval setup_xfail $args
|
||
|
|
}
|
||
|
|
|
||
|
|
kfail {
|
||
|
|
eval setup_kfail $args
|
||
|
|
}
|
||
|
|
|
||
|
|
default {
|
||
|
|
# Do nothing. Either the test is expected to PASS
|
||
|
|
# or we have an unhandled failure mode.
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|