summaryrefslogtreecommitdiff
path: root/Build/source/libs/mpfr/mpfr-src/src/exceptions.c
diff options
context:
space:
mode:
Diffstat (limited to 'Build/source/libs/mpfr/mpfr-src/src/exceptions.c')
-rw-r--r--Build/source/libs/mpfr/mpfr-src/src/exceptions.c498
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