| /* This is a software decimal floating point library. |
| Copyright (C) 2005, 2006 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 2, or (at your option) any later |
| version. |
| |
| In addition to the permissions in the GNU General Public License, the |
| Free Software Foundation gives you unlimited permission to link the |
| compiled version of this file into combinations with other programs, |
| and to distribute those combinations without any restriction coming |
| from the use of this file. (The General Public License restrictions |
| do apply in other respects; for example, they cover modification of |
| the file, and distribution when not linked into a combine |
| executable.) |
| |
| 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. |
| |
| You should have received a copy of the GNU General Public License |
| along with GCC; see the file COPYING. If not, write to the Free |
| Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA |
| 02110-1301, USA. */ |
| |
| /* This implements IEEE 754R 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>. */ |
| |
| /* The intended way to use this file is to make two copies, add `#define ' |
| to one copy, then compile both copies and add them to libgcc.a. */ |
| |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include <string.h> |
| #include <limits.h> |
| |
| #include "config/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 unary decNumber operation. */ |
| typedef decNumber* (*dfp_unary_func) |
| (decNumber *, decNumber *, decContext *); |
| |
| /* A pointer to a binary decNumber operation. */ |
| typedef decNumber* (*dfp_binary_func) |
| (decNumber *, decNumber *, decNumber *, decContext *); |
| |
| extern unsigned long __dec_byte_swap (unsigned long); |
| |
| /* Unary operations. */ |
| |
| static inline DFP_C_TYPE |
| dfp_unary_op (dfp_unary_func op, DFP_C_TYPE arg) |
| { |
| DFP_C_TYPE result; |
| decContext context; |
| decNumber arg1, res; |
| IEEE_TYPE a, encoded_result; |
| |
| HOST_TO_IEEE (arg, &a); |
| |
| decContextDefault (&context, CONTEXT_INIT); |
| context.round = CONTEXT_ROUND; |
| |
| TO_INTERNAL (&a, &arg1); |
| |
| /* Perform the operation. */ |
| op (&res, &arg1, &context); |
| |
| if (CONTEXT_TRAPS && CONTEXT_ERRORS (context)) |
| DFP_RAISE (0); |
| |
| TO_ENCODED (&encoded_result, &res, &context); |
| IEEE_TO_HOST (encoded_result, &result); |
| return result; |
| } |
| |
| /* Binary operations. */ |
| |
| static inline DFP_C_TYPE |
| dfp_binary_op (dfp_binary_func op, DFP_C_TYPE arg_a, DFP_C_TYPE arg_b) |
| { |
| DFP_C_TYPE result; |
| decContext context; |
| decNumber arg1, arg2, res; |
| IEEE_TYPE a, b, encoded_result; |
| |
| HOST_TO_IEEE (arg_a, &a); |
| HOST_TO_IEEE (arg_b, &b); |
| |
| decContextDefault (&context, CONTEXT_INIT); |
| context.round = CONTEXT_ROUND; |
| |
| TO_INTERNAL (&a, &arg1); |
| TO_INTERNAL (&b, &arg2); |
| |
| /* Perform the operation. */ |
| op (&res, &arg1, &arg2, &context); |
| |
| if (CONTEXT_TRAPS && CONTEXT_ERRORS (context)) |
| DFP_RAISE (0); |
| |
| TO_ENCODED (&encoded_result, &res, &context); |
| IEEE_TO_HOST (encoded_result, &result); |
| return result; |
| } |
| |
| /* Comparison operations. */ |
| |
| static inline int |
| dfp_compare_op (dfp_binary_func op, DFP_C_TYPE arg_a, DFP_C_TYPE arg_b) |
| { |
| IEEE_TYPE a, b; |
| decContext context; |
| decNumber arg1, arg2, res; |
| int result; |
| |
| HOST_TO_IEEE (arg_a, &a); |
| HOST_TO_IEEE (arg_b, &b); |
| |
| decContextDefault (&context, CONTEXT_INIT); |
| context.round = CONTEXT_ROUND; |
| |
| TO_INTERNAL (&a, &arg1); |
| TO_INTERNAL (&b, &arg2); |
| |
| /* Perform the comparison. */ |
| op (&res, &arg1, &arg2, &context); |
| |
| if (CONTEXT_TRAPS && CONTEXT_ERRORS (context)) |
| DFP_RAISE (0); |
| |
| if (decNumberIsNegative (&res)) |
| result = -1; |
| else if (decNumberIsZero (&res)) |
| result = 0; |
| else |
| result = 1; |
| |
| return result; |
| } |
| |
| |
| #if defined(L_conv_sd) |
| void |
| __host_to_ieee_32 (_Decimal32 in, decimal32 *out) |
| { |
| uint32_t t; |
| |
| if (!LIBGCC2_FLOAT_WORDS_BIG_ENDIAN) |
| { |
| memcpy (&t, &in, 4); |
| t = __dec_byte_swap (t); |
| memcpy (out, &t, 4); |
| } |
| else |
| memcpy (out, &in, 4); |
| } |
| |
| void |
| __ieee_to_host_32 (decimal32 in, _Decimal32 *out) |
| { |
| uint32_t t; |
| |
| if (!LIBGCC2_FLOAT_WORDS_BIG_ENDIAN) |
| { |
| memcpy (&t, &in, 4); |
| t = __dec_byte_swap (t); |
| memcpy (out, &t, 4); |
| } |
| else |
| memcpy (out, &in, 4); |
| } |
| #endif /* L_conv_sd */ |
| |
| #if defined(L_conv_dd) |
| static void |
| __swap64 (char *src, char *dst) |
| { |
| uint32_t t1, t2; |
| |
| if (!LIBGCC2_FLOAT_WORDS_BIG_ENDIAN) |
| { |
| memcpy (&t1, src, 4); |
| memcpy (&t2, src + 4, 4); |
| t1 = __dec_byte_swap (t1); |
| t2 = __dec_byte_swap (t2); |
| memcpy (dst, &t2, 4); |
| memcpy (dst + 4, &t1, 4); |
| } |
| else |
| memcpy (dst, src, 8); |
| } |
| |
| void |
| __host_to_ieee_64 (_Decimal64 in, decimal64 *out) |
| { |
| __swap64 ((char *) &in, (char *) out); |
| } |
| |
| void |
| __ieee_to_host_64 (decimal64 in, _Decimal64 *out) |
| { |
| __swap64 ((char *) &in, (char *) out); |
| } |
| #endif /* L_conv_dd */ |
| |
| #if defined(L_conv_td) |
| static void |
| __swap128 (char *src, char *dst) |
| { |
| uint32_t t1, t2, t3, t4; |
| |
| if (!LIBGCC2_FLOAT_WORDS_BIG_ENDIAN) |
| { |
| memcpy (&t1, src, 4); |
| memcpy (&t2, src + 4, 4); |
| memcpy (&t3, src + 8, 4); |
| memcpy (&t4, src + 12, 4); |
| t1 = __dec_byte_swap (t1); |
| t2 = __dec_byte_swap (t2); |
| t3 = __dec_byte_swap (t3); |
| t4 = __dec_byte_swap (t4); |
| memcpy (dst, &t4, 4); |
| memcpy (dst + 4, &t3, 4); |
| memcpy (dst + 8, &t2, 4); |
| memcpy (dst + 12, &t1, 4); |
| } |
| else |
| memcpy (dst, src, 16); |
| } |
| |
| void |
| __host_to_ieee_128 (_Decimal128 in, decimal128 *out) |
| { |
| __swap128 ((char *) &in, (char *) out); |
| } |
| |
| void |
| __ieee_to_host_128 (decimal128 in, _Decimal128 *out) |
| { |
| __swap128 ((char *) &in, (char *) out); |
| } |
| #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 (decNumberAdd, arg_a, arg_b); |
| } |
| |
| DFP_C_TYPE |
| DFP_SUB (DFP_C_TYPE arg_a, DFP_C_TYPE arg_b) |
| { |
| return dfp_binary_op (decNumberSubtract, 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 (decNumberMultiply, 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 (decNumberDivide, 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) |
| { |
| int stat; |
| stat = dfp_compare_op (decNumberCompare, 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 (decNumberCompare, arg_a, arg_b); |
| /* For NE return nonzero for true, zero for false. */ |
| 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 (decNumberCompare, 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 (decNumberCompare, 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 (decNumberCompare, arg_a, arg_b); |
| /* For LE return 0 (<= 0) for true, 1 for false. */ |
| 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 (decNumberCompare, arg_a, arg_b); |
| /* For GE return 1 (>=0) for true, -1 for false. */ |
| return (stat != -1) ? 1 : -1; |
| } |
| #endif /* L_ge */ |
| |
| #define BUFMAX 128 |
| |
| #if defined (L_sd_to_dd) || defined (L_sd_to_td) || defined (L_dd_to_sd) \ |
| || defined (L_dd_to_td) || defined (L_td_to_sd) || defined (L_td_to_dd) |
| DFP_C_TYPE_TO |
| DFP_TO_DFP (DFP_C_TYPE f_from) |
| { |
| DFP_C_TYPE_TO f_to; |
| IEEE_TYPE s_from; |
| IEEE_TYPE_TO s_to; |
| decNumber d; |
| decContext context; |
| |
| decContextDefault (&context, CONTEXT_INIT); |
| context.round = CONTEXT_ROUND; |
| |
| HOST_TO_IEEE (f_from, &s_from); |
| TO_INTERNAL (&s_from, &d); |
| TO_ENCODED_TO (&s_to, &d, &context); |
| if (CONTEXT_TRAPS && (context.status & DEC_Inexact) != 0) |
| DFP_RAISE (DEC_Inexact); |
| |
| IEEE_TO_HOST_TO (s_to, &f_to); |
| return f_to; |
| } |
| #endif |
| |
| #if defined (L_sd_to_si) || defined (L_dd_to_si) || defined (L_td_to_si) \ |
| || defined (L_sd_to_di) || defined (L_dd_to_di) || defined (L_td_to_di) \ |
| || defined (L_sd_to_usi) || defined (L_dd_to_usi) || defined (L_td_to_usi) \ |
| || defined (L_sd_to_udi) || defined (L_dd_to_udi) || defined (L_td_to_udi) |
| 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. */ |
| |
| IEEE_TYPE s; |
| char buf[BUFMAX]; |
| char *pos; |
| decNumber qval, n1, n2; |
| decContext context; |
| |
| decContextDefault (&context, CONTEXT_INIT); |
| /* 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, (char *) "1.0", &context); |
| /* Force the exponent to zero. */ |
| decNumberQuantize (&n1, &n2, &qval, &context); |
| /* This is based on text in N1107 section 5.1; it might turn out to be |
| undefined behavior instead. */ |
| if (context.status & DEC_Invalid_operation) |
| { |
| #if defined (L_sd_to_si) || defined (L_dd_to_si) || defined (L_td_to_si) |
| if (decNumberIsNegative(&n2)) |
| return INT_MIN; |
| else |
| return INT_MAX; |
| #elif defined (L_sd_to_di) || defined (L_dd_to_di) || defined (L_td_to_di) |
| if (decNumberIsNegative(&n2)) |
| /* Find a defined constant that will work here. */ |
| return (-9223372036854775807LL - 1LL); |
| else |
| /* Find a defined constant that will work here. */ |
| return 9223372036854775807LL; |
| #elif defined (L_sd_to_usi) || defined (L_dd_to_usi) || defined (L_td_to_usi) |
| return UINT_MAX; |
| #elif defined (L_sd_to_udi) || defined (L_dd_to_udi) || defined (L_td_to_udi) |
| /* Find a defined constant that will work here. */ |
| return 18446744073709551615ULL; |
| #endif |
| } |
| /* 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_sd) || defined (L_si_to_dd) || defined (L_si_to_td) \ |
| || defined (L_di_to_sd) || defined (L_di_to_dd) || defined (L_di_to_td) \ |
| || defined (L_usi_to_sd) || defined (L_usi_to_dd) || defined (L_usi_to_td) \ |
| || defined (L_udi_to_sd) || defined (L_udi_to_dd) || defined (L_udi_to_td) |
| 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); |
| context.round = CONTEXT_ROUND; |
| |
| /* Use a C library function to get a floating point string. */ |
| sprintf (buf, INT_FMT ".0", 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 (CONTEXT_TRAPS && (context.status & DEC_Inexact) != 0) |
| DFP_RAISE (DEC_Inexact); |
| 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)) \ |
| && LIBGCC2_HAS_XF_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)) \ |
| && LIBGCC2_HAS_XF_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); |
| context.round = CONTEXT_ROUND; |
| |
| /* Use a C library function to write the floating point value to a string. */ |
| #ifdef BFP_VIA_TYPE |
| /* FIXME: Is there a better way to output an XFmode variable in C? */ |
| sprintf (buf, BFP_FMT, (BFP_VIA_TYPE) x); |
| #else |
| sprintf (buf, BFP_FMT, x); |
| #endif |
| |
| /* Convert from the floating point string to a decimal* type. */ |
| FROM_STRING (&s, buf, &context); |
| IEEE_TO_HOST (s, &f); |
| if (CONTEXT_TRAPS && (context.status & DEC_Inexact) != 0) |
| DFP_RAISE (DEC_Inexact); |
| 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 */ |