690 lines
20 KiB
C
690 lines
20 KiB
C
|
/* This is a software decimal floating point library.
|
|||
|
|
Copyright (C) 2005-2021 Free Software Foundation, Inc.
|
|||
|
|
|
|||
|
|
This file is part of GCC.
|
|||
|
|
|
|||
|
|
GCC 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 3, or (at your option) any later
|
|||
|
|
version.
|
|||
|
|
|
|||
|
|
GCC 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.
|
|||
|
|
|
|||
|
|
Under Section 7 of GPL version 3, you are granted additional
|
|||
|
|
permissions described in the GCC Runtime Library Exception, version
|
|||
|
|
3.1, as published by the Free Software Foundation.
|
|||
|
|
|
|||
|
|
You should have received a copy of the GNU General Public License and
|
|||
|
|
a copy of the GCC Runtime Library Exception along with this program;
|
|||
|
|
see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
|
|||
|
|
<http://www.gnu.org/licenses/>. */
|
|||
|
|
|
|||
|
|
/* This implements IEEE 754 decimal floating point arithmetic, but
|
|||
|
|
does not provide a mechanism for setting the rounding mode, or for
|
|||
|
|
generating or handling exceptions. Conversions between decimal
|
|||
|
|
floating point types and other types depend on C library functions.
|
|||
|
|
|
|||
|
|
Contributed by Ben Elliston <bje@au.ibm.com>. */
|
|||
|
|
|
|||
|
|
#include <stdio.h>
|
|||
|
|
#include <stdlib.h>
|
|||
|
|
/* FIXME: compile with -std=gnu99 to get these from stdlib.h */
|
|||
|
|
extern float strtof (const char *, char **);
|
|||
|
|
extern long double strtold (const char *, char **);
|
|||
|
|
#include <string.h>
|
|||
|
|
#include <limits.h>
|
|||
|
|
|
|||
|
|
#include "dfp-bit.h"
|
|||
|
|
|
|||
|
|
/* Forward declarations. */
|
|||
|
|
#if WIDTH == 32 || WIDTH_TO == 32
|
|||
|
|
void __host_to_ieee_32 (_Decimal32 in, decimal32 *out);
|
|||
|
|
void __ieee_to_host_32 (decimal32 in, _Decimal32 *out);
|
|||
|
|
#endif
|
|||
|
|
#if WIDTH == 64 || WIDTH_TO == 64
|
|||
|
|
void __host_to_ieee_64 (_Decimal64 in, decimal64 *out);
|
|||
|
|
void __ieee_to_host_64 (decimal64 in, _Decimal64 *out);
|
|||
|
|
#endif
|
|||
|
|
#if WIDTH == 128 || WIDTH_TO == 128
|
|||
|
|
void __host_to_ieee_128 (_Decimal128 in, decimal128 *out);
|
|||
|
|
void __ieee_to_host_128 (decimal128 in, _Decimal128 *out);
|
|||
|
|
#endif
|
|||
|
|
|
|||
|
|
/* A pointer to a binary decFloat operation. */
|
|||
|
|
typedef decFloat* (*dfp_binary_func)
|
|||
|
|
(decFloat *, const decFloat *, const decFloat *, decContext *);
|
|||
|
|
|
|||
|
|
/* Binary operations. */
|
|||
|
|
|
|||
|
|
/* Use a decFloat (decDouble or decQuad) function to perform a DFP
|
|||
|
|
binary operation. */
|
|||
|
|
static inline decFloat
|
|||
|
|
dfp_binary_op (dfp_binary_func op, decFloat arg_a, decFloat arg_b)
|
|||
|
|
{
|
|||
|
|
decFloat result;
|
|||
|
|
decContext context;
|
|||
|
|
|
|||
|
|
decContextDefault (&context, CONTEXT_INIT);
|
|||
|
|
DFP_INIT_ROUNDMODE (context.round);
|
|||
|
|
|
|||
|
|
/* Perform the operation. */
|
|||
|
|
op (&result, &arg_a, &arg_b, &context);
|
|||
|
|
|
|||
|
|
if (DFP_EXCEPTIONS_ENABLED && context.status != 0)
|
|||
|
|
{
|
|||
|
|
/* decNumber exception flags we care about here. */
|
|||
|
|
int ieee_flags;
|
|||
|
|
int dec_flags = DEC_IEEE_854_Division_by_zero | DEC_IEEE_854_Inexact
|
|||
|
|
| DEC_IEEE_854_Invalid_operation | DEC_IEEE_854_Overflow
|
|||
|
|
| DEC_IEEE_854_Underflow;
|
|||
|
|
dec_flags &= context.status;
|
|||
|
|
ieee_flags = DFP_IEEE_FLAGS (dec_flags);
|
|||
|
|
if (ieee_flags != 0)
|
|||
|
|
DFP_HANDLE_EXCEPTIONS (ieee_flags);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
return result;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
#if WIDTH == 32
|
|||
|
|
/* The decNumber package doesn't provide arithmetic for decSingle (32 bits);
|
|||
|
|
convert to decDouble, use the operation for that, and convert back. */
|
|||
|
|
static inline _Decimal32
|
|||
|
|
d32_binary_op (dfp_binary_func op, _Decimal32 arg_a, _Decimal32 arg_b)
|
|||
|
|
{
|
|||
|
|
union { _Decimal32 c; decSingle f; } a32, b32, res32;
|
|||
|
|
decDouble a, b, res;
|
|||
|
|
decContext context;
|
|||
|
|
|
|||
|
|
/* Widen the operands and perform the operation. */
|
|||
|
|
a32.c = arg_a;
|
|||
|
|
b32.c = arg_b;
|
|||
|
|
decSingleToWider (&a32.f, &a);
|
|||
|
|
decSingleToWider (&b32.f, &b);
|
|||
|
|
res = dfp_binary_op (op, a, b);
|
|||
|
|
|
|||
|
|
/* Narrow the result, which might result in an underflow or overflow. */
|
|||
|
|
decContextDefault (&context, CONTEXT_INIT);
|
|||
|
|
DFP_INIT_ROUNDMODE (context.round);
|
|||
|
|
decSingleFromWider (&res32.f, &res, &context);
|
|||
|
|
if (DFP_EXCEPTIONS_ENABLED && context.status != 0)
|
|||
|
|
{
|
|||
|
|
/* decNumber exception flags we care about here. */
|
|||
|
|
int ieee_flags;
|
|||
|
|
int dec_flags = DEC_IEEE_854_Inexact | DEC_IEEE_854_Overflow
|
|||
|
|
| DEC_IEEE_854_Underflow;
|
|||
|
|
dec_flags &= context.status;
|
|||
|
|
ieee_flags = DFP_IEEE_FLAGS (dec_flags);
|
|||
|
|
if (ieee_flags != 0)
|
|||
|
|
DFP_HANDLE_EXCEPTIONS (ieee_flags);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
return res32.c;
|
|||
|
|
}
|
|||
|
|
#else
|
|||
|
|
/* decFloat operations are supported for decDouble (64 bits) and
|
|||
|
|
decQuad (128 bits). The bit patterns for the types are the same. */
|
|||
|
|
static inline DFP_C_TYPE
|
|||
|
|
dnn_binary_op (dfp_binary_func op, DFP_C_TYPE arg_a, DFP_C_TYPE arg_b)
|
|||
|
|
{
|
|||
|
|
union { DFP_C_TYPE c; decFloat f; } a, b, result;
|
|||
|
|
|
|||
|
|
a.c = arg_a;
|
|||
|
|
b.c = arg_b;
|
|||
|
|
result.f = dfp_binary_op (op, a.f, b.f);
|
|||
|
|
return result.c;
|
|||
|
|
}
|
|||
|
|
#endif
|
|||
|
|
|
|||
|
|
/* Comparison operations. */
|
|||
|
|
|
|||
|
|
/* Use a decFloat (decDouble or decQuad) function to perform a DFP
|
|||
|
|
comparison. */
|
|||
|
|
static inline CMPtype
|
|||
|
|
dfp_compare_op (dfp_binary_func op, decFloat arg_a, decFloat arg_b)
|
|||
|
|
{
|
|||
|
|
decContext context;
|
|||
|
|
decFloat res;
|
|||
|
|
int result;
|
|||
|
|
|
|||
|
|
decContextDefault (&context, CONTEXT_INIT);
|
|||
|
|
DFP_INIT_ROUNDMODE (context.round);
|
|||
|
|
|
|||
|
|
/* Perform the comparison. */
|
|||
|
|
op (&res, &arg_a, &arg_b, &context);
|
|||
|
|
|
|||
|
|
if (DEC_FLOAT_IS_SIGNED (&res))
|
|||
|
|
result = -1;
|
|||
|
|
else if (DEC_FLOAT_IS_ZERO (&res))
|
|||
|
|
result = 0;
|
|||
|
|
else if (DEC_FLOAT_IS_NAN (&res))
|
|||
|
|
result = -2;
|
|||
|
|
else
|
|||
|
|
result = 1;
|
|||
|
|
|
|||
|
|
return (CMPtype) result;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
#if WIDTH == 32
|
|||
|
|
/* The decNumber package doesn't provide comparisons for decSingle (32 bits);
|
|||
|
|
convert to decDouble, use the operation for that, and convert back. */
|
|||
|
|
static inline CMPtype
|
|||
|
|
d32_compare_op (dfp_binary_func op, _Decimal32 arg_a, _Decimal32 arg_b)
|
|||
|
|
{
|
|||
|
|
union { _Decimal32 c; decSingle f; } a32, b32;
|
|||
|
|
decDouble a, b;
|
|||
|
|
|
|||
|
|
a32.c = arg_a;
|
|||
|
|
b32.c = arg_b;
|
|||
|
|
decSingleToWider (&a32.f, &a);
|
|||
|
|
decSingleToWider (&b32.f, &b);
|
|||
|
|
return dfp_compare_op (op, a, b);
|
|||
|
|
}
|
|||
|
|
#else
|
|||
|
|
/* decFloat comparisons are supported for decDouble (64 bits) and
|
|||
|
|
decQuad (128 bits). The bit patterns for the types are the same. */
|
|||
|
|
static inline CMPtype
|
|||
|
|
dnn_compare_op (dfp_binary_func op, DFP_C_TYPE arg_a, DFP_C_TYPE arg_b)
|
|||
|
|
{
|
|||
|
|
union { DFP_C_TYPE c; decFloat f; } a, b;
|
|||
|
|
|
|||
|
|
a.c = arg_a;
|
|||
|
|
b.c = arg_b;
|
|||
|
|
return dfp_compare_op (op, a.f, b.f);
|
|||
|
|
}
|
|||
|
|
#endif
|
|||
|
|
|
|||
|
|
#if defined(L_conv_sd)
|
|||
|
|
void
|
|||
|
|
__host_to_ieee_32 (_Decimal32 in, decimal32 *out)
|
|||
|
|
{
|
|||
|
|
memcpy (out, &in, 4);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
void
|
|||
|
|
__ieee_to_host_32 (decimal32 in, _Decimal32 *out)
|
|||
|
|
{
|
|||
|
|
memcpy (out, &in, 4);
|
|||
|
|
}
|
|||
|
|
#endif /* L_conv_sd */
|
|||
|
|
|
|||
|
|
#if defined(L_conv_dd)
|
|||
|
|
void
|
|||
|
|
__host_to_ieee_64 (_Decimal64 in, decimal64 *out)
|
|||
|
|
{
|
|||
|
|
memcpy (out, &in, 8);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
void
|
|||
|
|
__ieee_to_host_64 (decimal64 in, _Decimal64 *out)
|
|||
|
|
{
|
|||
|
|
memcpy (out, &in, 8);
|
|||
|
|
}
|
|||
|
|
#endif /* L_conv_dd */
|
|||
|
|
|
|||
|
|
#if defined(L_conv_td)
|
|||
|
|
void
|
|||
|
|
__host_to_ieee_128 (_Decimal128 in, decimal128 *out)
|
|||
|
|
{
|
|||
|
|
memcpy (out, &in, 16);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
void
|
|||
|
|
__ieee_to_host_128 (decimal128 in, _Decimal128 *out)
|
|||
|
|
{
|
|||
|
|
memcpy (out, &in, 16);
|
|||
|
|
}
|
|||
|
|
#endif /* L_conv_td */
|
|||
|
|
|
|||
|
|
#if defined(L_addsub_sd) || defined(L_addsub_dd) || defined(L_addsub_td)
|
|||
|
|
DFP_C_TYPE
|
|||
|
|
DFP_ADD (DFP_C_TYPE arg_a, DFP_C_TYPE arg_b)
|
|||
|
|
{
|
|||
|
|
return DFP_BINARY_OP (DEC_FLOAT_ADD, arg_a, arg_b);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
DFP_C_TYPE
|
|||
|
|
DFP_SUB (DFP_C_TYPE arg_a, DFP_C_TYPE arg_b)
|
|||
|
|
{
|
|||
|
|
return DFP_BINARY_OP (DEC_FLOAT_SUBTRACT, arg_a, arg_b);
|
|||
|
|
}
|
|||
|
|
#endif /* L_addsub */
|
|||
|
|
|
|||
|
|
#if defined(L_mul_sd) || defined(L_mul_dd) || defined(L_mul_td)
|
|||
|
|
DFP_C_TYPE
|
|||
|
|
DFP_MULTIPLY (DFP_C_TYPE arg_a, DFP_C_TYPE arg_b)
|
|||
|
|
{
|
|||
|
|
return DFP_BINARY_OP (DEC_FLOAT_MULTIPLY, arg_a, arg_b);
|
|||
|
|
}
|
|||
|
|
#endif /* L_mul */
|
|||
|
|
|
|||
|
|
#if defined(L_div_sd) || defined(L_div_dd) || defined(L_div_td)
|
|||
|
|
DFP_C_TYPE
|
|||
|
|
DFP_DIVIDE (DFP_C_TYPE arg_a, DFP_C_TYPE arg_b)
|
|||
|
|
{
|
|||
|
|
return DFP_BINARY_OP (DEC_FLOAT_DIVIDE, arg_a, arg_b);
|
|||
|
|
}
|
|||
|
|
#endif /* L_div */
|
|||
|
|
|
|||
|
|
#if defined (L_eq_sd) || defined (L_eq_dd) || defined (L_eq_td)
|
|||
|
|
CMPtype
|
|||
|
|
DFP_EQ (DFP_C_TYPE arg_a, DFP_C_TYPE arg_b)
|
|||
|
|
{
|
|||
|
|
CMPtype stat;
|
|||
|
|
stat = DFP_COMPARE_OP (DEC_FLOAT_COMPARE, arg_a, arg_b);
|
|||
|
|
/* For EQ return zero for true, nonzero for false. */
|
|||
|
|
return stat != 0;
|
|||
|
|
}
|
|||
|
|
#endif /* L_eq */
|
|||
|
|
|
|||
|
|
#if defined (L_ne_sd) || defined (L_ne_dd) || defined (L_ne_td)
|
|||
|
|
CMPtype
|
|||
|
|
DFP_NE (DFP_C_TYPE arg_a, DFP_C_TYPE arg_b)
|
|||
|
|
{
|
|||
|
|
int stat;
|
|||
|
|
stat = DFP_COMPARE_OP (DEC_FLOAT_COMPARE, arg_a, arg_b);
|
|||
|
|
/* For NE return zero for true, nonzero for false. */
|
|||
|
|
if (__builtin_expect (stat == -2, 0)) /* An operand is NaN. */
|
|||
|
|
return 1;
|
|||
|
|
return stat != 0;
|
|||
|
|
}
|
|||
|
|
#endif /* L_ne */
|
|||
|
|
|
|||
|
|
#if defined (L_lt_sd) || defined (L_lt_dd) || defined (L_lt_td)
|
|||
|
|
CMPtype
|
|||
|
|
DFP_LT (DFP_C_TYPE arg_a, DFP_C_TYPE arg_b)
|
|||
|
|
{
|
|||
|
|
int stat;
|
|||
|
|
stat = DFP_COMPARE_OP (DEC_FLOAT_COMPARE, arg_a, arg_b);
|
|||
|
|
/* For LT return -1 (<0) for true, 1 for false. */
|
|||
|
|
return (stat == -1) ? -1 : 1;
|
|||
|
|
}
|
|||
|
|
#endif /* L_lt */
|
|||
|
|
|
|||
|
|
#if defined (L_gt_sd) || defined (L_gt_dd) || defined (L_gt_td)
|
|||
|
|
CMPtype
|
|||
|
|
DFP_GT (DFP_C_TYPE arg_a, DFP_C_TYPE arg_b)
|
|||
|
|
{
|
|||
|
|
int stat;
|
|||
|
|
stat = DFP_COMPARE_OP (DEC_FLOAT_COMPARE, arg_a, arg_b);
|
|||
|
|
/* For GT return 1 (>0) for true, -1 for false. */
|
|||
|
|
return (stat == 1) ? 1 : -1;
|
|||
|
|
}
|
|||
|
|
#endif
|
|||
|
|
|
|||
|
|
#if defined (L_le_sd) || defined (L_le_dd) || defined (L_le_td)
|
|||
|
|
CMPtype
|
|||
|
|
DFP_LE (DFP_C_TYPE arg_a, DFP_C_TYPE arg_b)
|
|||
|
|
{
|
|||
|
|
int stat;
|
|||
|
|
stat = DFP_COMPARE_OP (DEC_FLOAT_COMPARE, arg_a, arg_b);
|
|||
|
|
/* For LE return 0 (<= 0) for true, 1 for false. */
|
|||
|
|
if (__builtin_expect (stat == -2, 0)) /* An operand is NaN. */
|
|||
|
|
return 1;
|
|||
|
|
return stat == 1;
|
|||
|
|
}
|
|||
|
|
#endif /* L_le */
|
|||
|
|
|
|||
|
|
#if defined (L_ge_sd) || defined (L_ge_dd) || defined (L_ge_td)
|
|||
|
|
CMPtype
|
|||
|
|
DFP_GE (DFP_C_TYPE arg_a, DFP_C_TYPE arg_b)
|
|||
|
|
{
|
|||
|
|
int stat;
|
|||
|
|
stat = DFP_COMPARE_OP (DEC_FLOAT_COMPARE, arg_a, arg_b);
|
|||
|
|
/* For GE return 1 (>=0) for true, -1 for false. */
|
|||
|
|
if (__builtin_expect (stat == -2, 0)) /* An operand is NaN. */
|
|||
|
|
return -1;
|
|||
|
|
return (stat != -1) ? 1 : -1;
|
|||
|
|
}
|
|||
|
|
#endif /* L_ge */
|
|||
|
|
|
|||
|
|
#define BUFMAX 128
|
|||
|
|
|
|||
|
|
/* Check for floating point exceptions that are relevant for conversions
|
|||
|
|
between decimal float values and handle them. */
|
|||
|
|
static inline void
|
|||
|
|
dfp_conversion_exceptions (const int status)
|
|||
|
|
{
|
|||
|
|
/* decNumber exception flags we care about here. */
|
|||
|
|
int ieee_flags;
|
|||
|
|
int dec_flags = DEC_IEEE_854_Inexact | DEC_IEEE_854_Invalid_operation
|
|||
|
|
| DEC_IEEE_854_Overflow;
|
|||
|
|
dec_flags &= status;
|
|||
|
|
ieee_flags = DFP_IEEE_FLAGS (dec_flags);
|
|||
|
|
if (ieee_flags != 0)
|
|||
|
|
DFP_HANDLE_EXCEPTIONS (ieee_flags);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
#if defined (L_sd_to_dd)
|
|||
|
|
/* Use decNumber to convert directly from _Decimal32 to _Decimal64. */
|
|||
|
|
_Decimal64
|
|||
|
|
DFP_TO_DFP (_Decimal32 f_from)
|
|||
|
|
{
|
|||
|
|
union { _Decimal32 c; decSingle f; } from;
|
|||
|
|
union { _Decimal64 c; decDouble f; } to;
|
|||
|
|
|
|||
|
|
from.c = f_from;
|
|||
|
|
to.f = *decSingleToWider (&from.f, &to.f);
|
|||
|
|
return to.c;
|
|||
|
|
}
|
|||
|
|
#endif
|
|||
|
|
|
|||
|
|
#if defined (L_sd_to_td)
|
|||
|
|
/* Use decNumber to convert directly from _Decimal32 to _Decimal128. */
|
|||
|
|
_Decimal128
|
|||
|
|
DFP_TO_DFP (_Decimal32 f_from)
|
|||
|
|
{
|
|||
|
|
union { _Decimal32 c; decSingle f; } from;
|
|||
|
|
union { _Decimal128 c; decQuad f; } to;
|
|||
|
|
decDouble temp;
|
|||
|
|
|
|||
|
|
from.c = f_from;
|
|||
|
|
temp = *decSingleToWider (&from.f, &temp);
|
|||
|
|
to.f = *decDoubleToWider (&temp, &to.f);
|
|||
|
|
return to.c;
|
|||
|
|
}
|
|||
|
|
#endif
|
|||
|
|
|
|||
|
|
#if defined (L_dd_to_td)
|
|||
|
|
/* Use decNumber to convert directly from _Decimal64 to _Decimal128. */
|
|||
|
|
_Decimal128
|
|||
|
|
DFP_TO_DFP (_Decimal64 f_from)
|
|||
|
|
{
|
|||
|
|
union { _Decimal64 c; decDouble f; } from;
|
|||
|
|
union { _Decimal128 c; decQuad f; } to;
|
|||
|
|
|
|||
|
|
from.c = f_from;
|
|||
|
|
to.f = *decDoubleToWider (&from.f, &to.f);
|
|||
|
|
return to.c;
|
|||
|
|
}
|
|||
|
|
#endif
|
|||
|
|
|
|||
|
|
#if defined (L_dd_to_sd)
|
|||
|
|
/* Use decNumber to convert directly from _Decimal64 to _Decimal32. */
|
|||
|
|
_Decimal32
|
|||
|
|
DFP_TO_DFP (_Decimal64 f_from)
|
|||
|
|
{
|
|||
|
|
union { _Decimal32 c; decSingle f; } to;
|
|||
|
|
union { _Decimal64 c; decDouble f; } from;
|
|||
|
|
decContext context;
|
|||
|
|
|
|||
|
|
decContextDefault (&context, CONTEXT_INIT);
|
|||
|
|
DFP_INIT_ROUNDMODE (context.round);
|
|||
|
|
from.c = f_from;
|
|||
|
|
to.f = *decSingleFromWider (&to.f, &from.f, &context);
|
|||
|
|
if (DFP_EXCEPTIONS_ENABLED && context.status != 0)
|
|||
|
|
dfp_conversion_exceptions (context.status);
|
|||
|
|
return to.c;
|
|||
|
|
}
|
|||
|
|
#endif
|
|||
|
|
|
|||
|
|
#if defined (L_td_to_sd)
|
|||
|
|
/* Use decNumber to convert directly from _Decimal128 to _Decimal32. */
|
|||
|
|
_Decimal32
|
|||
|
|
DFP_TO_DFP (_Decimal128 f_from)
|
|||
|
|
{
|
|||
|
|
union { _Decimal32 c; decSingle f; } to;
|
|||
|
|
union { _Decimal128 c; decQuad f; } from;
|
|||
|
|
decDouble temp;
|
|||
|
|
decContext context;
|
|||
|
|
|
|||
|
|
decContextDefault (&context, CONTEXT_INIT);
|
|||
|
|
DFP_INIT_ROUNDMODE (context.round);
|
|||
|
|
from.c = f_from;
|
|||
|
|
temp = *decDoubleFromWider (&temp, &from.f, &context);
|
|||
|
|
to.f = *decSingleFromWider (&to.f, &temp, &context);
|
|||
|
|
if (DFP_EXCEPTIONS_ENABLED && context.status != 0)
|
|||
|
|
dfp_conversion_exceptions (context.status);
|
|||
|
|
return to.c;
|
|||
|
|
}
|
|||
|
|
#endif
|
|||
|
|
|
|||
|
|
#if defined (L_td_to_dd)
|
|||
|
|
/* Use decNumber to convert directly from _Decimal128 to _Decimal64. */
|
|||
|
|
_Decimal64
|
|||
|
|
DFP_TO_DFP (_Decimal128 f_from)
|
|||
|
|
{
|
|||
|
|
union { _Decimal64 c; decDouble f; } to;
|
|||
|
|
union { _Decimal128 c; decQuad f; } from;
|
|||
|
|
decContext context;
|
|||
|
|
|
|||
|
|
decContextDefault (&context, CONTEXT_INIT);
|
|||
|
|
DFP_INIT_ROUNDMODE (context.round);
|
|||
|
|
from.c = f_from;
|
|||
|
|
to.f = *decDoubleFromWider (&to.f, &from.f, &context);
|
|||
|
|
if (DFP_EXCEPTIONS_ENABLED && context.status != 0)
|
|||
|
|
dfp_conversion_exceptions (context.status);
|
|||
|
|
return to.c;
|
|||
|
|
}
|
|||
|
|
#endif
|
|||
|
|
|
|||
|
|
#if defined (L_dd_to_si) || defined (L_td_to_si) \
|
|||
|
|
|| defined (L_dd_to_usi) || defined (L_td_to_usi)
|
|||
|
|
/* Use decNumber to convert directly from decimal float to integer types. */
|
|||
|
|
INT_TYPE
|
|||
|
|
DFP_TO_INT (DFP_C_TYPE x)
|
|||
|
|
{
|
|||
|
|
union { DFP_C_TYPE c; decFloat f; } u;
|
|||
|
|
decContext context;
|
|||
|
|
INT_TYPE i;
|
|||
|
|
|
|||
|
|
decContextDefault (&context, DEC_INIT_DECIMAL128);
|
|||
|
|
context.round = DEC_ROUND_DOWN;
|
|||
|
|
u.c = x;
|
|||
|
|
i = DEC_FLOAT_TO_INT (&u.f, &context, context.round);
|
|||
|
|
if (DFP_EXCEPTIONS_ENABLED && context.status != 0)
|
|||
|
|
dfp_conversion_exceptions (context.status);
|
|||
|
|
return i;
|
|||
|
|
}
|
|||
|
|
#endif
|
|||
|
|
|
|||
|
|
#if defined (L_sd_to_si) || (L_sd_to_usi)
|
|||
|
|
/* Use decNumber to convert directly from decimal float to integer types. */
|
|||
|
|
INT_TYPE
|
|||
|
|
DFP_TO_INT (_Decimal32 x)
|
|||
|
|
{
|
|||
|
|
union { _Decimal32 c; decSingle f; } u32;
|
|||
|
|
decDouble f64;
|
|||
|
|
decContext context;
|
|||
|
|
INT_TYPE i;
|
|||
|
|
|
|||
|
|
decContextDefault (&context, DEC_INIT_DECIMAL128);
|
|||
|
|
context.round = DEC_ROUND_DOWN;
|
|||
|
|
u32.c = x;
|
|||
|
|
f64 = *decSingleToWider (&u32.f, &f64);
|
|||
|
|
i = DEC_FLOAT_TO_INT (&f64, &context, context.round);
|
|||
|
|
if (DFP_EXCEPTIONS_ENABLED && context.status != 0)
|
|||
|
|
dfp_conversion_exceptions (context.status);
|
|||
|
|
return i;
|
|||
|
|
}
|
|||
|
|
#endif
|
|||
|
|
|
|||
|
|
#if defined (L_sd_to_di) || defined (L_dd_to_di) || defined (L_td_to_di) \
|
|||
|
|
|| defined (L_sd_to_udi) || defined (L_dd_to_udi) || defined (L_td_to_udi)
|
|||
|
|
/* decNumber doesn't provide support for conversions to 64-bit integer
|
|||
|
|
types, so do it the hard way. */
|
|||
|
|
INT_TYPE
|
|||
|
|
DFP_TO_INT (DFP_C_TYPE x)
|
|||
|
|
{
|
|||
|
|
/* decNumber's decimal* types have the same format as C's _Decimal*
|
|||
|
|
types, but they have different calling conventions. */
|
|||
|
|
|
|||
|
|
/* TODO: Decimal float to integer conversions should raise FE_INVALID
|
|||
|
|
if the result value does not fit into the result type. */
|
|||
|
|
|
|||
|
|
IEEE_TYPE s;
|
|||
|
|
char buf[BUFMAX];
|
|||
|
|
char *pos;
|
|||
|
|
decNumber qval, n1, n2;
|
|||
|
|
decContext context;
|
|||
|
|
|
|||
|
|
/* Use a large context to avoid losing precision. */
|
|||
|
|
decContextDefault (&context, DEC_INIT_DECIMAL128);
|
|||
|
|
/* Need non-default rounding mode here. */
|
|||
|
|
context.round = DEC_ROUND_DOWN;
|
|||
|
|
|
|||
|
|
HOST_TO_IEEE (x, &s);
|
|||
|
|
TO_INTERNAL (&s, &n1);
|
|||
|
|
/* Rescale if the exponent is less than zero. */
|
|||
|
|
decNumberToIntegralValue (&n2, &n1, &context);
|
|||
|
|
/* Get a value to use for the quantize call. */
|
|||
|
|
decNumberFromString (&qval, "1.", &context);
|
|||
|
|
/* Force the exponent to zero. */
|
|||
|
|
decNumberQuantize (&n1, &n2, &qval, &context);
|
|||
|
|
/* Get a string, which at this point will not include an exponent. */
|
|||
|
|
decNumberToString (&n1, buf);
|
|||
|
|
/* Ignore the fractional part. */
|
|||
|
|
pos = strchr (buf, '.');
|
|||
|
|
if (pos)
|
|||
|
|
*pos = 0;
|
|||
|
|
/* Use a C library function to convert to the integral type. */
|
|||
|
|
return STR_TO_INT (buf, NULL, 10);
|
|||
|
|
}
|
|||
|
|
#endif
|
|||
|
|
|
|||
|
|
#if defined (L_si_to_dd) || defined (L_si_to_td) \
|
|||
|
|
|| defined (L_usi_to_dd) || defined (L_usi_to_td)
|
|||
|
|
/* Use decNumber to convert directly from integer to decimal float types. */
|
|||
|
|
DFP_C_TYPE
|
|||
|
|
INT_TO_DFP (INT_TYPE i)
|
|||
|
|
{
|
|||
|
|
union { DFP_C_TYPE c; decFloat f; } u;
|
|||
|
|
|
|||
|
|
u.f = *DEC_FLOAT_FROM_INT (&u.f, i);
|
|||
|
|
return u.c;
|
|||
|
|
}
|
|||
|
|
#endif
|
|||
|
|
|
|||
|
|
#if defined (L_si_to_sd) || defined (L_usi_to_sd)
|
|||
|
|
_Decimal32
|
|||
|
|
/* Use decNumber to convert directly from integer to decimal float types. */
|
|||
|
|
INT_TO_DFP (INT_TYPE i)
|
|||
|
|
{
|
|||
|
|
union { _Decimal32 c; decSingle f; } u32;
|
|||
|
|
decDouble f64;
|
|||
|
|
decContext context;
|
|||
|
|
|
|||
|
|
decContextDefault (&context, DEC_INIT_DECIMAL128);
|
|||
|
|
f64 = *DEC_FLOAT_FROM_INT (&f64, i);
|
|||
|
|
u32.f = *decSingleFromWider (&u32.f, &f64, &context);
|
|||
|
|
if (DFP_EXCEPTIONS_ENABLED && context.status != 0)
|
|||
|
|
dfp_conversion_exceptions (context.status);
|
|||
|
|
return u32.c;
|
|||
|
|
}
|
|||
|
|
#endif
|
|||
|
|
|
|||
|
|
#if defined (L_di_to_sd) || defined (L_di_to_dd) || defined (L_di_to_td) \
|
|||
|
|
|| defined (L_udi_to_sd) || defined (L_udi_to_dd) || defined (L_udi_to_td)
|
|||
|
|
/* decNumber doesn't provide support for conversions from 64-bit integer
|
|||
|
|
types, so do it the hard way. */
|
|||
|
|
DFP_C_TYPE
|
|||
|
|
INT_TO_DFP (INT_TYPE i)
|
|||
|
|
{
|
|||
|
|
DFP_C_TYPE f;
|
|||
|
|
IEEE_TYPE s;
|
|||
|
|
char buf[BUFMAX];
|
|||
|
|
decContext context;
|
|||
|
|
|
|||
|
|
decContextDefault (&context, CONTEXT_INIT);
|
|||
|
|
DFP_INIT_ROUNDMODE (context.round);
|
|||
|
|
|
|||
|
|
/* Use a C library function to get a floating point string. */
|
|||
|
|
sprintf (buf, INT_FMT ".", CAST_FOR_FMT(i));
|
|||
|
|
/* Convert from the floating point string to a decimal* type. */
|
|||
|
|
FROM_STRING (&s, buf, &context);
|
|||
|
|
IEEE_TO_HOST (s, &f);
|
|||
|
|
|
|||
|
|
if (DFP_EXCEPTIONS_ENABLED && context.status != 0)
|
|||
|
|
dfp_conversion_exceptions (context.status);
|
|||
|
|
|
|||
|
|
return f;
|
|||
|
|
}
|
|||
|
|
#endif
|
|||
|
|
|
|||
|
|
#if defined (L_sd_to_sf) || defined (L_dd_to_sf) || defined (L_td_to_sf) \
|
|||
|
|
|| defined (L_sd_to_df) || defined (L_dd_to_df) || defined (L_td_to_df) \
|
|||
|
|
|| defined (L_sd_to_kf) || defined (L_dd_to_kf) || defined (L_td_to_kf) \
|
|||
|
|
|| ((defined (L_sd_to_xf) || defined (L_dd_to_xf) || defined (L_td_to_xf)) \
|
|||
|
|
&& LONG_DOUBLE_HAS_XF_MODE) \
|
|||
|
|
|| ((defined (L_sd_to_tf) || defined (L_dd_to_tf) || defined (L_td_to_tf)) \
|
|||
|
|
&& LONG_DOUBLE_HAS_TF_MODE)
|
|||
|
|
BFP_TYPE
|
|||
|
|
DFP_TO_BFP (DFP_C_TYPE f)
|
|||
|
|
{
|
|||
|
|
IEEE_TYPE s;
|
|||
|
|
char buf[BUFMAX];
|
|||
|
|
|
|||
|
|
HOST_TO_IEEE (f, &s);
|
|||
|
|
/* Write the value to a string. */
|
|||
|
|
TO_STRING (&s, buf);
|
|||
|
|
/* Read it as the binary floating point type and return that. */
|
|||
|
|
return STR_TO_BFP (buf, NULL);
|
|||
|
|
}
|
|||
|
|
#endif
|
|||
|
|
|
|||
|
|
#if defined (L_sf_to_sd) || defined (L_sf_to_dd) || defined (L_sf_to_td) \
|
|||
|
|
|| defined (L_df_to_sd) || defined (L_df_to_dd) || defined (L_df_to_td) \
|
|||
|
|
|| defined (L_kf_to_sd) || defined (L_kf_to_dd) || defined (L_kf_to_td) \
|
|||
|
|
|| ((defined (L_xf_to_sd) || defined (L_xf_to_dd) || defined (L_xf_to_td)) \
|
|||
|
|
&& LONG_DOUBLE_HAS_XF_MODE) \
|
|||
|
|
|| ((defined (L_tf_to_sd) || defined (L_tf_to_dd) || defined (L_tf_to_td)) \
|
|||
|
|
&& LONG_DOUBLE_HAS_TF_MODE)
|
|||
|
|
DFP_C_TYPE
|
|||
|
|
BFP_TO_DFP (BFP_TYPE x)
|
|||
|
|
{
|
|||
|
|
DFP_C_TYPE f;
|
|||
|
|
IEEE_TYPE s;
|
|||
|
|
char buf[BUFMAX];
|
|||
|
|
decContext context;
|
|||
|
|
|
|||
|
|
decContextDefault (&context, CONTEXT_INIT);
|
|||
|
|
DFP_INIT_ROUNDMODE (context.round);
|
|||
|
|
|
|||
|
|
/* Use the sprintf library function to write the floating point value to a
|
|||
|
|
string.
|
|||
|
|
|
|||
|
|
If we are handling the IEEE 128-bit floating point on PowerPC, use the
|
|||
|
|
special function __sprintfkf instead of sprintf. This function allows us
|
|||
|
|
to use __sprintfieee128 if we have a new enough GLIBC, and it can fall back
|
|||
|
|
to using the traditional sprintf via conversion to IBM 128-bit if the glibc
|
|||
|
|
is older. */
|
|||
|
|
BFP_SPRINTF (buf, BFP_FMT, (BFP_VIA_TYPE) x);
|
|||
|
|
|
|||
|
|
/* Convert from the floating point string to a decimal* type. */
|
|||
|
|
FROM_STRING (&s, buf, &context);
|
|||
|
|
IEEE_TO_HOST (s, &f);
|
|||
|
|
|
|||
|
|
if (DFP_EXCEPTIONS_ENABLED && context.status != 0)
|
|||
|
|
{
|
|||
|
|
/* decNumber exception flags we care about here. */
|
|||
|
|
int ieee_flags;
|
|||
|
|
int dec_flags = DEC_IEEE_854_Inexact | DEC_IEEE_854_Invalid_operation
|
|||
|
|
| DEC_IEEE_854_Overflow | DEC_IEEE_854_Underflow;
|
|||
|
|
dec_flags &= context.status;
|
|||
|
|
ieee_flags = DFP_IEEE_FLAGS (dec_flags);
|
|||
|
|
if (ieee_flags != 0)
|
|||
|
|
DFP_HANDLE_EXCEPTIONS (ieee_flags);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
return f;
|
|||
|
|
}
|
|||
|
|
#endif
|
|||
|
|
|
|||
|
|
#if defined (L_unord_sd) || defined (L_unord_dd) || defined (L_unord_td)
|
|||
|
|
CMPtype
|
|||
|
|
DFP_UNORD (DFP_C_TYPE arg_a, DFP_C_TYPE arg_b)
|
|||
|
|
{
|
|||
|
|
decNumber arg1, arg2;
|
|||
|
|
IEEE_TYPE a, b;
|
|||
|
|
|
|||
|
|
HOST_TO_IEEE (arg_a, &a);
|
|||
|
|
HOST_TO_IEEE (arg_b, &b);
|
|||
|
|
TO_INTERNAL (&a, &arg1);
|
|||
|
|
TO_INTERNAL (&b, &arg2);
|
|||
|
|
return (decNumberIsNaN (&arg1) || decNumberIsNaN (&arg2));
|
|||
|
|
}
|
|||
|
|
#endif /* L_unord_sd || L_unord_dd || L_unord_td */
|