diff options
Diffstat (limited to 'Build/source/libs/mpfr/mpfr-src/src/exceptions.c')
-rw-r--r-- | Build/source/libs/mpfr/mpfr-src/src/exceptions.c | 498 |
1 files changed, 0 insertions, 498 deletions
diff --git a/Build/source/libs/mpfr/mpfr-src/src/exceptions.c b/Build/source/libs/mpfr/mpfr-src/src/exceptions.c deleted file mode 100644 index d197bd2c1f9..00000000000 --- a/Build/source/libs/mpfr/mpfr-src/src/exceptions.c +++ /dev/null @@ -1,498 +0,0 @@ -/* Exception flags and utilities. Constructors and destructors (debug). - -Copyright 2001-2020 Free Software Foundation, Inc. -Contributed by the AriC and Caramba projects, INRIA. - -This file is part of the GNU MPFR Library. - -The GNU MPFR Library is free software; you can redistribute it and/or modify -it under the terms of the GNU Lesser General Public License as published by -the Free Software Foundation; either version 3 of the License, or (at your -option) any later version. - -The GNU MPFR Library 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 Lesser General Public -License for more details. - -You should have received a copy of the GNU Lesser General Public License -along with the GNU MPFR Library; see the file COPYING.LESSER. If not, see -https://www.gnu.org/licenses/ or write to the Free Software Foundation, Inc., -51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA. */ - -#include "mpfr-impl.h" - -MPFR_THREAD_VAR (mpfr_flags_t, __gmpfr_flags, 0) -MPFR_THREAD_VAR (mpfr_exp_t, __gmpfr_emin, MPFR_EMIN_DEFAULT) -MPFR_THREAD_VAR (mpfr_exp_t, __gmpfr_emax, MPFR_EMAX_DEFAULT) - -#undef mpfr_get_emin - -MPFR_COLD_FUNCTION_ATTR mpfr_exp_t -mpfr_get_emin (void) -{ - return __gmpfr_emin; -} - -#undef mpfr_set_emin - -int -mpfr_set_emin (mpfr_exp_t exponent) -{ - if (MPFR_LIKELY (exponent >= MPFR_EMIN_MIN && exponent <= MPFR_EMIN_MAX)) - { - __gmpfr_emin = exponent; - return 0; - } - else - { - return 1; - } -} - -MPFR_COLD_FUNCTION_ATTR mpfr_exp_t -mpfr_get_emin_min (void) -{ - return MPFR_EMIN_MIN; -} - -MPFR_COLD_FUNCTION_ATTR mpfr_exp_t -mpfr_get_emin_max (void) -{ - return MPFR_EMIN_MAX; -} - -#undef mpfr_get_emax - -MPFR_COLD_FUNCTION_ATTR mpfr_exp_t -mpfr_get_emax (void) -{ - return __gmpfr_emax; -} - -#undef mpfr_set_emax - -int -mpfr_set_emax (mpfr_exp_t exponent) -{ - if (MPFR_LIKELY (exponent >= MPFR_EMAX_MIN && exponent <= MPFR_EMAX_MAX)) - { - __gmpfr_emax = exponent; - return 0; - } - else - { - return 1; - } -} - -MPFR_COLD_FUNCTION_ATTR mpfr_exp_t -mpfr_get_emax_min (void) -{ - return MPFR_EMAX_MIN; -} - -MPFR_COLD_FUNCTION_ATTR mpfr_exp_t -mpfr_get_emax_max (void) -{ - return MPFR_EMAX_MAX; -} - - -#undef mpfr_flags_clear - -MPFR_COLD_FUNCTION_ATTR void -mpfr_flags_clear (mpfr_flags_t mask) -{ - __gmpfr_flags &= MPFR_FLAGS_ALL ^ mask; -} - -#undef mpfr_flags_set - -MPFR_COLD_FUNCTION_ATTR void -mpfr_flags_set (mpfr_flags_t mask) -{ - __gmpfr_flags |= mask; -} - -#undef mpfr_flags_test - -MPFR_COLD_FUNCTION_ATTR mpfr_flags_t -mpfr_flags_test (mpfr_flags_t mask) -{ - return __gmpfr_flags & mask; -} - -#undef mpfr_flags_save - -MPFR_COLD_FUNCTION_ATTR mpfr_flags_t -mpfr_flags_save (void) -{ - return __gmpfr_flags; -} - -#undef mpfr_flags_restore - -MPFR_COLD_FUNCTION_ATTR void -mpfr_flags_restore (mpfr_flags_t flags, mpfr_flags_t mask) -{ - __gmpfr_flags = - (__gmpfr_flags & (MPFR_FLAGS_ALL ^ mask)) | - (flags & mask); -} - - -#undef mpfr_clear_flags - -void -mpfr_clear_flags (void) -{ - __gmpfr_flags = 0; -} - -#undef mpfr_clear_underflow - -MPFR_COLD_FUNCTION_ATTR void -mpfr_clear_underflow (void) -{ - __gmpfr_flags &= MPFR_FLAGS_ALL ^ MPFR_FLAGS_UNDERFLOW; -} - -#undef mpfr_clear_overflow - -MPFR_COLD_FUNCTION_ATTR void -mpfr_clear_overflow (void) -{ - __gmpfr_flags &= MPFR_FLAGS_ALL ^ MPFR_FLAGS_OVERFLOW; -} - -#undef mpfr_clear_divby0 - -MPFR_COLD_FUNCTION_ATTR void -mpfr_clear_divby0 (void) -{ - __gmpfr_flags &= MPFR_FLAGS_ALL ^ MPFR_FLAGS_DIVBY0; -} - -#undef mpfr_clear_nanflag - -MPFR_COLD_FUNCTION_ATTR void -mpfr_clear_nanflag (void) -{ - __gmpfr_flags &= MPFR_FLAGS_ALL ^ MPFR_FLAGS_NAN; -} - -#undef mpfr_clear_inexflag - -MPFR_COLD_FUNCTION_ATTR void -mpfr_clear_inexflag (void) -{ - __gmpfr_flags &= MPFR_FLAGS_ALL ^ MPFR_FLAGS_INEXACT; -} - -#undef mpfr_clear_erangeflag - -MPFR_COLD_FUNCTION_ATTR void -mpfr_clear_erangeflag (void) -{ - __gmpfr_flags &= MPFR_FLAGS_ALL ^ MPFR_FLAGS_ERANGE; -} - -#undef mpfr_set_underflow - -MPFR_COLD_FUNCTION_ATTR void -mpfr_set_underflow (void) -{ - __gmpfr_flags |= MPFR_FLAGS_UNDERFLOW; -} - -#undef mpfr_set_overflow - -MPFR_COLD_FUNCTION_ATTR void -mpfr_set_overflow (void) -{ - __gmpfr_flags |= MPFR_FLAGS_OVERFLOW; -} - -#undef mpfr_set_divby0 - -MPFR_COLD_FUNCTION_ATTR void -mpfr_set_divby0 (void) -{ - __gmpfr_flags |= MPFR_FLAGS_DIVBY0; -} - -#undef mpfr_set_nanflag - -MPFR_COLD_FUNCTION_ATTR void -mpfr_set_nanflag (void) -{ - __gmpfr_flags |= MPFR_FLAGS_NAN; -} - -#undef mpfr_set_inexflag - -MPFR_COLD_FUNCTION_ATTR void -mpfr_set_inexflag (void) -{ - __gmpfr_flags |= MPFR_FLAGS_INEXACT; -} - -#undef mpfr_set_erangeflag - -MPFR_COLD_FUNCTION_ATTR void -mpfr_set_erangeflag (void) -{ - __gmpfr_flags |= MPFR_FLAGS_ERANGE; -} - - -#undef mpfr_check_range - -/* Note: It is possible that for pure FP numbers, EXP(x) < MPFR_EMIN_MIN, - but the caller must make sure that the difference remains small enough - to avoid reaching the special exponent values. */ -int -mpfr_check_range (mpfr_ptr x, int t, mpfr_rnd_t rnd_mode) -{ - if (MPFR_LIKELY (! MPFR_IS_SINGULAR (x))) - { /* x is a non-zero FP */ - mpfr_exp_t exp = MPFR_EXP (x); /* Do not use MPFR_GET_EXP */ - - MPFR_ASSERTD (MPFR_IS_NORMALIZED (x)); - if (MPFR_UNLIKELY (exp < __gmpfr_emin)) - { - /* The following test is necessary because in the rounding to the - * nearest mode, mpfr_underflow always rounds away from 0. In - * this rounding mode, we need to round to 0 if: - * _ |x| < 2^(emin-2), or - * _ |x| = 2^(emin-2) and the absolute value of the exact - * result is <= 2^(emin-2). - */ - if (rnd_mode == MPFR_RNDN && - (exp + 1 < __gmpfr_emin || - (mpfr_powerof2_raw(x) && - (MPFR_IS_NEG(x) ? t <= 0 : t >= 0)))) - rnd_mode = MPFR_RNDZ; - return mpfr_underflow (x, rnd_mode, MPFR_SIGN(x)); - } - if (MPFR_UNLIKELY (exp > __gmpfr_emax)) - return mpfr_overflow (x, rnd_mode, MPFR_SIGN(x)); - } - else if (MPFR_UNLIKELY (t != 0 && MPFR_IS_INF (x))) - { - /* We need to do the following because most MPFR functions are - * implemented in the following way: - * Ziv's loop: - * | Compute an approximation to the result and an error bound. - * | Possible underflow/overflow detection -> return. - * | If can_round, break (exit the loop). - * | Otherwise, increase the working precision and loop. - * Round the approximation in the target precision. <== See below - * Restore the flags (that could have been set due to underflows - * or overflows during the internal computations). - * Execute: return mpfr_check_range (...). - * The problem is that an overflow could be generated when rounding the - * approximation (in general, such an overflow could not be detected - * earlier), and the overflow flag is lost when the flags are restored. - * This can occur only when the rounding yields an exponent change - * and the new exponent is larger than the maximum exponent, so that - * an infinity is necessarily obtained. - * So, the simplest solution is to detect this overflow case here in - * mpfr_check_range, which is easy to do since the rounded result is - * necessarily an inexact infinity. - */ - __gmpfr_flags |= MPFR_FLAGS_OVERFLOW; - } - MPFR_RET (t); /* propagate inexact ternary value, unlike most functions */ -} - - -#undef mpfr_underflow_p - -MPFR_COLD_FUNCTION_ATTR int -mpfr_underflow_p (void) -{ - MPFR_STAT_STATIC_ASSERT (MPFR_FLAGS_UNDERFLOW <= INT_MAX); - return __gmpfr_flags & MPFR_FLAGS_UNDERFLOW; -} - -#undef mpfr_overflow_p - -MPFR_COLD_FUNCTION_ATTR int -mpfr_overflow_p (void) -{ - MPFR_STAT_STATIC_ASSERT (MPFR_FLAGS_OVERFLOW <= INT_MAX); - return __gmpfr_flags & MPFR_FLAGS_OVERFLOW; -} - -#undef mpfr_divby0_p - -MPFR_COLD_FUNCTION_ATTR int -mpfr_divby0_p (void) -{ - MPFR_STAT_STATIC_ASSERT (MPFR_FLAGS_DIVBY0 <= INT_MAX); - return __gmpfr_flags & MPFR_FLAGS_DIVBY0; -} - -#undef mpfr_nanflag_p - -MPFR_COLD_FUNCTION_ATTR int -mpfr_nanflag_p (void) -{ - MPFR_STAT_STATIC_ASSERT (MPFR_FLAGS_NAN <= INT_MAX); - return __gmpfr_flags & MPFR_FLAGS_NAN; -} - -#undef mpfr_inexflag_p - -MPFR_COLD_FUNCTION_ATTR int -mpfr_inexflag_p (void) -{ - MPFR_STAT_STATIC_ASSERT (MPFR_FLAGS_INEXACT <= INT_MAX); - return __gmpfr_flags & MPFR_FLAGS_INEXACT; -} - -#undef mpfr_erangeflag_p - -MPFR_COLD_FUNCTION_ATTR int -mpfr_erangeflag_p (void) -{ - MPFR_STAT_STATIC_ASSERT (MPFR_FLAGS_ERANGE <= INT_MAX); - return __gmpfr_flags & MPFR_FLAGS_ERANGE; -} - - -/* #undef mpfr_underflow */ - -/* Note: In the rounding to the nearest mode, mpfr_underflow - always rounds away from 0. In this rounding mode, you must call - mpfr_underflow with rnd_mode = MPFR_RNDZ if the exact result - is <= 2^(emin-2) in absolute value. - We chose the default to round away from zero instead of toward zero - because rounding away from zero (MPFR_RNDA) wasn't supported at that - time (r1910), so that the caller had no way to change rnd_mode to - this mode. */ - -MPFR_COLD_FUNCTION_ATTR int -mpfr_underflow (mpfr_ptr x, mpfr_rnd_t rnd_mode, int sign) -{ - int inex; - - MPFR_LOG_FUNC - (("rnd=%d sign=%d", rnd_mode, sign), - ("x[%Pu]=%.*Rg", mpfr_get_prec (x), mpfr_log_prec, x)); - - MPFR_ASSERT_SIGN (sign); - - if (MPFR_IS_LIKE_RNDZ(rnd_mode, sign < 0)) - { - MPFR_SET_ZERO(x); - inex = -1; - } - else - { - mpfr_setmin (x, __gmpfr_emin); - inex = 1; - } - MPFR_SET_SIGN(x, sign); - __gmpfr_flags |= MPFR_FLAGS_INEXACT | MPFR_FLAGS_UNDERFLOW; - return sign > 0 ? inex : -inex; -} - -/* #undef mpfr_overflow */ - -MPFR_COLD_FUNCTION_ATTR int -mpfr_overflow (mpfr_ptr x, mpfr_rnd_t rnd_mode, int sign) -{ - int inex; - - MPFR_LOG_FUNC - (("rnd=%d sign=%d", rnd_mode, sign), - ("x[%Pu]=%.*Rg", mpfr_get_prec (x), mpfr_log_prec, x)); - - MPFR_ASSERT_SIGN (sign); - - if (MPFR_IS_LIKE_RNDZ(rnd_mode, sign < 0)) - { - mpfr_setmax (x, __gmpfr_emax); - inex = -1; - } - else - { - MPFR_SET_INF(x); - inex = 1; - } - MPFR_SET_SIGN(x, sign); - __gmpfr_flags |= MPFR_FLAGS_INEXACT | MPFR_FLAGS_OVERFLOW; - return sign > 0 ? inex : -inex; -} - -/**************************************************************************/ - -/* Code related to constructors and destructors (for debugging) should - be put here. The reason is that such code must be in an object file - that will be kept by the linker for symbol resolution, and symbols - __gmpfr_emin and __gmpfr_emax from this file will be used by every - program calling a MPFR math function (where rounding is involved). */ - -#if defined MPFR_DEBUG_PREDICTION - -/* Print prediction statistics at the end of a program. - * - * Code to debug branch prediction, based on Ulrich Drepper's paper - * "What Every Programmer Should Know About Memory": - * http://people.freebsd.org/~lstewart/articles/cpumemory.pdf - */ - -extern long int __start_predict_data; -extern long int __stop_predict_data; -extern long int __start_predict_line; -extern const char *__start_predict_file; - -static void __attribute__ ((destructor)) -predprint (void) -{ - long int *s = &__start_predict_data; - long int *e = &__stop_predict_data; - long int *sl = &__start_predict_line; - const char **sf = &__start_predict_file; - - while (s < e) - { - printf("%s:%ld: incorrect=%ld, correct=%ld%s\n", - *sf, *sl, s[0], s[1], - s[0] > s[1] ? " <==== WARNING" : ""); - ++sl; - ++sf; - s += 2; - } -} - -#endif - -#if MPFR_WANT_ASSERT >= 2 - -/* Similar to flags_out in tests/tests.c */ - -void -flags_fout (FILE *stream, mpfr_flags_t flags) -{ - int none = 1; - - if (flags & MPFR_FLAGS_UNDERFLOW) - none = 0, fprintf (stream, " underflow"); - if (flags & MPFR_FLAGS_OVERFLOW) - none = 0, fprintf (stream, " overflow"); - if (flags & MPFR_FLAGS_NAN) - none = 0, fprintf (stream, " nan"); - if (flags & MPFR_FLAGS_INEXACT) - none = 0, fprintf (stream, " inexact"); - if (flags & MPFR_FLAGS_ERANGE) - none = 0, fprintf (stream, " erange"); - if (none) - fprintf (stream, " none"); - fprintf (stream, " (%u)\n", flags); -} - -#endif |