gcc/config/dfp-bit.c

   1 /* This is a software decimal floating point library.
   2    Copyright (C) 2005, 2006 Free Software Foundation, Inc.
   3
   4 This file is part of GCC.
   5
   6 GCC is free software; you can redistribute it and/or modify it under
   7 the terms of the GNU General Public License as published by the Free
   8 Software Foundation; either version 2, or (at your option) any later
   9 version.
  10
  11 In addition to the permissions in the GNU General Public License, the
  12 Free Software Foundation gives you unlimited permission to link the
  13 compiled version of this file into combinations with other programs,
  14 and to distribute those combinations without any restriction coming
  15 from the use of this file.  (The General Public License restrictions
  16 do apply in other respects; for example, they cover modification of
  17 the file, and distribution when not linked into a combine
  18 executable.)
  19
  20 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  21 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  22 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  23 for more details.
  24
  25 You should have received a copy of the GNU General Public License
  26 along with GCC; see the file COPYING.  If not, write to the Free
  27 Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
  28 02110-1301, USA.  */
  29
  30 /* This implements IEEE 754R decimal floating point arithmetic, but
  31    does not provide a mechanism for setting the rounding mode, or for
  32    generating or handling exceptions.  Conversions between decimal
  33    floating point types and other types depend on C library functions.
  34
  35    Contributed by Ben Elliston  <bje@au.ibm.com>.  */
  36
  37 /* The intended way to use this file is to make two copies, add `#define '
  38    to one copy, then compile both copies and add them to libgcc.a.  */
  39
  40 #include <stdio.h>
  41 #include <stdlib.h>
  42 #include <string.h>
  43 #include <limits.h>
  44
  45 #include "config/dfp-bit.h"
  46
  47 /* Forward declarations.  */
  48 #if WIDTH == 32 || WIDTH_TO == 32
  49 void __host_to_ieee_32 (_Decimal32 in, decimal32 *out);
  50 void __ieee_to_host_32 (decimal32 in, _Decimal32 *out);
  51 #endif
  52 #if WIDTH == 64 || WIDTH_TO == 64
  53 void __host_to_ieee_64 (_Decimal64 in, decimal64 *out);
  54 void __ieee_to_host_64 (decimal64 in, _Decimal64 *out);
  55 #endif
  56 #if WIDTH == 128 || WIDTH_TO == 128
  57 void __host_to_ieee_128 (_Decimal128 in, decimal128 *out);
  58 void __ieee_to_host_128 (decimal128 in, _Decimal128 *out);
  59 #endif
  60
  61 /* A pointer to a unary decNumber operation.  */
  62 typedef decNumber* (*dfp_unary_func)
  63      (decNumber *, decNumber *, decContext *);
  64
  65 /* A pointer to a binary decNumber operation.  */
  66 typedef decNumber* (*dfp_binary_func)
  67      (decNumber *, decNumber *, decNumber *, decContext *);
  68
  69 extern unsigned long __dec_byte_swap (unsigned long);
  70 \f
  71 /* Unary operations.  */
  72
  73 static inline DFP_C_TYPE
  74 dfp_unary_op (dfp_unary_func op, DFP_C_TYPE arg)
  75 {
  76   DFP_C_TYPE result;
  77   decContext context;
  78   decNumber arg1, res;
  79   IEEE_TYPE a, encoded_result;
  80
  81   HOST_TO_IEEE (arg, &a);
  82
  83   decContextDefault (&context, CONTEXT_INIT);
  84   context.round = CONTEXT_ROUND;
  85
  86   TO_INTERNAL (&a, &arg1);
  87
  88   /* Perform the operation.  */
  89   op (&res, &arg1, &context);
  90
  91   if (CONTEXT_TRAPS && CONTEXT_ERRORS (context))
  92     DFP_RAISE (0);
  93
  94   TO_ENCODED (&encoded_result, &res, &context);
  95   IEEE_TO_HOST (encoded_result, &result);
  96   return result;
  97 }
  98
  99 /* Binary operations.  */
 100
 101 static inline DFP_C_TYPE
 102 dfp_binary_op (dfp_binary_func op, DFP_C_TYPE arg_a, DFP_C_TYPE arg_b)
 103 {
 104   DFP_C_TYPE result;
 105   decContext context;
 106   decNumber arg1, arg2, res;
 107   IEEE_TYPE a, b, encoded_result;
 108
 109   HOST_TO_IEEE (arg_a, &a);
 110   HOST_TO_IEEE (arg_b, &b);
 111
 112   decContextDefault (&context, CONTEXT_INIT);
 113   context.round = CONTEXT_ROUND;
 114
 115   TO_INTERNAL (&a, &arg1);
 116   TO_INTERNAL (&b, &arg2);
 117
 118   /* Perform the operation.  */
 119   op (&res, &arg1, &arg2, &context);
 120
 121   if (CONTEXT_TRAPS && CONTEXT_ERRORS (context))
 122     DFP_RAISE (0);
 123
 124   TO_ENCODED (&encoded_result, &res, &context);
 125   IEEE_TO_HOST (encoded_result, &result);
 126   return result;
 127 }
 128
 129 /* Comparison operations.  */
 130
 131 static inline int
 132 dfp_compare_op (dfp_binary_func op, DFP_C_TYPE arg_a, DFP_C_TYPE arg_b)
 133 {
 134   IEEE_TYPE a, b;
 135   decContext context;
 136   decNumber arg1, arg2, res;
 137   int result;
 138
 139   HOST_TO_IEEE (arg_a, &a);
 140   HOST_TO_IEEE (arg_b, &b);
 141
 142   decContextDefault (&context, CONTEXT_INIT);
 143   context.round = CONTEXT_ROUND;
 144
 145   TO_INTERNAL (&a, &arg1);
 146   TO_INTERNAL (&b, &arg2);
 147
 148   /* Perform the comparison.  */
 149   op (&res, &arg1, &arg2, &context);
 150
 151   if (CONTEXT_TRAPS && CONTEXT_ERRORS (context))
 152     DFP_RAISE (0);
 153
 154   if (decNumberIsNegative (&res))
 155     result = -1;
 156   else if (decNumberIsZero (&res))
 157     result = 0;
 158   else
 159     result = 1;
 160
 161   return result;
 162 }
 163
 164 \f
 165 #if defined(L_conv_sd)
 166 void
 167 __host_to_ieee_32 (_Decimal32 in, decimal32 *out)
 168 {
 169   uint32_t t;
 170
 171   if (!LIBGCC2_FLOAT_WORDS_BIG_ENDIAN)
 172     {
 173       memcpy (&t, &in, 4);
 174       t = __dec_byte_swap (t);
 175       memcpy (out, &t, 4);
 176     }
 177   else
 178     memcpy (out, &in, 4);
 179 }
 180
 181 void
 182 __ieee_to_host_32 (decimal32 in, _Decimal32 *out)
 183 {
 184   uint32_t t;
 185
 186   if (!LIBGCC2_FLOAT_WORDS_BIG_ENDIAN)
 187     {
 188       memcpy (&t, &in, 4);
 189       t = __dec_byte_swap (t);
 190       memcpy (out, &t, 4);
 191     }
 192   else
 193     memcpy (out, &in, 4);
 194 }
 195 #endif /* L_conv_sd */
 196
 197 #if defined(L_conv_dd)
 198 static void
 199 __swap64 (char *src, char *dst)
 200 {
 201   uint32_t t1, t2;
 202
 203   if (!LIBGCC2_FLOAT_WORDS_BIG_ENDIAN)
 204     {
 205       memcpy (&t1, src, 4);
 206       memcpy (&t2, src + 4, 4);
 207       t1 = __dec_byte_swap (t1);
 208       t2 = __dec_byte_swap (t2);
 209       memcpy (dst, &t2, 4);
 210       memcpy (dst + 4, &t1, 4);
 211     }
 212   else
 213     memcpy (dst, src, 8);
 214 }
 215
 216 void
 217 __host_to_ieee_64 (_Decimal64 in, decimal64 *out)
 218 {
 219   __swap64 ((char *) &in, (char *) out);
 220 }
 221
 222 void
 223 __ieee_to_host_64 (decimal64 in, _Decimal64 *out)
 224 {
 225   __swap64 ((char *) &in, (char *) out);
 226 }
 227 #endif /* L_conv_dd */
 228
 229 #if defined(L_conv_td)
 230 static void
 231 __swap128 (char *src, char *dst)
 232 {
 233   uint32_t t1, t2, t3, t4;
 234
 235   if (!LIBGCC2_FLOAT_WORDS_BIG_ENDIAN)
 236     {
 237       memcpy (&t1, src, 4);
 238       memcpy (&t2, src + 4, 4);
 239       memcpy (&t3, src + 8, 4);
 240       memcpy (&t4, src + 12, 4);
 241       t1 = __dec_byte_swap (t1);
 242       t2 = __dec_byte_swap (t2);
 243       t3 = __dec_byte_swap (t3);
 244       t4 = __dec_byte_swap (t4);
 245       memcpy (dst, &t4, 4);
 246       memcpy (dst + 4, &t3, 4);
 247       memcpy (dst + 8, &t2, 4);
 248       memcpy (dst + 12, &t1, 4);
 249     }
 250   else
 251     memcpy (dst, src, 16);
 252 }
 253
 254 void
 255 __host_to_ieee_128 (_Decimal128 in, decimal128 *out)
 256 {
 257   __swap128 ((char *) &in, (char *) out);
 258 }
 259
 260 void
 261 __ieee_to_host_128 (decimal128 in, _Decimal128 *out)
 262 {
 263   __swap128 ((char *) &in, (char *) out);
 264 }
 265 #endif /* L_conv_td */
 266
 267 #if defined(L_addsub_sd) || defined(L_addsub_dd) || defined(L_addsub_td)
 268 DFP_C_TYPE
 269 DFP_ADD (DFP_C_TYPE arg_a, DFP_C_TYPE arg_b)
 270 {
 271   return dfp_binary_op (decNumberAdd, arg_a, arg_b);
 272 }
 273
 274 DFP_C_TYPE
 275 DFP_SUB (DFP_C_TYPE arg_a, DFP_C_TYPE arg_b)
 276 {
 277   return dfp_binary_op (decNumberSubtract, arg_a, arg_b);
 278 }
 279 #endif /* L_addsub */
 280
 281 #if defined(L_mul_sd) || defined(L_mul_dd) || defined(L_mul_td)
 282 DFP_C_TYPE
 283 DFP_MULTIPLY (DFP_C_TYPE arg_a, DFP_C_TYPE arg_b)
 284 {
 285   return dfp_binary_op (decNumberMultiply, arg_a, arg_b);
 286 }
 287 #endif /* L_mul */
 288
 289 #if defined(L_div_sd) || defined(L_div_dd) || defined(L_div_td)
 290 DFP_C_TYPE
 291 DFP_DIVIDE (DFP_C_TYPE arg_a, DFP_C_TYPE arg_b)
 292 {
 293   return dfp_binary_op (decNumberDivide, arg_a, arg_b);
 294 }
 295 #endif /* L_div */
 296
 297 #if defined (L_eq_sd) || defined (L_eq_dd) || defined (L_eq_td)
 298 CMPtype
 299 DFP_EQ (DFP_C_TYPE arg_a, DFP_C_TYPE arg_b)
 300 {
 301   int stat;
 302   stat = dfp_compare_op (decNumberCompare, arg_a, arg_b);
 303   /* For EQ return zero for true, nonzero for false.  */
 304   return stat != 0;
 305 }
 306 #endif /* L_eq */
 307
 308 #if defined (L_ne_sd) || defined (L_ne_dd) || defined (L_ne_td)
 309 CMPtype
 310 DFP_NE (DFP_C_TYPE arg_a, DFP_C_TYPE arg_b)
 311 {
 312   int stat;
 313   stat = dfp_compare_op (decNumberCompare, arg_a, arg_b);
 314   /* For NE return nonzero for true, zero for false.  */
 315   return stat != 0;
 316 }
 317 #endif /* L_ne */
 318
 319 #if defined (L_lt_sd) || defined (L_lt_dd) || defined (L_lt_td)
 320 CMPtype
 321 DFP_LT (DFP_C_TYPE arg_a, DFP_C_TYPE arg_b)
 322 {
 323   int stat;
 324   stat = dfp_compare_op (decNumberCompare, arg_a, arg_b);
 325   /* For LT return -1 (<0) for true, 1 for false.  */
 326   return (stat == -1) ? -1 : 1;
 327 }
 328 #endif /* L_lt */
 329
 330 #if defined (L_gt_sd) || defined (L_gt_dd) || defined (L_gt_td)
 331 CMPtype
 332 DFP_GT (DFP_C_TYPE arg_a, DFP_C_TYPE arg_b)
 333 {
 334   int stat;
 335   stat = dfp_compare_op (decNumberCompare, arg_a, arg_b);
 336   /* For GT return 1 (>0) for true, -1 for false.  */
 337   return (stat == 1) ? 1 : -1;
 338 }
 339 #endif
 340
 341 #if defined (L_le_sd) || defined (L_le_dd) || defined (L_le_td)
 342 CMPtype
 343 DFP_LE (DFP_C_TYPE arg_a, DFP_C_TYPE arg_b)
 344 {
 345   int stat;
 346   stat = dfp_compare_op (decNumberCompare, arg_a, arg_b);
 347   /* For LE return 0 (<= 0) for true, 1 for false.  */
 348   return stat == 1;
 349 }
 350 #endif /* L_le */
 351
 352 #if defined (L_ge_sd) || defined (L_ge_dd) || defined (L_ge_td)
 353 CMPtype
 354 DFP_GE (DFP_C_TYPE arg_a, DFP_C_TYPE arg_b)
 355 {
 356   int stat;
 357   stat = dfp_compare_op (decNumberCompare, arg_a, arg_b);
 358   /* For GE return 1 (>=0) for true, -1 for false.  */
 359   return (stat != -1) ? 1 : -1;
 360 }
 361 #endif /* L_ge */
 362
 363 #define BUFMAX 128
 364
 365 #if defined (L_sd_to_dd) || defined (L_sd_to_td) || defined (L_dd_to_sd) \
 366  || defined (L_dd_to_td) || defined (L_td_to_sd) || defined (L_td_to_dd)
 367 DFP_C_TYPE_TO
 368 DFP_TO_DFP (DFP_C_TYPE f_from)
 369 {
 370   DFP_C_TYPE_TO f_to;
 371   IEEE_TYPE s_from;
 372   IEEE_TYPE_TO s_to;
 373   decNumber d;
 374   decContext context;
 375
 376   decContextDefault (&context, CONTEXT_INIT);
 377   context.round = CONTEXT_ROUND;
 378
 379   HOST_TO_IEEE (f_from, &s_from);
 380   TO_INTERNAL (&s_from, &d);
 381   TO_ENCODED_TO (&s_to, &d, &context);
 382   if (CONTEXT_TRAPS && (context.status & DEC_Inexact) != 0)
 383     DFP_RAISE (DEC_Inexact);
 384
 385   IEEE_TO_HOST_TO (s_to, &f_to);
 386   return f_to;
 387 }
 388 #endif
 389
 390 #if defined (L_sd_to_si) || defined (L_dd_to_si) || defined (L_td_to_si) \
 391   || defined (L_sd_to_di) || defined (L_dd_to_di) || defined (L_td_to_di) \
 392   || defined (L_sd_to_usi) || defined (L_dd_to_usi) || defined (L_td_to_usi) \
 393   || defined (L_sd_to_udi) || defined (L_dd_to_udi) || defined (L_td_to_udi)
 394 INT_TYPE
 395 DFP_TO_INT (DFP_C_TYPE x)
 396 {
 397   /* decNumber's decimal* types have the same format as C's _Decimal*
 398      types, but they have different calling conventions.  */
 399
 400   IEEE_TYPE s;
 401   char buf[BUFMAX];
 402   char *pos;
 403   decNumber qval, n1, n2;
 404   decContext context;
 405
 406   decContextDefault (&context, CONTEXT_INIT);
 407   /* Need non-default rounding mode here.  */
 408   context.round = DEC_ROUND_DOWN;
 409
 410   HOST_TO_IEEE (x, &s);
 411   TO_INTERNAL (&s, &n1);
 412   /* Rescale if the exponent is less than zero.  */
 413   decNumberToIntegralValue (&n2, &n1, &context);
 414   /* Get a value to use for the quanitize call.  */
 415   decNumberFromString (&qval, (char *) "1.0", &context);
 416   /* Force the exponent to zero.  */
 417   decNumberQuantize (&n1, &n2, &qval, &context);
 418   /* This is based on text in N1107 secton 5.1; it might turn out to be
 419      undefined behavior instead.  */
 420   if (context.status & DEC_Invalid_operation)
 421     {
 422 #if defined (L_sd_to_si) || defined (L_dd_to_si) || defined (L_td_to_si)
 423       if (decNumberIsNegative(&n2))
 424         return INT_MIN;
 425       else
 426         return INT_MAX;
 427 #elif defined (L_sd_to_di) || defined (L_dd_to_di) || defined (L_td_to_di)
 428       if (decNumberIsNegative(&n2))
 429         /* Find a defined constant that will work here.  */
 430         return (-9223372036854775807LL - 1LL);
 431       else
 432         /* Find a defined constant that will work here.  */
 433         return 9223372036854775807LL;
 434 #elif defined (L_sd_to_usi) || defined (L_dd_to_usi) || defined (L_td_to_usi)
 435       return UINT_MAX;
 436 #elif defined (L_sd_to_udi) || defined (L_dd_to_udi) || defined (L_td_to_udi)
 437         /* Find a defined constant that will work here.  */
 438       return 18446744073709551615ULL;
 439 #endif
 440     }
 441   /* Get a string, which at this point will not include an exponent.  */
 442   decNumberToString (&n1, buf);
 443   /* Ignore the fractional part.  */
 444   pos = strchr (buf, '.');
 445   if (pos)
 446     *pos = 0;
 447   /* Use a C library function to convert to the integral type.  */
 448   return STR_TO_INT (buf, NULL, 10);
 449 }
 450 #endif
 451
 452 #if defined (L_si_to_sd) || defined (L_si_to_dd) || defined (L_si_to_td) \
 453   || defined (L_di_to_sd) || defined (L_di_to_dd) || defined (L_di_to_td) \
 454   || defined (L_usi_to_sd) || defined (L_usi_to_dd) || defined (L_usi_to_td) \
 455   || defined (L_udi_to_sd) || defined (L_udi_to_dd) || defined (L_udi_to_td)
 456 DFP_C_TYPE
 457 INT_TO_DFP (INT_TYPE i)
 458 {
 459   DFP_C_TYPE f;
 460   IEEE_TYPE s;
 461   char buf[BUFMAX];
 462   decContext context;
 463
 464   decContextDefault (&context, CONTEXT_INIT);
 465   context.round = CONTEXT_ROUND;
 466
 467   /* Use a C library function to get a floating point string.  */
 468   sprintf (buf, INT_FMT ".0", CAST_FOR_FMT(i));
 469   /* Convert from the floating point string to a decimal* type.  */
 470   FROM_STRING (&s, buf, &context);
 471   IEEE_TO_HOST (s, &f);
 472   if (CONTEXT_TRAPS && (context.status & DEC_Inexact) != 0)
 473     DFP_RAISE (DEC_Inexact);
 474   return f;
 475 }
 476 #endif
 477
 478 #if defined (L_sd_to_sf) || defined (L_dd_to_sf) || defined (L_td_to_sf) \
 479  || defined (L_sd_to_df) || defined (L_dd_to_df) || defined (L_td_to_df) \
 480  || ((defined (L_sd_to_xf) || defined (L_dd_to_xf) || defined (L_td_to_xf)) \
 481      && LIBGCC2_HAS_XF_MODE)
 482 BFP_TYPE
 483 DFP_TO_BFP (DFP_C_TYPE f)
 484 {
 485   IEEE_TYPE s;
 486   char buf[BUFMAX];
 487
 488   HOST_TO_IEEE (f, &s);
 489   /* Write the value to a string.  */
 490   TO_STRING (&s, buf);
 491   /* Read it as the binary floating point type and return that.  */
 492   return STR_TO_BFP (buf, NULL);
 493 }
 494 #endif
 495
 496 #if defined (L_sf_to_sd) || defined (L_sf_to_dd) || defined (L_sf_to_td) \
 497  || defined (L_df_to_sd) || defined (L_df_to_dd) || defined (L_df_to_td) \
 498  || ((defined (L_xf_to_sd) || defined (L_xf_to_dd) || defined (L_xf_to_td)) \
 499      && LIBGCC2_HAS_XF_MODE)
 500 DFP_C_TYPE
 501 BFP_TO_DFP (BFP_TYPE x)
 502 {
 503   DFP_C_TYPE f;
 504   IEEE_TYPE s;
 505   char buf[BUFMAX];
 506   decContext context;
 507
 508   decContextDefault (&context, CONTEXT_INIT);
 509   context.round = CONTEXT_ROUND;
 510
 511   /* Use a C library function to write the floating point value to a string.  */
 512 #ifdef BFP_VIA_TYPE
 513   /* FIXME: Is threre a better way to output an XFmode variable in C?  */
 514   sprintf (buf, BFP_FMT, (BFP_VIA_TYPE) x);
 515 #else
 516   sprintf (buf, BFP_FMT, x);
 517 #endif
 518
 519   /* Convert from the floating point string to a decimal* type.  */
 520   FROM_STRING (&s, buf, &context);
 521   IEEE_TO_HOST (s, &f);
 522   if (CONTEXT_TRAPS && (context.status & DEC_Inexact) != 0)
 523     DFP_RAISE (DEC_Inexact);
 524   return f;
 525 }
 526 #endif
 527
 528 #if defined (L_unord_sd) || defined (L_unord_dd) || defined (L_unord_td)
 529 CMPtype
 530 DFP_UNORD (DFP_C_TYPE arg_a, DFP_C_TYPE arg_b)
 531 {
 532   decNumber arg1, arg2;
 533   IEEE_TYPE a, b;
 534
 535   HOST_TO_IEEE (arg_a, &a);
 536   HOST_TO_IEEE (arg_b, &b);
 537   TO_INTERNAL (&a, &arg1);
 538   TO_INTERNAL (&b, &arg2);
 539   return (decNumberIsNaN (&arg1) || decNumberIsNaN (&arg2));
 540 }
 541 #endif /* L_unord_sd || L_unord_dd || L_unord_td */