[RFC] decimal float point patch based on libdecnumber: testcase

[RFC] decimal float point patch based on libdecnumber: testcase

[Wu Zhou]

Hello Daniel/all,

About one week ago, I said that I will rework my dfp patch based on libdecnumber.
OK.  Here it is.  This post is about what it can support right now.  The
testcase can tell easily about this.  The gdb patch will be posted in 
another email.

The functions this patch provides are much the same as before.  But it is 
more exensible because it is based on libdecnumber.  I list here what is 
available now.  If you think any functionality is desirable, please tell 
me.  I will try to add them in.

- for dfp constants, this patch supports two kind of representation: 
scientific one and non-scientific one.  To input any dfp constants, you 
need to add suffix to differentiate it from binary float: "df" for deciaml 
float (32 bits), "dd" for deciaml double (64 bits), and "dl" for deciaml
long (128 bits).  When printing dfp constants, it will strip the suffix.  

- it supports the displaying of dfp values in variables, struct, function 
argument and also back trace.  Any more is needed?

- it support the negation operation (-dfp), assign operation (d1 = d2 or 
d1 = -d2),

- it can handle finite dfp numbers, infinity (positive and negative), and 
NaN (not a number).  

- it can also support the max, normalized min and subnormalized min well.

- we can't do conversion between binary float and decimal float right, or 
between two different dfp types right now

Here goes the testcase.  Please review.  Any comment or suggestion is 
highly appreciated.  

P.S: I am trying to make it self explanatory.  But if you think more 
comment is needed in some place, feel free to tell me.

2006-06-21  Wu Zhou  <woodzltc@cn.ibm.com>

	* gdb.base/dfp-exprs.exp: New testcase to verify that gdb can
	handle dfp constants correctly.
	* gdb.base/dfp-test.c: New test file, used for dfp-test.exp.
	* gdb.base/dfp-test.exp: New testcase toverify that gdb can handle
	dfp related operation.

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	21 Jun 2006 21:00:23 -0000
@@ -0,0 +1,88 @@
+# 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, covering 32-bit, 64-bit and 128-bit ones
+
+    # _Decimal32 constants, which can support up to 7 digits
+    gdb_test "p 1.2df" " = 1.2"
+    gdb_test "p -1.2df" " = -1.2"
+    gdb_test "p 1.234567df" " = 1.234567" 
+    gdb_test "p -1.234567df" " = -1.234567"
+    gdb_test "p 1234567.df" " = 1234567"
+    gdb_test "p -1234567.df" " = -1234567"
+
+    gdb_test "p 1.2E1df" " = 12"
+    gdb_test "p 1.2E10df" " = 1.2E\\+10"
+    gdb_test "p 1.2E-10df" " = 1.2E-10"
+
+    # The largest exponent for 32-bit dfp value is 96.
+    gdb_test "p 1.2E96df" " = 1.200000E\\+96"
+
+    # _Decimal64 constants, which can support up to 16 digits
+    gdb_test "p 1.2dd" " = 1.2"
+    gdb_test "p -1.2dd" " = -1.2"
+    gdb_test "p 1.234567890123456dd" " = 1.234567890123456"
+    gdb_test "p -1.234567890123456dd" " = -1.234567890123456"
+    gdb_test "p 1234567890123456.dd" " = 1234567890123456"
+    gdb_test "p -1234567890123456.dd" " = -1234567890123456"
+
+    gdb_test "p 1.2E1dd" " = 12"
+    gdb_test "p 1.2E10dd" " = 1.2E\\+10"
+    gdb_test "p 1.2E-10dd" " = 1.2E-10"
+
+    # The largest exponent for 64-bit dfp value is 384.
+    gdb_test "p 1.2E384dd" " = 1.200000000000000E\\+384"
+
+    # _Decimal128 constants, which can support up to 34 digits
+    gdb_test "p 1.2dl" " = 1.2"
+    gdb_test "p -1.2dl" " = -1.2"
+    gdb_test "p 1.234567890123456789012345678901234dl" " = 1.234567890123456789012345678901234"
+    gdb_test "p -1.234567890123456789012345678901234dl" " = -1.234567890123456789012345678901234"
+    gdb_test "p 1234567890123456789012345678901234.dl" " = 1234567890123456789012345678901234"
+    gdb_test "p -1234567890123456789012345678901234.dl" " = -1234567890123456789012345678901234"
+
+    gdb_test "p 1.2E1dl" " = 12"
+    gdb_test "p 1.2E10dl" " = 1.2E\\+10"
+    gdb_test "p 1.2E-10dl" " = 1.2E-10"
+
+    # The largest exponent for 128-bit dfp value is 6144.
+    gdb_test "p 1.2E6144dl" " = 1.200000000000000000000000000000000E\\+6144"  
+}
+
+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	21 Jun 2006 21:00:23 -0000
@@ -0,0 +1,95 @@
+/* This testcase is part of GDB, the GNU debugger.
+
+   Copyright 2006 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	21 Jun 2006 21:00:23 -0000
@@ -0,0 +1,247 @@
+# 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 hane decimal floating point introduced in IEEE 754R.
+
+proc d32_set_tests {} {
+
+    gdb_test "p d32=123.45df" " = 123.45"
+    gdb_test "p d32=12345.df" " = 12345"
+    gdb_test "p d32=12345.67df" " = 12345.67"
+    gdb_test "p d32=1234567.df" " = 1234567"
+
+    gdb_test "p d32=1.234567E0df" " = 1.234567" 
+    gdb_test "p d32=1.234567E10df" " = 1.234567E\\+10"
+    gdb_test "p d32=1.234567E+96df" " = 1.234567E\\+96"
+
+    # Test that gdb could handle the max, normalized min and subnormalized min.
+    gdb_test "p d32=9.999999E96df" " = 9.999999E\\+96"
+    gdb_test "p d32=1.0E-95df" " = 1.0E\\-95"
+    gdb_test "p d32=1.E-101df" " = 1E\\-101"
+    gdb_test "p d32=0.000001E-95df" " = 1E\\-101"
+
+    # Test that gdb could detect coefficient/exponent out of range.
+    # The coefficient out of range will be rounded to its nearest value.
+    # And the exponent out of range will be handled as infinity.
+    gdb_test "p d32=1.2345678df" " = 1.234568" "1.2345678 is rounded to 1.234568"
+    gdb_test "p d32=1.0E-101df" " = 1E-101" "1.0E-101 is rounded to 1E-101"
+    gdb_test "p d32=1.234567E+97df" " = Infinity" "1.234567E+97 is Infinity"
+
+    # Test that gdb could detect the errors in the string representation of _Decimal32
+    gdb_test "p d32=12345.df" " = 12345" "12345. is an valid number"
+    gdb_test "p d32=12345df" ".*Invalid number.*" "12345 is an invalid number"
+    gdb_test "p d32=1.23Edf" " = NaN" "1.23E is NaN (not a number)"
+    gdb_test "p d32=1.23E45Adf" " = NaN" "1.23E45A is NaN (not a number)"
+}
+
+proc d64_set_tests {} {
+
+    gdb_test "p d64=123.45dd" " = 123.45"
+    gdb_test "p d64=12345.dd" " = 12345"
+    gdb_test "p d64=12345.67dd" " = 12345.67"
+    gdb_test "p d64=1.234567890123456dd" " = 1.234567890123456"
+
+    gdb_test "p d64=1.234567890123456E10dd" " = 12345678901.23456"
+    gdb_test "p d64=1.234567890123456E100dd" " = 1.234567890123456E\\+100"
+    gdb_test "p d64=1.234567890123456E384dd" " = 1.234567890123456E\\+384"
+
+    # Test that gdb could handle the max, normalized min and subnormalized min.
+    gdb_test "p d64=9.999999999999999E384dd" " = 9.999999999999999E\\+384"
+    gdb_test "p d64=1.E-383dd" " = 1E\\-383"
+    gdb_test "p d64=1.E-398dd" " = 1E\\-398"
+    gdb_test "p d64=0.000000000000001E-383dd" " = 1E\\-398"
+
+    # Test that gdb could detect coefficient/exponent out of range.
+    # The coefficient out of range will be rounded to its nearest value.
+    # And the exponent out of range will be handled as infinity.
+    gdb_test "p d64=1.2345678901234567dd" " = 1.234567890123457" "1.2345678901234567 is rounded to 1.234567890123457" 
+    gdb_test "p d64=9.9999999999999999E384dd" " = Infinity" "d64=9.9999999999999999E384 is Infinity"
+    gdb_test "p d64=1.234567890123456E385dd" " = Infinity" "d64=1.234567890123456E385 is Infinity"
+
+    # Test that gdb could detect the errors in the string representation of _Decimal64
+    gdb_test "p d64=12345dd" ".*Invalid number.*" "12345dd is an invalid number"
+    gdb_test "p d64=1.23Edd" " = NaN" "1.23E is NaN (not a number)"
+    gdb_test "p d64=1.23E45Add" "= NaN" "1.23E45A is NaN (not a number)"
+}
+
+proc d128_set_tests {} {
+
+    gdb_test "p d128=123.45dl" " = 123.45"
+    gdb_test "p d128=12345.dl" " = 12345"
+    gdb_test "p d128=12345.67dl" " = 12345.67"
+    gdb_test "p d128=1.234567890123456789012345678901234dl" " = 1.234567890123456789012345678901234"
+
+    gdb_test "p d128=1.234567890123456E10dl" " = 12345678901.23456"
+    gdb_test "p d128=1.234567890123456E100dl" " = 1.234567890123456E\\+100"
+    gdb_test "p d128=1.234567890123456E1000dl" " = 1.234567890123456E\\+1000"
+
+    # Test that gdb could handle the max, normalized min and subnormalized min.
+    gdb_test "p d128=9.999999999999999999999999999999999E6144dl" " = 9.999999999999999999999999999999999E\\+6144"
+    gdb_test "p d128=1.E-6143dl" " = 1E\\-6143"
+    gdb_test "p d128=1.E-6176dl" " = 1E\\-6176"
+    gdb_test "p d128=0.000000000000000000000000000000001E-6143dl" " = 1E\\-6176"
+
+    # Test that gdb could detect coefficient/exponent out of range.
+    # The coefficient out of range will be rounded to its nearest value.
+    # And the exponent out of range will be handled as infinity.
+    gdb_test "p d128=1.2345678901234567890123456789012345dl" "1.234567890123456789012345678901234" "1.2345678901234567890123456789012345 is rounded to 1.234567890123456789012345678901234"
+    gdb_test "p d128=1.234567890123456E6145dl" "Infinity" "d128=1.234567890123456E6145 is Infinity"
+
+    # Test that gdb could detect the errors in the string representation of _Decimal128
+    gdb_test "p d128=12345dl" ".*Invalid number.*" "12345dl is an invalid number"
+    gdb_test "p d128=1.23Edl" " = NaN" "1.23E is NaN (not a number)"
+    gdb_test "p d128=1.23E45Adl" "= NaN" "1.23E45A is NaN (not a number)"
+}
+
+
+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.2345" "d32 is initialized to 1.2345"
+
+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.2345.*" \
+    "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.2345" "d64 is initialized to 1.2345"
+
+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.2345.*" \
+    "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.2345" "d128 is initialized to 1.2345"
+
+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.1, arg1=1.0, arg2=2.0, arg3=3.0, arg4=4.0, arg5=5.0\\).*" "backtrace at arg0_32"
+
+gdb_breakpoint arg0_64
+gdb_continue_to_breakpoint "entry to arg0_64"
+gdb_test "backtrace" ".*arg0_64 \\(arg0=0.1, arg1=1.0, arg2=2.0, arg3=3.0, arg4=4.0, arg5=5.0\\).*" "backtrace at arg0_64"
+
+gdb_breakpoint arg0_128
+gdb_continue_to_breakpoint "entry to arg0_128"
+gdb_test "backtrace" ".*arg0_128 \\(arg0=0.1, arg1=1.0, arg2=2.0, arg3=3.0, arg4=4.0, arg5=5.0\\).*" "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.2345"
+gdb_test "print ds.dec64" " = 1.2345"
+gdb_test "print ds.dec128" " = 1.2345"
+
+# The following tests are intended to verify that gdb can handle "d1=d2"
+# and "d1=-d2" correctly.
+
+gdb_test "print ds.dec32=d32" " = 0.1"
+gdb_test "print ds.dec64=d64" " = 0.1"
+gdb_test "print ds.dec128=d128" " = 0.1"
+gdb_test "print ds.dec32 = -d32" " = -0.1"
+gdb_test "print ds.dec64 = -d64" " = -0.1"
+gdb_test "print ds.dec128 = -d128" " = -0.1"


Regards
- Wu Zhou

[RFC] decimal float point patch based on libdecnumber: gdb patch

[Wu Zhou]

Appended is the patch.  I had tested it with the latest gcc-4.2 cvs tree 
on x86, with option "--enable-decimal-float". All the 121 tests passed.
Please review and comment.  Thanks a lot.

2006-06-21  Wu Zhou  <woodzltc@cn.ibm.com>

	* expression.h (enum exp_opcode): Add an opcode (OP_DECDOUBLE) for
	DFP constants.
	(union exp_element): Add decdoubleconst to represent DFP elements,
	which is 16 bytes by default.
	* parser-defs.h (write_exp_elt_decdblcst): Prototype.
	* parse.c (write_exp_elt_decdblcst): New function to write a decimal
	double const into the expression.
	(operator_length_standard): Set operator length for OP_DECDOUBLE 
	to 4.
	* c-exp.y (YYSTYPE): Add typed_val_decfloat for decimal floating 
	point in YYSTYPE union.
	Add token DECFLOAT for typed_val_decfloat.
	Add expression element handling code for DECFLOAT.
	(parse_number): Parse DFP constants, which end with suffix 'df',
	'dd' or 'dl'.  Return DECFLOAT.
	* c-lang.c (c_create_fundamental_type): Create fundamental types
	for DFP.
	* c-valprint.c (c_val_print): Call print_decimal_floating to print
	DFP values.
	* dwarf2read.c (read_base_type): Read DW_ATE_decimal_float attribute
	code and return TYPE_CODE_DECFLT.
	(dwarf_base_type): Set dwarf2_fundamental_type for DFP values.
	* eval.c (evaluate_subexp_standard): Call value_from_decdouble to
	handle OP_DECDOUBLE.
	* gdbtypes.h: Add three fundamental types for DFP.
	(enum type_code): Add TYPE_CODE_DECFLT as a type code for DFP.
	(struct builtin_type): Add builtin_decfloat, builtin_decdouble
	and builtin_declong.
	* gdbtypes.c: Add three builtin types for DFP.
	(build_gdbtypes): Build these three builtin types for DFP.
	(gdbtypes_post_init): Initialize builtin_decfloat, builtin_decdouble
	and builtin_declong.
	* value.h (value_from_decdouble): Prototype.
	(print_decimal_floating): Prototype.
	* valprint.c (print_decimal_floating): New function to print DFP
	values.
	* value.c (value_from_decdouble): New function to get the value
	from a decimal double.
	* valarith.c (value_neg): Add some code to handle the negation
	operation of DFP values.
	* dfp.h: New header file for decimal floating point support in
	GDB.
	* dfp.c: New source file for decimal floating point support in
	GDB.  Implement decimal_from_string and decimal_to_string based
	on libdecnumber API.
	* Makefile.in: Add decimal floating point related entry.  Add
	some macro to specify the libdecnumber directory, cflags and the
	name of libdecnumber library.

Index: expression.h
===================================================================
RCS file: /cvs/src/src/gdb/expression.h,v
retrieving revision 1.18
diff -u -r1.18 expression.h
--- expression.h	17 Dec 2005 22:33:59 -0000	1.18
+++ expression.h	21 Jun 2006 23:08:51 -0000
@@ -327,6 +327,11 @@
     /* A F90 array range operator (for "exp:exp", "exp:", ":exp" and ":").  */
     OP_F90_RANGE,
 
