From edcc8c754b3bb1e366ea5f5b9d1832625f865e25 Mon Sep 17 00:00:00 2001 From: Andrew Cagney Date: Thu, 21 Feb 2002 01:55:05 +0000 Subject: [PATCH] * gdb.base/sizeof.c (main): Call fill_structs. Print value of signed, unsigned and straight char. (padding_char, padding_short, padding_int, padding_long, padding_long_long, padding_float, padding_double, padding_long_double): New global variables. (fill, fill_structs): New functions. * gdb.base/sizeof.exp: Check for signed and unsigned char. Check for correctly sized writes. Update copyright. (get_valueof): New procedure. (get_sizeof): Call get_valueof. (check_valueof): New procedure. (check_padding): New procedure. --- gdb/testsuite/ChangeLog | 16 ++++++ gdb/testsuite/gdb.base/sizeof.c | 103 ++++++++++++++++++++++++++++++++++++++ gdb/testsuite/gdb.base/sizeof.exp | 80 +++++++++++++++++++++++++---- 3 files changed, 188 insertions(+), 11 deletions(-) diff --git a/gdb/testsuite/ChangeLog b/gdb/testsuite/ChangeLog index ae69e5d..7b6f57e 100644 --- a/gdb/testsuite/ChangeLog +++ b/gdb/testsuite/ChangeLog @@ -1,3 +1,19 @@ +2002-02-20 Andrew Cagney + + * gdb.base/sizeof.c (main): Call fill_structs. Print value of + signed, unsigned and straight char. + (padding_char, padding_short, padding_int, padding_long, + padding_long_long, padding_float, padding_double, + padding_long_double): New global variables. + (fill, fill_structs): New functions. + + * gdb.base/sizeof.exp: Check for signed and unsigned char. Check + for correctly sized writes. Update copyright. + (get_valueof): New procedure. + (get_sizeof): Call get_valueof. + (check_valueof): New procedure. + (check_padding): New procedure. + 2002-02-20 Michael Chastain * gdb.c++/virtfunc.exp (test_virtual_calls): Remove obsolete calls diff --git a/gdb/testsuite/gdb.base/sizeof.c b/gdb/testsuite/gdb.base/sizeof.c index 51f8c2f..95d379e 100644 --- a/gdb/testsuite/gdb.base/sizeof.c +++ b/gdb/testsuite/gdb.base/sizeof.c @@ -1,8 +1,105 @@ #include +typedef char padding[16]; + +struct { + padding p1; + char v; + padding p2; +} padding_char; + +struct { + padding p1; + short v; + padding p2; +} padding_short; + +struct { + padding p1; + int v; + padding p2; +} padding_int; + +struct { + padding p1; + long v; + padding p2; +} padding_long; + +struct { + padding p1; + long long v; + padding p2; +} padding_long_long; + +struct { + padding p1; + float v; + padding p2; +} padding_float; + +struct { + padding p1; + double v; + padding p2; +} padding_double; + +struct { + padding p1; + long double v; + padding p2; +} padding_long_double; + +static void +fill (void *buf, long sizeof_buf) +{ + char *p = buf; + int i; + for (i = 0; i < sizeof_buf; i++) + p[i] = "The quick brown dingo jumped over the layzy dog."[i]; +} + +void +fill_structs (void) +{ + fill (&padding_char.p1, sizeof (padding)); + fill (&padding_char.v, sizeof (padding_char.v)); + fill (&padding_char.p2, sizeof (padding)); + + fill (&padding_short.p1, sizeof (padding)); + fill (&padding_short.v, sizeof (padding_short.v)); + fill (&padding_short.p2, sizeof (padding)); + + fill (&padding_int.p1, sizeof (padding)); + fill (&padding_int.v, sizeof (padding_int.v)); + fill (&padding_int.p2, sizeof (padding)); + + fill (&padding_long.p1, sizeof (padding)); + fill (&padding_long.v, sizeof (padding_long.v)); + fill (&padding_long.p2, sizeof (padding)); + + fill (&padding_long_long.p1, sizeof (padding)); + fill (&padding_long_long.v, sizeof (padding_long_long.v)); + fill (&padding_long_long.p2, sizeof (padding)); + + fill (&padding_float.p1, sizeof (padding)); + fill (&padding_float.v, sizeof (padding_float.v)); + fill (&padding_float.p2, sizeof (padding)); + + fill (&padding_double.p1, sizeof (padding)); + fill (&padding_double.v, sizeof (padding_double.v)); + fill (&padding_double.p2, sizeof (padding)); + + fill (&padding_long_double.p1, sizeof (padding)); + fill (&padding_long_double.v, sizeof (padding_long_double.v)); + fill (&padding_long_double.p2, sizeof (padding)); +} + int main () { + fill_structs (); + printf ("sizeof (char) == %d\n", sizeof (char)); printf ("sizeof (short) == %d\n", sizeof (short)); printf ("sizeof (int) == %d\n", sizeof (int)); @@ -15,5 +112,11 @@ main () printf ("sizeof (float) == %d\n", sizeof (float)); printf ("sizeof (double) == %d\n", sizeof (double)); printf ("sizeof (long double) == %d\n", sizeof (long double)); + + /* Signed char? */ + printf ("valueof ((int) (char) -1) == %d\n", (int) (char) -1); + printf ("valueof ((int) (signed char) -1) == %d\n", (int) (signed char) -1); + printf ("valueof ((int) (unsigned char) -1) == %d\n", (int) (unsigned char) -1); + return 0; } diff --git a/gdb/testsuite/gdb.base/sizeof.exp b/gdb/testsuite/gdb.base/sizeof.exp index 9125343..7c03905 100644 --- a/gdb/testsuite/gdb.base/sizeof.exp +++ b/gdb/testsuite/gdb.base/sizeof.exp @@ -1,4 +1,4 @@ -# Copyright 2000 Free Software Foundation, Inc. +# Copyright 2000, 2002 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 @@ -56,22 +56,28 @@ if ![runto_main] then { # Query GDB for the size of various types # -proc get_sizeof { type default } { +proc get_valueof { fmt exp default } { global gdb_prompt - send_gdb "print/d sizeof (${type})\n" + send_gdb "print${fmt} ${exp}\n" gdb_expect { - -re "\\$\[0-9\]* = (\[0-9\]*).*$gdb_prompt $" { - set size $expect_out(1,string) - pass "get sizeof ${type} ($size)" + -re "\\$\[0-9\]* = (\[-\]*\[0-9\]*).*$gdb_prompt $" { + set val $expect_out(1,string) + pass "get value of ${exp} ($val)" } timeout { set size ${default} - fail "get sizeof ${type} (timeout)" + fail "get value of ${exp} (timeout)" } } - return ${size} + return ${val} +} + +proc get_sizeof { type default } { + return [get_valueof "/d" "sizeof (${type})" $default] } +gdb_test "next" + set sizeof_char [get_sizeof "char" 1] set sizeof_short [get_sizeof "short" 2] set sizeof_int [get_sizeof "int" 4] @@ -85,7 +91,6 @@ set sizeof_float [get_sizeof "float" 4] set sizeof_double [get_sizeof "double" 8] set sizeof_long_double [get_sizeof "long double" 8] - # # Compare GDB's idea of types with the running program # @@ -97,10 +102,10 @@ proc check_sizeof { type size } { return; } - set pat [string_to_regexp ${type}] + set pat [string_to_regexp "sizeof (${type}) == ${size}"] send_gdb "next\n" gdb_expect { - -re "sizeof \\(${pat}\\) == ${size}\[\r\n\].*$gdb_prompt $" { + -re "${pat}\[\r\n\].*$gdb_prompt $" { pass "check sizeof ${type} == ${size}" } -re ".*$gdb_prompt $" { @@ -125,6 +130,59 @@ check_sizeof "float" ${sizeof_float} check_sizeof "double" ${sizeof_double} check_sizeof "long double" ${sizeof_long_double} +proc check_valueof { exp val } { + global gdb_prompt + + if [gdb_skip_stdio_test "check valueof $exp == $val"] { + return; + } + + set pat [string_to_regexp "valueof (${exp}) == ${val}"] + send_gdb "next\n" + gdb_expect { + -re "${pat}\[\r\n\].*$gdb_prompt $" { + pass "check valueof ${exp} == ${val}" + } + -re ".*$gdb_prompt $" { + fail "check valueof ${exp} == ${val}" + } + timeout { + fail "check valueof ${exp} == ${val} (timeout)" + } + } +} + +# Check that GDB and the target agree over the sign of a character. + +set signof_char [get_valueof "/d" "(int) (char) -1" -1] +set signof_signed_char [get_valueof "/d" "(int) (signed char) -1" -1] +set signof_unsigned_char [get_valueof "/d" "(int) (unsigned char) -1" -1] + +check_valueof "(int) (char) -1" ${signof_char} +check_valueof "(int) (signed char) -1" ${signof_signed_char} +check_valueof "(int) (unsigned char) -1" ${signof_unsigned_char} + +proc check_padding { fmt type val } { + global gdb_prompt + gdb_test "set padding_${type}.v = ${val}" + gdb_test "print padding_${type}.p1" "= \"The quick brown \"" + gdb_test "print${fmt} padding_${type}.v" "= ${val}" + gdb_test "print padding_${type}.p2" "\"The quick brown \".*" +} + +# Check that GDB is managing to store a value in a struct field +# without corrupting the fields immediately adjacent to it. + +check_padding "/d" "char" 1 +check_padding "/d" "short" 2 +check_padding "/d" "int" 4 +check_padding "/d" "long" 4 +check_padding "/d" "long_long" 8 + +# use multiples of two which can be represented exactly +check_padding "/f" "float" 1 +check_padding "/f" "double" 2 +check_padding "/f" "long_double" 4 # # For reference, dump out the entire architecture -- 2.7.4