This is the mail archive of the gdb-patches@sourceware.org mailing list for the GDB project.


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]
Other format: [Raw text]

[RFC] Decimal Floating Point support for GDB (Part 2: testcase -Revised)


Hi Daniel,

Appended is the testcase for newly rewrited DFP patch.  I had seperated 
the testcases into two parts: dfp-exprs.exp which don't need any DFP code 
to be run, dfp-test.exp which need to compile a source file dfp-test.c. 
In dfp-test.exp, I added a few tests to verify that GDB could correctly 
handle the DFP members in C struct and also some tests to handle dfp value 
setting by "dfp1=dfp2".  I had tested it on x86 using dfp-branch gcc.  All 
passed.  And no regression was found with any other testcases too.  

Please review and comment.  Thanks a lot!

2005-10-18  Wu Zhou  <woodzltc@cn.ibm.com>

	* dfp-exprs.exp: New testcase to evaluate simple DFP expressions.
	* dfp-test.exp: New testcase to verify the printing and setting of
	DFP values.
	* dfp-test.c: New source file.

Index: gdb.base/dfp-exprs.exp
===================================================================
RCS file: gdb.base/dfp-exprs.exp
diff -N gdb.base/dfp-exprs.exp
*** /dev/null	1 Jan 1970 00:00:00 -0000
--- gdb.base/dfp-exprs.exp	18 Oct 2005 07:52:59 -0000
***************
*** 0 ****
--- 1,65 ----
+ # Copyright (C) 2005 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 written by Wu Zhou. (woodzltc@cn.ibm.com)
+ 
+ # This file is part of the gdb testsuite.  It contains test for evaluating 
+ # simple decimal floating point (DFP) expression.
+ 
+ if $tracelevel then {
+ 	strace $tracelevel
+ }
+ 
+ proc test_dfp_literals_accepted {} {
+ 
+     # Test various dfp values.
+ 
+     gdb_test "p 1.2df" " = 1.2df"
+     gdb_test "p -1.2df" " = -1.2df"
+     gdb_test "p 1.234567df" " = 1.234567df"
+     gdb_test "p -1.234567df" " = -1.234567df"
+     gdb_test "p 1234567.df" " = 1234567.df"
+     gdb_test "p -1234567.df" " = -1234567.df"
+ 
+     gdb_test "p 1.2dd" " = 1.2dd"
+     gdb_test "p -1.2dd" " = -1.2dd"
+     gdb_test "p 1.234567890123456dd" " = 1.234567890123456dd"
+     gdb_test "p -1.234567890123456dd" " = -1.234567890123456dd"
+     gdb_test "p 1234567890123456.dd" " = 1234567890123456.dd"
+     gdb_test "p -1234567890123456.dd" " = -1234567890123456.dd"
+ 
+     gdb_test "p 1.2dl" " = 1.2dl"
+     gdb_test "p -1.2dl" " = -1.2dl"
+     gdb_test "p 1.234567890123456789012345678901234dl" " = 1.234567890123456789012345678901234dl"
+     gdb_test "p -1.234567890123456789012345678901234dl" " = -1.234567890123456789012345678901234dl"
+     gdb_test "p 1234567890123456789012345678901234.dl" " = 1234567890123456789012345678901234.dl"
+     gdb_test "p -1234567890123456789012345678901234.dl" " = -1234567890123456789012345678901234.dl"
+ 
+ }
+ 
+ proc test_arithmetic_expressions {} {
+ 
+ # Arithmetic operations for DFP types are not yet implemented in GDB.
+ 
+ }
+ 
+ # Start with a fresh gdb.
+ 
+ gdb_exit
+ gdb_start
+ gdb_reinitialize_dir $srcdir/$subdir
+ 
+ test_dfp_literals_accepted
Index: gdb.base/dfp-test.c
===================================================================
RCS file: gdb.base/dfp-test.c
diff -N gdb.base/dfp-test.c
*** /dev/null	1 Jan 1970 00:00:00 -0000
--- gdb.base/dfp-test.c	18 Oct 2005 07:52:59 -0000
***************
*** 0 ****
--- 1,95 ----
+ /* This testcase is part of GDB, the GNU debugger.
+ 
+    Copyright 2005 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.  */
+ 
+ #include <stdio.h>
+ #include <stdlib.h>
+ 
+ volatile _Decimal32 d32;
+ volatile _Decimal64 d64;
+ volatile _Decimal128 d128;
+ 
+ struct decstruct
+ {
+   int int4;
+   long long8;
+   _Decimal32 dec32;
+   _Decimal64 dec64;
+   _Decimal128 dec128;
+ } ds;
+ 
+ static _Decimal32
+ arg0_32 (_Decimal32 arg0, _Decimal32 arg1, _Decimal32 arg2,
+          _Decimal32 arg3, _Decimal32 arg4, _Decimal32 arg5)
+ {
+   return arg0;
+ }
+ 
+ static _Decimal64
+ arg0_64 (_Decimal64 arg0, _Decimal64 arg1, _Decimal64 arg2,
+          _Decimal64 arg3, _Decimal64 arg4, _Decimal64 arg5)
+ {
+   return arg0;
+ }
+ 
+ static _Decimal128
+ arg0_128 (_Decimal128 arg0, _Decimal128 arg1, _Decimal128 arg2,
+          _Decimal128 arg3, _Decimal128 arg4, _Decimal128 arg5)
+ {
+   return arg0;
+ }
+ 
+ int main()
+ {
+   /* An finite 32-bits decimal floating point.  */
+   d32 = 1.2345df;		/* Initialize d32.  */
+ 
+   /* Non-finite 32-bits decimal floating point: infinity and NaN.  */
+   d32 = __builtin_infd32();	/* Positive infd32.  */
+   d32 = -__builtin_infd32();	/* Negative infd32.  */
+   d32 = __builtin_nand32("");
+ 
+   /* An finite 64-bits decimal floating point.  */
+   d64 = 1.2345dd;		/* Initialize d64.  */
+ 
+   /* Non-finite 64-bits decimal floating point: infinity and NaN.  */
+   d64 = __builtin_infd64();	/* Positive infd64.  */
+   d64 = -__builtin_infd64();	/* Negative infd64.  */
+   d64 = __builtin_nand64("");
+ 
+   /* An finite 128-bits decimal floating point.  */
+   d128 = 1.2345dl;		/* Initialize d128.  */
+ 
+   /* Non-finite 128-bits decimal floating point: infinity and NaN.  */
+   d128 = __builtin_infd128();	/* Positive infd128.  */
+   d128 = -__builtin_infd128();	/* Negative infd128.  */
+   d128 = __builtin_nand128("");
+ 
+   /* Functions with decimal floating point as parameter and return value.  */
+   d32 = arg0_32 (0.1df, 1.0df, 2.0df, 3.0df, 4.0df, 5.0df);
+   d64 = arg0_64 (0.1dd, 1.0dd, 2.0dd, 3.0dd, 4.0dd, 5.0dd);
+   d128 = arg0_128 (0.1dl, 1.0dl, 2.0dl, 3.0dl, 4.0dl, 5.0dl);
+ 
+   ds.int4 = 1;
+   ds.long8 = 2;
+   ds.dec32 = 1.2345df;
+   ds.dec64 = 1.2345dd;
+   ds.dec128 = 1.2345dl;
+ 
+   return 0;	/* Exit point.  */
+ }
Index: gdb.base/dfp-test.exp
===================================================================
RCS file: gdb.base/dfp-test.exp
diff -N gdb.base/dfp-test.exp
*** /dev/null	1 Jan 1970 00:00:00 -0000
--- gdb.base/dfp-test.exp	18 Oct 2005 07:53:00 -0000
***************
*** 0 ****
--- 1,243 ----
+ # Copyright 2005 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 written by Wu Zhou. (woodzltc@cn.ibm.com)
+ 
+ # This file is part of the gdb testsuite.  It is intended to test that
+ # gdb could correctly handle decimal floating point introduced in IEEE 754R.
+ 
+ proc d32_set_tests {} {
+ 
+     gdb_test "p d32=123.45df" " = 123.45df"
+     gdb_test "p d32=12345.df" " = 12345.df"
+     gdb_test "p d32=12345.67df" " = 12345.67df"
+     gdb_test "p d32=1234567.df" " = 1234567.df"
+ 
+     gdb_test "p d32=1.234567E0df" " = 1.234567df" 
+     gdb_test "p d32=1.234567E10df" " = 1.234567E\\+10df"
+     gdb_test "p d32=1.234567E+96df" " = 1.234567E\\+96df"
+ 
+     # Test that gdb could handle the max, normalized min and subnormalized min.
+     gdb_test "p d32=9.999999E+96df" " = 9.999999E\\+96df"
+     gdb_test "p d32=1.0E-95df" " = 1.E\\-95df"
+     gdb_test "p d32=1.E-101df" " = 1.E\\-101df"
+     gdb_test "p d32=0.000001E-95df" " = 1.E\\-101df"
+ 
+     # Test that gdb could detect coefficient/exponent out of range.
+     gdb_test "p d32=1.2345678df" ".*coefficient is out of range.*" "1.2345678df is out of range (coefficient)"
+     gdb_test "p d32=1.0E-101df" ".*exponent is out of range.*" "1.0E-101df is out of range (exponent)"
+     gdb_test "p d32=1.234567E+97df" ".*exponent is out of range.*" "1.234567E+97df is out of range (exponent)"
+ 
+     # Test that gdb could detect the errors in the string representation of _Decimal32
+     gdb_test "p d32=12345df" ".*Invalid number.*" "12345df is an invalid number"
+     gdb_test "p d32=1.23Edf" ".*Digit expected.*" "p d32=1.23Edf"
+     gdb_test "p d32=1.23E45Adf" ".*Invalid char found.*" "p d32=1.23E45Adf"
+ }
+ 
+ proc d64_set_tests {} {
+ 
+     gdb_test "p d64=123.45dd" " = 123.45dd"
+     gdb_test "p d64=12345.dd" " = 12345.dd"
+     gdb_test "p d64=12345.67dd" " = 12345.67dd"
+     gdb_test "p d64=1.234567890123456dd" " = 1.234567890123456dd"
+ 
+     gdb_test "p d64=1.234567890123456E10dd" " = 12345678901.23456dd"
+     gdb_test "p d64=1.234567890123456E100dd" " = 1.234567890123456E\\+100dd"
+     gdb_test "p d64=1.234567890123456E384dd" " = 1.234567890123456E\\+384dd"
+ 
+     # Test that gdb could handle the max, normalized min and subnormalized min.
+     gdb_test "p d64=9.999999999999999E384dd" " = 9.999999999999999E\\+384dd"
+     gdb_test "p d64=1.E-383dd" " = 1.E\\-383dd"
+     gdb_test "p d64=1.E-398dd" " = 1.E\\-398dd"
+     gdb_test "p d64=0.000000000000001E-383dd" " = 1.E\\-398dd"
+ 
+     # Test that gdb could detect coefficient/exponent out of range.
+     gdb_test "p d64=1.2345678901234567dd" ".*coefficient is out of range.*" "1.2345678901234567dd is out of range (coefficient)"
+     gdb_test "p d64=9.9999999999999999E384dd" ".*coefficient is out of range.*" "d64=9.9999999999999999E384dd is out of range (coefficient)"
+     gdb_test "p d64=1.234567890123456E385dd" ".*exponent is out of range.*" "d64=1.234567890123456E385dd is out of range (exponent)"
+     gdb_test "p d64=1.E-399dd" ".*exponent is out of range.*" "d64=1.E-399dd is out of range (exponent)"
+ 
+     # Test that gdb could detect the errors in the string representation of _Decimal32
+     gdb_test "p d64=12345dd" ".*Invalid number.*" "12345dd is an invalid number"
+     gdb_test "p d64=1.23Edd" ".*Digit expected.*" "p d64=1.23Edd"
+     gdb_test "p d64=1.23E45Add" ".*Invalid char found.*" "p d64=1.23E45Add"
+ }
+ 
+ proc d128_set_tests {} {
+ 
+     gdb_test "p d128=123.45dl" " = 123.45dl"
+     gdb_test "p d128=12345.dl" " = 12345.dl"
+     gdb_test "p d128=12345.67dl" " = 12345.67dl"
+     gdb_test "p d128=1.234567890123456789012345678901234dl" "= 1.234567890123456789012345678901234dl"
+ 
+     gdb_test "p d128=1.234567890123456E10dl" " = 12345678901.23456dl"
+     gdb_test "p d128=1.234567890123456E100dl" " = 1.234567890123456E\\+100dl"
+     gdb_test "p d128=1.234567890123456E1000dl" " = 1.234567890123456E\\+1000dl"
+ 
+     # Test that gdb could handle the max, normalized min and subnormalized min.
+     gdb_test "p d128=9.99999999999999999999999999999999E6144dl" " = 9.99999999999999999999999999999999E\\+6144dl"
+     gdb_test "p d128=1.E-6143dl" " = 1.E\\-6143dl"
+     gdb_test "p d128=1.E-6176dl" " = 1.E\\-6176dl"
+     gdb_test "p d128=0.000000000000000000000000000000001E-6143dl" " = 1.E\\-6176dl"
+ 
+     # Test that gdb could detect coefficient/exponent out of range.
+     gdb_test "p d128=1.2345678901234567890123456789012345dl" ".*coefficient is out of range.*" "1.2345678901234567890123456789012345dl is out of range (coefficient)"
+     gdb_test "p d128=9.9999999999999999999999999999999999dl" ".*coefficient is out of range.*" "d128=9.9999999999999999999999999999999999 is out of range (coefficient)"
+     gdb_test "p d128=1.234567890123456E6145dl" ".*exponent is out of range.*" "d128=1.234567890123456E6145dl is out of range (exponent)"
+     gdb_test "p d128=1.E-6177dl" ".*exponent is out of range.*" "d128=1.E-6177dl is out of range (exponent)"
+ 
+     # Test that gdb could detect the errors in the string representation of _Decimal32
+     gdb_test "p d128=12345dl" ".*Invalid number.*" "12345dl is an invalid number"
+     gdb_test "p d128=1.23Edl" ".*Digit expected.*" "p d128=1.23Edl"
+     gdb_test "p d128=1.23E45Adl" ".*Invalid char found.*" "p d128=1.23E45Adl"
+ }
+ 
+ 
+ if $tracelevel {
+     strace $tracelevel
+ }
+ 
+ set testfile "dfp-test"
+ set srcfile ${testfile}.c
+ set binfile ${objdir}/${subdir}/${testfile}
+ if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {debug}] != "" } {
+     untested "Couldn't compile ${srcfile}"
+     return -1
+ }
+ 
+ gdb_exit
+ gdb_start
+ gdb_reinitialize_dir $srcdir/$subdir
+ gdb_load ${binfile}
+ 
+ if ![runto_main] then {
+     perror "couldn't run to breakpoint"
+     continue
+ }
+ 
+ # Different tests on 32-bits decimal floating point, including the printing 
+ # of finite numbers, infinite and NaN, and also the setting of different
+ # decimal value.
+ 
+ if [gdb_test "next" \
+     ".*Positive infd32.*" \
+     "next after initializing d32"] then { gdb_suppress_tests }
+ gdb_test "print d32" "1.2345df" "d32 is initialized to 1.2345df"
+ 
+ if [gdb_test "next" \
+     ".*Negative infd32.*" \
+     "next after assigning builtin infinity to d32"] then { gdb_suppress_tests }
+ gdb_test "print d32" "Infinity" "d32 is positive Infinity"
+ 
+ if [gdb_test "next" \
+     ".*__builtin_nand32.*" \
+     "next after assigning negative builtin infinity to d32"] then { gdb_suppress_tests }
+ gdb_test "print d32" "-Infinity" "d32 is negative Infinity"
+ 
+ if [gdb_test "next" \
+     ".*d64 = 1.2345dd.*" \
+     "next after assigning builtin NaN to d32"] then { gdb_suppress_tests }
+ gdb_test "print d32" "NaN" "d32 is NaN"
+ 
+ d32_set_tests 
+ 
+ 
+ # Different tests on 64-bits decimal floating point, including the display
+ # of finite number, infinite and NaN, and also the setting of different
+ # decimal value.
+ 
+ if [gdb_test "next" \
+     ".*Positive infd64.*" \
+     "next after initializing d64"] then { gdb_suppress_tests }
+ gdb_test "print d64" "1.2345dd" "d64 is initialized to 1.2345dd"
+ 
+ if [gdb_test "next" \
+     ".*Negative infd64.*" \
+     "next after assigning builtin infinity to d64"] then { gdb_suppress_tests }
+ gdb_test "print d64" "Infinity" "d64 is positive Infinity"
+ 
+ if [gdb_test "next" \
+     ".*__builtin_nand64.*" \
+     "next after assigning negative builtin infinity to d64"] then { gdb_suppress_tests }
+ gdb_test "print d64" "-Infinity" "d64 is negative Infinity"
+ 
+ if [gdb_test "next" \
+     ".*d128 = 1.2345dl.*" \
+     "next after assigning builtin NaN to d64"] then { gdb_suppress_tests }
+ gdb_test "print d64" "NaN" "d64 is NaN"
+ 
+ d64_set_tests 
+ 
+ 
+ # Different tests on 128-bits decimal floating point, including the display
+ # of finite number, infinite and NaN, and also the setting of different
+ # decimal value.
+ 
+ if [gdb_test "next" \
+     ".*Positive infd128.*" \
+     "next after initializing d128"] then { gdb_suppress_tests }
+ gdb_test "print d128" "1.2345dl" "d128 is initialized to 1.2345dl"
+ 
+ d128_set_tests
+ 
+ if [gdb_test "next" \
+     ".*Negative infd128.*" \
+     "next after assigning builtin infinity to d128"] then { gdb_suppress_tests }
+ gdb_test "print d128" "Infinity" "d128 is positive Infinity"
+ 
+ if [gdb_test "next" \
+     ".*__builtin_nand128.*" \
+     "next after assigning negative builtin infinity to d128"] then { gdb_suppress_tests }
+ gdb_test "print d128" "-Infinity" "d128 is negative Infinity"
+ 
+ if [gdb_test "next" \
+     ".*arg0_32.*" \
+     "next after assigning builtin NaN to d128"] then { gdb_suppress_tests }
+ gdb_test "print d128" "NaN" "d128 is NaN"
+ 
+ # The following tests are intended to verify that gdb can correctly handle 
+ # DFP types in function arguments.
+ 
+ gdb_breakpoint arg0_32
+ gdb_continue_to_breakpoint "entry to arg0_32"
+ gdb_test "backtrace" ".*arg0_32 \\(arg0=0.1df, arg1=1.df, arg2=2.df, arg3=3.df, arg4=4.df, arg5=5.df\\).*" "backtrace at arg0_32"
+ 
+ gdb_breakpoint arg0_64
+ gdb_continue_to_breakpoint "entry to arg0_64"
+ gdb_test "backtrace" ".*arg0_64 \\(arg0=0.1dd, arg1=1.dd, arg2=2.dd, arg3=3.dd, arg4=4.dd, arg5=5.dd\\).*" "backtrace at arg0_64"
+ 
+ gdb_breakpoint arg0_128
+ gdb_continue_to_breakpoint "entry to arg0_128"
+ gdb_test "backtrace" ".*arg0_128 \\(arg0=0.1dl, arg1=1.dl, arg2=2.dl, arg3=3.dl, arg4=4.dl, arg5=5.dl\\).*" "backtrace at arg0_128"
+ 
+ # The following tests are intended to verify that gdb can handle DFP types
+ # correctly in struct.
+ 
+ gdb_breakpoint [gdb_get_line_number "Exit point"]
+ gdb_continue_to_breakpoint "Setting a decimal struct"
+ gdb_test "print ds.dec32" " = 1.2345df"
+ gdb_test "print ds.dec64" " = 1.2345dd"
+ gdb_test "print ds.dec128" " = 1.2345dl"
+ 
+ # The following tests are intended to verify that gdb can handle "dfp1=dfp2"
+ # and "dfp1=-dfp2" correctly.
+ 
+ gdb_test "print ds.dec32=d32" " = 0.1df"
+ gdb_test "print ds.dec64=d64" " = 0.1dd"
+ gdb_test "print ds.dec128=d128" " = 0.1dl"
+ gdb_test "print ds.dec32 = -d32" " = -0.1df"
+ gdb_test "print ds.dec64 = -d64" " = -0.1dd"
+ gdb_test "print ds.dec128 = -d128" " = -0.1dl"