+    /* OP_DECDOUBLE is followed by a type pointer in the next exp_element
+       and a dec long constant value in the following exp_element.
+       Then comes another OP_DECDOUBLE.  */
+    OP_DECDOUBLE,
+
      /* First extension operator.  Individual language modules define
         extra operators they need as constants with values 
         OP_LANGUAGE_SPECIFIC0 + k, for k >= 0, using a separate 
@@ -354,6 +359,7 @@
     struct symbol *symbol;
     LONGEST longconst;
     DOUBLEST doubleconst;
+    gdb_byte decdoubleconst[16];
     /* Really sizeof (union exp_element) characters (or less for the last
        element of a string).  */
     char string;
Index: parser-defs.h
===================================================================
RCS file: /cvs/src/src/gdb/parser-defs.h,v
retrieving revision 1.20
diff -u -r1.20 parser-defs.h
--- parser-defs.h	17 Dec 2005 22:34:01 -0000	1.20
+++ parser-defs.h	21 Jun 2006 23:08:51 -0000
@@ -121,6 +121,8 @@
 
 extern void write_exp_elt_dblcst (DOUBLEST);
 
+extern void write_exp_elt_decdblcst (gdb_byte *);
+
 extern void write_exp_elt_type (struct type *);
 
 extern void write_exp_elt_intern (struct internalvar *);
Index: parse.c
===================================================================
RCS file: /cvs/src/src/gdb/parse.c,v
retrieving revision 1.52
diff -u -r1.52 parse.c
--- parse.c	24 Jan 2006 15:20:10 -0000	1.52
+++ parse.c	21 Jun 2006 23:08:51 -0000
@@ -236,6 +236,18 @@
 }
 
 void
+write_exp_elt_decdblcst (gdb_byte expelt[16])
+{
+  union exp_element tmp;
+  int index;
+
+  for (index = 0; index < 16; index++)
+    tmp.decdoubleconst[index] = expelt[index];
+
+  write_exp_elt (tmp);
+}
+
+void
 write_exp_elt_type (struct type *expelt)
 {
   union exp_element tmp;
@@ -857,6 +869,7 @@
 
     case OP_LONG:
     case OP_DOUBLE:
+    case OP_DECDOUBLE:
     case OP_VAR_VALUE:
       oplen = 4;
       break;
Index: c-exp.y
===================================================================
RCS file: /cvs/src/src/gdb/c-exp.y,v
retrieving revision 1.34
diff -u -r1.34 c-exp.y
--- c-exp.y	23 Feb 2006 18:43:41 -0000	1.34
+++ c-exp.y	21 Jun 2006 23:08:51 -0000
@@ -53,6 +53,7 @@
 #include "charset.h"
 #include "block.h"
 #include "cp-support.h"
+#include "dfp.h"
 
 /* Remap normal yacc parser interface names (yyparse, yylex, yyerror, etc),
    as well as gratuitiously global symbol names, so we can have multiple
@@ -131,6 +132,10 @@
       DOUBLEST dval;
       struct type *type;
     } typed_val_float;
+    struct {
+      gdb_byte val[16];
+      struct type *type;
+    } typed_val_decfloat;
     struct symbol *sym;
     struct type *tval;
     struct stoken sval;
@@ -163,6 +168,7 @@
 
 %token <typed_val_int> INT
 %token <typed_val_float> FLOAT
+%token <typed_val_decfloat> DECFLOAT
 
 /* Both NAME and TYPENAME tokens represent symbols in the input,
    and both convey their data as strings.
@@ -497,6 +503,13 @@
 			  write_exp_elt_opcode (OP_DOUBLE); }
 	;
 
+exp	:	DECFLOAT
+			{ write_exp_elt_opcode (OP_DECDOUBLE);
+			  write_exp_elt_type ($1.type);
+			  write_exp_elt_decdblcst ($1.val);
+			  write_exp_elt_opcode (OP_DECDOUBLE); }
+	;
+
 exp	:	variable
 	;
 
@@ -1080,6 +1093,49 @@
       char saved_char = p[len];
 
       p[len] = 0;	/* null-terminate the token */
+
+      /* If it ends at "df", "dd" or "dl", take it as type of decimal floating
+         point.  Return DECFLOAT.  */
+
+      if (p[len - 2] == 'd' && p[len - 1] == 'f')
+	{
+	  gdb_byte *dec_val = (gdb_byte *)malloc (4);
+	  p[len - 2] = '\0';
+	  putithere->typed_val_decfloat.type = 
+	    builtin_type (current_gdbarch)->builtin_decfloat;
+	  decimal_from_string (dec_val, 4, p);
+	  reverse_dfp (dec_val, 4, putithere->typed_val_decfloat.val);
+	  free (dec_val);
+	  p[len] = saved_char;
+	  return (DECFLOAT);
+	}
+
+      if (p[len - 2] == 'd' && p[len - 1] == 'd')
+	{
+	  gdb_byte *dec_val = (gdb_byte *)malloc (8);
+	  p[len - 2] = '\0';
+	  putithere->typed_val_decfloat.type = 
+	    builtin_type (current_gdbarch)->builtin_decdouble;
+	  decimal_from_string (dec_val, 8, p);
+	  reverse_dfp (dec_val, 8, putithere->typed_val_decfloat.val);
+	  free (dec_val);
+	  p[len] = saved_char;
+	  return (DECFLOAT);
+	}
+
+      if (p[len - 2] == 'd' && p[len - 1] == 'l')
+	{
+	  gdb_byte *dec_val = (gdb_byte *)malloc (16);
+	  p[len - 2] = '\0';
+	  putithere->typed_val_decfloat.type = 
+	    builtin_type (current_gdbarch)->builtin_declong;
+	  decimal_from_string (dec_val, 16, p);
+	  reverse_dfp (dec_val, 16, putithere->typed_val_decfloat.val);
+	  free (dec_val);
+	  p[len] = saved_char;
+	  return (DECFLOAT);
+	}
+
       num = sscanf (p, DOUBLEST_SCAN_FORMAT "%s",
 		    &putithere->typed_val_float.dval, s);
       p[len] = saved_char;	/* restore the input stream */
Index: c-lang.c
===================================================================
RCS file: /cvs/src/src/gdb/c-lang.c,v
retrieving revision 1.39
diff -u -r1.39 c-lang.c
--- c-lang.c	17 Dec 2005 22:33:59 -0000	1.39
+++ c-lang.c	21 Jun 2006 23:08:52 -0000
@@ -322,6 +322,21 @@
 			TARGET_LONG_DOUBLE_BIT / TARGET_CHAR_BIT,
 			0, "long double", objfile);
       break;
