1# Copyright 1992, 1994, 1995, 1997, 2004, 2007 Free Software Foundation, Inc. 2 3# This program is free software; you can redistribute it and/or modify 4# it under the terms of the GNU General Public License as published by 5# the Free Software Foundation; either version 3 of the License, or 6# (at your option) any later version. 7# 8# This program is distributed in the hope that it will be useful, 9# but WITHOUT ANY WARRANTY; without even the implied warranty of 10# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 11# GNU General Public License for more details. 12# 13# You should have received a copy of the GNU General Public License 14# along with this program. If not, see <http://www.gnu.org/licenses/>. 15 16# This file was adapted from bitfields.exp by Paul Hilfinger 17# (Hilfinger@gnat.com) 18 19# 20# Tests for bit-fields that do not fit in type (unsigned) int, but do fit 21# in type (unsigned) long long. We perform essentially the same tests as 22# in bitfields.c, which considers only bit-fields that are <= 9 bits long. 23# 24 25if $tracelevel then { 26 strace $tracelevel 27} 28 29set prms_id 0 30set bug_id 0 31 32set testfile "bitfields2" 33set srcfile ${testfile}.c 34set binfile ${objdir}/${subdir}/${testfile} 35if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {debug}] != "" } { 36 untested bitfields2.exp 37 return -1 38} 39 40set has_signed_bitfields 1 41 42# 43# Continue to expected breakpoint at FUNCTION. Append TAG to make pass/fail 44# messages (to make them unique). Suppress tests on failure. 45# 46proc continue_test { function tag } { 47 global decimal 48 global srcfile 49 50 if [gdb_test "cont" "Break.*$function \\(\\) at .*$srcfile:$decimal.*" "continuing to $function $tag"] { 51 gdb_suppress_tests 52 } 53} 54 55# 56# Start next test by running to tester and then to FUNCTION. Suppresses 57# tests on failure. 58# 59proc start_test { function } { 60 delete_breakpoints 61 if [gdb_test "break tester" "" "break tester prior to $function"] { 62 gdb_suppress_tests 63 } 64 continue_test "tester" "prior to $function" 65 if ![gdb_breakpoint $function] { 66 gdb_suppress_tests 67 } 68 continue_test $function "#0" 69} 70 71 72# 73# Test bitfield locating and uniqueness. 74# For each member, set that member to 1 and verify that the member (and only 75# that member) is 1, then reset it back to 0. 76# 77 78proc bitfield_uniqueness {} { 79 global decimal 80 global hex 81 global gdb_prompt 82 global srcfile 83 84 start_test break1 85 86 if [gdb_test "print flags" ".*u1 = 0, u2 = 0, u3 = 0, s1 = 1, s2 = 0, s3 = 0.*" "bitfield uniqueness; flags.s1 = 1"] { 87 gdb_suppress_tests; 88 } 89 continue_test break1 "#1" 90 if [gdb_test "print flags" ".*u1 = 1, u2 = 0, u3 = 0, s1 = 0, s2 = 0, s3 = 0.*" "bitfield uniqueness; flags.u1 = 1"] { 91 gdb_suppress_tests; 92 } 93 continue_test break1 "#2" 94 if [gdb_test "print flags" ".*u1 = 0, u2 = 0, u3 = 0, s1 = 0, s2 = 1, s3 = 0.*" "bitfield uniqueness; flags.s2 = 1"] { 95 gdb_suppress_tests; 96 } 97 continue_test break1 "#3" 98 if [gdb_test "print flags" ".*u1 = 0, u2 = 1, u3 = 0, s1 = 0, s2 = 0, s3 = 0.*" "bitfield uniqueness; flags.u2 = 1"] { 99 gdb_suppress_tests; 100 } 101 continue_test break1 "#4" 102 if [gdb_test "print flags" ".*u1 = 0, u2 = 0, u3 = 0, s1 = 0, s2 = 0, s3 = 1.*" "bitfield uniqueness; flags.s3 = 1"] { 103 gdb_suppress_tests; 104 } 105 continue_test break1 "#5" 106 if [gdb_test "print flags" ".*u1 = 0, u2 = 0, u3 = 1, s1 = 0, s2 = 0, s3 = 0.*" "bitfield uniqueness; flags.u3 = 1"] { 107 gdb_suppress_tests 108 } 109 gdb_stop_suppressing_tests; 110} 111 112 113# 114# Test bitfield containment. 115# Fill alternating fields with all 1's and verify that none of the bits 116# "bleed over" to the other fields. 117# 118 119proc bitfield_containment {} { 120 global decimal 121 global hex 122 global gdb_prompt 123 global srcfile 124 125 start_test break2 126 127 # If program is compiled with Sun CC, signed fields print out as their 128 # actual sizes; if compiled with gcc, they print out as 0xffffffff. 129 if [gdb_test "print/x flags" "= {u1 = 0x7fff, u2 = 0x0, u3 = 0xffff, s1 = 0x0, s2 = 0x(1ffffffff|f*), s3 = 0x0}" "bitfield containment; flags.u1, flags.u3, and flags.s3 to all 1s"] { 130 gdb_suppress_tests 131 } 132 133 continue_test break2 "#1" 134 135 if [gdb_test "print/x flags" "= {u1 = 0x0, u2 = 0x1ffffffff, u3 = 0x0, s1 = 0x(7fff|f*), s2 = 0x0, s3 = 0xf*}" "bitfield containment; flags.u2, flags.s1, flags.s2 to all 1s"] { 136 gdb_suppress_tests 137 } 138 gdb_stop_suppressing_tests; 139} 140 141# Test unsigned bitfields for unsignedness and range. 142# Fill the unsigned fields with the maximum positive value and verify that 143# the values are printed correctly. 144 145proc bitfield_unsignedness {} { 146 global decimal 147 global hex 148 global gdb_prompt 149 global srcfile 150 151 start_test break3 152 153 if [gdb_test "print flags" ".*u1 = 32767, u2 = 8589934591, u3 = 65535, s1 = 0, s2 = 0, s3 = 0.*" "maximum unsigned bitfield values"] { 154 gdb_suppress_tests 155 } 156 gdb_stop_suppressing_tests; 157} 158 159# 160# Test signed bitfields for signedness and range. 161# Fill the signed fields with the maximum positive value, then the maximally 162# negative value, then -1, and verify in each case that the values are 163# printed correctly. 164# 165 166proc bitfield_signedness {} { 167 global decimal 168 global hex 169 global gdb_prompt 170 global srcfile 171 global has_signed_bitfields 172 173 start_test break4 174 175 if [gdb_test "print flags" "= {.*u1 = 0, u2 = 0, u3 = 0, s1 = 16383, s2 = 4294967295, s3 = 32767.*}" "maximum signed bitfield values"] { 176 gdb_suppress_tests 177 } 178 179 continue_test break4 "#1" 180 181 # Determine if the target has signed bitfields so we can skip 182 # the signed bitfield tests if it doesn't. 183 set test "determining signed-ness of bitfields" 184 set has_signed_bitfields 0 185 gdb_test_multiple "print i" $test { 186 -re ".* = -32768.*$gdb_prompt $" { 187 set has_signed_bitfields 1 188 pass "determining signed-ness of bitfields" 189 } 190 -re ".* = 32768.*$gdb_prompt $" { 191 pass "determining signed-ness of bitfields" 192 } 193 -re ".*$gdb_prompt $" { 194 fail "determining signed-ness of bitfields" 195 gdb_suppress_tests 196 } 197 } 198 199 set test "most negative signed bitfield values" 200 if $has_signed_bitfields then { 201 if [gdb_test "print flags" "u1 = 0, u2 = 0, u3 = 0, s1 = -16384, s2 = -4294967296, s3 = -32768.*" $test ] { 202 gdb_suppress_tests 203 } 204 } else { 205 unsupported $test 206 } 207 208 continue_test break4 "#2" 209 210 set test "signed bitfields containing -1" 211 if $has_signed_bitfields then { 212 if [gdb_test "print flags" "u1 = 0, u2 = 0, u3 = 0, s1 = -1, s2 = -1, s3 = -1.*" $test ] { 213 gdb_suppress_tests 214 } 215 } else { 216 unsupported $test 217 } 218 219 gdb_stop_suppressing_tests; 220} 221 222 223# Test setting of long long bit fields from within GDB. 224 225proc bitfield_set {} { 226 global decimal 227 global hex 228 global gdb_prompt 229 global srcfile 230 global has_signed_bitfields 231 232 start_test break5 233 234 set big_set_failed 0 235 set test "set long long unsigned bitfield" 236 gdb_test_multiple "print flags.u2 = 0x100000000" $test { 237 -re "warning: Value does not fit.*$gdb_prompt $" { 238 fail "$test" 239 gdb_suppress_tests 240 } 241 -re "= 4294967296.*$gdb_prompt $" { 242 pass "$test" 243 } 244 } 245 246 set test "set long long signed bitfield positive" 247 gdb_test_multiple "print flags.s2 = 0x80000000" $test { 248 -re "warning: Value does not fit.*$gdb_prompt $" { 249 fail "$test" 250 gdb_suppress_tests 251 } 252 -re "= 2147483648.*$gdb_prompt $" { 253 pass "$test" 254 } 255 } 256 257 if [gdb_test "print flags" "u1 = 0, u2 = 4294967296, u3 = 0, s1 = 0, s2 = 2147483648, s3 = 0.*" "long long bitfield values after set"] { 258 gdb_suppress_tests 259 } 260 261 set test "set long long signed bitfield negative" 262 if $has_signed_bitfields then { 263 gdb_test_multiple "print flags.s2 = -1" $test { 264 -re "warning: Value does not fit.*$gdb_prompt $" { 265 fail "$test" 266 gdb_suppress_tests 267 } 268 -re "= -1.*$gdb_prompt $" { 269 pass "$test" 270 } 271 } 272 } else { 273 unsupported $test 274 } 275 276 set test "long long bitfield values after set negative" 277 if $has_signed_bitfields then { 278 if [gdb_test "print flags" "u1 = 0, u2 = 4294967296, u3 = 0, s1 = 0, s2 = -1, s3 = 0.*" $test] { 279 gdb_suppress_tests 280 } 281 } else { 282 unsupported $test 283 } 284 285 gdb_stop_suppressing_tests; 286} 287 288gdb_start 289gdb_reinitialize_dir $srcdir/$subdir 290gdb_load ${binfile} 291 292send_gdb "set print sevenbit-strings\n" ; gdb_expect -re "$gdb_prompt $" 293runto_main 294 295bitfield_uniqueness 296bitfield_containment 297bitfield_unsignedness 298bitfield_signedness 299bitfield_set 300 301