1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
|
# Copyright 2015, 2016 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.
# 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.
#
# Otherwise, all expressions are considered implicit.
#
# Pass -value, -compile, and/or -print to indicate that the value,
# compile, or print steps will optionally fail. Specify "xfail" or
# "kfail" to indicate how each particular step will fail. These may be
# followed by any accepted DejaGNU parameters such as architecture and
# bug#.
#
# -compile and -value are used when a "code" test is run, the former
# specifying that the "compile code" command (to GDB) will fail or pass
# in the prescribed manner. -value indicates that the "print $VARIABLE"
# command (to GDB) will fail in the prescribed manner.
#
# -print is used to specify that an expression will fail in the presribed
# 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 {{compile {"" ""}} {value {"" ""}} {print {"" ""}} {name ""}
{noprint} {nocode} {explicit}}
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.
}
}
}
}
|
