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 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.
+
2002-02-20 Michael Chastain <mec@shout.net>
* gdb.c++/virtfunc.exp (test_virtual_calls): Remove obsolete calls
#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));
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;
}
-# 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
# 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]
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
#
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 $" {
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
projects / platform / upstream / binutils.git / commitdiff