Best Regards
- Wu Zhou


On Sun, 2 Oct 2005, Daniel Jacobowitz wrote:

> On Wed, Sep 28, 2005 at 01:28:07PM +0800, Wu Zhou wrote:
> > In this testcase, there are totally 83 tests.  Most of them are about 
> > displaying and setting of dfp types, which are partitioned into 
> > three groups, one for each dfp types (_Decimal32, _Decimal64 and 
> > _Decimal128).  In each group, we first begin with the printing of 
> > a normal finite dfp value, then Infinity and NaN. Then we call 
> > d32_set_tests (d64_set_tests or d128_set_tests) to test that GDB 
> > could handle the setting different values of variable d32 (d64 or 
> > d128).
> > 
> > At the end of the testcase, we test that GDB could print out the dfp
> > values correctly in the function arguments and backtrace.
> 
> Just a few comments on the tests:
> 
> - This should be at least two separate tests, since the "p 1.5df" tests
> can be run without a GCC which supports DFP, even though dfp-test.c
> can't be compiled.
> 
> - C files need to have copyright headers.
> 
> In this:
> 
> > +     gdb_test "p d32=123.45df" "123.45df" "p d32=123.45df"
> 
> - The third argument to gdb_test defaults to the first argument, so you
> don't need it.
> 
> - The second argument should be more specific.  Something like
> "\$${decimal} = 123.45df".  I went to look at this test to see if my
> understanding of the use of string types was right, and the matching
> patterns were so loose I couldn't tell.
> 
> Otherwise I'll wait to look at this further until we're agreed on the
> GDB support.
> 
> -- 
> Daniel Jacobowitz
> CodeSourcery, LLC
> 
> 


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]