Rebuild patch queue from patch-queue branch

Added patch:
debian-hacks/Fix-Floating-Point-Normalization-breakage-on-32bit-Linux.patch

debian/patches/debian-hacks/Fix-Floating-Point-Normalization-breakage-on-32bit-Linux.patch

+From: Carsten Schoenert <c.schoenert@t-online.de>
+Date: Sat, 23 Oct 2021 08:45:32 +0200
+Subject: Fix Floating-Point Normalization breakage on 32bit Linux
+
+This patch is picked from ther bug report about broken
+Floating-Point Normalization breaks build on 32bit Linux from the user
+acmodor https://bugzilla.mozilla.org/attachment.cgi?id=9247105&action=diff
+
+Author: Christoph Moench-Tegeder and acmodor
+Forwarded: https://bugzilla.mozilla.org/show_bug.cgi?id=1729459
+---
+ modules/fdlibm/src/math_private.h | 74 ++++++++++++++++++++++++++++++++++++++-
+ 1 file changed, 73 insertions(+), 1 deletion(-)
+
+diff --git a/modules/fdlibm/src/math_private.h b/modules/fdlibm/src/math_private.h
+index 51d79f9..ad4b083 100644
+--- a/modules/fdlibm/src/math_private.h
++++ b/modules/fdlibm/src/math_private.h
+@@ -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,41 @@ rnint(__double_t x)
+ 	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)
++{
++#if (LDBL_MANT_DIG == 64)
++	return (x + __CONCAT(0x1.8p, 64) / 2 -
++		__CONCAT(0x1.8p, 64) / 2);
++#else
++	return (x + __CONCAT(0x1.8p, LDBL_MANT_DIG) / 2 -
++		__CONCAT(0x1.8p, LDBL_MANT_DIG) / 2);
++#endif
++}
++#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 +685,39 @@ rnint(__double_t x)
+ #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")

debian/patches/series

@@ -27,3 +27,4 @@ porting-ppc64el/work-around-a-build-failure-with-clang-on-ppc64el.patch
 porting-armhf/Don-t-use-LLVM-internal-assembler-on-armhf.patch
 debian-hacks/Make-Thunderbird-build-reproducible.patch
 debian-hacks/Decrease-Cargo-minimal-version-to-1.46.0.patch
+debian-hacks/Fix-Floating-Point-Normalization-breakage-on-32bit-Linux.patch