diff options
| author | jsm28 <jsm28@138bc75d-0d04-0410-961f-82ee72b054a4> | 2008-10-29 17:05:42 +0000 |
|---|---|---|
| committer | jsm28 <jsm28@138bc75d-0d04-0410-961f-82ee72b054a4> | 2008-10-29 17:05:42 +0000 |
| commit | 02c52e944f67987d3e2a506e9e3e9c60282db7ae (patch) | |
| tree | f0bc48b745fe374d4990579d0ef02a2d88bb7799 /gcc/convert.c | |
| parent | b43b7954e03f8578e48822cd9b5753feae3ec616 (diff) | |
| download | gcc-02c52e944f67987d3e2a506e9e3e9c60282db7ae.tar.gz | |
PR middle-end/36578
* convert.c (convert_to_real): Do not optimize conversions of
binary arithmetic operations between binary and decimal
floating-point types. Consider mode of target type in determining
decimal type for arithmetic. Unless
flag_unsafe_math_optimizations, do not optimize binary conversions
where this may change rounding behavior.
* real.c (real_can_shorten_arithmetic): New.
* real.h (real_can_shorten_arithmetic): Declare.
testsuite:
* gcc.dg/dfp/convert-bfp-13.c, gcc.dg/dfp/convert-bfp-14.c,
gcc.dg/dfp/convert-dfp-fold-2.c, gcc.target/i386/pr36578-1.c,
gcc.target/i386/pr36578-2.c: New tests.
git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@141432 138bc75d-0d04-0410-961f-82ee72b054a4
Diffstat (limited to 'gcc/convert.c')
| -rw-r--r-- | gcc/convert.c | 39 |
1 files changed, 34 insertions, 5 deletions
diff --git a/gcc/convert.c b/gcc/convert.c index 24617728298..1a462e7626f 100644 --- a/gcc/convert.c +++ b/gcc/convert.c @@ -263,18 +263,22 @@ convert_to_real (tree type, tree expr) tree arg1 = strip_float_extensions (TREE_OPERAND (expr, 1)); if (FLOAT_TYPE_P (TREE_TYPE (arg0)) - && FLOAT_TYPE_P (TREE_TYPE (arg1))) + && FLOAT_TYPE_P (TREE_TYPE (arg1)) + && DECIMAL_FLOAT_TYPE_P (itype) == DECIMAL_FLOAT_TYPE_P (type)) { tree newtype = type; if (TYPE_MODE (TREE_TYPE (arg0)) == SDmode - || TYPE_MODE (TREE_TYPE (arg1)) == SDmode) + || TYPE_MODE (TREE_TYPE (arg1)) == SDmode + || TYPE_MODE (type) == SDmode) newtype = dfloat32_type_node; if (TYPE_MODE (TREE_TYPE (arg0)) == DDmode - || TYPE_MODE (TREE_TYPE (arg1)) == DDmode) + || TYPE_MODE (TREE_TYPE (arg1)) == DDmode + || TYPE_MODE (type) == DDmode) newtype = dfloat64_type_node; if (TYPE_MODE (TREE_TYPE (arg0)) == TDmode - || TYPE_MODE (TREE_TYPE (arg1)) == TDmode) + || TYPE_MODE (TREE_TYPE (arg1)) == TDmode + || TYPE_MODE (type) == TDmode) newtype = dfloat128_type_node; if (newtype == dfloat32_type_node || newtype == dfloat64_type_node @@ -292,7 +296,32 @@ convert_to_real (tree type, tree expr) newtype = TREE_TYPE (arg0); if (TYPE_PRECISION (TREE_TYPE (arg1)) > TYPE_PRECISION (newtype)) newtype = TREE_TYPE (arg1); - if (TYPE_PRECISION (newtype) < TYPE_PRECISION (itype)) + /* Sometimes this transformation is safe (cannot + change results through affecting double rounding + cases) and sometimes it is not. If NEWTYPE is + wider than TYPE, e.g. (float)((long double)double + + (long double)double) converted to + (float)(double + double), the transformation is + unsafe regardless of the details of the types + involved; double rounding can arise if the result + of NEWTYPE arithmetic is a NEWTYPE value half way + between two representable TYPE values but the + exact value is sufficiently different (in the + right direction) for this difference to be + visible in ITYPE arithmetic. If NEWTYPE is the + same as TYPE, however, the transformation may be + safe depending on the types involved: it is safe + if the ITYPE has strictly more than twice as many + mantissa bits as TYPE, can represent infinities + and NaNs if the TYPE can, and has sufficient + exponent range for the product or ratio of two + values representable in the TYPE to be within the + range of normal values of ITYPE. */ + if (TYPE_PRECISION (newtype) < TYPE_PRECISION (itype) + && (flag_unsafe_math_optimizations + || (TYPE_PRECISION (newtype) == TYPE_PRECISION (type) + && real_can_shorten_arithmetic (TYPE_MODE (itype), + TYPE_MODE (type))))) { expr = build2 (TREE_CODE (expr), newtype, fold (convert_to_real (newtype, arg0)), |