diff options
Diffstat (limited to 'libre/iceweasel/firefox-93.0_x86_math_private_20211110.patch')
| -rw-r--r-- | libre/iceweasel/firefox-93.0_x86_math_private_20211110.patch | 112 |
1 files changed, 112 insertions, 0 deletions
diff --git a/libre/iceweasel/firefox-93.0_x86_math_private_20211110.patch b/libre/iceweasel/firefox-93.0_x86_math_private_20211110.patch new file mode 100644 index 000000000..bdc889061 --- /dev/null +++ b/libre/iceweasel/firefox-93.0_x86_math_private_20211110.patch @@ -0,0 +1,112 @@ +diff -w -ruN firefox-93.0.org/modules/fdlibm/src/math_private.h firefox-93.0/modules/fdlibm/src/math_private.h +--- firefox-93.0.org/modules/fdlibm/src/math_private.h 2021-09-27 16:47:42.000000000 -0600 ++++ firefox-93.0/modules/fdlibm/src/math_private.h 2021-11-10 17:39:03.495621830 -0600 +@@ -30,9 +30,13 @@ + * Adapted from https://github.com/freebsd/freebsd-src/search?q=__double_t + */ + ++#ifdef __LP64__ + typedef double __double_t; ++#else ++typedef long double __double_t; ++#endif + typedef __double_t double_t; +- ++typedef float __float_t; + /* + * The original fdlibm code used statements like: + * n0 = ((*(int*)&one)>>29)^1; * index of high word * +@@ -630,6 +634,53 @@ + return ((double)(x + 0x1.8p52) - 0x1.8p52); + } + ++static inline float ++rnintf(__float_t x) ++{ ++ /* ++ * As for rnint(), except we could just call that to handle the ++ * extra precision case, usually without losing efficiency. ++ */ ++ return ((float)(x + 0x1.8p23F) - 0x1.8p23F); ++} ++ ++#ifdef LDBL_MANT_DIG ++/* ++ * The complications for extra precision are smaller for rnintl() since it ++ * can safely assume that the rounding precision has been increased from ++ * its default to FP_PE on x86. We don't exploit that here to get small ++ * optimizations from limiting the rangle to double. We just need it for ++ * the magic number to work with long doubles. ld128 callers should use ++ * rnint() instead of this if possible. ld80 callers should prefer ++ * rnintl() since for amd64 this avoids swapping the register set, while ++ * for i386 it makes no difference (assuming FP_PE), and for other arches ++ * it makes little difference. ++ */ ++ ++static inline long double ++rnintl(long double x) ++{ ++ /* The WRAPPED__CONCAT() macro below is required for non-FreeBSD targets ++ which don't have a multi-level CONCAT macro implementation. On those ++ targets the hexadecimal floating-point values being created don't expand ++ properly resulting in code that cannot be compiled. ++ ++ The extra level provided by this macro should not affect FreeBSD, should ++ this code be used there. ++ ++ See the following for more details: ++ ++ https://gcc.gnu.org/onlinedocs/gcc-3.0.1/cpp_3.html#SEC32 ++ https://sources.debian.org/src/glibc/2.32-3/misc/sys/cdefs.h/ ++ https://github.com/freebsd/freebsd-src/blob/main/sys/sys/cdefs.h ++ */ ++ #define WRAPPED__CONCAT(x,y) __CONCAT(x,y) ++ ++ return (x + WRAPPED__CONCAT(0x1.8p, LDBL_MANT_DIG) / 2 - ++ WRAPPED__CONCAT(0x1.8p, LDBL_MANT_DIG) / 2); ++} ++#endif /* LDBL_MANT_DIG */ ++ + /* + * irint() and i64rint() give the same result as casting to their integer + * return type provided their arg is a floating point integer. They can +@@ -646,6 +697,39 @@ + #define irint(x) ((int)(x)) + #endif + ++#define i64rint(x) ((int64_t)(x)) /* only needed for ld128 so not opt. */ ++ ++#if defined(__i386__) && defined(__GNUCLIKE_ASM) ++static __inline int ++irintf(float x) ++{ ++ int n; ++ ++ __asm("fistl %0" : "=m" (n) : "t" (x)); ++ return (n); ++} ++ ++static __inline int ++irintd(double x) ++{ ++ int n; ++ ++ __asm("fistl %0" : "=m" (n) : "t" (x)); ++ return (n); ++} ++#endif ++ ++#if (defined(__amd64__) || defined(__i386__)) && defined(__GNUCLIKE_ASM) ++static __inline int ++irintl(long double x) ++{ ++ int n; ++ ++ __asm("fistl %0" : "=m" (n) : "t" (x)); ++ return (n); ++} ++#endif ++ + #ifdef DEBUG + #if defined(__amd64__) || defined(__i386__) + #define breakpoint() asm("int $3") |