diff options
Diffstat (limited to 'gcc-4.9/libgcc/dfp-bit.c')
| -rw-r--r-- | gcc-4.9/libgcc/dfp-bit.c | 680 |
1 files changed, 680 insertions, 0 deletions
diff --git a/gcc-4.9/libgcc/dfp-bit.c b/gcc-4.9/libgcc/dfp-bit.c new file mode 100644 index 000000000..a83256ab5 --- /dev/null +++ b/gcc-4.9/libgcc/dfp-bit.c @@ -0,0 +1,680 @@ +/* This is a software decimal floating point library. + Copyright (C) 2005-2014 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_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_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 a C library function to write the floating point value to a string. */ + 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 */ |