Re: [rfa:testsuite} Overhaul sizeof.exp

Fernando Nasser
2002-02-20T16:19:49Z

Andrew Cagney wrote:
>
> I think this one avoids any potential ``print/d (long double)1'' problems.
>
> enjoy,
> Andrew
>

If Michael has no more objections it is OK with me.

Thanks to Andrew for the new tests and to Michael for reviewing it.

Fernando

> ------------------------------------------------------------------------
> 2002-02-19 Andrew Cagney <ac131313@redhat.com>
>
> * 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.
>
> Index: gdb.base/sizeof.c
> ===================================================================
> RCS file: /cvs/src/src/gdb/testsuite/gdb.base/sizeof.c,v
> retrieving revision 1.2
> diff -p -r1.2 sizeof.c
> *** sizeof.c 2000/08/02 22:13:01 1.2
> --- sizeof.c 2002/02/20 15:15:17
> ***************
> *** 1,8 ****
> --- 1,105 ----
> #include <stdio.h>
>
> + 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));
> *************** main ()
> *** 15,19 ****
> --- 112,122 ----
> 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;
> }
> Index: gdb.base/sizeof.exp
> ===================================================================
> RCS file: /cvs/src/src/gdb/testsuite/gdb.base/sizeof.exp,v
> retrieving revision 1.3
> diff -p -r1.3 sizeof.exp
> *** sizeof.exp 2001/03/06 08:21:51 1.3
> --- sizeof.exp 2002/02/20 15:15:17
> ***************
> *** 1,4 ****
> ! # Copyright 2000 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
> --- 1,4 ----
> ! # 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
> *************** if ![runto_main] then {
> *** 56,77 ****
> # Query GDB for the size of various types
> #
>
> ! proc get_sizeof { type default } {
> global gdb_prompt
> ! send_gdb "print/d sizeof (${type})\n"
> gdb_expect {
> ! -re "\\$\[0-9\]* = (\[0-9\]*).*$gdb_prompt $" {
> ! set size $expect_out(1,string)
> ! pass "get sizeof ${type} ($size)"
> }
> timeout {
> set size ${default}
> ! fail "get sizeof ${type} (timeout)"
> }
> }
> ! return ${size}
> }
>
> set sizeof_char [get_sizeof "char" 1]
> set sizeof_short [get_sizeof "short" 2]
> set sizeof_int [get_sizeof "int" 4]
> --- 56,83 ----
> # Query GDB for the size of various types
> #
>
> ! proc get_valueof { fmt exp default } {
> global gdb_prompt
> ! send_gdb "print${fmt} ${exp}\n"
> gdb_expect {
> ! -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 value of ${exp} (timeout)"
> }
> }
> ! 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]
> *************** set sizeof_float [get_sizeof "float" 4]
> *** 85,91 ****
> 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
> #
> --- 91,96 ----
> *************** proc check_sizeof { type size } {
> *** 97,106 ****
> return;
> }
>
> ! set pat [string_to_regexp ${type}]
> send_gdb "next\n"
> gdb_expect {
> ! -re "sizeof \\(${pat}\\) == ${size}\[\r\n\].*$gdb_prompt $" {
> pass "check sizeof ${type} == ${size}"
> }
> -re ".*$gdb_prompt $" {
> --- 102,111 ----
> return;
> }
>
> ! set pat [string_to_regexp "sizeof (${type}) == ${size}"]
> send_gdb "next\n"
> gdb_expect {
> ! -re "${pat}\[\r\n\].*$gdb_prompt $" {
> pass "check sizeof ${type} == ${size}"
> }
> -re ".*$gdb_prompt $" {
> *************** check_sizeof "float" ${sizeof_float}
> *** 125,130 ****
> --- 130,188 ----
> 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

--
Fernando Nasser
Red Hat Canada Ltd. E-Mail: fnasser@redhat.com
2323 Yonge Street, Suite #300
Toronto, Ontario M4P 2C9