Re: [rfa:testsuite} Overhaul sizeof.exp

[Andrew Cagney <ac131313@cygnus.com>]

[-- Attachment #1: Type: text/plain, Size: 90 bytes --]

I think this one avoids any potential ``print/d (long double)1'' problems.

enjoy,
Andrew

[-- Attachment #2: diffs --]
[-- Type: text/plain, Size: 8639 bytes --]

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