+    case FT_DECFLOAT:
+      type = init_type (TYPE_CODE_DECFLT,
+			32 / 8,
+			0, "decimal float", objfile);
+      break;
+    case FT_DBL_PREC_DECFLOAT:
+      type = init_type (TYPE_CODE_DECFLT,
+			64 / 8,
+			0, "decimal double", objfile);
+      break;
+    case FT_EXT_PREC_DECFLOAT:
+      type = init_type (TYPE_CODE_DECFLT,
+			128 / 8,
+			0, "decimal long double", objfile);
+      break;
     case FT_COMPLEX:
       type = init_type (TYPE_CODE_FLT,
 			2 * TARGET_FLOAT_BIT / TARGET_CHAR_BIT,
Index: c-valprint.c
===================================================================
RCS file: /cvs/src/src/gdb/c-valprint.c,v
retrieving revision 1.39
diff -u -r1.39 c-valprint.c
--- c-valprint.c	18 Jan 2006 21:24:19 -0000	1.39
+++ c-valprint.c	21 Jun 2006 23:08:52 -0000
@@ -442,6 +442,17 @@
 	}
       break;
 
+    case TYPE_CODE_DECFLT:
+      if (format)
+	{
+	  print_scalar_formatted (valaddr + embedded_offset, type, format, 0, stream);
+	}
+      else
+	{
+	  print_decimal_floating (valaddr + embedded_offset, type, stream);
+	}
+      break;
+
     case TYPE_CODE_METHOD:
       {
 	struct value *v = value_at (type, address);
Index: dwarf2read.c
===================================================================
RCS file: /cvs/src/src/gdb/dwarf2read.c,v
retrieving revision 1.198
diff -u -r1.198 dwarf2read.c
--- dwarf2read.c	9 Jun 2006 00:44:28 -0000	1.198
+++ dwarf2read.c	21 Jun 2006 23:08:52 -0000
@@ -4739,6 +4739,9 @@
 	case DW_ATE_complex_float:
 	  code = TYPE_CODE_COMPLEX;
 	  break;
+	case DW_ATE_decimal_float:
+	  code = TYPE_CODE_DECFLT;
+	  break;
 	case DW_ATE_float:
 	  code = TYPE_CODE_FLT;
 	  break;
@@ -7507,6 +7510,14 @@
 	  type = dwarf2_fundamental_type (objfile, FT_FLOAT, cu);
 	}
       return type;
+    case DW_ATE_decimal_float:
+      if (size == 16)
+	type = dwarf2_fundamental_type (objfile, FT_DBL_PREC_DECFLOAT, cu);
+      else if (size == 8)
+	type = dwarf2_fundamental_type (objfile, FT_EXT_PREC_DECFLOAT, cu);
+      else
+	type = dwarf2_fundamental_type (objfile, FT_DECFLOAT, cu);
+      return type;
     case DW_ATE_signed:
       switch (size)
 	{
Index: eval.c
===================================================================
RCS file: /cvs/src/src/gdb/eval.c,v
retrieving revision 1.61
diff -u -r1.61 eval.c
--- eval.c	18 Feb 2006 20:47:54 -0000	1.61
+++ eval.c	21 Jun 2006 23:08:52 -0000
@@ -447,6 +447,11 @@
       return value_from_double (exp->elts[pc + 1].type,
 				exp->elts[pc + 2].doubleconst);
 
+    case OP_DECDOUBLE:
+      (*pos) += 3;
+      return value_from_decdouble (expect_type, exp->elts[pc + 1].type,
+				exp->elts[pc + 2].decdoubleconst);
+
     case OP_VAR_VALUE:
       (*pos) += 3;
       if (noside == EVAL_SKIP)
Index: gdbtypes.h
===================================================================
RCS file: /cvs/src/src/gdb/gdbtypes.h,v
retrieving revision 1.65
diff -u -r1.65 gdbtypes.h
--- gdbtypes.h	1 Feb 2006 23:14:10 -0000	1.65
+++ gdbtypes.h	21 Jun 2006 23:08:52 -0000
@@ -67,7 +67,12 @@
 #define FT_UNSIGNED_BYTE	27
 #define FT_TEMPLATE_ARG		28
 
-#define FT_NUM_MEMBERS		29	/* Highest FT_* above, plus one. */
+/* The following three fundamental types are for decimal floating point.  */
+#define FT_DECFLOAT		29	
+#define FT_DBL_PREC_DECFLOAT	30
+#define FT_EXT_PREC_DECFLOAT	31	
+
+#define FT_NUM_MEMBERS		32	/* Highest FT_* above, plus one. */
 
 /* Some macros for char-based bitfields.  */
 
@@ -159,7 +164,9 @@
     TYPE_CODE_TEMPLATE,		/* C++ template */
     TYPE_CODE_TEMPLATE_ARG,	/* C++ template arg */
 
-    TYPE_CODE_NAMESPACE		/* C++ namespace.  */
+    TYPE_CODE_NAMESPACE,	/* C++ namespace.  */
+
+    TYPE_CODE_DECFLT		/* Decimal floating point.  */
   };
 
 /* For now allow source to use TYPE_CODE_CLASS for C++ classes, as an
@@ -1005,6 +1012,9 @@
   struct type *builtin_bool;
   struct type *builtin_long_long;
   struct type *builtin_unsigned_long_long;
+  struct type *builtin_decfloat;
+  struct type *builtin_decdouble;
+  struct type *builtin_declong;
 };
 
 /* Return the type table for the specified architecture.  */
@@ -1028,6 +1038,9 @@
 extern struct type *builtin_type_double_complex;
 extern struct type *builtin_type_string;
 extern struct type *builtin_type_bool;
+extern struct type *builtin_type_decfloat;
+extern struct type *builtin_type_decdouble;
+extern struct type *builtin_type_declong;
 
 /* Address/pointer types: */
 /* (C) Language `pointer to data' type.  Some target platforms use an
Index: gdbtypes.c
===================================================================
RCS file: /cvs/src/src/gdb/gdbtypes.c,v
retrieving revision 1.105
diff -u -r1.105 gdbtypes.c
--- gdbtypes.c	1 Mar 2006 19:34:46 -0000	1.105
+++ gdbtypes.c	21 Jun 2006 23:08:52 -0000
@@ -76,6 +76,12 @@
 struct type *builtin_type_uint128;
 struct type *builtin_type_bool;
 
+/* The following three are about decimal floating point types, which are now 
+   considered as potential extension to C99 standard.  */ 
+struct type *builtin_type_decfloat;
+struct type *builtin_type_decdouble;
+struct type *builtin_type_declong;
+
 /* 128 bit long vector types */
 struct type *builtin_type_v2_double;
 struct type *builtin_type_v4_float;
@@ -3379,6 +3385,21 @@
 #if 0
   TYPE_FLOATFORMAT (builtin_type_long_double) = TARGET_LONG_DOUBLE_FORMAT;
 #endif
+
+  /* Builtin types for decimal floating point types.  */
+  builtin_type_decfloat =
+    init_type (TYPE_CODE_DECFLT, 32 / 8,
+	       0,
+	       "decimal float", (struct objfile *) NULL);
+  builtin_type_decdouble =
+    init_type (TYPE_CODE_DECFLT, 64 / 8,
+               0,
+               "decimal double", (struct objfile *) NULL);
+  builtin_type_declong =
+    init_type (TYPE_CODE_DECFLT, 128 / 8,
+	       0,
+	       "decimal long double", (struct objfile *) NULL);
+
   builtin_type_complex =
     init_type (TYPE_CODE_COMPLEX, 2 * TARGET_FLOAT_BIT / TARGET_CHAR_BIT,
 	       0,
@@ -3604,6 +3625,21 @@
 	       0,
 	       "bool", (struct objfile *) NULL);
 
+  /* The following three are about decimal floating point types, which are 
+     32-bits, 64-bits and 128-bits respectively.  */
+  builtin_type->builtin_decfloat = 
+   init_type (TYPE_CODE_DECFLT, 32 / 8,
+               0,
+               "decimal float", (struct objfile *) NULL);
+  builtin_type->builtin_decdouble =
+    init_type (TYPE_CODE_DECFLT, 64 / 8,
+               0,
+               "decimal double", (struct objfile *) NULL);
+  builtin_type->builtin_declong =
+    init_type (TYPE_CODE_DECFLT, 128 / 8,
+               0,
+               "decimal long double", (struct objfile *) NULL);
+
   /* Pointer/Address types. */
 
   /* NOTE: on some targets, addresses and pointers are not necessarily
@@ -3742,6 +3778,9 @@
   DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_void_func_ptr);
   DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_CORE_ADDR);
   DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_bfd_vma);
+  DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_decfloat);
+  DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_decdouble);
+  DEPRECATED_REGISTER_GDBARCH_SWAP (builtin_type_declong);
   deprecated_register_gdbarch_swap (NULL, 0, build_gdbtypes);
 
   /* Note: These types do not need to be swapped - they are target
Index: value.h
===================================================================
RCS file: /cvs/src/src/gdb/value.h,v
retrieving revision 1.91
diff -u -r1.91 value.h
--- value.h	31 Mar 2006 10:36:18 -0000	1.91
+++ value.h	21 Jun 2006 23:08:52 -0000
@@ -274,6 +274,7 @@
 extern struct value *value_from_longest (struct type *type, LONGEST num);
 extern struct value *value_from_pointer (struct type *type, CORE_ADDR addr);
 extern struct value *value_from_double (struct type *type, DOUBLEST num);
+extern struct value *value_from_decdouble (struct type *expect_type, struct type *type, gdb_byte decbytes[16]);
 extern struct value *value_from_string (char *string);
 
 extern struct value *value_at (struct type *type, CORE_ADDR addr);
@@ -469,6 +470,9 @@
 extern void print_floating (const gdb_byte *valaddr, struct type *type,
 			    struct ui_file *stream);
 
+extern void print_decimal_floating (const gdb_byte *valaddr, struct type *type,
+			    struct ui_file *stream);
+
 extern int value_print (struct value *val, struct ui_file *stream, int format,
 			enum val_prettyprint pretty);
 
Index: valprint.c
===================================================================
RCS file: /cvs/src/src/gdb/valprint.c,v
retrieving revision 1.60
diff -u -r1.60 valprint.c
--- valprint.c	15 May 2006 16:53:38 -0000	1.60
+++ valprint.c	21 Jun 2006 23:08:53 -0000
@@ -35,6 +35,7 @@
 #include "floatformat.h"
 #include "doublest.h"
 #include "exceptions.h"
+#include "dfp.h"
 
 #include <errno.h>
 
@@ -496,6 +497,21 @@
 }
 
 void
+print_decimal_floating (const gdb_byte *valaddr, struct type *type,
+		struct ui_file *stream)
+{
+  char decstr[128];
+  unsigned len = TYPE_LENGTH (type);
+  gdb_byte *dec_val = (gdb_byte *)malloc (len);
+
+  reverse_dfp (valaddr, len, dec_val);
+  decimal_to_string (dec_val, len, decstr);
+  fputs_filtered (decstr, stream);
+  free (dec_val);
+  return;
+}
+
+void
 print_binary_chars (struct ui_file *stream, const gdb_byte *valaddr,
 		    unsigned len)
 {
Index: value.c
===================================================================
RCS file: /cvs/src/src/gdb/value.c,v
retrieving revision 1.36
diff -u -r1.36 value.c
--- value.c	31 Mar 2006 10:36:18 -0000	1.36
+++ value.c	21 Jun 2006 23:08:53 -0000
@@ -37,6 +37,7 @@
 #include "gdb_assert.h"
 #include "regcache.h"
 #include "block.h"
+#include "dfp.h"
 
 /* Prototypes for exported functions. */
 
