1/* This is a software decimal floating point library. 2 Copyright (C) 2005-2015 Free Software Foundation, Inc. 3 4This file is part of GCC. 5 6GCC is free software; you can redistribute it and/or modify it under 7the terms of the GNU General Public License as published by the Free 8Software Foundation; either version 3, or (at your option) any later 9version. 10 11GCC is distributed in the hope that it will be useful, but WITHOUT ANY 12WARRANTY; without even the implied warranty of MERCHANTABILITY or 13FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 14for more details. 15 16Under Section 7 of GPL version 3, you are granted additional 17permissions described in the GCC Runtime Library Exception, version 183.1, as published by the Free Software Foundation. 19 20You should have received a copy of the GNU General Public License and 21a copy of the GCC Runtime Library Exception along with this program; 22see the files COPYING3 and COPYING.RUNTIME respectively. If not, see 23<http://www.gnu.org/licenses/>. */ 24 25/* This implements IEEE 754 decimal floating point arithmetic, but 26 does not provide a mechanism for setting the rounding mode, or for 27 generating or handling exceptions. Conversions between decimal 28 floating point types and other types depend on C library functions. 29 30 Contributed by Ben Elliston <bje@au.ibm.com>. */ 31 32#include <stdio.h> 33#include <stdlib.h> 34/* FIXME: compile with -std=gnu99 to get these from stdlib.h */ 35extern float strtof (const char *, char **); 36extern long double strtold (const char *, char **); 37#include <string.h> 38#include <limits.h> 39 40#include "dfp-bit.h" 41 42/* Forward declarations. */ 43#if WIDTH == 32 || WIDTH_TO == 32 44void __host_to_ieee_32 (_Decimal32 in, decimal32 *out); 45void __ieee_to_host_32 (decimal32 in, _Decimal32 *out); 46#endif 47#if WIDTH == 64 || WIDTH_TO == 64 48void __host_to_ieee_64 (_Decimal64 in, decimal64 *out); 49void __ieee_to_host_64 (decimal64 in, _Decimal64 *out); 50#endif 51#if WIDTH == 128 || WIDTH_TO == 128 52void __host_to_ieee_128 (_Decimal128 in, decimal128 *out); 53void __ieee_to_host_128 (decimal128 in, _Decimal128 *out); 54#endif 55 56/* A pointer to a binary decFloat operation. */ 57typedef decFloat* (*dfp_binary_func) 58 (decFloat *, const decFloat *, const decFloat *, decContext *); 59 60/* Binary operations. */ 61 62/* Use a decFloat (decDouble or decQuad) function to perform a DFP 63 binary operation. */ 64static inline decFloat 65dfp_binary_op (dfp_binary_func op, decFloat arg_a, decFloat arg_b) 66{ 67 decFloat result; 68 decContext context; 69 70 decContextDefault (&context, CONTEXT_INIT); 71 DFP_INIT_ROUNDMODE (context.round); 72 73 /* Perform the operation. */ 74 op (&result, &arg_a, &arg_b, &context); 75 76 if (DFP_EXCEPTIONS_ENABLED && context.status != 0) 77 { 78 /* decNumber exception flags we care about here. */ 79 int ieee_flags; 80 int dec_flags = DEC_IEEE_854_Division_by_zero | DEC_IEEE_854_Inexact 81 | DEC_IEEE_854_Invalid_operation | DEC_IEEE_854_Overflow 82 | DEC_IEEE_854_Underflow; 83 dec_flags &= context.status; 84 ieee_flags = DFP_IEEE_FLAGS (dec_flags); 85 if (ieee_flags != 0) 86 DFP_HANDLE_EXCEPTIONS (ieee_flags); 87 } 88 89 return result; 90} 91 92#if WIDTH == 32 93/* The decNumber package doesn't provide arithmetic for decSingle (32 bits); 94 convert to decDouble, use the operation for that, and convert back. */ 95static inline _Decimal32 96d32_binary_op (dfp_binary_func op, _Decimal32 arg_a, _Decimal32 arg_b) 97{ 98 union { _Decimal32 c; decSingle f; } a32, b32, res32; 99 decDouble a, b, res; 100 decContext context; 101 102 /* Widen the operands and perform the operation. */ 103 a32.c = arg_a; 104 b32.c = arg_b; 105 decSingleToWider (&a32.f, &a); 106 decSingleToWider (&b32.f, &b); 107 res = dfp_binary_op (op, a, b); 108 109 /* Narrow the result, which might result in an underflow or overflow. */ 110 decContextDefault (&context, CONTEXT_INIT); 111 DFP_INIT_ROUNDMODE (context.round); 112 decSingleFromWider (&res32.f, &res, &context); 113 if (DFP_EXCEPTIONS_ENABLED && context.status != 0) 114 { 115 /* decNumber exception flags we care about here. */ 116 int ieee_flags; 117 int dec_flags = DEC_IEEE_854_Inexact | DEC_IEEE_854_Overflow 118 | DEC_IEEE_854_Underflow; 119 dec_flags &= context.status; 120 ieee_flags = DFP_IEEE_FLAGS (dec_flags); 121 if (ieee_flags != 0) 122 DFP_HANDLE_EXCEPTIONS (ieee_flags); 123 } 124 125 return res32.c; 126} 127#else 128/* decFloat operations are supported for decDouble (64 bits) and 129 decQuad (128 bits). The bit patterns for the types are the same. */ 130static inline DFP_C_TYPE 131dnn_binary_op (dfp_binary_func op, DFP_C_TYPE arg_a, DFP_C_TYPE arg_b) 132{ 133 union { DFP_C_TYPE c; decFloat f; } a, b, result; 134 135 a.c = arg_a; 136 b.c = arg_b; 137 result.f = dfp_binary_op (op, a.f, b.f); 138 return result.c; 139} 140#endif 141 142/* Comparison operations. */ 143 144/* Use a decFloat (decDouble or decQuad) function to perform a DFP 145 comparison. */ 146static inline CMPtype 147dfp_compare_op (dfp_binary_func op, decFloat arg_a, decFloat arg_b) 148{ 149 decContext context; 150 decFloat res; 151 int result; 152 153 decContextDefault (&context, CONTEXT_INIT); 154 DFP_INIT_ROUNDMODE (context.round); 155 156 /* Perform the comparison. */ 157 op (&res, &arg_a, &arg_b, &context); 158 159 if (DEC_FLOAT_IS_SIGNED (&res)) 160 result = -1; 161 else if (DEC_FLOAT_IS_ZERO (&res)) 162 result = 0; 163 else if (DEC_FLOAT_IS_NAN (&res)) 164 result = -2; 165 else 166 result = 1; 167 168 return (CMPtype) result; 169} 170 171#if WIDTH == 32 172/* The decNumber package doesn't provide comparisons for decSingle (32 bits); 173 convert to decDouble, use the operation for that, and convert back. */ 174static inline CMPtype 175d32_compare_op (dfp_binary_func op, _Decimal32 arg_a, _Decimal32 arg_b) 176{ 177 union { _Decimal32 c; decSingle f; } a32, b32; 178 decDouble a, b; 179 180 a32.c = arg_a; 181 b32.c = arg_b; 182 decSingleToWider (&a32.f, &a); 183 decSingleToWider (&b32.f, &b); 184 return dfp_compare_op (op, a, b); 185} 186#else 187/* decFloat comparisons are supported for decDouble (64 bits) and 188 decQuad (128 bits). The bit patterns for the types are the same. */ 189static inline CMPtype 190dnn_compare_op (dfp_binary_func op, DFP_C_TYPE arg_a, DFP_C_TYPE arg_b) 191{ 192 union { DFP_C_TYPE c; decFloat f; } a, b; 193 194 a.c = arg_a; 195 b.c = arg_b; 196 return dfp_compare_op (op, a.f, b.f); 197} 198#endif 199 200#if defined(L_conv_sd) 201void 202__host_to_ieee_32 (_Decimal32 in, decimal32 *out) 203{ 204 memcpy (out, &in, 4); 205} 206 207void 208__ieee_to_host_32 (decimal32 in, _Decimal32 *out) 209{ 210 memcpy (out, &in, 4); 211} 212#endif /* L_conv_sd */ 213 214#if defined(L_conv_dd) 215void 216__host_to_ieee_64 (_Decimal64 in, decimal64 *out) 217{ 218 memcpy (out, &in, 8); 219} 220 221void 222__ieee_to_host_64 (decimal64 in, _Decimal64 *out) 223{ 224 memcpy (out, &in, 8); 225} 226#endif /* L_conv_dd */ 227 228#if defined(L_conv_td) 229void 230__host_to_ieee_128 (_Decimal128 in, decimal128 *out) 231{ 232 memcpy (out, &in, 16); 233} 234 235void 236__ieee_to_host_128 (decimal128 in, _Decimal128 *out) 237{ 238 memcpy (out, &in, 16); 239} 240#endif /* L_conv_td */ 241 242#if defined(L_addsub_sd) || defined(L_addsub_dd) || defined(L_addsub_td) 243DFP_C_TYPE 244DFP_ADD (DFP_C_TYPE arg_a, DFP_C_TYPE arg_b) 245{ 246 return DFP_BINARY_OP (DEC_FLOAT_ADD, arg_a, arg_b); 247} 248 249DFP_C_TYPE 250DFP_SUB (DFP_C_TYPE arg_a, DFP_C_TYPE arg_b) 251{ 252 return DFP_BINARY_OP (DEC_FLOAT_SUBTRACT, arg_a, arg_b); 253} 254#endif /* L_addsub */ 255 256#if defined(L_mul_sd) || defined(L_mul_dd) || defined(L_mul_td) 257DFP_C_TYPE 258DFP_MULTIPLY (DFP_C_TYPE arg_a, DFP_C_TYPE arg_b) 259{ 260 return DFP_BINARY_OP (DEC_FLOAT_MULTIPLY, arg_a, arg_b); 261} 262#endif /* L_mul */ 263 264#if defined(L_div_sd) || defined(L_div_dd) || defined(L_div_td) 265DFP_C_TYPE 266DFP_DIVIDE (DFP_C_TYPE arg_a, DFP_C_TYPE arg_b) 267{ 268 return DFP_BINARY_OP (DEC_FLOAT_DIVIDE, arg_a, arg_b); 269} 270#endif /* L_div */ 271 272#if defined (L_eq_sd) || defined (L_eq_dd) || defined (L_eq_td) 273CMPtype 274DFP_EQ (DFP_C_TYPE arg_a, DFP_C_TYPE arg_b) 275{ 276 CMPtype stat; 277 stat = DFP_COMPARE_OP (DEC_FLOAT_COMPARE, arg_a, arg_b); 278 /* For EQ return zero for true, nonzero for false. */ 279 return stat != 0; 280} 281#endif /* L_eq */ 282 283#if defined (L_ne_sd) || defined (L_ne_dd) || defined (L_ne_td) 284CMPtype 285DFP_NE (DFP_C_TYPE arg_a, DFP_C_TYPE arg_b) 286{ 287 int stat; 288 stat = DFP_COMPARE_OP (DEC_FLOAT_COMPARE, arg_a, arg_b); 289 /* For NE return zero for true, nonzero for false. */ 290 if (__builtin_expect (stat == -2, 0)) /* An operand is NaN. */ 291 return 1; 292 return stat != 0; 293} 294#endif /* L_ne */ 295 296#if defined (L_lt_sd) || defined (L_lt_dd) || defined (L_lt_td) 297CMPtype 298DFP_LT (DFP_C_TYPE arg_a, DFP_C_TYPE arg_b) 299{ 300 int stat; 301 stat = DFP_COMPARE_OP (DEC_FLOAT_COMPARE, arg_a, arg_b); 302 /* For LT return -1 (<0) for true, 1 for false. */ 303 return (stat == -1) ? -1 : 1; 304} 305#endif /* L_lt */ 306 307#if defined (L_gt_sd) || defined (L_gt_dd) || defined (L_gt_td) 308CMPtype 309DFP_GT (DFP_C_TYPE arg_a, DFP_C_TYPE arg_b) 310{ 311 int stat; 312 stat = DFP_COMPARE_OP (DEC_FLOAT_COMPARE, arg_a, arg_b); 313 /* For GT return 1 (>0) for true, -1 for false. */ 314 return (stat == 1) ? 1 : -1; 315} 316#endif 317 318#if defined (L_le_sd) || defined (L_le_dd) || defined (L_le_td) 319CMPtype 320DFP_LE (DFP_C_TYPE arg_a, DFP_C_TYPE arg_b) 321{ 322 int stat; 323 stat = DFP_COMPARE_OP (DEC_FLOAT_COMPARE, arg_a, arg_b); 324 /* For LE return 0 (<= 0) for true, 1 for false. */ 325 if (__builtin_expect (stat == -2, 0)) /* An operand is NaN. */ 326 return 1; 327 return stat == 1; 328} 329#endif /* L_le */ 330 331#if defined (L_ge_sd) || defined (L_ge_dd) || defined (L_ge_td) 332CMPtype 333DFP_GE (DFP_C_TYPE arg_a, DFP_C_TYPE arg_b) 334{ 335 int stat; 336 stat = DFP_COMPARE_OP (DEC_FLOAT_COMPARE, arg_a, arg_b); 337 /* For GE return 1 (>=0) for true, -1 for false. */ 338 if (__builtin_expect (stat == -2, 0)) /* An operand is NaN. */ 339 return -1; 340 return (stat != -1) ? 1 : -1; 341} 342#endif /* L_ge */ 343 344#define BUFMAX 128 345 346/* Check for floating point exceptions that are relevant for conversions 347 between decimal float values and handle them. */ 348static inline void 349dfp_conversion_exceptions (const int status) 350{ 351 /* decNumber exception flags we care about here. */ 352 int ieee_flags; 353 int dec_flags = DEC_IEEE_854_Inexact | DEC_IEEE_854_Invalid_operation 354 | DEC_IEEE_854_Overflow; 355 dec_flags &= status; 356 ieee_flags = DFP_IEEE_FLAGS (dec_flags); 357 if (ieee_flags != 0) 358 DFP_HANDLE_EXCEPTIONS (ieee_flags); 359} 360 361#if defined (L_sd_to_dd) 362/* Use decNumber to convert directly from _Decimal32 to _Decimal64. */ 363_Decimal64 364DFP_TO_DFP (_Decimal32 f_from) 365{ 366 union { _Decimal32 c; decSingle f; } from; 367 union { _Decimal64 c; decDouble f; } to; 368 369 from.c = f_from; 370 to.f = *decSingleToWider (&from.f, &to.f); 371 return to.c; 372} 373#endif 374 375#if defined (L_sd_to_td) 376/* Use decNumber to convert directly from _Decimal32 to _Decimal128. */ 377_Decimal128 378DFP_TO_DFP (_Decimal32 f_from) 379{ 380 union { _Decimal32 c; decSingle f; } from; 381 union { _Decimal128 c; decQuad f; } to; 382 decDouble temp; 383 384 from.c = f_from; 385 temp = *decSingleToWider (&from.f, &temp); 386 to.f = *decDoubleToWider (&temp, &to.f); 387 return to.c; 388} 389#endif 390 391#if defined (L_dd_to_td) 392/* Use decNumber to convert directly from _Decimal64 to _Decimal128. */ 393_Decimal128 394DFP_TO_DFP (_Decimal64 f_from) 395{ 396 union { _Decimal64 c; decDouble f; } from; 397 union { _Decimal128 c; decQuad f; } to; 398 399 from.c = f_from; 400 to.f = *decDoubleToWider (&from.f, &to.f); 401 return to.c; 402} 403#endif 404 405#if defined (L_dd_to_sd) 406/* Use decNumber to convert directly from _Decimal64 to _Decimal32. */ 407_Decimal32 408DFP_TO_DFP (_Decimal64 f_from) 409{ 410 union { _Decimal32 c; decSingle f; } to; 411 union { _Decimal64 c; decDouble f; } from; 412 decContext context; 413 414 decContextDefault (&context, CONTEXT_INIT); 415 DFP_INIT_ROUNDMODE (context.round); 416 from.c = f_from; 417 to.f = *decSingleFromWider (&to.f, &from.f, &context); 418 if (DFP_EXCEPTIONS_ENABLED && context.status != 0) 419 dfp_conversion_exceptions (context.status); 420 return to.c; 421} 422#endif 423 424#if defined (L_td_to_sd) 425/* Use decNumber to convert directly from _Decimal128 to _Decimal32. */ 426_Decimal32 427DFP_TO_DFP (_Decimal128 f_from) 428{ 429 union { _Decimal32 c; decSingle f; } to; 430 union { _Decimal128 c; decQuad f; } from; 431 decDouble temp; 432 decContext context; 433 434 decContextDefault (&context, CONTEXT_INIT); 435 DFP_INIT_ROUNDMODE (context.round); 436 from.c = f_from; 437 temp = *decDoubleFromWider (&temp, &from.f, &context); 438 to.f = *decSingleFromWider (&to.f, &temp, &context); 439 if (DFP_EXCEPTIONS_ENABLED && context.status != 0) 440 dfp_conversion_exceptions (context.status); 441 return to.c; 442} 443#endif 444 445#if defined (L_td_to_dd) 446/* Use decNumber to convert directly from _Decimal128 to _Decimal64. */ 447_Decimal64 448DFP_TO_DFP (_Decimal128 f_from) 449{ 450 union { _Decimal64 c; decDouble f; } to; 451 union { _Decimal128 c; decQuad f; } from; 452 decContext context; 453 454 decContextDefault (&context, CONTEXT_INIT); 455 DFP_INIT_ROUNDMODE (context.round); 456 from.c = f_from; 457 to.f = *decDoubleFromWider (&to.f, &from.f, &context); 458 if (DFP_EXCEPTIONS_ENABLED && context.status != 0) 459 dfp_conversion_exceptions (context.status); 460 return to.c; 461} 462#endif 463 464#if defined (L_dd_to_si) || defined (L_td_to_si) \ 465 || defined (L_dd_to_usi) || defined (L_td_to_usi) 466/* Use decNumber to convert directly from decimal float to integer types. */ 467INT_TYPE 468DFP_TO_INT (DFP_C_TYPE x) 469{ 470 union { DFP_C_TYPE c; decFloat f; } u; 471 decContext context; 472 INT_TYPE i; 473 474 decContextDefault (&context, DEC_INIT_DECIMAL128); 475 context.round = DEC_ROUND_DOWN; 476 u.c = x; 477 i = DEC_FLOAT_TO_INT (&u.f, &context, context.round); 478 if (DFP_EXCEPTIONS_ENABLED && context.status != 0) 479 dfp_conversion_exceptions (context.status); 480 return i; 481} 482#endif 483 484#if defined (L_sd_to_si) || (L_sd_to_usi) 485/* Use decNumber to convert directly from decimal float to integer types. */ 486INT_TYPE 487DFP_TO_INT (_Decimal32 x) 488{ 489 union { _Decimal32 c; decSingle f; } u32; 490 decDouble f64; 491 decContext context; 492 INT_TYPE i; 493 494 decContextDefault (&context, DEC_INIT_DECIMAL128); 495 context.round = DEC_ROUND_DOWN; 496 u32.c = x; 497 f64 = *decSingleToWider (&u32.f, &f64); 498 i = DEC_FLOAT_TO_INT (&f64, &context, context.round); 499 if (DFP_EXCEPTIONS_ENABLED && context.status != 0) 500 dfp_conversion_exceptions (context.status); 501 return i; 502} 503#endif 504 505#if defined (L_sd_to_di) || defined (L_dd_to_di) || defined (L_td_to_di) \ 506 || defined (L_sd_to_udi) || defined (L_dd_to_udi) || defined (L_td_to_udi) 507/* decNumber doesn't provide support for conversions to 64-bit integer 508 types, so do it the hard way. */ 509INT_TYPE 510DFP_TO_INT (DFP_C_TYPE x) 511{ 512 /* decNumber's decimal* types have the same format as C's _Decimal* 513 types, but they have different calling conventions. */ 514 515 /* TODO: Decimal float to integer conversions should raise FE_INVALID 516 if the result value does not fit into the result type. */ 517 518 IEEE_TYPE s; 519 char buf[BUFMAX]; 520 char *pos; 521 decNumber qval, n1, n2; 522 decContext context; 523 524 /* Use a large context to avoid losing precision. */ 525 decContextDefault (&context, DEC_INIT_DECIMAL128); 526 /* Need non-default rounding mode here. */ 527 context.round = DEC_ROUND_DOWN; 528 529 HOST_TO_IEEE (x, &s); 530 TO_INTERNAL (&s, &n1); 531 /* Rescale if the exponent is less than zero. */ 532 decNumberToIntegralValue (&n2, &n1, &context); 533 /* Get a value to use for the quantize call. */ 534 decNumberFromString (&qval, "1.", &context); 535 /* Force the exponent to zero. */ 536 decNumberQuantize (&n1, &n2, &qval, &context); 537 /* Get a string, which at this point will not include an exponent. */ 538 decNumberToString (&n1, buf); 539 /* Ignore the fractional part. */ 540 pos = strchr (buf, '.'); 541 if (pos) 542 *pos = 0; 543 /* Use a C library function to convert to the integral type. */ 544 return STR_TO_INT (buf, NULL, 10); 545} 546#endif 547 548#if defined (L_si_to_dd) || defined (L_si_to_td) \ 549 || defined (L_usi_to_dd) || defined (L_usi_to_td) 550/* Use decNumber to convert directly from integer to decimal float types. */ 551DFP_C_TYPE 552INT_TO_DFP (INT_TYPE i) 553{ 554 union { DFP_C_TYPE c; decFloat f; } u; 555 556 u.f = *DEC_FLOAT_FROM_INT (&u.f, i); 557 return u.c; 558} 559#endif 560 561#if defined (L_si_to_sd) || defined (L_usi_to_sd) 562_Decimal32 563/* Use decNumber to convert directly from integer to decimal float types. */ 564INT_TO_DFP (INT_TYPE i) 565{ 566 union { _Decimal32 c; decSingle f; } u32; 567 decDouble f64; 568 decContext context; 569 570 decContextDefault (&context, DEC_INIT_DECIMAL128); 571 f64 = *DEC_FLOAT_FROM_INT (&f64, i); 572 u32.f = *decSingleFromWider (&u32.f, &f64, &context); 573 if (DFP_EXCEPTIONS_ENABLED && context.status != 0) 574 dfp_conversion_exceptions (context.status); 575 return u32.c; 576} 577#endif 578 579#if defined (L_di_to_sd) || defined (L_di_to_dd) || defined (L_di_to_td) \ 580 || defined (L_udi_to_sd) || defined (L_udi_to_dd) || defined (L_udi_to_td) 581/* decNumber doesn't provide support for conversions from 64-bit integer 582 types, so do it the hard way. */ 583DFP_C_TYPE 584INT_TO_DFP (INT_TYPE i) 585{ 586 DFP_C_TYPE f; 587 IEEE_TYPE s; 588 char buf[BUFMAX]; 589 decContext context; 590 591 decContextDefault (&context, CONTEXT_INIT); 592 DFP_INIT_ROUNDMODE (context.round); 593 594 /* Use a C library function to get a floating point string. */ 595 sprintf (buf, INT_FMT ".", CAST_FOR_FMT(i)); 596 /* Convert from the floating point string to a decimal* type. */ 597 FROM_STRING (&s, buf, &context); 598 IEEE_TO_HOST (s, &f); 599 600 if (DFP_EXCEPTIONS_ENABLED && context.status != 0) 601 dfp_conversion_exceptions (context.status); 602 603 return f; 604} 605#endif 606 607#if defined (L_sd_to_sf) || defined (L_dd_to_sf) || defined (L_td_to_sf) \ 608 || defined (L_sd_to_df) || defined (L_dd_to_df) || defined (L_td_to_df) \ 609 || ((defined (L_sd_to_xf) || defined (L_dd_to_xf) || defined (L_td_to_xf)) \ 610 && LONG_DOUBLE_HAS_XF_MODE) \ 611 || ((defined (L_sd_to_tf) || defined (L_dd_to_tf) || defined (L_td_to_tf)) \ 612 && LONG_DOUBLE_HAS_TF_MODE) 613BFP_TYPE 614DFP_TO_BFP (DFP_C_TYPE f) 615{ 616 IEEE_TYPE s; 617 char buf[BUFMAX]; 618 619 HOST_TO_IEEE (f, &s); 620 /* Write the value to a string. */ 621 TO_STRING (&s, buf); 622 /* Read it as the binary floating point type and return that. */ 623 return STR_TO_BFP (buf, NULL); 624} 625#endif 626 627#if defined (L_sf_to_sd) || defined (L_sf_to_dd) || defined (L_sf_to_td) \ 628 || defined (L_df_to_sd) || defined (L_df_to_dd) || defined (L_df_to_td) \ 629 || ((defined (L_xf_to_sd) || defined (L_xf_to_dd) || defined (L_xf_to_td)) \ 630 && LONG_DOUBLE_HAS_XF_MODE) \ 631 || ((defined (L_tf_to_sd) || defined (L_tf_to_dd) || defined (L_tf_to_td)) \ 632 && LONG_DOUBLE_HAS_TF_MODE) 633DFP_C_TYPE 634BFP_TO_DFP (BFP_TYPE x) 635{ 636 DFP_C_TYPE f; 637 IEEE_TYPE s; 638 char buf[BUFMAX]; 639 decContext context; 640 641 decContextDefault (&context, CONTEXT_INIT); 642 DFP_INIT_ROUNDMODE (context.round); 643 644 /* Use a C library function to write the floating point value to a string. */ 645 sprintf (buf, BFP_FMT, (BFP_VIA_TYPE) x); 646 647 /* Convert from the floating point string to a decimal* type. */ 648 FROM_STRING (&s, buf, &context); 649 IEEE_TO_HOST (s, &f); 650 651 if (DFP_EXCEPTIONS_ENABLED && context.status != 0) 652 { 653 /* decNumber exception flags we care about here. */ 654 int ieee_flags; 655 int dec_flags = DEC_IEEE_854_Inexact | DEC_IEEE_854_Invalid_operation 656 | DEC_IEEE_854_Overflow | DEC_IEEE_854_Underflow; 657 dec_flags &= context.status; 658 ieee_flags = DFP_IEEE_FLAGS (dec_flags); 659 if (ieee_flags != 0) 660 DFP_HANDLE_EXCEPTIONS (ieee_flags); 661 } 662 663 return f; 664} 665#endif 666 667#if defined (L_unord_sd) || defined (L_unord_dd) || defined (L_unord_td) 668CMPtype 669DFP_UNORD (DFP_C_TYPE arg_a, DFP_C_TYPE arg_b) 670{ 671 decNumber arg1, arg2; 672 IEEE_TYPE a, b; 673 674 HOST_TO_IEEE (arg_a, &a); 675 HOST_TO_IEEE (arg_b, &b); 676 TO_INTERNAL (&a, &arg1); 677 TO_INTERNAL (&b, &arg2); 678 return (decNumberIsNaN (&arg1) || decNumberIsNaN (&arg2)); 679} 680#endif /* L_unord_sd || L_unord_dd || L_unord_td */ 681