blob: ddfd65771f57058673403162240ac563e835abe6 [file] [log] [blame]
# 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
# 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 <>.
# 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.