@@ -1610,6 +1611,30 @@
 }
 
 struct value *
+value_from_decdouble (struct type *expect_type, struct type *type, 
+		      gdb_byte decbytes[16])
+{
+  struct value *val = allocate_value (type);
+  int len = TYPE_LENGTH (type);
+  gdb_byte *dec_val = (gdb_byte *)malloc (16);
+
+  if (expect_type)
+    {
+      int expect_len = TYPE_LENGTH (expect_type);
+      char decstr[128];
+      int real_len;
+
+      reverse_dfp (decbytes, expect_len, dec_val);
+      decimal_to_string (dec_val, len, decstr);
+      decimal_from_string (dec_val, expect_len, decstr);
+      reverse_dfp (dec_val, expect_len, decbytes);
+    }
+
+  memcpy (value_contents_raw (val), decbytes, len);
+  return val;
+}
+
+struct value *
 coerce_ref (struct value *arg)
 {
   struct type *value_type_arg_tmp = check_typedef (value_type (arg));
Index: valarith.c
===================================================================
RCS file: /cvs/src/src/gdb/valarith.c,v
retrieving revision 1.45
diff -u -r1.45 valarith.c
--- valarith.c	24 Jan 2006 21:21:12 -0000	1.45
+++ valarith.c	21 Jun 2006 23:08:53 -0000
@@ -1378,6 +1378,18 @@
 
   type = check_typedef (value_type (arg1));
 
+  if (TYPE_CODE (type) == TYPE_CODE_DECFLT)
+    {
+      struct value *val = allocate_value (result_type);
+      int len = TYPE_LENGTH (type);
+      gdb_byte *decbytes = (gdb_byte *) value_contents (arg1);
+
+      /* To change the first bit is ok.  */
+      decbytes[len-1] = decbytes[len - 1] | 0x80;
+      memcpy (value_contents_raw (val), decbytes, 16);
+      return val;
+    }
+
   if (TYPE_CODE (type) == TYPE_CODE_FLT)
     return value_from_double (result_type, -value_as_double (arg1));
   else if (is_integral_type (type))
Index: dfp.h
===================================================================
RCS file: dfp.h
diff -N dfp.h
--- /dev/null	1 Jan 1970 00:00:00 -0000
+++ dfp.h	21 Jun 2006 23:08:53 -0000
@@ -0,0 +1,45 @@
+/* Decimal floating point support for GDB.
+
+   Copyright 2006 Free Software Foundation, Inc.
+
+   This file is part of GDB.
+
+   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.  */
+
+/* Decimal floating point is one of the extension to IEEE 754, which is
+   described in http://grouper.ieee.org/groups/754/revision.html and
+   http://www2.hursley.ibm.com/decimal/.  It completes binary floating
+   point by representing floating point more exactly.  */
+
+/* There is a project intended to add DFP support into GCC, described in
+   http://gcc.gnu.org/wiki/Decimal%20Floating-Point.  This file is intended
+   to add DFP support into GDB.  */
+
+#ifndef DFP_H
+#define DFP_H
+#include <string.h>
+#include <stdio.h>
+#include <stdint.h>
+
+/* The conversion from decimal floating point to string, and reverse.  */
+extern void decimal_to_string (const uint8_t *, int, char *);
+extern void decimal_from_string (uint8_t *, int, char *);
+
+/* The value struct of gdb and decimal type of libdecnumber are using
+   different endian for storing the content.  This routine is used to
+   convert between these two.  */
+extern void reverse_dfp (const gdb_byte *, int, gdb_byte *);
+#endif
Index: dfp.c
===================================================================
RCS file: dfp.c
diff -N dfp.c
--- /dev/null	1 Jan 1970 00:00:00 -0000
+++ dfp.c	21 Jun 2006 23:08:53 -0000
@@ -0,0 +1,104 @@
+/* Decimal floating point support for GDB.
+
+   Copyright 2006 Free Software Foundation, Inc.
+
+   This file is part of GDB.
+
+   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 "defs.h"
+#include "dfp.h"
+#include <ctype.h>
+
+/* The order of the following headers is important for making sure
+   decNumber structure is large enough to hold decimal128 digits.  */
+
+#include "decimal128.h"
+#include "decimal64.h"
+#include "decimal32.h"
+#include "decNumber.h"
+
+void
+reverse_dfp (const gdb_byte *valaddr, int len, gdb_byte *dec_val)
+{
+  int index;
+
+  for (index = 0; index < len; index++)
+    dec_val[index] = valaddr[len - index - 1];
+
+  return;
+}
+
+/* Convert deciaml type to its string representation.  LEN is the length
+   of the decimal type, 4 bytes for decimal32, 8 bytes for decimal64 and
+   16 bytes for decimal128.  */
+void
+decimal_to_string (const uint8_t *dec, int len, char *s)
+{
+  switch (len)
+    {
+      case 4:
+        decimal32ToString ((decimal32 *)dec, s);
+        return;
+      case 8:
+        decimal64ToString ((decimal64 *)dec, s);
+        return;
+      case 16:
+        decimal128ToString ((decimal128 *)dec, s);
+        return;
+      default:
+	error ("We don't support decimal number of %d bytes.", len);
+    }
+}
+
+void
+decimal_from_string (uint8_t *dec, int len, char *string)
+{
+  decNumber dn;
+  decContext set;
+  switch (len)
+    {
+      case 4:
+	decContextDefault (&set, DEC_INIT_DECIMAL32);
+	break;
+      case 8:
+	decContextDefault (&set, DEC_INIT_DECIMAL64);
+	break;
+      case 16:
+	decContextDefault (&set, DEC_INIT_DECIMAL128);
+	break;
+      default:
+	error ("We don't support decimal number of %d bytes.", len);
+    }
+
+  set.traps = 0;
+
+  decNumberFromString (&dn, string, &set);
+  switch (len)
+    {
+      case 4:
+	decimal32FromNumber ((decimal32 *)dec, &dn, &set);
+	return;
+      case 8:
+	decimal64FromNumber ((decimal64 *)dec, &dn, &set);
+	return;
+      case 16:
+	decimal128FromNumber ((decimal128 *)dec, &dn, &set);
+	return;
+      default:
+	error ("We don't support decimal number of %d bytes.", len);
+    }
+}
Index: Makefile.in
===================================================================
RCS file: /cvs/src/src/gdb/Makefile.in,v
retrieving revision 1.821
diff -u -r1.821 Makefile.in
--- Makefile.in	31 May 2006 15:14:36 -0000	1.821
+++ Makefile.in	21 Jun 2006 23:08:53 -0000
@@ -122,6 +122,12 @@
 BFD_SRC = $(srcdir)/$(BFD_DIR)
 BFD_CFLAGS = -I$(BFD_DIR) -I$(BFD_SRC)
 
+# Where is the decnumber library?  Typically in ../libdecnumber.
+LIBDECNUMBER_DIR = ../libdecnumber
+LIBDECNUMBER = $(LIBDECNUMBER_DIR)/libdecnumber.a
+LIBDECNUMBER_SRC = $(srcdir)/$(LIBDECNUMBER_DIR)
+LIBDECNUMBER_CFLAGS = -I$(LIBDECNUMBER_DIR) -I$(LIBDECNUMBER_SRC)
+
 # Where is the READLINE library?  Typically in ../readline.
 READLINE_DIR = ../readline
 READLINE = $(READLINE_DIR)/libreadline.a
@@ -348,7 +354,7 @@
 INTERNAL_CFLAGS_BASE = \
 	$(CFLAGS) $(GLOBAL_CFLAGS) $(PROFILE_CFLAGS) \
 	$(GDB_CFLAGS) $(OPCODES_CFLAGS) $(READLINE_CFLAGS) \
-	$(BFD_CFLAGS) $(INCLUDE_CFLAGS) \
+	$(BFD_CFLAGS) $(INCLUDE_CFLAGS) $(LIBDECNUMBER_CFLAGS) \
 	$(INTL_CFLAGS) $(ENABLE_CFLAGS)
 INTERNAL_WARN_CFLAGS = $(INTERNAL_CFLAGS_BASE) $(GDB_WARN_CFLAGS)
 INTERNAL_CFLAGS = $(INTERNAL_WARN_CFLAGS) $(GDB_WERROR_CFLAGS)
@@ -371,10 +377,10 @@
 # LIBIBERTY appears twice on purpose.
 # If you have the Cygnus libraries installed,
 # you can use 'CLIBS=$(INSTALLED_LIBS)' 'CDEPS='
-INSTALLED_LIBS=-lbfd -lreadline -lopcodes -liberty \
+INSTALLED_LIBS=-lbfd -lreadline -lopcodes -liberty -ldecnumber \
 	$(XM_CLIBS) $(TM_CLIBS) $(NAT_CLIBS) $(GDBTKLIBS) @LIBS@ \
 	-lintl -liberty
-CLIBS = $(SIM) $(READLINE) $(OPCODES) $(BFD) $(INTL) $(LIBIBERTY) \
+CLIBS = $(SIM) $(READLINE) $(OPCODES) $(BFD) $(INTL) $(LIBIBERTY) $(LIBDECNUMBER) \
 	$(XM_CLIBS) $(TM_CLIBS) $(NAT_CLIBS) $(GDBTKLIBS) @LIBS@ \
 	$(LIBICONV) \
 	$(LIBIBERTY) $(WIN32LIBS)
@@ -605,6 +611,10 @@
 safe_ctype_h =  $(INCLUDE_DIR)/safe-ctype.h
 hashtab_h =	$(INCLUDE_DIR)/hashtab.h
 
+decimal128_h = $(LIBDECNUMBER_DIR)/decimal128.h
+decimal64_h = $(LIBDECNUMBER_DIR)/decimal64.h
+decimal32_h = $(LIBDECNUMBER_DIR)/decimal32.h
+
 #
 # $BUILD/ headers
 #
@@ -670,6 +680,7 @@
 disasm_h = disasm.h
 doublest_h = doublest.h $(floatformat_h)
 dummy_frame_h = dummy-frame.h
+dfp_h = dfp.h
 dwarf2expr_h = dwarf2expr.h
 dwarf2_frame_h = dwarf2-frame.h
 dwarf2loc_h = dwarf2loc.h
@@ -912,7 +923,7 @@
 	auxv.o \
 	bfd-target.o \
 	blockframe.o breakpoint.o findvar.o regcache.o \
-	charset.o disasm.o dummy-frame.o \
+	charset.o disasm.o dummy-frame.o dfp.o \
 	source.o value.o eval.o valops.o valarith.o valprint.o printcmd.o \
 	block.o symtab.o symfile.o symmisc.o linespec.o dictionary.o \
 	infcall.o \
@@ -1917,6 +1928,7 @@
 dummy-frame.o: dummy-frame.c $(defs_h) $(dummy_frame_h) $(regcache_h) \
 	$(frame_h) $(inferior_h) $(gdb_assert_h) $(frame_unwind_h) \
 	$(command_h) $(gdbcmd_h) $(gdb_string_h)
+dfp.o: dfp.c $(defs_h) $(dfp_h) $(decimal128_h) $(decimal64_h) $(decimal32_h)
 dve3900-rom.o: dve3900-rom.c $(defs_h) $(gdbcore_h) $(target_h) $(monitor_h) \
 	$(serial_h) $(inferior_h) $(command_h) $(gdb_string_h) $(regcache_h) \
 	$(mips_tdep_h)
@@ -2790,7 +2802,7 @@
 valprint.o: valprint.c $(defs_h) $(gdb_string_h) $(symtab_h) $(gdbtypes_h) \
 	$(value_h) $(gdbcore_h) $(gdbcmd_h) $(target_h) $(language_h) \
 	$(annotate_h) $(valprint_h) $(floatformat_h) $(doublest_h) \
-	$(exceptions_h)
+	$(exceptions_h) $(dfp_h)
 value.o: value.c $(defs_h) $(gdb_string_h) $(symtab_h) $(gdbtypes_h) \
 	$(value_h) $(gdbcore_h) $(command_h) $(gdbcmd_h) $(target_h) \
 	$(language_h) $(scm_lang_h) $(demangle_h) $(doublest_h) \


Here is the patch to add libdecnumber code into gdb top-level repository.  
I didn't figure out how to add a whole new directory into the cvs.  Anyone 
can help me on this?  I only attach the makefile change here:

Index: Makefile.in
===================================================================
RCS file: /cvs/src/src/Makefile.in,v
retrieving revision 1.244
diff -r1.244 Makefile.in
396a397,401
> @if libdecnumber
> HOST_LIB_PATH_libdecnumber = \
>   $$r/$(HOST_SUBDIR)/libdecnumber/.libs:$$r/$(HOST_SUBDIR)/prev-libdecnumber/.libs:
> @endif libdecnumber
> 


Regards
- Wu Zhou

On Thu, 22 Jun 2006, Wu Zhou wrote:

> Hello Daniel/all,
> 
> About one week ago, I said that I will rework my dfp patch based on libdecnumber.
> OK.  Here it is.  This post is about what it can support right now.  The
> testcase can tell easily about this.  The gdb patch will be posted in 
> another email.
> 
> The functions this patch provides are much the same as before.  But it is 
> more exensible because it is based on libdecnumber.  I list here what is 
> available now.  If you think any functionality is desirable, please tell 
> me.  I will try to add them in.
> 
> - for dfp constants, this patch supports two kind of representation: 
> scientific one and non-scientific one.  To input any dfp constants, you 
> need to add suffix to differentiate it from binary float: "df" for deciaml 
> float (32 bits), "dd" for deciaml double (64 bits), and "dl" for deciaml
> long (128 bits).  When printing dfp constants, it will strip the suffix.  
> 
> - it supports the displaying of dfp values in variables, struct, function 
> argument and also back trace.  Any more is needed?
> 
> - it support the negation operation (-dfp), assign operation (d1 = d2 or 
> d1 = -d2),
> 
> - it can handle finite dfp numbers, infinity (positive and negative), and 
> NaN (not a number).  
> 
> - it can also support the max, normalized min and subnormalized min well.
> 
> - we can't do conversion between binary float and decimal float right, or 
> between two different dfp types right now
> 
> Here goes the testcase.  Please review.  Any comment or suggestion is 
> highly appreciated.  
> 
> P.S: I am trying to make it self explanatory.  But if you think more 
> comment is needed in some place, feel free to tell me.
> 
> 2006-06-21  Wu Zhou  <woodzltc@cn.ibm.com>
> 
> 	* gdb.base/dfp-exprs.exp: New testcase to verify that gdb can
> 	handle dfp constants correctly.
> 	* gdb.base/dfp-test.c: New test file, used for dfp-test.exp.
> 	* gdb.base/dfp-test.exp: New testcase toverify that gdb can handle
> 	dfp related operation.
> 
> 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	21 Jun 2006 21:00:23 -0000
> @@ -0,0 +1,88 @@
> +# 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, covering 32-bit, 64-bit and 128-bit ones
> +
> +    # _Decimal32 constants, which can support up to 7 digits
> +    gdb_test "p 1.2df" " = 1.2"
> +    gdb_test "p -1.2df" " = -1.2"
> +    gdb_test "p 1.234567df" " = 1.234567" 
> +    gdb_test "p -1.234567df" " = -1.234567"
> +    gdb_test "p 1234567.df" " = 1234567"
> +    gdb_test "p -1234567.df" " = -1234567"
> +
> +    gdb_test "p 1.2E1df" " = 12"
> +    gdb_test "p 1.2E10df" " = 1.2E\\+10"
> +    gdb_test "p 1.2E-10df" " = 1.2E-10"
> +
> +    # The largest exponent for 32-bit dfp value is 96.
> +    gdb_test "p 1.2E96df" " = 1.200000E\\+96"
> +
> +    # _Decimal64 constants, which can support up to 16 digits
> +    gdb_test "p 1.2dd" " = 1.2"
> +    gdb_test "p -1.2dd" " = -1.2"
> +    gdb_test "p 1.234567890123456dd" " = 1.234567890123456"
> +    gdb_test "p -1.234567890123456dd" " = -1.234567890123456"
> +    gdb_test "p 1234567890123456.dd" " = 1234567890123456"
> +    gdb_test "p -1234567890123456.dd" " = -1234567890123456"
> +
> +    gdb_test "p 1.2E1dd" " = 12"
> +    gdb_test "p 1.2E10dd" " = 1.2E\\+10"
> +    gdb_test "p 1.2E-10dd" " = 1.2E-10"
> +
> +    # The largest exponent for 64-bit dfp value is 384.
> +    gdb_test "p 1.2E384dd" " = 1.200000000000000E\\+384"
> +
> +    # _Decimal128 constants, which can support up to 34 digits
> +    gdb_test "p 1.2dl" " = 1.2"
> +    gdb_test "p -1.2dl" " = -1.2"
> +    gdb_test "p 1.234567890123456789012345678901234dl" " = 1.234567890123456789012345678901234"
> +    gdb_test "p -1.234567890123456789012345678901234dl" " = -1.234567890123456789012345678901234"
> +    gdb_test "p 1234567890123456789012345678901234.dl" " = 1234567890123456789012345678901234"
> +    gdb_test "p -1234567890123456789012345678901234.dl" " = -1234567890123456789012345678901234"
> +
> +    gdb_test "p 1.2E1dl" " = 12"
> +    gdb_test "p 1.2E10dl" " = 1.2E\\+10"
> +    gdb_test "p 1.2E-10dl" " = 1.2E-10"
> +
> +    # The largest exponent for 128-bit dfp value is 6144.
> +    gdb_test "p 1.2E6144dl" " = 1.200000000000000000000000000000000E\\+6144"  
> +}
> +
> +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	21 Jun 2006 21:00:23 -0000
> @@ -0,0 +1,95 @@
> +/* This testcase is part of GDB, the GNU debugger.
> +
> +   Copyright 2006 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	21 Jun 2006 21:00:23 -0000
> @@ -0,0 +1,247 @@
> +# 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 hane decimal floating point introduced in IEEE 754R.
> +
> +proc d32_set_tests {} {
> +
> +    gdb_test "p d32=123.45df" " = 123.45"
> +    gdb_test "p d32=12345.df" " = 12345"
> +    gdb_test "p d32=12345.67df" " = 12345.67"
> +    gdb_test "p d32=1234567.df" " = 1234567"
> +
> +    gdb_test "p d32=1.234567E0df" " = 1.234567" 
> +    gdb_test "p d32=1.234567E10df" " = 1.234567E\\+10"
> +    gdb_test "p d32=1.234567E+96df" " = 1.234567E\\+96"
> +
> +    # Test that gdb could handle the max, normalized min and subnormalized min.
> +    gdb_test "p d32=9.999999E96df" " = 9.999999E\\+96"
> +    gdb_test "p d32=1.0E-95df" " = 1.0E\\-95"
> +    gdb_test "p d32=1.E-101df" " = 1E\\-101"
> +    gdb_test "p d32=0.000001E-95df" " = 1E\\-101"
> +
> +    # Test that gdb could detect coefficient/exponent out of range.
> +    # The coefficient out of range will be rounded to its nearest value.
> +    # And the exponent out of range will be handled as infinity.
> +    gdb_test "p d32=1.2345678df" " = 1.234568" "1.2345678 is rounded to 1.234568"
> +    gdb_test "p d32=1.0E-101df" " = 1E-101" "1.0E-101 is rounded to 1E-101"
> +    gdb_test "p d32=1.234567E+97df" " = Infinity" "1.234567E+97 is Infinity"
> +
> +    # Test that gdb could detect the errors in the string representation of _Decimal32
> +    gdb_test "p d32=12345.df" " = 12345" "12345. is an valid number"
> +    gdb_test "p d32=12345df" ".*Invalid number.*" "12345 is an invalid number"
> +    gdb_test "p d32=1.23Edf" " = NaN" "1.23E is NaN (not a number)"
> +    gdb_test "p d32=1.23E45Adf" " = NaN" "1.23E45A is NaN (not a number)"
> +}
> +
> +proc d64_set_tests {} {
> +
> +    gdb_test "p d64=123.45dd" " = 123.45"
> +    gdb_test "p d64=12345.dd" " = 12345"
> +    gdb_test "p d64=12345.67dd" " = 12345.67"
> +    gdb_test "p d64=1.234567890123456dd" " = 1.234567890123456"
> +
> +    gdb_test "p d64=1.234567890123456E10dd" " = 12345678901.23456"
> +    gdb_test "p d64=1.234567890123456E100dd" " = 1.234567890123456E\\+100"
> +    gdb_test "p d64=1.234567890123456E384dd" " = 1.234567890123456E\\+384"
> +
> +    # Test that gdb could handle the max, normalized min and subnormalized min.
> +    gdb_test "p d64=9.999999999999999E384dd" " = 9.999999999999999E\\+384"
> +    gdb_test "p d64=1.E-383dd" " = 1E\\-383"
> +    gdb_test "p d64=1.E-398dd" " = 1E\\-398"
> +    gdb_test "p d64=0.000000000000001E-383dd" " = 1E\\-398"
> +
> +    # Test that gdb could detect coefficient/exponent out of range.
> +    # The coefficient out of range will be rounded to its nearest value.
> +    # And the exponent out of range will be handled as infinity.
> +    gdb_test "p d64=1.2345678901234567dd" " = 1.234567890123457" "1.2345678901234567 is rounded to 1.234567890123457" 
> +    gdb_test "p d64=9.9999999999999999E384dd" " = Infinity" "d64=9.9999999999999999E384 is Infinity"
> +    gdb_test "p d64=1.234567890123456E385dd" " = Infinity" "d64=1.234567890123456E385 is Infinity"
> +
> +    # Test that gdb could detect the errors in the string representation of _Decimal64
> +    gdb_test "p d64=12345dd" ".*Invalid number.*" "12345dd is an invalid number"
> +    gdb_test "p d64=1.23Edd" " = NaN" "1.23E is NaN (not a number)"
> +    gdb_test "p d64=1.23E45Add" "= NaN" "1.23E45A is NaN (not a number)"
> +}
> +
> +proc d128_set_tests {} {
> +
> +    gdb_test "p d128=123.45dl" " = 123.45"
> +    gdb_test "p d128=12345.dl" " = 12345"
> +    gdb_test "p d128=12345.67dl" " = 12345.67"
> +    gdb_test "p d128=1.234567890123456789012345678901234dl" " = 1.234567890123456789012345678901234"
> +
> +    gdb_test "p d128=1.234567890123456E10dl" " = 12345678901.23456"
> +    gdb_test "p d128=1.234567890123456E100dl" " = 1.234567890123456E\\+100"
> +    gdb_test "p d128=1.234567890123456E1000dl" " = 1.234567890123456E\\+1000"
> +
> +    # Test that gdb could handle the max, normalized min and subnormalized min.
> +    gdb_test "p d128=9.999999999999999999999999999999999E6144dl" " = 9.999999999999999999999999999999999E\\+6144"
> +    gdb_test "p d128=1.E-6143dl" " = 1E\\-6143"
> +    gdb_test "p d128=1.E-6176dl" " = 1E\\-6176"
> +    gdb_test "p d128=0.000000000000000000000000000000001E-6143dl" " = 1E\\-6176"
> +
> +    # Test that gdb could detect coefficient/exponent out of range.
> +    # The coefficient out of range will be rounded to its nearest value.
> +    # And the exponent out of range will be handled as infinity.
> +    gdb_test "p d128=1.2345678901234567890123456789012345dl" "1.234567890123456789012345678901234" "1.2345678901234567890123456789012345 is rounded to 1.234567890123456789012345678901234"
> +    gdb_test "p d128=1.234567890123456E6145dl" "Infinity" "d128=1.234567890123456E6145 is Infinity"
> +
> +    # Test that gdb could detect the errors in the string representation of _Decimal128
> +    gdb_test "p d128=12345dl" ".*Invalid number.*" "12345dl is an invalid number"
> +    gdb_test "p d128=1.23Edl" " = NaN" "1.23E is NaN (not a number)"
> +    gdb_test "p d128=1.23E45Adl" "= NaN" "1.23E45A is NaN (not a number)"
> +}
> +
> +
> +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.2345" "d32 is initialized to 1.2345"
> +
> +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.2345.*" \
> +    "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.2345" "d64 is initialized to 1.2345"
> +
> +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.2345.*" \
> +    "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.2345" "d128 is initialized to 1.2345"
> +
> +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.1, arg1=1.0, arg2=2.0, arg3=3.0, arg4=4.0, arg5=5.0\\).*" "backtrace at arg0_32"
> +
> +gdb_breakpoint arg0_64
> +gdb_continue_to_breakpoint "entry to arg0_64"
> +gdb_test "backtrace" ".*arg0_64 \\(arg0=0.1, arg1=1.0, arg2=2.0, arg3=3.0, arg4=4.0, arg5=5.0\\).*" "backtrace at arg0_64"
> +
> +gdb_breakpoint arg0_128
> +gdb_continue_to_breakpoint "entry to arg0_128"
> +gdb_test "backtrace" ".*arg0_128 \\(arg0=0.1, arg1=1.0, arg2=2.0, arg3=3.0, arg4=4.0, arg5=5.0\\).*" "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.2345"
> +gdb_test "print ds.dec64" " = 1.2345"
> +gdb_test "print ds.dec128" " = 1.2345"
> +
> +# The following tests are intended to verify that gdb can handle "d1=d2"
> +# and "d1=-d2" correctly.
> +
> +gdb_test "print ds.dec32=d32" " = 0.1"
> +gdb_test "print ds.dec64=d64" " = 0.1"
> +gdb_test "print ds.dec128=d128" " = 0.1"
> +gdb_test "print ds.dec32 = -d32" " = -0.1"
> +gdb_test "print ds.dec64 = -d64" " = -0.1"
> +gdb_test "print ds.dec128 = -d128" " = -0.1"
> 
> 
> Regards
> - Wu Zhou
> 

Re: [RFC] decimal float point patch based on libdecnumber: gdb patch

[Eli Zaretskii]

> Date: Thu, 22 Jun 2006 07:36:17 +0800 (CST)
> From: Wu Zhou <woodzltc@cn.ibm.com>
> 
> 
> Appended is the patch.  I had tested it with the latest gcc-4.2 cvs tree 
> on x86, with option "--enable-decimal-float". All the 121 tests passed.

Thanks.

> Please review and comment.  Thanks a lot.

Does this patch affect user-visible behavior in any way?  If so, we
need to reflect that in the user manual.

> 	* Makefile.in: Add decimal floating point related entry.  Add
> 	some macro to specify the libdecnumber directory, cflags and the
> 	name of libdecnumber library.

The ChangeLog entry for Makefile.in should cite the target(s) and
macros in which you made the changes, as if they were functions in a
source file.

Re: [RFC] decimal float point patch based on libdecnumber: gdb patch

[Wu Zhou]

Eli,

Thanks for your comments!  See below for my response.

On Thu, 22 Jun 2006, Eli Zaretskii wrote:

> > Date: Thu, 22 Jun 2006 07:36:17 +0800 (CST)
> > From: Wu Zhou <woodzltc@cn.ibm.com>
> > 
> > 
> > Appended is the patch.  I had tested it with the latest gcc-4.2 cvs tree 
> > on x86, with option "--enable-decimal-float". All the 121 tests passed.
> 
> Thanks.
> 
> > Please review and comment.  Thanks a lot.
> 
> Does this patch affect user-visible behavior in any way?  If so, we
> need to reflect that in the user manual.

Yes. I am thinking of adding some text to describe this.

> 
> > 	* Makefile.in: Add decimal floating point related entry.  Add
> > 	some macro to specify the libdecnumber directory, cflags and the
> > 	name of libdecnumber library.
> 
> The ChangeLog entry for Makefile.in should cite the target(s) and
> macros in which you made the changes, as if they were functions in a
> source file.

Thanks for the correction.  I didn't add any changelog for such things 
(Makefile.in) before.  Learn something new.  :-)  Will change that in the 
next round patch.

Regards
- Wu Zhou

Re: [RFC] decimal float point patch based on libdecnumber: gdb patch

[Daniel Jacobowitz]

On Thu, Jun 22, 2006 at 07:36:17AM +0800, Wu Zhou wrote:
> 
> Appended is the patch.  I had tested it with the latest gcc-4.2 cvs tree 
> on x86, with option "--enable-decimal-float". All the 121 tests passed.
> Please review and comment.  Thanks a lot.

Sometimes you use DECDBL and sometimes you use DECDOUBLE and sometimes
you use DECFLOAT and sometimes you use DECFLT.  Let's pick one or the
other and use it everywhere.  This makes it easier to search for
code that knows about decimal float.  "decfloat" might be more
readable?

Why is reverse_dfp necessary?  It says GDB uses the opposite endianness
from decNumber, but I don't see why.  This might be a related problem,
but are you accomodating target endianness when you read values from
the target?  If not, a cross debugger will do the wrong thing.

> Index: expression.h
> ===================================================================
> RCS file: /cvs/src/src/gdb/expression.h,v
> retrieving revision 1.18
> diff -u -r1.18 expression.h
> --- expression.h	17 Dec 2005 22:33:59 -0000	1.18
> +++ expression.h	21 Jun 2006 23:08:51 -0000
> @@ -327,6 +327,11 @@
>      /* A F90 array range operator (for "exp:exp", "exp:", ":exp" and ":").  */
>      OP_F90_RANGE,
>  
> +    /* OP_DECDOUBLE is followed by a type pointer in the next exp_element
> +       and a dec long constant value in the following exp_element.
> +       Then comes another OP_DECDOUBLE.  */
> +    OP_DECDOUBLE,
> +

