* [RFA] Some testcases for long long bitfields
@ 2004-11-01 11:38 Paul Hilfinger
2004-11-11 20:09 ` Andrew Cagney
0 siblings, 1 reply; 6+ messages in thread
From: Paul Hilfinger @ 2004-11-01 11:38 UTC (permalink / raw)
To: gdb-patches
Since some mailers appear to have been adapted from dog simulations (causing
them to eat large sections of selected messages), I am resending drafts
of two files containing some test cases for selecting and setting long
long bit-fields.
OK?
Paul Hilfinger
2004-11-01 Paul N. Hilfinger <Hilfinger@gnat.com>
* values.c (modify_field): Correct handling of bit-fields that
don't fit in 32 bits. Use unsigned operations throughout and
simplify the code a bit. Document preconditions.
Index: merge.237/gdb/testsuite/gdb.base/bitfields2.exp
--- merge.237/gdb/testsuite/gdb.base/bitfields2.exp Mon, 01 Nov 2004 03:28:53 -0800 hilfingr ()
+++ merge.239(w)/gdb/testsuite/gdb.base/bitfields2.exp Sun, 31 Oct 2004 00:51:17 -0700 hilfingr (GdbPub/q/c/36_bitfields2 1.1 644)
@@ -0,0 +1,325 @@
+# Copyright 1992, 1994, 1995, 1997, 2004 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 2 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, write to the Free Software
+# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+
+# Please email any bugs, comments, and/or additions to this file to:
+# bug-gdb@prep.ai.mit.edu
+
+# This file was adapted from bitfields.exp by Paul Hilfinger
+# (Hilfinger@gnat.com)
+
+#
+# Tests for bit-fields that do not fit in type (unsigned) int, but do fit
+# in type (unsigned) long long. We perform essentially the same tests as
+# in bitfields.c, which considers only bit-fields that are <= 9 bits long.
+#
+
+if $tracelevel then {
+ strace $tracelevel
+}
+
+set prms_id 0
+set bug_id 0
+
+set testfile "bitfields2"
+set srcfile ${testfile}.c
+set binfile ${objdir}/${subdir}/${testfile}
+if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {debug}] != "" } {
+ gdb_suppress_entire_file "Testcase compile failed, so all tests in this file will automatically fail."
+}
+
+set no_signed 0
+
+#
+# Test bitfield locating and uniqueness.
+# For each member, set that member to 1 and verify that the member (and only
+# that member) is 1, then reset it back to 0.
+#
+
+proc bitfield_uniqueness {} {
+ global decimal
+ global hex
+ global gdb_prompt
+ global srcfile
+
+ if { ! [runto break1] } {
+ gdb_suppress_tests;
+ }
+
+ if [gdb_test "print flags" ".*u1 = 0, u2 = 0, u3 = 0, s1 = 1, s2 = 0, s3 = 0.*" "bitfield uniqueness (s1)"] {
+ gdb_suppress_tests;
+ }
+ if [gdb_test "cont" "Break.*break1 \\(\\) at .*$srcfile:$decimal.*" "continuing to break1 #1"] {
+ gdb_suppress_tests;
+ }
+ if [gdb_test "print flags" ".*u1 = 1, u2 = 0, u3 = 0, s1 = 0, s2 = 0, s3 = 0.*" "bitfield uniqueness (u1)"] {
+ gdb_suppress_tests;
+ }
+ if [gdb_test "cont" "Break.*break1 \\(\\) at .*$srcfile:$decimal.*" "continuing to break1 #2"] {
+ gdb_suppress_tests;
+ }
+ if [gdb_test "print flags" ".*u1 = 0, u2 = 0, u3 = 0, s1 = 0, s2 = 1, s3 = 0.*" "bitfield uniqueness (s2)"] {
+ gdb_suppress_tests;
+ }
+ if [gdb_test "cont" "Break.*break1 \\(\\) at .*$srcfile:$decimal.*" "continuing to break1 #3"] {
+ gdb_suppress_tests;
+ }
+ if [gdb_test "print flags" ".*u1 = 0, u2 = 1, u3 = 0, s1 = 0, s2 = 0, s3 = 0.*" "bitfield uniqueness (u2)"] {
+ gdb_suppress_tests;
+ }
+ if [gdb_test "cont" "Break.*break1 \\(\\) at .*$srcfile:$decimal.*" "continuing to break1 #4"] {
+ gdb_suppress_tests;
+ }
+ if [gdb_test "print flags" ".*u1 = 0, u2 = 0, u3 = 0, s1 = 0, s2 = 0, s3 = 1.*" "bitfield uniqueness (s3)"] {
+ gdb_suppress_tests;
+ }
+ if [gdb_test "cont" "Break.*break1 \\(\\) at .*$srcfile:$decimal.*" "continuing to break1 #5"] {
+ gdb_suppress_tests;
+ }
+ if [gdb_test "print flags" ".*u1 = 0, u2 = 0, u3 = 1, s1 = 0, s2 = 0, s3 = 0.*" "bitfield uniqueness (u3)"] {
+ gdb_suppress_tests
+ }
+ gdb_stop_suppressing_tests;
+}
+
+
+#
+# Test bitfield containment.
+# Fill alternating fields with all 1's and verify that none of the bits
+# "bleed over" to the other fields.
+#
+
+proc bitfield_containment {} {
+ global decimal
+ global hex
+ global gdb_prompt
+ global srcfile
+
+ delete_breakpoints
+
+ if { ![runto break2] } {
+ gdb_suppress_tests
+ }
+
+ # If program is compiled with Sun CC, signed fields print out as their
+ # actual sizes; if compiled with gcc, they print out as 0xffffffff.
+ if [gdb_test "print/x flags" "= {u1 = 0x7fff, u2 = 0x0, u3 = 0xffff, s1 = 0x0, s2 = 0x(1ffffffff|f*), s3 = 0x0}" "bitfield containment #1"] {
+ gdb_suppress_tests
+ }
+
+ if [gdb_test "cont" "Break.*break2 \\(\\) at .*$srcfile:$decimal.*" "continuing to break2"] {
+ gdb_suppress_tests
+ }
+
+ if [gdb_test "print/x flags" "= {u1 = 0x0, u2 = 0x1ffffffff, u3 = 0x0, s1 = 0x(7fff|f*), s2 = 0x0, s3 = 0xf*}" "bitfield containment #2"] {
+ gdb_suppress_tests
+ }
+ gdb_stop_suppressing_tests;
+}
+
+# Test unsigned bitfields for unsignedness and range.
+# Fill the unsigned fields with the maximum positive value and verify that
+# the values are printed correctly.
+
+proc bitfield_unsignedness {} {
+ global decimal
+ global hex
+ global gdb_prompt
+ global srcfile
+
+ delete_breakpoints
+
+ if { ![runto break3] } {
+ gdb_suppress_tests
+ }
+
+ if [gdb_test "print flags" ".*u1 = 32767, u2 = 8589934591, u3 = 65535, s1 = 0, s2 = 0, s3 = 0.*" "unsigned bitfield ranges"] {
+ gdb_suppress_tests
+ }
+ gdb_stop_suppressing_tests;
+}
+
+#
+# Test signed bitfields for signedness and range.
+# Fill the signed fields with the maximum positive value, then the maximally
+# negative value, then -1, and verify in each case that the values are
+# printed correctly.
+#
+
+proc bitfield_signedness {} {
+ global decimal
+ global hex
+ global gdb_prompt
+ global srcfile
+ global no_signed
+
+ delete_breakpoints
+
+ if { ! [runto break4] } {
+ gdb_suppress_tests
+ }
+
+ if [gdb_test "print flags" "= {.*u1 = 0, u2 = 0, u3 = 0, s1 = 16383, s2 = 4294967295, s3 = 32767.*}" "signed bitfields, max positive values"] {
+ gdb_suppress_tests
+ }
+
+ if [gdb_test "cont" "Break.*break4 \\(\\) at .*$srcfile:$decimal.*" "continuing to break4 #1"] {
+ gdb_suppress_tests
+ }
+
+ # Determine if the target has signed bitfields so we can xfail the
+ # the signed bitfield tests if it doesn't.
+ set no_signed 1
+ send_gdb "print i\n"
+ gdb_expect {
+ -re ".* = -32768.*$gdb_prompt $" {
+ set no_signed 0
+ pass "determining signed-ness of bitfields"
+ }
+ -re ".* = 32768.*$gdb_prompt $" {
+ pass "determining signed-ness of bitfields"
+ setup_xfail "*-*-*"
+ }
+ -re ".*$gdb_prompt $" {
+ fail "determining signed-ness of bitfields"
+ gdb_suppress_tests
+ }
+ default {
+ fail "determining signed-ness of bitfields" ;
+ gdb_suppress_tests;
+ }
+ }
+
+ if [gdb_test "print flags" "u1 = 0, u2 = 0, u3 = 0, s1 = -16384, s2 = -4294967296, s3 = -32768.*" "signed bitfields, max negative values"] {
+ gdb_suppress_tests
+ }
+
+ if [gdb_test "cont" "Break.*break4 \\(\\) at .*$srcfile:$decimal.*" "continuing to break4 #2"] {
+ gdb_suppress_tests
+ }
+
+ if [gdb_test "print flags" "u1 = 0, u2 = 0, u3 = 0, s1 = -1, s2 = -1, s3 = -1.*" "signed bitfields with -1"] {
+ gdb_suppress_tests
+ }
+ # Hmmmm???
+ gdb_stop_suppressing_tests;
+}
+
+
+# Test setting of long long bit fields from within GDB.
+
+proc bitfield_set {} {
+ global decimal
+ global hex
+ global gdb_prompt
+ global srcfile
+ global no_signed
+
+ delete_breakpoints
+
+ if { ! [runto break5] } {
+ gdb_suppress_tests
+ }
+
+ set big_set_failed 0
+ set test "set long long unsigned bitfield"
+ gdb_test_multiple "print flags.u2 = 0x100000000" $test {
+ -re "warning: Value does not fit.*$gdb_prompt $" {
+ fail "$test"
+ gdb_suppress_tests
+ }
+ -re "= 4294967296.*$gdb_prompt $" {
+ pass "$test"
+ }
+ }
+
+ set test "set long long signed bitfield positive"
+ gdb_test_multiple "print flags.s2 = 0x80000000" $test {
+ -re "warning: Value does not fit.*$gdb_prompt $" {
+ fail "$test"
+ gdb_suppress_tests
+ }
+ -re "= 2147483648.*$gdb_prompt $" {
+ pass "$test"
+ }
+ }
+
+ if [gdb_test "print flags" "u1 = 0, u2 = 4294967296, u3 = 0, s1 = 0, s2 = 2147483648, s3 = 0.*" "long long bitfield values after set"] {
+ gdb_suppress_tests
+ }
+
+ if $no_signed then {
+ setup_xfail "*-*-*"
+ }
+ set test "set long long signed bitfield negative"
+ gdb_test_multiple "print flags.s2 = -1" $test {
+ -re "warning: Value does not fit.*$gdb_prompt $" {
+ fail "$test"
+ gdb_suppress_tests
+ }
+ -re "= -1.*$gdb_prompt $" {
+ pass "$test"
+ }
+ }
+
+ if $no_signed then {
+ setup_xfail "*-*-*"
+ }
+ if [gdb_test "print flags" "u1 = 0, u2 = 4294967296, u3 = 0, s1 = 0, s2 = -1, s3 = 0.*" "long long bitfield values after set negative"] {
+ gdb_suppress_tests
+ }
+ gdb_stop_suppressing_tests;
+}
+
+gdb_start
+gdb_reinitialize_dir $srcdir/$subdir
+gdb_load ${binfile}
+
+send_gdb "set print sevenbit-strings\n" ; gdb_expect -re "$gdb_prompt $"
+
+bitfield_uniqueness
+if [istarget "mips-idt-*"] then {
+ # Restart because IDT/SIM runs out of file descriptors.
+ gdb_exit
+ gdb_start
+ gdb_reinitialize_dir $srcdir/$subdir
+ gdb_load ${binfile}
+}
+bitfield_containment
+if [istarget "mips-idt-*"] then {
+ # Restart because IDT/SIM runs out of file descriptors.
+ gdb_exit
+ gdb_start
+ gdb_reinitialize_dir $srcdir/$subdir
+ gdb_load ${binfile}
+}
+bitfield_unsignedness
+if [istarget "mips-idt-*"] then {
+ # Restart because IDT/SIM runs out of file descriptors.
+ gdb_exit
+ gdb_start
+ gdb_reinitialize_dir $srcdir/$subdir
+ gdb_load ${binfile}
+}
+bitfield_signedness
+if [istarget "mips-idt-*"] then {
+ # Restart because IDT/SIM runs out of file descriptors.
+ gdb_exit
+ gdb_start
+ gdb_reinitialize_dir $srcdir/$subdir
+ gdb_load ${binfile}
+}
+bitfield_set
+
Index: merge.237/gdb/testsuite/gdb.base/bitfields2.c
--- merge.237/gdb/testsuite/gdb.base/bitfields2.c Mon, 01 Nov 2004 03:28:53 -0800 hilfingr ()
+++ merge.239(w)/gdb/testsuite/gdb.base/bitfields2.c Sun, 31 Oct 2004 00:51:17 -0700 hilfingr (GdbPub/q/c/37_bitfields2 1.1 644)
@@ -0,0 +1,162 @@
+/* Test program to test bit field operations on bit fields of large
+ integer types. */
+
+/* This file is expected to fail to compile if the type long long int
+ is not supported, but in that case it is irrelevant. */
+
+#if !defined(__STDC__) && !defined(__cplusplus)
+#define signed /**/
+#endif
+
+struct fields
+{
+ unsigned long long u1 : 15;
+ unsigned long long u2 : 33;
+ unsigned long long u3 : 16;
+ signed long long s1 : 15;
+ signed long long s2 : 33;
+ signed long long s3 : 16;
+} flags;
+
+void break1 ()
+{
+}
+
+void break2 ()
+{
+}
+
+void break3 ()
+{
+}
+
+void break4 ()
+{
+}
+
+void break5 ()
+{
+}
+
+void break6 ()
+{
+}
+
+void break7 ()
+{
+}
+
+void break8 ()
+{
+}
+
+void break9 ()
+{
+}
+
+void break10 ()
+{
+}
+
+/* This is used by bitfields.exp to determine if the target understands
+ signed bitfields. */
+int i;
+
+int main ()
+{
+ /* For each member, set that member to 1, allow gdb to verify that the
+ member (and only that member) is 1, and then reset it back to 0. */
+
+#ifdef usestubs
+ set_debug_traps();
+ breakpoint();
+#endif
+ flags.s1 = 1;
+ break1 ();
+ flags.s1 = 0;
+
+ flags.u1 = 1;
+ break1 ();
+ flags.u1 = 0;
+
+ flags.s2 = 1;
+ break1 ();
+ flags.s2 = 0;
+
+ flags.u2 = 1;
+ break1 ();
+ flags.u2 = 0;
+
+ flags.s3 = 1;
+ break1 ();
+ flags.s3 = 0;
+
+ flags.u3 = 1;
+ break1 ();
+ flags.u3 = 0;
+
+ /* Fill alternating fields with all 1's and verify that none of the bits
+ "bleed over" to the other fields. */
+
+ flags.u1 = 0x7FFF;
+ flags.u3 = 0xFFFF;
+ flags.s2 = -1LL;
+ break2 ();
+ flags.u1 = 0;
+ flags.u3 = 0;
+ flags.s2 = 0;
+
+ flags.u2 = 0x1FFFFFFFFLL;
+ flags.s1 = -1;
+ flags.s3 = -1;
+ break2 ();
+
+ flags.u2 = 0;
+ flags.s1 = 0;
+ flags.s3 = 0;
+
+ /* Fill the unsigned fields with the maximum positive value and verify
+ that the values are printed correctly. */
+
+ flags.u1 = 0x7FFF;
+ flags.u2 = 0x1FFFFFFFFLL;
+ flags.u3 = 0xFFFF;
+ break3 ();
+ flags.u1 = 0;
+ flags.u2 = 0;
+ flags.u3 = 0;
+
+ /* Fill the signed fields with the maximum positive value, then the maximally
+ negative value, then -1, and verify in each case that the values are
+ printed correctly. */
+
+ /* Maximum positive values */
+ flags.s1 = 0x3FFF;
+ flags.s2 = 0xFFFFFFFFLL;
+ flags.s3 = 0x7FFF;
+ break4 ();
+
+ /* Maximally negative values */
+ flags.s1 = -0x4000;
+ flags.s2 = -0x100000000LL;
+ flags.s3 = -0x8000;
+
+ /* Extract bitfield value so that bitfield.exp can check if the target
+ understands signed bitfields. */
+ i = flags.s3;
+ break4 ();
+
+ /* -1 */
+ flags.s1 = -1;
+ flags.s2 = -1;
+ flags.s3 = -1;
+ break4 ();
+
+ flags.s1 = 0;
+ flags.s2 = 0;
+ flags.s3 = 0;
+
+ break5 ();
+
+ return 0;
+}
^ permalink raw reply [flat|nested] 6+ messages in thread
* Re: [RFA] Some testcases for long long bitfields
2004-11-01 11:38 [RFA] Some testcases for long long bitfields Paul Hilfinger
@ 2004-11-11 20:09 ` Andrew Cagney
2004-11-11 20:32 ` Paul Hilfinger
2004-11-26 22:49 ` Paul Hilfinger
0 siblings, 2 replies; 6+ messages in thread
From: Andrew Cagney @ 2004-11-11 20:09 UTC (permalink / raw)
To: Paul Hilfinger; +Cc: gdb-patches
Here we go :-)
- which system was it tested on?
- loose this:
> +# Please email any bugs, comments, and/or additions to this file to:
> +# bug-gdb@prep.ai.mit.edu
- reword the tests from:
> "bitfield uniqueness (u1)"
to something like:
bitfield uniqueness; flags.u1 = 1
so that what's being tested is clearer and the names are unique.
- on similar lines, take the gdb.sum file from running this testand put
it through 'uniq -d' s.fixing any duplicate
- use gdb_test_multiple
> + # Determine if the target has signed bitfields so we can xfail the
> + # the signed bitfield tests if it doesn't.
> + set no_signed 1
> + send_gdb "print i\n"
> + gdb_expect {
> + -re ".* = -32768.*$gdb_prompt $" {
> + set no_signed 0
> + pass "determining signed-ness of bitfields"
> + }
- Why? Or is this really a known bug?
> + if $no_signed then {
> + setup_xfail "*-*-*"
> + }
> + set test "set long long signed bitfield negative"
> + gdb_test_multiple "print flags.s2 = -1" $test {
> + -re "warning: Value does not fit.*$gdb_prompt $" {
> + fail "$test"
> + gdb_suppress_tests
> + }
> + -re "= -1.*$gdb_prompt $" {
> + pass "$test"
> + }
> + }
- ditto?
> + if $no_signed then {
> + setup_xfail "*-*-*"
> + }
> + if [gdb_test "print flags" "u1 = 0, u2 = 4294967296, u3 = 0, s1 = 0, s2 = -1, s3 = 0.*" "long long bitfield values after set negative"] {
> + gdb_suppress_tests
> + }
> + gdb_stop_suppressing_tests;
> +}
> +bitfield_uniqueness
- delete this:
> +if [istarget "mips-idt-*"] then {
> + # Restart because IDT/SIM runs out of file descriptors.
> + gdb_exit
> + gdb_start
> + gdb_reinitialize_dir $srcdir/$subdir
> + gdb_load ${binfile}
> +}
- for all these:
+ if { ! [runto break5] } {
+ gdb_suppress_tests
+ }
perhaphs think about what I did for the sig*.exp tests - have main as a
loop so that it looped around after each test sequence was finished -
will on remote systems improve the performance somewhat. But what ever.
Once all this are addressed, post the update _along_ with the system
tested on, and then it can be committed.
Andrew
^ permalink raw reply [flat|nested] 6+ messages in thread
* Re: [RFA] Some testcases for long long bitfields
2004-11-11 20:09 ` Andrew Cagney
@ 2004-11-11 20:32 ` Paul Hilfinger
2004-11-26 22:49 ` Paul Hilfinger
1 sibling, 0 replies; 6+ messages in thread
From: Paul Hilfinger @ 2004-11-11 20:32 UTC (permalink / raw)
To: Andrew Cagney; +Cc: gdb-patches
Andrew,
Thanks for the comments. I'll address them presently. If you have
free time on your hands (:->) you might want to turn your gimlet eye
on bitfields.exp, from which I stole most of this.
Paul Hilfinger
^ permalink raw reply [flat|nested] 6+ messages in thread
* Re: [RFA] Some testcases for long long bitfields
2004-11-11 20:09 ` Andrew Cagney
2004-11-11 20:32 ` Paul Hilfinger
@ 2004-11-26 22:49 ` Paul Hilfinger
2004-11-28 17:34 ` Andrew Cagney
1 sibling, 1 reply; 6+ messages in thread
From: Paul Hilfinger @ 2004-11-26 22:49 UTC (permalink / raw)
To: cagney; +Cc: gdb-patches
I believe that the following revision of the bitfields2 test (for
bitfields in long long fields) addresses Andrew's comments. I have
tested it on i686 GNU/Linux with GCC 3.2.3. OK?
Some specifics:
> - Why? Or is this really a known bug?
> > + if $no_signed then {
> > + setup_xfail "*-*-*"
> > + }
> > + set test "set long long signed bitfield negative"
> > + gdb_test_multiple "print flags.s2 = -1" $test {
> > + -re "warning: Value does not fit.*$gdb_prompt $" {
> > + fail "$test"
> > + gdb_suppress_tests
> > + }
> > + -re "= -1.*$gdb_prompt $" {
> > + pass "$test"
> > + }
> > + }
Well, this is what bitfields does, which is what I used as a model. On
reflection, however, it seems to me that XFAIL is inappropriate, since if
there is a failure here, it is most likely due to the fact the compiler
being used does not support signed bitfields---that is, a compiler for
which !defined(__STDC__) && !defined(__cplusplus) and which interprets
bitfields as unsigned. So it seems that the tests ought to be considered
unsupported instead, and I have made that change. But that merely changes
your question to "ARE there any compilers we need worry about with this
property". I have no idea, but other testcases seem to be written as if
there are.
> - delete this:
> +if [istarget "mips-idt-*"] then {
> + # Restart because IDT/SIM runs out of file descriptors.
> + gdb_exit
> + gdb_start
> + gdb_reinitialize_dir $srcdir/$subdir
> + gdb_load ${binfile}
> +}
Done. I observe, by the way, that this same code appears in several
existing tests: bitfields, funcargs, opaque, scope.
> perhaps think about what I did for the sig*.exp tests - have main as a
> loop so that it looped around after each test sequence was finished -
> will on remote systems improve the performance somewhat. But what ever.
OK. I have made a variant of this change that does not use GDB to modify the
control flow of the program.
Paul Hilfinger
ChangeLog:
2004-11-26 Paul N. Hilfinger <Hilfinger@gnat.com>
* gdb.base/bitfields2.c: New file.
* gdb.base/bitfields2.exp: New test.
Index: current-public.120/gdb/testsuite/gdb.base/bitfields2.exp
--- current-public.120/gdb/testsuite/gdb.base/bitfields2.exp Fri, 26 Nov 2004 14:10:02 -0800 hilfingr ()
+++ current-public.120(w)/gdb/testsuite/gdb.base/bitfields2.exp Fri, 26 Nov 2004 13:41:57 -0800 hilfingr (GdbPub/r/c/13_bitfields2 644)
@@ -0,0 +1,300 @@
+# Copyright 1992, 1994, 1995, 1997, 2004 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 2 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, write to the Free Software
+# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+
+# This file was adapted from bitfields.exp by Paul Hilfinger
+# (Hilfinger@gnat.com)
+
+#
+# Tests for bit-fields that do not fit in type (unsigned) int, but do fit
+# in type (unsigned) long long. We perform essentially the same tests as
+# in bitfields.c, which considers only bit-fields that are <= 9 bits long.
+#
+
+if $tracelevel then {
+ strace $tracelevel
+}
+
+set prms_id 0
+set bug_id 0
+
+set testfile "bitfields2"
+set srcfile ${testfile}.c
+set binfile ${objdir}/${subdir}/${testfile}
+if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {debug}] != "" } {
+ gdb_suppress_entire_file "Testcase compile failed, so all tests in this file will automatically fail."
+}
+
+set has_signed_bitfields 1
+
+#
+# Continue to expected breakpoint at FUNCTION. Append TAG to make pass/fail
+# messages (to make them unique). Suppress tests on failure.
+#
+proc continue_test { function tag } {
+ global decimal
+ global srcfile
+
+ if [gdb_test "cont" "Break.*$function \\(\\) at .*$srcfile:$decimal.*" "continuing to $function $tag"] {
+ gdb_suppress_tests
+ }
+}
+
+#
+# Start next test by running to tester and then to FUNCTION. Suppresses
+# tests on failure.
+#
+proc start_test { function } {
+ delete_breakpoints
+ if [gdb_test "break tester" "" "break tester prior to $function"] {
+ gdb_suppress_tests
+ }
+ continue_test "tester" "prior to $function"
+ if ![gdb_breakpoint $function] {
+ gdb_suppress_tests
+ }
+ continue_test $function "#0"
+}
+
+
+#
+# Test bitfield locating and uniqueness.
+# For each member, set that member to 1 and verify that the member (and only
+# that member) is 1, then reset it back to 0.
+#
+
+proc bitfield_uniqueness {} {
+ global decimal
+ global hex
+ global gdb_prompt
+ global srcfile
+
+ start_test break1
+
+ if [gdb_test "print flags" ".*u1 = 0, u2 = 0, u3 = 0, s1 = 1, s2 = 0, s3 = 0.*" "bitfield uniqueness; flags.s1 = 1"] {
+ gdb_suppress_tests;
+ }
+ continue_test break1 "#1"
+ if [gdb_test "print flags" ".*u1 = 1, u2 = 0, u3 = 0, s1 = 0, s2 = 0, s3 = 0.*" "bitfield uniqueness; flags.u1 = 1"] {
+ gdb_suppress_tests;
+ }
+ continue_test break1 "#2"
+ if [gdb_test "print flags" ".*u1 = 0, u2 = 0, u3 = 0, s1 = 0, s2 = 1, s3 = 0.*" "bitfield uniqueness; flags.s2 = 1"] {
+ gdb_suppress_tests;
+ }
+ continue_test break1 "#3"
+ if [gdb_test "print flags" ".*u1 = 0, u2 = 1, u3 = 0, s1 = 0, s2 = 0, s3 = 0.*" "bitfield uniqueness; flags.u2 = 1"] {
+ gdb_suppress_tests;
+ }
+ continue_test break1 "#4"
+ if [gdb_test "print flags" ".*u1 = 0, u2 = 0, u3 = 0, s1 = 0, s2 = 0, s3 = 1.*" "bitfield uniqueness; flags.s3 = 1"] {
+ gdb_suppress_tests;
+ }
+ continue_test break1 "#5"
+ if [gdb_test "print flags" ".*u1 = 0, u2 = 0, u3 = 1, s1 = 0, s2 = 0, s3 = 0.*" "bitfield uniqueness; flags.u3 = 1"] {
+ gdb_suppress_tests
+ }
+ gdb_stop_suppressing_tests;
+}
+
+
+#
+# Test bitfield containment.
+# Fill alternating fields with all 1's and verify that none of the bits
+# "bleed over" to the other fields.
+#
+
+proc bitfield_containment {} {
+ global decimal
+ global hex
+ global gdb_prompt
+ global srcfile
+
+ start_test break2
+
+ # If program is compiled with Sun CC, signed fields print out as their
+ # actual sizes; if compiled with gcc, they print out as 0xffffffff.
+ 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"] {
+ gdb_suppress_tests
+ }
+
+ continue_test break2 "#1"
+
+ 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"] {
+ gdb_suppress_tests
+ }
+ gdb_stop_suppressing_tests;
+}
+
+# Test unsigned bitfields for unsignedness and range.
+# Fill the unsigned fields with the maximum positive value and verify that
+# the values are printed correctly.
+
+proc bitfield_unsignedness {} {
+ global decimal
+ global hex
+ global gdb_prompt
+ global srcfile
+
+ start_test break3
+
+ if [gdb_test "print flags" ".*u1 = 32767, u2 = 8589934591, u3 = 65535, s1 = 0, s2 = 0, s3 = 0.*" "maximum unsigned bitfield values"] {
+ gdb_suppress_tests
+ }
+ gdb_stop_suppressing_tests;
+}
+
+#
+# Test signed bitfields for signedness and range.
+# Fill the signed fields with the maximum positive value, then the maximally
+# negative value, then -1, and verify in each case that the values are
+# printed correctly.
+#
+
+proc bitfield_signedness {} {
+ global decimal
+ global hex
+ global gdb_prompt
+ global srcfile
+ global has_signed_bitfields
+
+ start_test break4
+
+ if [gdb_test "print flags" "= {.*u1 = 0, u2 = 0, u3 = 0, s1 = 16383, s2 = 4294967295, s3 = 32767.*}" "maximum signed bitfield values"] {
+ gdb_suppress_tests
+ }
+
+ continue_test break4 "#1"
+
+ # Determine if the target has signed bitfields so we can skip
+ # the signed bitfield tests if it doesn't.
+ set test "determining signed-ness of bitfields"
+ set has_signed_bitfields 0
+ gdb_test_multiple "print i" $test {
+ -re ".* = -32768.*$gdb_prompt $" {
+ set has_signed_bitfields 1
+ pass "determining signed-ness of bitfields"
+ }
+ -re ".* = 32768.*$gdb_prompt $" {
+ pass "determining signed-ness of bitfields"
+ }
+ -re ".*$gdb_prompt $" {
+ fail "determining signed-ness of bitfields"
+ gdb_suppress_tests
+ }
+ }
+
+ set test "most negative signed bitfield values"
+ if $has_signed_bitfields then {
+ if [gdb_test "print flags" "u1 = 0, u2 = 0, u3 = 0, s1 = -16384, s2 = -4294967296, s3 = -32768.*" $test ] {
+ gdb_suppress_tests
+ }
+ } else {
+ unsupported $test
+ }
+
+ continue_test break4 "#2"
+
+ set test "signed bitfields containing -1"
+ if $has_signed_bitfields then {
+ if [gdb_test "print flags" "u1 = 0, u2 = 0, u3 = 0, s1 = -1, s2 = -1, s3 = -1.*" $test ] {
+ gdb_suppress_tests
+ }
+ } else {
+ unsupported $test
+ }
+
+ gdb_stop_suppressing_tests;
+}
+
+
+# Test setting of long long bit fields from within GDB.
+
+proc bitfield_set {} {
+ global decimal
+ global hex
+ global gdb_prompt
+ global srcfile
+ global has_signed_bitfields
+
+ start_test break5
+
+ set big_set_failed 0
+ set test "set long long unsigned bitfield"
+ gdb_test_multiple "print flags.u2 = 0x100000000" $test {
+ -re "warning: Value does not fit.*$gdb_prompt $" {
+ fail "$test"
+ gdb_suppress_tests
+ }
+ -re "= 4294967296.*$gdb_prompt $" {
+ pass "$test"
+ }
+ }
+
+ set test "set long long signed bitfield positive"
+ gdb_test_multiple "print flags.s2 = 0x80000000" $test {
+ -re "warning: Value does not fit.*$gdb_prompt $" {
+ fail "$test"
+ gdb_suppress_tests
+ }
+ -re "= 2147483648.*$gdb_prompt $" {
+ pass "$test"
+ }
+ }
+
+ if [gdb_test "print flags" "u1 = 0, u2 = 4294967296, u3 = 0, s1 = 0, s2 = 2147483648, s3 = 0.*" "long long bitfield values after set"] {
+ gdb_suppress_tests
+ }
+
+ set test "set long long signed bitfield negative"
+ if $has_signed_bitfields then {
+ gdb_test_multiple "print flags.s2 = -1" $test {
+ -re "warning: Value does not fit.*$gdb_prompt $" {
+ fail "$test"
+ gdb_suppress_tests
+ }
+ -re "= -1.*$gdb_prompt $" {
+ pass "$test"
+ }
+ }
+ } else {
+ unsupported $test
+ }
+
+ set test "long long bitfield values after set negative"
+ if $has_signed_bitfields then {
+ if [gdb_test "print flags" "u1 = 0, u2 = 4294967296, u3 = 0, s1 = 0, s2 = -1, s3 = 0.*" $test] {
+ gdb_suppress_tests
+ }
+ } else {
+ unsupported $test
+ }
+
+ gdb_stop_suppressing_tests;
+}
+
+gdb_start
+gdb_reinitialize_dir $srcdir/$subdir
+gdb_load ${binfile}
+
+send_gdb "set print sevenbit-strings\n" ; gdb_expect -re "$gdb_prompt $"
+runto_main
+
+bitfield_uniqueness
+bitfield_containment
+bitfield_unsignedness
+bitfield_signedness
+bitfield_set
+
Index: current-public.120/gdb/testsuite/gdb.base/bitfields2.c
--- current-public.120/gdb/testsuite/gdb.base/bitfields2.c Fri, 26 Nov 2004 14:10:02 -0800 hilfingr ()
+++ current-public.120(w)/gdb/testsuite/gdb.base/bitfields2.c Fri, 26 Nov 2004 13:41:57 -0800 hilfingr (GdbPub/r/c/14_bitfields2 644)
@@ -0,0 +1,172 @@
+/* Test program to test bit field operations on bit fields of large
+ integer types. */
+
+/* This file is expected to fail to compile if the type long long int
+ is not supported, but in that case it is irrelevant. */
+
+#include <stdlib.h>
+#include <string.h>
+
+#if !defined(__STDC__) && !defined(__cplusplus)
+#define signed /**/
+#endif
+
+struct fields
+{
+ unsigned long long u1 : 15;
+ unsigned long long u2 : 33;
+ unsigned long long u3 : 16;
+ signed long long s1 : 15;
+ signed long long s2 : 33;
+ signed long long s3 : 16;
+} flags;
+
+void break1 ()
+{
+}
+
+void break2 ()
+{
+}
+
+void break3 ()
+{
+}
+
+void break4 ()
+{
+}
+
+void break5 ()
+{
+}
+
+void break6 ()
+{
+}
+
+void break7 ()
+{
+}
+
+void break8 ()
+{
+}
+
+void break9 ()
+{
+}
+
+void break10 ()
+{
+}
+
+/* This is used by bitfields.exp to determine if the target understands
+ signed bitfields. */
+int i;
+
+void tester ()
+{
+ memset ((char *) &flags, 0, sizeof (flags));
+
+ /* For each member, set that member to 1, allow gdb to verify that the
+ member (and only that member) is 1, and then reset it back to 0. */
+ flags.s1 = 1;
+ break1 ();
+ flags.s1 = 0;
+
+ flags.u1 = 1;
+ break1 ();
+ flags.u1 = 0;
+
+ flags.s2 = 1;
+ break1 ();
+ flags.s2 = 0;
+
+ flags.u2 = 1;
+ break1 ();
+ flags.u2 = 0;
+
+ flags.s3 = 1;
+ break1 ();
+ flags.s3 = 0;
+
+ flags.u3 = 1;
+ break1 ();
+ flags.u3 = 0;
+
+ /* Fill alternating fields with all 1's and verify that none of the bits
+ "bleed over" to the other fields. */
+
+ flags.u1 = 0x7FFF;
+ flags.u3 = 0xFFFF;
+ flags.s2 = -1LL;
+ break2 ();
+ flags.u1 = 0;
+ flags.u3 = 0;
+ flags.s2 = 0;
+
+ flags.u2 = 0x1FFFFFFFFLL;
+ flags.s1 = -1;
+ flags.s3 = -1;
+ break2 ();
+
+ flags.u2 = 0;
+ flags.s1 = 0;
+ flags.s3 = 0;
+
+ /* Fill the unsigned fields with the maximum positive value and verify
+ that the values are printed correctly. */
+
+ flags.u1 = 0x7FFF;
+ flags.u2 = 0x1FFFFFFFFLL;
+ flags.u3 = 0xFFFF;
+ break3 ();
+ flags.u1 = 0;
+ flags.u2 = 0;
+ flags.u3 = 0;
+
+ /* Fill the signed fields with the maximum positive value, then the maximally
+ negative value, then -1, and verify in each case that the values are
+ printed correctly. */
+
+ /* Maximum positive values */
+ flags.s1 = 0x3FFF;
+ flags.s2 = 0xFFFFFFFFLL;
+ flags.s3 = 0x7FFF;
+ break4 ();
+
+ /* Maximally negative values */
+ flags.s1 = -0x4000;
+ flags.s2 = -0x100000000LL;
+ flags.s3 = -0x8000;
+
+ /* Extract bitfield value so that bitfield.exp can check if the target
+ understands signed bitfields. */
+ i = flags.s3;
+ break4 ();
+
+ /* -1 */
+ flags.s1 = -1;
+ flags.s2 = -1;
+ flags.s3 = -1;
+ break4 ();
+
+ flags.s1 = 0;
+ flags.s2 = 0;
+ flags.s3 = 0;
+
+ break5 ();
+}
+
+int main ()
+{
+ int i;
+#ifdef usestubs
+ set_debug_traps();
+ breakpoint();
+#endif
+ for (i = 0; i < 5; i += 1)
+ tester ();
+ return 0;
+}
^ permalink raw reply [flat|nested] 6+ messages in thread
* Re: [RFA] Some testcases for long long bitfields
2004-11-26 22:49 ` Paul Hilfinger
@ 2004-11-28 17:34 ` Andrew Cagney
2004-11-29 9:22 ` Paul Hilfinger
0 siblings, 1 reply; 6+ messages in thread
From: Andrew Cagney @ 2004-11-28 17:34 UTC (permalink / raw)
To: Paul Hilfinger; +Cc: gdb-patches
Paul Hilfinger wrote:
> I believe that the following revision of the bitfields2 test (for
> bitfields in long long fields) addresses Andrew's comments. I have
> tested it on i686 GNU/Linux with GCC 3.2.3. OK?
>
> Some specifics:
>
>
>>- Why? Or is this really a known bug?
>>
>>>+ if $no_signed then {
>>>+ setup_xfail "*-*-*"
>>>+ }
>>>+ set test "set long long signed bitfield negative"
>>>+ gdb_test_multiple "print flags.s2 = -1" $test {
>>>+ -re "warning: Value does not fit.*$gdb_prompt $" {
>>>+ fail "$test"
>>>+ gdb_suppress_tests
>>>+ }
>>>+ -re "= -1.*$gdb_prompt $" {
>>>+ pass "$test"
>>>+ }
>>>+ }
>
>
> Well, this is what bitfields does, which is what I used as a model. On
> reflection, however, it seems to me that XFAIL is inappropriate, since if
> there is a failure here, it is most likely due to the fact the compiler
> being used does not support signed bitfields---that is, a compiler for
> which !defined(__STDC__) && !defined(__cplusplus) and which interprets
> bitfields as unsigned. So it seems that the tests ought to be considered
> unsupported instead, and I have made that change. But that merely changes
> your question to "ARE there any compilers we need worry about with this
> property". I have no idea, but other testcases seem to be written as if
> there are.
True, ok.
>>- delete this:
>>+if [istarget "mips-idt-*"] then {
>>+ # Restart because IDT/SIM runs out of file descriptors.
>>+ gdb_exit
>>+ gdb_start
>>+ gdb_reinitialize_dir $srcdir/$subdir
>>+ gdb_load ${binfile}
>>+}
>
>
> Done. I observe, by the way, that this same code appears in several
> existing tests: bitfields, funcargs, opaque, scope.
>
>
>>perhaps think about what I did for the sig*.exp tests - have main as a
>>loop so that it looped around after each test sequence was finished -
>>will on remote systems improve the performance somewhat. But what ever.
>
>
> OK. I have made a variant of this change that does not use GDB to modify the
> control flow of the program.
Thanks! Ok for commit.
Andrew
^ permalink raw reply [flat|nested] 6+ messages in thread
* Re: [RFA] Some testcases for long long bitfields
2004-11-28 17:34 ` Andrew Cagney
@ 2004-11-29 9:22 ` Paul Hilfinger
0 siblings, 0 replies; 6+ messages in thread
From: Paul Hilfinger @ 2004-11-29 9:22 UTC (permalink / raw)
To: cagney; +Cc: gdb-patches
> Thanks! Ok for commit.
Thanks yourself. Committed.
Paul Hilfinger
^ permalink raw reply [flat|nested] 6+ messages in thread
end of thread, other threads:[~2004-11-29 9:22 UTC | newest]
Thread overview: 6+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2004-11-01 11:38 [RFA] Some testcases for long long bitfields Paul Hilfinger
2004-11-11 20:09 ` Andrew Cagney
2004-11-11 20:32 ` Paul Hilfinger
2004-11-26 22:49 ` Paul Hilfinger
2004-11-28 17:34 ` Andrew Cagney
2004-11-29 9:22 ` Paul Hilfinger
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox