| # Copyright 2015-2021 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. |
| } |
| } |
| } |
| } |