A comment on the format of the data would be nice here.  Is it in
target byte order?

> Index: c-valprint.c
> ===================================================================
> RCS file: /cvs/src/src/gdb/c-valprint.c,v
> retrieving revision 1.39
> diff -u -r1.39 c-valprint.c
> --- c-valprint.c	18 Jan 2006 21:24:19 -0000	1.39
> +++ c-valprint.c	21 Jun 2006 23:08:52 -0000
> @@ -442,6 +442,17 @@
>  	}
>        break;
>  
> +    case TYPE_CODE_DECFLT:
> +      if (format)
> +	{
> +	  print_scalar_formatted (valaddr + embedded_offset, type, format, 0, stream);
> +	}
> +      else
> +	{
> +	  print_decimal_floating (valaddr + embedded_offset, type, stream);
> +	}
> +      break;
> +
>      case TYPE_CODE_METHOD:
>        {
>  	struct value *v = value_at (type, address);

You don't need the braces in this; please omit them when you don't need
to.  It saves a level of indentation, which generally makes them easier
to read.

-- 
Daniel Jacobowitz
CodeSourcery

Re: [RFC] decimal float point patch based on libdecnumber: testcase

[Daniel Jacobowitz]

Hi Wu,

By and large this looks very good.  There are a couple of minor
formatting issues, which I'll run through for you when I get a chance
if no one else does; it may not be until after the GCC Summit next
week, though.

Moving libdecnumber into src is a bit tricky.  I'll take care of that
when we're ready for the patch.  It also has to go into src-release,
CVSROOT/modules, and some dependencies in Makefile.def.  So don't worry
about that.

I did have one question for you.  This struck me as strange...

On Thu, Jun 22, 2006 at 05:03:34AM +0800, Wu Zhou wrote:
> +    # _Decimal64 constants, which can support up to 16 digits
> +    gdb_test "p 1.2dd" " = 1.2"
> +    gdb_test "p -1.2dd" " = -1.2"
> +    gdb_test "p 1.234567890123456dd" " = 1.234567890123456"
> +    gdb_test "p -1.234567890123456dd" " = -1.234567890123456"
> +    gdb_test "p 1234567890123456.dd" " = 1234567890123456"
> +    gdb_test "p -1234567890123456.dd" " = -1234567890123456"
> +
> +    gdb_test "p 1.2E1dd" " = 12"
> +    gdb_test "p 1.2E10dd" " = 1.2E\\+10"

If "p 1234567890123456.dd" prints it back with digits, why does "p
1.2E10dd" print it back with an exponent?  Which would
"p 1200000000000000.dd" do?

> +proc test_arithmetic_expressions {} {
> +
> +# Arithmetic operations for DFP types are not yet implemented in GDB.
> +
> +}

Might want some tests for whatever does happen if you try it, in the
meantime.  It should give a sensible error message.

-- 
Daniel Jacobowitz
CodeSourcery

Re: [RFC] decimal float point patch based on libdecnumber: testcase

[Wu Zhou]

Hi Daniel,

Thanks for the review.  See below for my response.

On Thu, 22 Jun 2006, Daniel Jacobowitz wrote:

> Hi Wu,
> 
> By and large this looks very good.  There are a couple of minor
> formatting issues, which I'll run through for you when I get a chance
> if no one else does; it may not be until after the GCC Summit next
> week, though.

I will go through the patches to see if I find the formatting issues 
myself.  If anybody can help point them out, that will be appreciated.

> Moving libdecnumber into src is a bit tricky.  I'll take care of that
> when we're ready for the patch.  It also has to go into src-release,
> CVSROOT/modules, and some dependencies in Makefile.def.  So don't worry
> about that.

Thanks. I won't bother to think about that then.

> 
> I did have one question for you.  This struck me as strange...
> 
> On Thu, Jun 22, 2006 at 05:03:34AM +0800, Wu Zhou wrote:
> > +    # _Decimal64 constants, which can support up to 16 digits
> > +    gdb_test "p 1.2dd" " = 1.2"
> > +    gdb_test "p -1.2dd" " = -1.2"
> > +    gdb_test "p 1.234567890123456dd" " = 1.234567890123456"
> > +    gdb_test "p -1.234567890123456dd" " = -1.234567890123456"
> > +    gdb_test "p 1234567890123456.dd" " = 1234567890123456"
> > +    gdb_test "p -1234567890123456.dd" " = -1234567890123456"
> > +
> > +    gdb_test "p 1.2E1dd" " = 12"
> > +    gdb_test "p 1.2E10dd" " = 1.2E\\+10"
> 
> If "p 1234567890123456.dd" prints it back with digits, why does "p
> 1.2E10dd" print it back with an exponent?  Which would
> "p 1200000000000000.dd" do?

That is because they have different precision/exponent. Number 
1234567890123456.dd have 16 digits, its coefficient is 1234567890123456, 
and exponent is 0, so it won't print back with an exponent.  While in the 
case of "1.2E10dd", the coefficient is 12, exponent is 9, so it will print 
back with an exponent. And in exponent display mode, the coefficient will 
be normalized, in this case, to 1.2; and exponent get to 10 respectively.

For "p 1200000000000000.dd", it will return 1200000000000000. It is 
equal to but different than 1.2E+15.  Their precison is not the same.

> > +proc test_arithmetic_expressions {} {
> > +
> > +# Arithmetic operations for DFP types are not yet implemented in GDB.
> > +
> > +}
> 
> Might want some tests for whatever does happen if you try it, in the
> meantime.  It should give a sensible error message.

Using my patched gdb, addition and multiple will return the following 
error message:

(gdb) p 1.2df + 1.3df
Argument to arithmetic operation not a number or boolean.
(gdb) p 1.2df * 1.3df
Argument to arithmetic operation not a number or boolean.

Do you mean that we need to output something more close to the fact. to 
say, "Addition/Multiple of decimal floating point is not supported right 
now".  or something other like this.  If you want, I can do that.

Regards
- Wu Zhou

Re: [RFC] decimal float point patch based on libdecnumber: testcase

[Daniel Jacobowitz]

On Fri, Jun 23, 2006 at 07:27:29AM +0800, Wu Zhou wrote:
> That is because they have different precision/exponent. Number 
> 1234567890123456.dd have 16 digits, its coefficient is 1234567890123456, 
> and exponent is 0, so it won't print back with an exponent.  While in the 
> case of "1.2E10dd", the coefficient is 12, exponent is 9, so it will print 
> back with an exponent. And in exponent display mode, the coefficient will 
> be normalized, in this case, to 1.2; and exponent get to 10 respectively.
> 
> For "p 1200000000000000.dd", it will return 1200000000000000. It is 
> equal to but different than 1.2E+15.  Their precison is not the same.

So they map down to different bit patterns.  How bizarre.

> Do you mean that we need to output something more close to the fact. to 
> say, "Addition/Multiple of decimal floating point is not supported right 
> now".  or something other like this.  If you want, I can do that.

No, I think what's there is fine - but add a test or two for that error
message.

-- 
Daniel Jacobowitz
CodeSourcery

Re: [RFC] decimal float point patch based on libdecnumber: testcase

[Wu Zhou]

On Thu, 22 Jun 2006, Daniel Jacobowitz wrote:

> On Fri, Jun 23, 2006 at 07:27:29AM +0800, Wu Zhou wrote:
> > That is because they have different precision/exponent. Number 
> > 1234567890123456.dd have 16 digits, its coefficient is 1234567890123456, 
> > and exponent is 0, so it won't print back with an exponent.  While in the 
> > case of "1.2E10dd", the coefficient is 12, exponent is 9, so it will print 
> > back with an exponent. And in exponent display mode, the coefficient will 
> > be normalized, in this case, to 1.2; and exponent get to 10 respectively.
> > 
> > For "p 1200000000000000.dd", it will return 1200000000000000. It is 
> > equal to but different than 1.2E+15.  Their precison is not the same.
> 
> So they map down to different bit patterns.  How bizarre.

Yes, they do.  A little bizarre when I first saw this.  But I don't feel 
like this now.  :-)  It is desirable to be able to differentiate 
between floating numbers with same value but different precision anyway.

