* gdb.base/bitfields2.exp: New test.
* gdb.base/bitfields2.c: New file.
This commit is contained in:
Paul N. Hilfinger
parent
cbfc58d125
commit
c817078231
|
|
@ -1,3 +1,8 @@
|
|||
2004-11-29 Paul Hilfinger <Hilfinger@gnat.com>
|
||||
|
||||
* gdb.base/bitfields2.exp: New test.
|
||||
* gdb.base/bitfields2.c: New file.
|
||||
|
||||
2004-11-28 Richard Earnshaw <rearnsha@arm.com>
|
||||
|
||||
* config/sim.exp (gdb_load): Return 0 on success, -1 on failure.
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
}
|
||||
|
|
@ -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
|
||||
|
||||
Loading…
Reference in New Issue