> 
> > Do you mean that we need to output something more close to the fact. to 
> > say, "Addition/Multiple of decimal floating point is not supported right 
> > now".  or something other like this.  If you want, I can do that.
> 
> No, I think what's there is fine - but add a test or two for that error
> message.

OK.  Understand.  We can use XFAIL for them, right?

Regards
- Wu Zhou

Re: [RFC] decimal float point patch based on libdecnumber: testcase

[Daniel Jacobowitz]

On Sat, Jun 24, 2006 at 02:39:41AM +0800, Wu Zhou wrote:
> > > Do you mean that we need to output something more close to the fact. to 
> > > say, "Addition/Multiple of decimal floating point is not supported right 
> > > now".  or something other like this.  If you want, I can do that.
> > 
> > No, I think what's there is fine - but add a test or two for that error
> > message.
> 
> OK.  Understand.  We can use XFAIL for them, right?

I mean tests that PASS given the current state - for now, it's what we
want to happen, so test that it does happen.

-- 
Daniel Jacobowitz
CodeSourcery

Re: [RFC] decimal float point patch based on libdecnumber: testcase

[Wu Zhou]

So what is XFAIL intended for?  In my opinion, it is intended for failure, 
but an expected failure.  I guess it can be used for such situation like:
the output is expected, but is not what we want at last.  We might fix 
that at a later time.  

Just my two cents anyway.  Correct me if I am wrong.

Thanks
- Wu Zhou

On Fri, 23 Jun 2006, Daniel Jacobowitz wrote:

> On Sat, Jun 24, 2006 at 02:39:41AM +0800, Wu Zhou wrote:
> > > > Do you mean that we need to output something more close to the fact. to 
> > > > say, "Addition/Multiple of decimal floating point is not supported right 
> > > > now".  or something other like this.  If you want, I can do that.
> > > 
> > > No, I think what's there is fine - but add a test or two for that error
> > > message.
> > 
> > OK.  Understand.  We can use XFAIL for them, right?
> 
> I mean tests that PASS given the current state - for now, it's what we
> want to happen, so test that it does happen.
> 
> -- 
> Daniel Jacobowitz
> CodeSourcery
> 

Re: [RFC] decimal float point patch based on libdecnumber: testcase

[Daniel Jacobowitz]

On Sat, Jun 24, 2006 at 03:25:10AM +0800, Wu Zhou wrote:
> So what is XFAIL intended for?  In my opinion, it is intended for failure, 
> but an expected failure.  I guess it can be used for such situation like:
> the output is expected, but is not what we want at last.  We might fix 
> that at a later time.  
> 
> Just my two cents anyway.  Correct me if I am wrong.

*shrug*

It's not a big deal.  I'm happy with them xfailing, but then you have
to have some guess as to what the pass output would be.

-- 
Daniel Jacobowitz
CodeSourcery

Re: [RFC] decimal float point patch based on libdecnumber: testcase

[Wu Zhou]

Daniel,

Attached is the revised patch for DFP testcase. Please review. Any  
errors, please correct me.  Thanks!

2006-07-11  Wu Zhou  <woodzltc@cn.ibm.com>

	* gdb.base/dfp-exprs.exp: New testcase to verify that gdb can
	handle dfp constants correctly.
	* gdb.base/dfp-test.c: New test file, used for dfp-test.exp.
	* gdb.base/dfp-test.exp: New testcase toverify that gdb can handle
	dfp related operation.

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	21 Jun 2006 22:20:32 -0000
@@ -0,0 +1,95 @@
+# Copyright (C) 2006 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, covering 32-bit, 64-bit and 128-bit ones
+
+    # _Decimal32 constants, which can support up to 7 digits
+    gdb_test "p 1.2df" " = 1.2"
+    gdb_test "p -1.2df" " = -1.2"
+    gdb_test "p 1.234567df" " = 1.234567"
+    gdb_test "p -1.234567df" " = -1.234567"
+    gdb_test "p 1234567.df" " = 1234567"
+    gdb_test "p -1234567.df" " = -1234567"
+
+    gdb_test "p 1.2E1df" " = 12"
+    gdb_test "p 1.2E10df" " = 1.2E\\+10"
+    gdb_test "p 1.2E-10df" " = 1.2E-10"
+
+    # The largest exponent for 32-bit dfp value is 96.
+    gdb_test "p 1.2E96df" " = 1.200000E\\+96"
+
+    # _Decimal64 constants, which can support up to 16 digits
+    gdb_test "p 1.2dd" " = 1.2"
+    gdb_test "p -1.2dd" " = -1.2"
+    gdb_test "p 1.234567890123456dd" " = 1.234567890123456"
+    gdb_test "p -1.234567890123456dd" " = -1.234567890123456"
+    gdb_test "p 1234567890123456.dd" " = 1234567890123456"
+    gdb_test "p -1234567890123456.dd" " = -1234567890123456"
+
+    gdb_test "p 1.2E1dd" " = 12"
+    gdb_test "p 1.2E10dd" " = 1.2E\\+10"
+    gdb_test "p 1.2E-10dd" " = 1.2E-10"
+
+    # The largest exponent for 64-bit dfp value is 384.
+    gdb_test "p 1.2E384dd" " = 1.200000000000000E\\+384"
+
+    # _Decimal128 constants, which can support up to 34 digits
+    gdb_test "p 1.2dl" " = 1.2"
+    gdb_test "p -1.2dl" " = -1.2"
+    gdb_test "p 1.234567890123456789012345678901234dl" " =  
1.234567890123456789012345678901234"
+    gdb_test "p -1.234567890123456789012345678901234dl" " =  
-1.234567890123456789012345678901234"
+    gdb_test "p 1234567890123456789012345678901234.dl" " =  
1234567890123456789012345678901234"
+    gdb_test "p -1234567890123456789012345678901234.dl" " =  
-1234567890123456789012345678901234"
+
+    gdb_test "p 1.2E1dl" " = 12"
+    gdb_test "p 1.2E10dl" " = 1.2E\\+10"
+    gdb_test "p 1.2E-10dl" " = 1.2E-10"
+
+    # The largest exponent for 128-bit dfp value is 6144.
+    gdb_test "p 1.2E6144dl" " = 1.200000000000000000000000000000000E\\+6144"
+}
+
+proc test_dfp_arithmetic_expressions {} {
+
+# Arithmetic operations for DFP types are not yet implemented in GDB.
+# These tests are to verify that they will generate expected error messages.
+
+   gdb_test "p 1.4df + 1.2df" "Argument to arithmetic operation not a  
number or boolean.*"
+   gdb_test "p 1.4df - 1.2df" ".*Argument to arithmetic operation not  
a number or boolean.*"
+   gdb_test "p 1.4df * 1.2df" "Argument to arithmetic operation not a  
number or boolean.*"
+   gdb_test "p 1.4df / 1.2df" "Argument to arithmetic operation not a  
number or boolean.*"
+
+}
+
+# Start with a fresh gdb.
+
+gdb_exit
+gdb_start
+gdb_reinitialize_dir $srcdir/$subdir
+
+test_dfp_literals_accepted
+test_dfp_arithmetic_expressions
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	21 Jun 2006 22:20:32 -0000
@@ -0,0 +1,95 @@
+/* This testcase is part of GDB, the GNU debugger.
+
+   Copyright 2006 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	21 Jun 2006 22:20:32 -0000
@@ -0,0 +1,247 @@
+# Copyright 2006 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 hane decimal floating point introduced in IEEE 754R.
+
+proc d32_set_tests {} {
+
+    gdb_test "p d32=123.45df" " = 123.45"
+    gdb_test "p d32=12345.df" " = 12345"
+    gdb_test "p d32=12345.67df" " = 12345.67"
+    gdb_test "p d32=1234567.df" " = 1234567"
+
+    gdb_test "p d32=1.234567E0df" " = 1.234567"
+    gdb_test "p d32=1.234567E10df" " = 1.234567E\\+10"
+    gdb_test "p d32=1.234567E+96df" " = 1.234567E\\+96"
+
+    # Test that gdb could handle the max, normalized min and  
subnormalized min.
+    gdb_test "p d32=9.999999E96df" " = 9.999999E\\+96"
+    gdb_test "p d32=1.0E-95df" " = 1.0E\\-95"
+    gdb_test "p d32=1.E-101df" " = 1E\\-101"
+    gdb_test "p d32=0.000001E-95df" " = 1E\\-101"
+
+    # Test that gdb could detect coefficient/exponent out of range.
+    # The coefficient out of range will be rounded to its nearest value.
+    # And the exponent out of range will be handled as infinity.
+    gdb_test "p d32=1.2345678df" " = 1.234568" "1.2345678 is rounded  
to 1.234568"
+    gdb_test "p d32=1.0E-101df" " = 1E-101" "1.0E-101 is rounded to 1E-101"
+    gdb_test "p d32=1.234567E+97df" " = Infinity" "1.234567E+97 is Infinity"
+
+    # Test that gdb could detect the errors in the string  
representation of _Decimal32
+    gdb_test "p d32=12345.df" " = 12345" "12345. is an valid number"
+    gdb_test "p d32=12345df" ".*Invalid number.*" "12345 is an  
invalid number"
+    gdb_test "p d32=1.23Edf" " = NaN" "1.23E is NaN (not a number)"
+    gdb_test "p d32=1.23E45Adf" " = NaN" "1.23E45A is NaN (not a number)"
+}
+
+proc d64_set_tests {} {
+
+    gdb_test "p d64=123.45dd" " = 123.45"
+    gdb_test "p d64=12345.dd" " = 12345"
+    gdb_test "p d64=12345.67dd" " = 12345.67"
+    gdb_test "p d64=1.234567890123456dd" " = 1.234567890123456"
+
+    gdb_test "p d64=1.234567890123456E10dd" " = 12345678901.23456"
+    gdb_test "p d64=1.234567890123456E100dd" " = 1.234567890123456E\\+100"
+    gdb_test "p d64=1.234567890123456E384dd" " = 1.234567890123456E\\+384"
+
+    # Test that gdb could handle the max, normalized min and  
subnormalized min.
+    gdb_test "p d64=9.999999999999999E384dd" " = 9.999999999999999E\\+384"
+    gdb_test "p d64=1.E-383dd" " = 1E\\-383"
+    gdb_test "p d64=1.E-398dd" " = 1E\\-398"
+    gdb_test "p d64=0.000000000000001E-383dd" " = 1E\\-398"
+
+    # Test that gdb could detect coefficient/exponent out of range.
+    # The coefficient out of range will be rounded to its nearest value.
+    # And the exponent out of range will be handled as infinity.
+    gdb_test "p d64=1.2345678901234567dd" " = 1.234567890123457"  
"1.2345678901234567 is rounded to 1.234567890123457"
+    gdb_test "p d64=9.9999999999999999E384dd" " = Infinity"  
"d64=9.9999999999999999E384 is Infinity"
+    gdb_test "p d64=1.234567890123456E385dd" " = Infinity"  
"d64=1.234567890123456E385 is Infinity"
+
+    # Test that gdb could detect the errors in the string  
representation of _Decimal64
+    gdb_test "p d64=12345dd" ".*Invalid number.*" "12345dd is an  
invalid number"
+    gdb_test "p d64=1.23Edd" " = NaN" "1.23E is NaN (not a number)"
+    gdb_test "p d64=1.23E45Add" "= NaN" "1.23E45A is NaN (not a number)"
+}
+
+proc d128_set_tests {} {
+
+    gdb_test "p d128=123.45dl" " = 123.45"
+    gdb_test "p d128=12345.dl" " = 12345"
+    gdb_test "p d128=12345.67dl" " = 12345.67"
+    gdb_test "p d128=1.234567890123456789012345678901234dl" " =  
1.234567890123456789012345678901234"
+
+    gdb_test "p d128=1.234567890123456E10dl" " = 12345678901.23456"
+    gdb_test "p d128=1.234567890123456E100dl" " = 1.234567890123456E\\+100"
+    gdb_test "p d128=1.234567890123456E1000dl" " = 1.234567890123456E\\+1000"
+
+    # Test that gdb could handle the max, normalized min and  
subnormalized min.
+    gdb_test "p d128=9.999999999999999999999999999999999E6144dl" " =  
9.999999999999999999999999999999999E\\+6144"
+    gdb_test "p d128=1.E-6143dl" " = 1E\\-6143"
+    gdb_test "p d128=1.E-6176dl" " = 1E\\-6176"
+    gdb_test "p d128=0.000000000000000000000000000000001E-6143dl" " =  
1E\\-6176"
+
+    # Test that gdb could detect coefficient/exponent out of range.
+    # The coefficient out of range will be rounded to its nearest value.
+    # And the exponent out of range will be handled as infinity.
+    gdb_test "p d128=1.2345678901234567890123456789012345dl"  
"1.234567890123456789012345678901234"  
"1.2345678901234567890123456789012345 is rounded to  
1.234567890123456789012345678901234"
+    gdb_test "p d128=1.234567890123456E6145dl" "Infinity"  
"d128=1.234567890123456E6145 is Infinity"
+
+    # Test that gdb could detect the errors in the string  
representation of _Decimal128
+    gdb_test "p d128=12345dl" ".*Invalid number.*" "12345dl is an  
invalid number"
+    gdb_test "p d128=1.23Edl" " = NaN" "1.23E is NaN (not a number)"
+    gdb_test "p d128=1.23E45Adl" "= NaN" "1.23E45A is NaN (not a number)"
+}
+
+
+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.2345" "d32 is initialized to 1.2345"
+
+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.2345.*" \
+    "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.2345" "d64 is initialized to 1.2345"
+
+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.2345.*" \
+    "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.2345" "d128 is initialized to 1.2345"
+
+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.1, arg1=1.0, arg2=2.0,  
arg3=3.0, arg4=4.0, arg5=5.0\\).*" "backtrace at arg0_32"
+
+gdb_breakpoint arg0_64
+gdb_continue_to_breakpoint "entry to arg0_64"
+gdb_test "backtrace" ".*arg0_64 \\(arg0=0.1, arg1=1.0, arg2=2.0,  
arg3=3.0, arg4=4.0, arg5=5.0\\).*" "backtrace at arg0_64"
+
+gdb_breakpoint arg0_128
+gdb_continue_to_breakpoint "entry to arg0_128"
+gdb_test "backtrace" ".*arg0_128 \\(arg0=0.1, arg1=1.0, arg2=2.0,  
arg3=3.0, arg4=4.0, arg5=5.0\\).*" "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.2345"
+gdb_test "print ds.dec64" " = 1.2345"
+gdb_test "print ds.dec128" " = 1.2345"
+
+# The following tests are intended to verify that gdb can handle "d1=d2"
+# and "d1=-d2" correctly.
+
+gdb_test "print ds.dec32=d32" " = 0.1"
+gdb_test "print ds.dec64=d64" " = 0.1"
+gdb_test "print ds.dec128=d128" " = 0.1"
+gdb_test "print ds.dec32 = -d32" " = -0.1"
+gdb_test "print ds.dec64 = -d64" " = -0.1"
+gdb_test "print ds.dec128 = -d128" " = -0.1"


Regards
- Wu Zhou

Re: [RFC] decimal float point patch based on libdecnumber: testcase

[Daniel Jacobowitz]

On Tue, Jul 11, 2006 at 11:35:12AM -0400, Wu Zhou wrote:
> Daniel,
> 
> Attached is the revised patch for DFP testcase. Please review. Any  
> errors, please correct me.  Thanks!
> 
> 2006-07-11  Wu Zhou  <woodzltc@cn.ibm.com>
> 
> 	* gdb.base/dfp-exprs.exp: New testcase to verify that gdb can
> 	handle dfp constants correctly.
> 	* gdb.base/dfp-test.c: New test file, used for dfp-test.exp.
> 	* gdb.base/dfp-test.exp: New testcase toverify that gdb can handle
> 	dfp related operation.

"toverify" -> "to verify".

This looks fine!  Once we're ready for the rest of the DFP support,
feel free to commit this too.

-- 
Daniel Jacobowitz
CodeSourcery