--- libgcc/config/aarch64/t-softfp.jj	2023-08-08 15:54:35.737595343 +0200
+++ libgcc/config/aarch64/t-softfp	2023-08-08 16:12:02.346939560 +0200
@@ -3,7 +3,7 @@ softfp_int_modes := si di ti
 softfp_extensions := sftf dftf hftf bfsf
 softfp_truncations := tfsf tfdf tfhf tfbf dfbf sfbf hfbf
 softfp_exclude_libgcc2 := n
-softfp_extras := fixhfti fixunshfti floattihf floatuntihf \
+softfp_extras += fixhfti fixunshfti floattihf floatuntihf \
 		 floatdibf floatundibf floattibf floatuntibf
 
 TARGET_LIBGCC2_CFLAGS += -Wno-missing-prototypes
--- libgcc/config/i386/64/t-softfp.jj	2023-08-08 15:54:35.766594936 +0200
+++ libgcc/config/i386/64/t-softfp	2023-08-08 16:12:02.346939560 +0200
@@ -1,4 +1,4 @@
-softfp_extras := fixhfti fixunshfti floattihf floatuntihf \
+softfp_extras += fixhfti fixunshfti floattihf floatuntihf \
 		 floattibf floatuntibf
 
 CFLAGS-fixhfti.c += -msse2
--- libgcc/config/i386/libgcc-glibc.ver.jj	2023-08-08 15:54:35.831594026 +0200
+++ libgcc/config/i386/libgcc-glibc.ver	2023-08-08 16:12:02.347939546 +0200
@@ -226,3 +226,13 @@ GCC_13.0.0 {
   __truncxfbf2
   __trunchfbf2
 }
+
+%inherit GCC_14.0.0 GCC_13.0.0
+GCC_14.0.0 {
+  __PFX__fixxfbitint
+  __PFX__fixtfbitint
+  __PFX__floatbitintbf
+  __PFX__floatbitinthf
+  __PFX__floatbitintxf
+  __PFX__floatbitinttf
+}
--- libgcc/config/i386/t-softfp.jj	2023-08-08 15:55:09.819118062 +0200
+++ libgcc/config/i386/t-softfp	2023-08-08 16:12:02.347939546 +0200
@@ -10,7 +10,7 @@ softfp_extensions := hfsf hfdf hftf hfxf
 softfp_truncations := tfhf xfhf dfhf sfhf tfsf dfsf tfdf tfxf \
 		      tfbf xfbf dfbf sfbf hfbf
 
-softfp_extras += eqhf2
+softfp_extras += eqhf2 fixxfbitint $(foreach m,hf bf xf,floatbitint$(m))
 
 CFLAGS-extendhfsf2.c += -msse2
 CFLAGS-extendhfdf2.c += -msse2
@@ -28,6 +28,9 @@ CFLAGS-truncxfbf2.c += -msse2
 CFLAGS-trunctfbf2.c += -msse2
 CFLAGS-trunchfbf2.c += -msse2
 
+CFLAGS-floatbitintbf.c += -msse2
+CFLAGS-floatbitinthf.c += -msse2
+
 CFLAGS-eqhf2.c += -msse2
 CFLAGS-_divhc3.c += -msse2
 CFLAGS-_mulhc3.c += -msse2
--- libgcc/config/riscv/t-softfp32.jj	2023-08-08 15:54:35.920592780 +0200
+++ libgcc/config/riscv/t-softfp32	2023-08-08 16:12:02.347939546 +0200
@@ -13,7 +13,7 @@ softfp_extensions := sftf dftf
 softfp_truncations := tfsf tfdf
 
 # Enable divide routines to make -mno-fdiv work.
-softfp_extras := divsf3 divdf3
+softfp_extras += divsf3 divdf3
 
 else
 # !ABI_DOUBLE
@@ -28,7 +28,7 @@ else
 # ABI_SINGLE
 
 # Enable divide routines to make -mno-fdiv work.
-softfp_extras := divsf3
+softfp_extras += divsf3
 
 endif
 
@@ -38,7 +38,7 @@ else
 # ABI_QUAD
 
 # Enable divide routines to make -mno-fdiv work.
-softfp_extras := divsf3 divdf3 divtf3
+softfp_extras += divsf3 divdf3 divtf3
 
 endif
 
--- libgcc/config/rs6000/t-e500v1-fp.jj	2023-08-08 15:54:35.965592150 +0200
+++ libgcc/config/rs6000/t-e500v1-fp	2023-08-08 16:12:02.347939546 +0200
@@ -29,4 +29,4 @@ softfp_int_modes := si di
 softfp_extensions := sfdf
 softfp_truncations := dfsf
 softfp_exclude_libgcc2 := n
-softfp_extras := unordsf2
+softfp_extras += unordsf2
--- libgcc/config/rs6000/t-e500v2-fp.jj	2023-08-08 15:54:35.965592150 +0200
+++ libgcc/config/rs6000/t-e500v2-fp	2023-08-08 16:12:02.347939546 +0200
@@ -23,4 +23,4 @@ softfp_int_modes :=
 softfp_extensions :=
 softfp_truncations :=
 softfp_exclude_libgcc2 := n
-softfp_extras := unordsf2 unorddf2
+softfp_extras += unordsf2 unorddf2
--- libgcc/config/t-softfp.jj	2023-08-08 15:54:35.992591772 +0200
+++ libgcc/config/t-softfp	2023-08-08 16:22:09.404440148 +0200
@@ -64,12 +64,21 @@ softfp_float_funcs = add$(m)3 div$(m)3 e
   neg$(m)2 sub$(m)3 unord$(m)2
 softfp_floatint_funcs = fix$(m)$(i) fixuns$(m)$(i) \
   float$(i)$(m) floatun$(i)$(m)
+softfp_floatbitint_funcs = fix$(m)bitint floatbitint$(m)
+softfp_bid_list := 
+ifeq ($(decimal_float),yes)
+ifeq ($(enable_decimal_float),bid)
+softfp_bid_list += bitintpow10 \
+		   $(foreach m,sd dd td,fix$(m)bitint floatbitint$(m))
+endif
+endif
 
 softfp_func_list := \
   $(foreach m,$(softfp_float_modes), \
               $(softfp_float_funcs) \
               $(foreach i,$(softfp_int_modes), \
                           $(softfp_floatint_funcs))) \
+  $(foreach m,sf df,$(softfp_floatbitint_funcs)) \
   $(foreach e,$(softfp_extensions),extend$(e)2) \
   $(foreach t,$(softfp_truncations),trunc$(t)2) \
   $(softfp_extras)
@@ -116,6 +125,8 @@ softfp_file_list := \
   $(addsuffix .c,$(addprefix $(srcdir)/soft-fp/,$(softfp_func_list)))
 endif
 endif
+softfp_bid_file_list := \
+  $(addsuffix .c,$(addprefix $(srcdir)/soft-fp/,$(softfp_bid_list)))
 
 # Disable missing prototype and type limit warnings.  The prototypes
 # for the functions in the soft-fp files have not been brought across
@@ -129,6 +140,7 @@ soft-fp-objects = $(addsuffix $(objext),
 $(soft-fp-objects) : INTERNAL_CFLAGS += -Wno-missing-prototypes -Wno-type-limits
 
 LIB2ADD += $(softfp_file_list)
+LIB2ADD_ST += $(softfp_bid_file_list)
 
 ifneq ($(softfp_exclude_libgcc2),y)
 # Functions in libgcc2.c are excluded for each soft-float mode (a
--- libgcc/config/t-softfp-sfdftf.jj	2023-08-08 15:54:35.992591772 +0200
+++ libgcc/config/t-softfp-sfdftf	2023-08-08 16:12:02.347939546 +0200
@@ -2,4 +2,5 @@ softfp_float_modes := sf df tf
 softfp_int_modes := si di
 softfp_extensions := sfdf sftf dftf xftf
 softfp_truncations := dfsf tfsf tfdf tfxf
+softfp_extras += fixtfbitint floatbitinttf
 softfp_exclude_libgcc2 := n
--- libgcc/config/t-softfp-tf.jj	2023-08-08 15:54:36.011591506 +0200
+++ libgcc/config/t-softfp-tf	2023-08-08 16:12:02.347939546 +0200
@@ -2,4 +2,5 @@ softfp_float_modes := tf
 softfp_int_modes := si di ti
 softfp_extensions := sftf dftf xftf
 softfp_truncations := tfsf tfdf tfxf
+softfp_extras += fixtfbitint floatbitinttf
 softfp_exclude_libgcc2 := n
--- libgcc/libgcc2.c.jj	2023-08-08 15:54:36.059590834 +0200
+++ libgcc/libgcc2.c	2023-08-08 16:12:02.348939532 +0200
@@ -1301,6 +1301,687 @@ __udivdi3 (UDWtype n, UDWtype d)
 }
 #endif
 
+#if (defined(__BITINT_MAXWIDTH__) \
+     && (defined(L_mulbitint3) || defined(L_divmodbitint4)))
+/* _BitInt support.  */
+
+/* If *P is zero or sign extended (the latter only for PREC < 0) from
+   some narrower _BitInt value, reduce precision.  */
+
+static inline __attribute__((__always_inline__)) SItype
+bitint_reduce_prec (const UWtype **p, SItype prec)
+{
+  UWtype mslimb;
+  SItype i;
+  if (prec < 0)
+    {
+#if __LIBGCC_BITINT_ORDER__ == __ORDER_BIG_ENDIAN__
+      i = 0;
+#else
+      i = ((USItype) -1 - prec) / W_TYPE_SIZE;
+#endif
+      mslimb = (*p)[i];
+      if (mslimb & ((UWtype) 1 << (((USItype) -1 - prec) % W_TYPE_SIZE)))
+	{
+	  SItype n = ((USItype) -prec) % W_TYPE_SIZE;
+	  if (n)
+	    {
+	      mslimb |= ((UWtype) -1 << (((USItype) -1 - prec) % W_TYPE_SIZE));
+	      if (mslimb == (UWtype) -1)
+		{
+		  prec += n;
+		  if (prec >= -1)
+		    return -2;
+#if __LIBGCC_BITINT_ORDER__ == __ORDER_BIG_ENDIAN__
+		  ++p;
+#else
+		  --i;
+#endif
+		  mslimb = (*p)[i];
+		  n = 0;
+		}
+	    }
+	  while (mslimb == (UWtype) -1)
+	    {
+	      prec += W_TYPE_SIZE;
+	      if (prec >= -1)
+		return -2;
+#if __LIBGCC_BITINT_ORDER__ == __ORDER_BIG_ENDIAN__
+	      ++p;
+#else
+	      --i;
+#endif
+	      mslimb = (*p)[i];
+	    }
+	  if (n == 0)
+	    {
+	      if ((Wtype) mslimb >= 0)
+		{
+#if __LIBGCC_BITINT_ORDER__ == __ORDER_BIG_ENDIAN__
+		  --p;
+#endif
+		  return prec - 1;
+		}
+	    }
+	  return prec;
+	}
+      else
+	prec = -prec;
+    }
+  else
+    {
+#if __LIBGCC_BITINT_ORDER__ == __ORDER_BIG_ENDIAN__
+      i = 0;
+#else
+      i = ((USItype) prec - 1) / W_TYPE_SIZE;
+#endif
+      mslimb = (*p)[i];
+    }
+  SItype n = ((USItype) prec) % W_TYPE_SIZE;
+  if (n)
+    {
+      mslimb &= ((UWtype) 1 << (((USItype) prec) % W_TYPE_SIZE)) - 1;
+      if (mslimb == 0)
+	{
+	  prec -= n;
+	  if (prec == 0)
+	    return 1;
+#if __LIBGCC_BITINT_ORDER__ == __ORDER_BIG_ENDIAN__
+	  ++p;
+#else
+	  --i;
+#endif
+	  mslimb = (*p)[i];
+	}
+    }
+  while (mslimb == 0)
+    {
+      prec -= W_TYPE_SIZE;
+      if (prec == 0)
+	return 1;
+#if __LIBGCC_BITINT_ORDER__ == __ORDER_BIG_ENDIAN__
+      ++p;
+#else
+      --i;
+#endif
+      mslimb = (*p)[i];
+    }
+  return prec;
+}
+
+#if __LIBGCC_BITINT_ORDER__ == __ORDER_BIG_ENDIAN__
+# define BITINT_INC -1
+# define BITINT_END(be, le) (be)
+#else
+# define BITINT_INC 1
+# define BITINT_END(be, le) (le)
+#endif
+
+#ifdef L_mulbitint3
+/* D = S * L.  */
+
+static UWtype
+bitint_mul_1 (UWtype *d, const UWtype *s, UWtype l, SItype n)
+{
+  UWtype sv, hi, lo, c = 0;
+  do
+    {
+      sv = *s;
+      s += BITINT_INC;
+      umul_ppmm (hi, lo, sv, l);
+      c = __builtin_add_overflow (lo, c, &lo) + hi;
+      *d = lo;
+      d += BITINT_INC;
+    }
+  while (--n);
+  return c;
+}
+
+/* D += S * L.  */
+
+static UWtype
+bitint_addmul_1 (UWtype *d, const UWtype *s, UWtype l, SItype n)
+{
+  UWtype sv, hi, lo, c = 0;
+  do
+    {
+      sv = *s;
+      s += BITINT_INC;
+      umul_ppmm (hi, lo, sv, l);
+      hi += __builtin_add_overflow (lo, *d, &lo);
+      c = __builtin_add_overflow (lo, c, &lo) + hi;
+      *d = lo;
+      d += BITINT_INC;
+    }
+  while (--n);
+  return c;
+}
+
+/* If XPREC is positive, it is precision in bits
+   of an unsigned _BitInt operand (which has XPREC/W_TYPE_SIZE
+   full limbs and if Xprec%W_TYPE_SIZE one partial limb.
+   If Xprec is negative, -XPREC is precision in bits
+   of a signed _BitInt operand.  RETPREC should be always
+   positive.  */
+
+void
+__mulbitint3 (UWtype *ret, SItype retprec,
+	      const UWtype *u, SItype uprec,
+	      const UWtype *v, SItype vprec)
+{
+  uprec = bitint_reduce_prec (&u, uprec);
+  vprec = bitint_reduce_prec (&v, vprec);
+  USItype auprec = uprec < 0 ? -uprec : uprec;
+  USItype avprec = vprec < 0 ? -vprec : vprec;
+
+  /* Prefer non-negative U.
+     Otherwise make sure V doesn't have higher precision than U.  */
+  if ((uprec < 0 && vprec >= 0)
+      || (avprec > auprec && !(uprec >= 0 && vprec < 0)))
+    {
+      SItype p;
+      const UWtype *t;
+      p = uprec; uprec = vprec; vprec = p;
+      p = auprec; auprec = avprec; avprec = p;
+      t = u; u = v; v = t;
+    }
+
+  USItype un = auprec / W_TYPE_SIZE;
+  USItype un2 = (auprec + W_TYPE_SIZE - 1) / W_TYPE_SIZE;
+  USItype vn = avprec / W_TYPE_SIZE;
+  USItype vn2 = (avprec + W_TYPE_SIZE - 1) / W_TYPE_SIZE;
+  USItype retn = ((USItype) retprec + W_TYPE_SIZE - 1) / W_TYPE_SIZE;
+  USItype retidx, uidx, vidx;
+  UWtype vv;
+  /* Indexes of least significant limb.  */
+#if __LIBGCC_BITINT_ORDER__ == __ORDER_BIG_ENDIAN__
+  retidx = retn - 1;
+  uidx = un2 - 1;
+  vidx = vn2 - 1;
+#else
+  retidx = 0;
+  uidx = 0;
+  vidx = 0;
+#endif
+  if (__builtin_expect (auprec <= W_TYPE_SIZE, 0) && vprec < 0)
+    {
+      UWtype uu = u[uidx];
+      if (__builtin_expect (auprec < W_TYPE_SIZE, 0))
+	uu &= ((UWtype) 1 << (auprec % W_TYPE_SIZE)) - 1;
+      if (uu == 0)
+	{
+	  /* 0 * negative would be otherwise mishandled below, so
+	     handle it specially.  */
+	  __builtin_memset (ret, 0, retn * sizeof (UWtype));
+	  return;
+	}
+    }
+  vv = v[vidx];
+  if (__builtin_expect (avprec < W_TYPE_SIZE, 0))
+    {
+      if (vprec > 0)
+	vv &= ((UWtype) 1 << (avprec % W_TYPE_SIZE)) - 1;
+      else
+	vv |= (UWtype) -1 << (avprec % W_TYPE_SIZE);
+    }
+
+  USItype n = un > retn ? retn : un;
+  USItype n2 = n;
+  USItype retidx2 = retidx + n * BITINT_INC;
+  UWtype c = 0, uv = 0;
+  if (n)
+    c = bitint_mul_1 (ret + retidx, u + uidx, vv, n);
+  if (retn > un && un2 != un)
+    {
+      UWtype hi, lo;
+      uv = u[uidx + n * BITINT_INC];
+      if (uprec > 0)
+	uv &= ((UWtype) 1 << (auprec % W_TYPE_SIZE)) - 1;
+      else
+	uv |= (UWtype) -1 << (auprec % W_TYPE_SIZE);
+      umul_ppmm (hi, lo, uv, vv);
+      c = __builtin_add_overflow (lo, c, &lo) + hi;
+      ret[retidx2] = lo;
+      retidx2 += BITINT_INC;
+      ++n2;
+    }
+  if (retn > un2)
+    {
+      if (uprec < 0)
+	{
+	  while (n2 < retn)
+	    {
+	      if (n2 >= un2 + vn2)
+		break;
+	      UWtype hi, lo;
+	      umul_ppmm (hi, lo, (UWtype) -1, vv);
+	      c = __builtin_add_overflow (lo, c, &lo) + hi;
+	      ret[retidx2] = lo;
+	      retidx2 += BITINT_INC;
+	      ++n2;
+	    }
+	}
+      else
+	{
+	  ret[retidx2] = c;
+	  retidx2 += BITINT_INC;
+	  ++n2;
+	}
+      /* If RET has more limbs than U after precision reduction,
+	 fill in the remaining limbs.  */
+      while (n2 < retn)
+	{
+	  if (n2 < un2 + vn2 || (uprec ^ vprec) >= 0)
+	    c = 0;
+	  else
+	    c = (UWtype) -1;
+	  ret[retidx2] = c;
+	  retidx2 += BITINT_INC;
+	  ++n2;
+	}
+    }
+  /* N is now number of possibly non-zero limbs in RET (ignoring
+     limbs above UN2 + VN2 which if any have been finalized already).  */
+  USItype end = vprec < 0 ? un2 + vn2 : vn2;
+  if (retn > un2 + vn2) retn = un2 + vn2;
+  if (end > retn) end = retn;
+  for (USItype m = 1; m < end; ++m)
+    {
+      retidx += BITINT_INC;
+      vidx += BITINT_INC;
+      if (m < vn2)
+	{
+	  vv = v[vidx];
+	  if (__builtin_expect (m == vn, 0))
+	    {
+	      if (vprec > 0)
+		vv &= ((UWtype) 1 << (avprec % W_TYPE_SIZE)) - 1;
+	      else
+		vv |= (UWtype) -1 << (avprec % W_TYPE_SIZE);
+	    }
+	}
+      else
+	vv = (UWtype) -1;
+      if (m + n > retn)
+	n = retn - m;
+      c = 0;
+      if (n)
+	c = bitint_addmul_1 (ret + retidx, u + uidx, vv, n);
+      n2 = m + n;
+      retidx2 = retidx + n * BITINT_INC;
+      if (n2 < retn && un2 != un)
+	{
+	  UWtype hi, lo;
+	  umul_ppmm (hi, lo, uv, vv);
+	  hi += __builtin_add_overflow (lo, ret[retidx2], &lo);
+	  c = __builtin_add_overflow (lo, c, &lo) + hi;
+	  ret[retidx2] = lo;
+	  retidx2 += BITINT_INC;
+	  ++n2;
+	}
+      if (uprec < 0)
+	while (n2 < retn)
+	  {
+	    UWtype hi, lo;
+	    umul_ppmm (hi, lo, (UWtype) -1, vv);
+	    hi += __builtin_add_overflow (lo, ret[retidx2], &lo);
+	    c = __builtin_add_overflow (lo, c, &lo) + hi;
+	    ret[retidx2] = lo;
+	    retidx2 += BITINT_INC;
+	    ++n2;
+	  }
+      else if (n2 < retn)
+	{
+	  ret[retidx2] = c;
+	  retidx2 += BITINT_INC;
+	}
+    }
+}
+#endif
+
+#ifdef L_divmodbitint4
+static void
+bitint_negate (UWtype *d, const UWtype *s, SItype n)
+{
+  UWtype c = 1;
+  do
+    {
+      UWtype sv = *s, lo;
+      s += BITINT_INC;
+      c = __builtin_add_overflow (~sv, c, &lo);
+      *d = lo;
+      d += BITINT_INC;
+    }
+  while (--n);
+}
+
+/* D -= S * L.  */
+
+static UWtype
+bitint_submul_1 (UWtype *d, const UWtype *s, UWtype l, SItype n)
+{
+  UWtype sv, hi, lo, c = 0;
+  do
+    {
+      sv = *s;
+      s += BITINT_INC;
+      umul_ppmm (hi, lo, sv, l);
+      hi += __builtin_sub_overflow (*d, lo, &lo);
+      c = __builtin_sub_overflow (lo, c, &lo) + hi;
+      *d = lo;
+      d += BITINT_INC;
+    }
+  while (--n);
+  return c;
+}
+
+/* If XPREC is positive, it is precision in bits
+   of an unsigned _BitInt operand (which has XPREC/W_TYPE_SIZE
+   full limbs and if Xprec%W_TYPE_SIZE one partial limb.
+   If Xprec is negative, -XPREC is precision in bits
+   of a signed _BitInt operand.  QPREC and RPREC should be
+   always non-negative.  If either Q or R is NULL (at least
+   one should be non-NULL), then corresponding QPREC or RPREC
+   should be 0.  */
+
+void
+__divmodbitint4 (UWtype *q, SItype qprec,
+		 UWtype *r, SItype rprec,
+		 const UWtype *u, SItype uprec,
+		 const UWtype *v, SItype vprec)
+{
+  uprec = bitint_reduce_prec (&u, uprec);
+  vprec = bitint_reduce_prec (&v, vprec);
+  USItype auprec = uprec < 0 ? -uprec : uprec;
+  USItype avprec = vprec < 0 ? -vprec : vprec;
+  USItype un = (auprec + W_TYPE_SIZE - 1) / W_TYPE_SIZE;
+  USItype vn = (avprec + W_TYPE_SIZE - 1) / W_TYPE_SIZE;
+  USItype qn = ((USItype) qprec + W_TYPE_SIZE - 1) / W_TYPE_SIZE;
+  USItype rn = ((USItype) rprec + W_TYPE_SIZE - 1) / W_TYPE_SIZE;
+  USItype up = auprec % W_TYPE_SIZE;
+  USItype vp = avprec % W_TYPE_SIZE;
+  if (__builtin_expect (un < vn, 0))
+    {
+      /* If abs(v) > abs(u), then q is 0 and r is u.  */
+      if (q)
+	__builtin_memset (q, 0, qn * sizeof (UWtype));
+      if (r == NULL)
+	return;
+#if __LIBGCC_BITINT_ORDER__ == __ORDER_BIG_ENDIAN__
+      r += rn - 1;
+      u += un - 1;
+#endif
+      if (up)
+	--un;
+      if (rn < un)
+	un = rn;
+      for (rn -= un; un; --un)
+	{
+	  *r = *u;
+	  r += BITINT_INC;
+	  u += BITINT_INC;
+	}
+      if (!rn)
+	return;
+      if (up)
+	{
+	  if (uprec > 0)
+	    *r = *u & (((UWtype) 1 << up) - 1);
+	  else
+	    *r = *u | ((UWtype) -1 << up);
+	  r += BITINT_INC;
+	  if (!--rn)
+	    return;
+	}
+      UWtype c = uprec < 0 ? (UWtype) -1 : (UWtype) 0;
+      for (; rn; --rn)
+	{
+	  *r = c;
+	  r += BITINT_INC;
+	}
+      return;
+    }
+  USItype qn2 = un - vn + 1;
+  if (qn >= qn2)
+    qn2 = 0;
+  USItype sz = un + 1 + vn + qn2;
+  UWtype *buf = __builtin_alloca (sz * sizeof (UWtype));
+  USItype uidx, vidx;
+#if __LIBGCC_BITINT_ORDER__ == __ORDER_BIG_ENDIAN__
+  uidx = un - 1;
+  vidx = vn - 1;
+#else
+  uidx = 0;
+  vidx = 0;
+#endif
+  if (uprec < 0)
+    bitint_negate (buf + BITINT_END (uidx + 1, 0), u + uidx, un);
+  else
+    __builtin_memcpy (buf + BITINT_END (1, 0), u, un * sizeof (UWtype));
+  if (up)
+    buf[BITINT_END (1, un - 1)] &= (((UWtype) 1 << up) - 1);
+  if (vprec < 0)
+    bitint_negate (buf + un + 1 + vidx, v + vidx, vn);
+  else
+    __builtin_memcpy (buf + un + 1, v, vn * sizeof (UWtype));
+  if (vp)
+    buf[un + 1 + BITINT_END (0, vn - 1)] &= (((UWtype) 1 << vp) - 1);
+  UWtype *u2 = buf;
+  UWtype *v2 = u2 + un + 1;
+  UWtype *q2 = v2 + vn;
+  if (!qn2)
+    q2 = q + BITINT_END (qn - (un - vn + 1), 0);
+
+  /* Knuth's algorithm.  See also ../gcc/wide-int.cc (divmod_internal_2).  */
+
+#ifndef UDIV_NEEDS_NORMALIZATION
+  /* Handle single limb divisor first.  */
+  if (vn == 1)
+    {
+      UWtype vv = v2[0];
+      if (vv == 0)
+	vv = 1 / vv; /* Divide intentionally by zero.  */
+      UWtype k = 0;
+#if __LIBGCC_BITINT_ORDER__ == __ORDER_BIG_ENDIAN__
+      for (SItype i = 0; i <= un - 1; ++i)
+#else
+      for (SItype i = un - 1; i >= 0; --i)
+#endif
+	udiv_qrnnd (q2[i], k, k, u2[BITINT_END (i + 1, i)], vv);
+      if (r != NULL)
+	r[BITINT_END (rn - 1, 0)] = k;
+    }
+  else
+#endif
+    {
+      SItype s;
+#ifdef UDIV_NEEDS_NORMALIZATION
+      if (vn == 1 && v2[0] == 0)
+	s = 0;
+      else
+#endif
+      if (sizeof (0U) == sizeof (UWtype))
+	s = __builtin_clz (v2[BITINT_END (0, vn - 1)]);
+      else if (sizeof (0UL) == sizeof (UWtype))
+	s = __builtin_clzl (v2[BITINT_END (0, vn - 1)]);
+      else
+	s = __builtin_clzll (v2[BITINT_END (0, vn - 1)]);
+      if (s)
+	{
+	  /* Normalize by shifting v2 left so that it has msb set.  */
+	  const SItype n = sizeof (UWtype) * __CHAR_BIT__;
+#if __LIBGCC_BITINT_ORDER__ == __ORDER_BIG_ENDIAN__
+	  for (SItype i = 0; i < vn - 1; ++i)
+#else
+	  for (SItype i = vn - 1; i > 0; --i)
+#endif
+	    v2[i] = (v2[i] << s) | (v2[i - BITINT_INC] >> (n - s));
+	  v2[vidx] = v2[vidx] << s;
+	  /* And shift u2 left by the same amount.  */
+	  u2[BITINT_END (0, un)] = u2[BITINT_END (1, un - 1)] >> (n - s);
+#if __LIBGCC_BITINT_ORDER__ == __ORDER_BIG_ENDIAN__
+	  for (SItype i = 1; i < un; ++i)
+#else
+	  for (SItype i = un - 1; i > 0; --i)
+#endif
+	    u2[i] = (u2[i] << s) | (u2[i - BITINT_INC] >> (n - s));
+	  u2[BITINT_END (un, 0)] = u2[BITINT_END (un, 0)] << s;
+	}
+      else
+	u2[BITINT_END (0, un)] = 0;
+#ifdef UDIV_NEEDS_NORMALIZATION
+      /* Handle single limb divisor first.  */
+      if (vn == 1)
+	{
+	  UWtype vv = v2[0];
+	  if (vv == 0)
+	    vv = 1 / vv; /* Divide intentionally by zero.  */
+	  UWtype k = u2[BITINT_END (0, un)];
+#if __LIBGCC_BITINT_ORDER__ == __ORDER_BIG_ENDIAN__
+	  for (SItype i = 0; i <= un - 1; ++i)
+#else
+	  for (SItype i = un - 1; i >= 0; --i)
+#endif
+	    udiv_qrnnd (q2[i], k, k, u2[BITINT_END (i + 1, i)], vv);
+	  if (r != NULL)
+	    r[BITINT_END (rn - 1, 0)] = k >> s;
+	}
+      else
+#endif
+	{
+	  UWtype vv1 = v2[BITINT_END (0, vn - 1)];
+	  UWtype vv0 = v2[BITINT_END (1, vn - 2)];
+	  /* Main loop.  */
+	  for (SItype j = un - vn; j >= 0; --j)
+	    {
+	      /* Compute estimate in qhat.  */
+	      UWtype uv1 = u2[BITINT_END (un - j - vn, j + vn)];
+	      UWtype uv0 = u2[BITINT_END (un - j - vn + 1, j + vn - 1)];
+	      UWtype qhat, rhat, hi, lo, c;
+	      if (uv1 >= vv1)
+		{
+		  /* udiv_qrnnd doesn't support quotients which don't
+		     fit into UWtype, so subtract from uv1:uv0 vv1
+		     first.  */
+		  uv1 -= vv1 + __builtin_sub_overflow (uv0, vv1, &uv0);
+		  udiv_qrnnd (qhat, rhat, uv1, uv0, vv1);
+		  if (!__builtin_add_overflow (rhat, vv1, &rhat))
+		    goto again;
+		}
+	      else
+		{
+		  udiv_qrnnd (qhat, rhat, uv1, uv0, vv1);
+		again:
+		  umul_ppmm (hi, lo, qhat, vv0);
+		  if (hi > rhat
+		      || (hi == rhat
+			  && lo > u2[BITINT_END (un - j - vn + 2,
+						 j + vn - 2)]))
+		    {
+		      --qhat;
+		      if (!__builtin_add_overflow (rhat, vv1, &rhat))
+			goto again;
+		    }
+		}
+
+	      c = bitint_submul_1 (u2 + BITINT_END (un - j, j),
+				   v2 + BITINT_END (vn - 1, 0), qhat, vn);
+	      u2[BITINT_END (un - j - vn, j + vn)] -= c;
+	      /* If we've subtracted too much, decrease qhat and
+		 and add back.  */
+	      if ((Wtype) u2[BITINT_END (un - j - vn, j + vn)] < 0)
+		{
+		  --qhat;
+		  c = 0;
+		  for (USItype i = 0; i < vn; ++i)
+		    {
+		      UWtype s = v2[BITINT_END (vn - 1 - i, i)];
+		      UWtype d = u2[BITINT_END (un - i - j, i + j)];
+		      UWtype c1 = __builtin_add_overflow (d, s, &d);
+		      UWtype c2 = __builtin_add_overflow (d, c, &d);
+		      c = c1 + c2;
+		      u2[BITINT_END (un - i - j, i + j)] = d;
+		    }
+		  u2[BITINT_END (un - j - vn, j + vn)] += c;
+		}
+	      q2[BITINT_END (un - vn - j, j)] = qhat;
+	    }
+	  if (r != NULL)
+	    {
+	      if (s)
+		{
+		  const SItype n = sizeof (UWtype) * __CHAR_BIT__;
+		  /* Unnormalize remainder.  */
+		  USItype i;
+		  for (i = 0; i < vn && i < rn; ++i)
+		    r[BITINT_END (rn - 1 - i, i)]
+		      = ((u2[BITINT_END (un - i, i)] >> s)
+			 | (u2[BITINT_END (un - i - 1, i + 1)] << (n - s)));
+		  if (i < rn)
+		    r[BITINT_END (rn - vn, vn - 1)]
+		      = u2[BITINT_END (un - vn + 1, vn - 1)] >> s;
+		}
+	      else if (rn > vn)
+		__builtin_memcpy (&r[BITINT_END (rn - vn, 0)],
+				  &u2[BITINT_END (un + 1 - vn, 0)],
+				  vn * sizeof (UWtype));
+	      else
+		__builtin_memcpy (&r[0], &u2[BITINT_END (un + 1 - rn, 0)],
+				  rn * sizeof (UWtype));
+	    }
+	}
+    }
+  if (q != NULL)
+    {
+      if ((uprec < 0) ^ (vprec < 0))
+	{
+	  /* Negative quotient.  */
+	  USItype n;
+	  if (un - vn + 1 > qn)
+	    n = qn;
+	  else
+	    n = un - vn + 1;
+	  bitint_negate (q + BITINT_END (qn - 1, 0),
+			 q2 + BITINT_END (un - vn, 0), n);
+	  if (qn > n)
+	    __builtin_memset (q + BITINT_END (0, n), -1,
+			      (qn - n) * sizeof (UWtype));
+	}
+      else
+	{
+	  /* Positive quotient.  */
+	  if (qn2)
+	    __builtin_memcpy (q, q2 + BITINT_END (un - vn + 1 - qn, 0),
+			      qn * sizeof (UWtype));
+	  else if (qn > un - vn + 1)
+	    __builtin_memset (q + BITINT_END (0, un - vn + 1), 0,
+			      (qn - (un - vn + 1)) * sizeof (UWtype));
+	}
+    }
+  if (r != NULL)
+    {
+      if (uprec < 0)
+	{
+	  /* Negative remainder.  */
+	  bitint_negate (r + BITINT_END (rn - 1, 0),
+			 r + BITINT_END (rn - 1, 0),
+			 rn > vn ? vn : rn);
+	  if (rn > vn)
+	    __builtin_memset (r + BITINT_END (0, vn), -1,
+			      (rn - vn) * sizeof (UWtype));
+	}
+      else
+	{
+	  /* Positive remainder.  */
+	  if (rn > vn)
+	    __builtin_memset (r + BITINT_END (0, vn), 0,
+			      (rn - vn) * sizeof (UWtype));
+	}
+    }
+}
+#endif
+#endif
+
 #ifdef L_cmpdi2
 cmp_return_type
 __cmpdi2 (DWtype a, DWtype b)
--- libgcc/libgcc2.h.jj	2023-08-08 15:54:36.075590609 +0200
+++ libgcc/libgcc2.h	2023-08-08 16:12:02.348939532 +0200
@@ -181,6 +181,12 @@ typedef int shift_count_type __attribute
 #define float bogus_type
 #define double bogus_type
 
+#if (defined(__BITINT_MAXWIDTH__) \
+     && (defined(L_mulbitint3) || defined(L_divmodbitint4)))
+#undef LIBGCC2_UNITS_PER_WORD
+#define LIBGCC2_UNITS_PER_WORD (__LIBGCC_BITINT_LIMB_WIDTH__ / __CHAR_BIT__)
+#endif
+
 /* Versions prior to 3.4.4 were not taking into account the word size for
    the 5 trapping arithmetic functions absv, addv, subv, mulv and negv.  As
    a consequence, the si and di variants were always and the only ones emitted.
@@ -390,6 +396,15 @@ extern DWtype __divmoddi4 (DWtype, DWtyp
 extern UDWtype __udivmoddi4 (UDWtype, UDWtype, UDWtype *);
 #endif
 
+#if (defined(__BITINT_MAXWIDTH__) \
+     && (defined(L_mulbitint3) || defined(L_divmodbitint4)))
+/* _BitInt support.  */
+extern void __mulbitint3 (UWtype *, SItype, const UWtype *, SItype,
+			  const UWtype *, SItype);
+extern void __divmodbitint4 (UWtype *, SItype, UWtype *, SItype,
+			     const UWtype *, SItype, const UWtype *, SItype);
+#endif
+
 /* __negdi2 is static inline when building other libgcc2 portions.  */
 #if !defined(L_divdi3) && !defined(L_moddi3)
 extern DWtype __negdi2 (DWtype);
--- libgcc/libgcc-std.ver.in.jj	2023-08-08 15:54:36.029591253 +0200
+++ libgcc/libgcc-std.ver.in	2023-08-08 16:12:02.348939532 +0200
@@ -1944,3 +1944,13 @@ GCC_7.0.0 {
   __PFX__divmoddi4
   __PFX__divmodti4
 }
+
+%inherit GCC_14.0.0 GCC_7.0.0
+GCC_14.0.0 {
+  __PFX__mulbitint3
+  __PFX__divmodbitint4
+  __PFX__fixsfbitint
+  __PFX__fixdfbitint
+  __PFX__floatbitintsf
+  __PFX__floatbitintdf
+}
--- libgcc/Makefile.in.jj	2023-08-08 15:54:35.711595707 +0200
+++ libgcc/Makefile.in	2023-08-08 16:12:02.348939532 +0200
@@ -446,7 +446,7 @@ lib2funcs = _muldi3 _negdi2 _lshrdi3 _as
 	    _paritysi2 _paritydi2 _powisf2 _powidf2 _powixf2 _powitf2	   \
 	    _mulhc3 _mulsc3 _muldc3 _mulxc3 _multc3 _divhc3 _divsc3	   \
 	    _divdc3 _divxc3 _divtc3 _bswapsi2 _bswapdi2 _clrsbsi2	   \
-	    _clrsbdi2
+	    _clrsbdi2 _mulbitint3
 
 # The floating-point conversion routines that involve a single-word integer.
 # XX stands for the integer mode.
@@ -466,7 +466,8 @@ endif
 # These might cause a divide overflow trap and so are compiled with
 # unwinder info.
 LIB2_DIVMOD_FUNCS = _divdi3 _moddi3 _divmoddi4 \
-		    _udivdi3 _umoddi3 _udivmoddi4 _udiv_w_sdiv
+		    _udivdi3 _umoddi3 _udivmoddi4 _udiv_w_sdiv \
+		    _divmodbitint4
 
 # Remove any objects from lib2funcs and LIB2_DIVMOD_FUNCS that are
 # defined as optimized assembly code in LIB1ASMFUNCS or as C code
--- libgcc/soft-fp/bitint.h.jj	2023-08-08 16:12:02.348939532 +0200
+++ libgcc/soft-fp/bitint.h	2023-08-08 16:21:45.953768373 +0200
@@ -0,0 +1,329 @@
+/* Software floating-point emulation.
+   Definitions for _BitInt implementation details.
+
+   Copyright (C) 2023 Free Software Foundation, Inc.
+
+This file is part of GCC.
+
+GCC is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free
+Software Foundation; either version 3, or (at your option) any later
+version.
+
+GCC 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 General Public License
+for more details.
+
+Under Section 7 of GPL version 3, you are granted additional
+permissions described in the GCC Runtime Library Exception, version
+3.1, as published by the Free Software Foundation.
+
+You should have received a copy of the GNU General Public License and
+a copy of the GCC Runtime Library Exception along with this program;
+see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+<http://www.gnu.org/licenses/>.  */
+
+#ifndef GCC_SOFT_FP_BITINT_H
+#define GCC_SOFT_FP_BITINT_H
+
+#ifdef __BITINT_MAXWIDTH__
+#define BIL_UNITS_PER_WORD (__LIBGCC_BITINT_LIMB_WIDTH__ / __CHAR_BIT__)
+
+#if BIL_UNITS_PER_WORD == 8
+#define BIL_TYPE_SIZE (8 * __CHAR_BIT__)
+#define BILtype		DItype
+#define UBILtype	UDItype
+#elif BIL_UNITS_PER_WORD == 4
+#define BIL_TYPE_SIZE (4 * __CHAR_BIT__)
+#define BILtype		SItype
+#define UBILtype	USItype
+#elif BIL_UNITS_PER_WORD == 2
+#define BIL_TYPE_SIZE (2 * __CHAR_BIT__)
+#define BILtype		HItype
+#define UBILtype	UHItype
+#else
+#define BIL_TYPE_SIZE __CHAR_BIT__
+#define BILtype		QItype
+#define UBILtype	UQItype
+#endif
+
+/* If *P is zero or sign extended (the latter only for PREC < 0) from
+   some narrower _BitInt value, reduce precision.  */
+
+static inline __attribute__((__always_inline__)) SItype
+bitint_reduce_prec (const UBILtype **p, SItype prec)
+{
+  UBILtype mslimb;
+  SItype i;
+  if (prec < 0)
+    {
+#if __LIBGCC_BITINT_ORDER__ == __ORDER_BIG_ENDIAN__
+      i = 0;
+#else
+      i = ((USItype) -1 - prec) / BIL_TYPE_SIZE;
+#endif
+      mslimb = (*p)[i];
+      if (mslimb & ((UBILtype) 1 << (((USItype) -1 - prec) % BIL_TYPE_SIZE)))
+	{
+	  SItype n = ((USItype) -prec) % BIL_TYPE_SIZE;
+	  if (n)
+	    {
+	      mslimb |= ((UBILtype) -1 << (((USItype) -1 - prec) % BIL_TYPE_SIZE));
+	      if (mslimb == (UBILtype) -1)
+		{
+		  prec += n;
+		  if (prec >= -1)
+		    return -2;
+#if __LIBGCC_BITINT_ORDER__ == __ORDER_BIG_ENDIAN__
+		  ++p;
+#else
+		  --i;
+#endif
+		  mslimb = (*p)[i];
+		  n = 0;
+		}
+	    }
+	  while (mslimb == (UBILtype) -1)
+	    {
+	      prec += BIL_TYPE_SIZE;
+	      if (prec >= -1)
+		return -2;
+#if __LIBGCC_BITINT_ORDER__ == __ORDER_BIG_ENDIAN__
+	      ++p;
+#else
+	      --i;
+#endif
+	      mslimb = (*p)[i];
+	    }
+	  if (n == 0)
+	    {
+	      if ((BILtype) mslimb >= 0)
+		{
+#if __LIBGCC_BITINT_ORDER__ == __ORDER_BIG_ENDIAN__
+		  --p;
+#endif
+		  return prec - 1;
+		}
+	    }
+	  return prec;
+	}
+      else
+	prec = -prec;
+    }
+  else
+    {
+#if __LIBGCC_BITINT_ORDER__ == __ORDER_BIG_ENDIAN__
+      i = 0;
+#else
+      i = ((USItype) prec - 1) / BIL_TYPE_SIZE;
+#endif
+      mslimb = (*p)[i];
+    }
+  SItype n = ((USItype) prec) % BIL_TYPE_SIZE;
+  if (n)
+    {
+      mslimb &= ((UBILtype) 1 << (((USItype) prec) % BIL_TYPE_SIZE)) - 1;
+      if (mslimb == 0)
+	{
+	  prec -= n;
+	  if (prec == 0)
+	    return 1;
+#if __LIBGCC_BITINT_ORDER__ == __ORDER_BIG_ENDIAN__
+	  ++p;
+#else
+	  --i;
+#endif
+	  mslimb = (*p)[i];
+	}
+    }
+  while (mslimb == 0)
+    {
+      prec -= BIL_TYPE_SIZE;
+      if (prec == 0)
+	return 1;
+#if __LIBGCC_BITINT_ORDER__ == __ORDER_BIG_ENDIAN__
+      ++p;
+#else
+      --i;
+#endif
+      mslimb = (*p)[i];
+    }
+  return prec;
+}
+
+#if __LIBGCC_BITINT_ORDER__ == __ORDER_BIG_ENDIAN__
+# define BITINT_INC -1
+# define BITINT_END(be, le) (be)
+#else
+# define BITINT_INC 1
+# define BITINT_END(be, le) (le)
+#endif
+
+static inline __attribute__((__always_inline__)) void
+bitint_negate (UBILtype *d, const UBILtype *s, SItype n)
+{
+  UBILtype c = 1;
+  do
+    {
+      UBILtype sv = *s, lo;
+      s += BITINT_INC;
+      c = __builtin_add_overflow (~sv, c, &lo);
+      *d = lo;
+      d += BITINT_INC;
+    }
+  while (--n);
+}
+
+#define FP_TO_BITINT(r, rn, arprec, shift, rv, rsize, rsigned, ovf, DI) \
+  if (ovf)								\
+    {									\
+      if ((rv & 1) != 0)						\
+	__builtin_memset (r, -1, rn * sizeof (UBILtype));		\
+      else								\
+	__builtin_memset (r, 0, rn * sizeof (UBILtype));		\
+      if (rv & (((U##DI##type) 1) << (rsize - 1)))			\
+	r[BITINT_END (0, rn - 1)]					\
+	  |= (UBILtype) -1 << ((arprec - 1) % BIL_TYPE_SIZE);		\
+      else								\
+	r[BITINT_END (0, rn - 1)]					\
+	  &= ~((UBILtype) -1 << ((arprec - 1) % BIL_TYPE_SIZE));	\
+    }									\
+  else									\
+    {									\
+      USItype shiftl = shift / BIL_TYPE_SIZE;				\
+      rsize = DI##_BITS;						\
+      if (rsigned && (DI##type) rv >= 0)				\
+	rsigned = 0;							\
+      if (shift + DI##_BITS > arprec)					\
+	rsize = arprec - shift;						\
+      USItype shiftr = shift % BIL_TYPE_SIZE;				\
+      if (shiftl)							\
+	__builtin_memset (r + BITINT_END (rn - shiftl, 0), 0,		\
+			  shiftl * sizeof (UBILtype));			\
+      USItype idx = BITINT_END (rn - shiftl - 1, shiftl);		\
+      DI##type rvs = rv;						\
+      if (shiftr)							\
+	{								\
+	  r[idx] = (rsigned ? (UBILtype) rvs : (UBILtype) rv) << shiftr;\
+	  idx += BITINT_INC;						\
+	  if (rsize > BIL_TYPE_SIZE - shiftr)				\
+	    {								\
+	      rv >>= BIL_TYPE_SIZE - shiftr;				\
+	      rvs >>= BIL_TYPE_SIZE - shiftr;				\
+	      rsize -= BIL_TYPE_SIZE - shiftr;				\
+	    }								\
+	  else								\
+	    rsize = 0;							\
+	}								\
+      while (rsize)							\
+	{								\
+	  r[idx] = rsigned ? (UBILtype) rvs : (UBILtype) rv;		\
+	  idx += BITINT_INC;						\
+	  if (rsize <= BIL_TYPE_SIZE)					\
+	    break;							\
+	  rv >>= (DI##_BITS > BIL_TYPE_SIZE ? BIL_TYPE_SIZE : 0);	\
+	  rvs >>= (DI##_BITS > BIL_TYPE_SIZE ? BIL_TYPE_SIZE : 0);	\
+	  rsize -= BIL_TYPE_SIZE;					\
+	}								\
+      if (idx < rn)							\
+	__builtin_memset (r + BITINT_END (0, idx), rsigned ? -1 : 0,	\
+			  BITINT_END (idx + 1, rn - idx)		\
+			  * sizeof (UBILtype));				\
+    }
+
+#define FP_FROM_BITINT(i, iprec, iv, shift, DI)				\
+  do									\
+    {									\
+      iprec = bitint_reduce_prec (&i, iprec);				\
+      USItype aiprec = iprec < 0 ? -iprec : iprec;			\
+      USItype in = (aiprec + BIL_TYPE_SIZE - 1) / BIL_TYPE_SIZE;	\
+      USItype idx = BITINT_END (0, in - 1);				\
+      UBILtype msb = i[idx];						\
+      SItype n = 0;							\
+      if (aiprec % BIL_TYPE_SIZE)					\
+	{								\
+	  if (iprec > 0)						\
+	    msb &= ((UBILtype) 1 << (aiprec % BIL_TYPE_SIZE)) - 1;	\
+	  else								\
+	    msb |= (UBILtype) -1 << (aiprec % BIL_TYPE_SIZE);		\
+	}								\
+      if (iprec < 0)							\
+	{								\
+	  n = sizeof (0ULL) * __CHAR_BIT__ + 1 - __builtin_clzll (~msb);\
+	  if (BIL_TYPE_SIZE > DI##_BITS && n > DI##_BITS)		\
+	    {								\
+	      iv = msb >> (n - DI##_BITS);				\
+	      shift = n - DI##_BITS;					\
+	      n = 0;							\
+	    }								\
+	  else								\
+	    {								\
+	      iv = (BILtype) msb;					\
+	      n = DI##_BITS - n;					\
+	    }								\
+	}								\
+      /* bitint_reduce_prec guarantees that if msb is 0, then whole	\
+	 i must be zero, otherwise it would have reduced the		\
+	 precision.  */							\
+      else if (msb == 0)						\
+	iv = 0;								\
+      else								\
+	{								\
+	  n = sizeof (0ULL) * __CHAR_BIT__ - __builtin_clzll (msb);	\
+	  if (BIL_TYPE_SIZE >= DI##_BITS && n >= DI##_BITS)		\
+	    {								\
+	      iv = msb >> (n - DI##_BITS + 1);				\
+	      shift = n - DI##_BITS + 1;				\
+	      n = 0;							\
+	    }								\
+	  else								\
+	    {								\
+	      iv = msb;							\
+	      n = DI##_BITS - 1 - n;					\
+	    }								\
+	}								\
+      while (n && BITINT_END (idx < in - 1, idx))			\
+	{								\
+	  idx -= BITINT_INC;						\
+	  msb = i[idx];							\
+	  if (BIL_TYPE_SIZE < DI##_BITS && n >= BIL_TYPE_SIZE)		\
+	    {								\
+	      iv = (U##DI##type) iv << (BIL_TYPE_SIZE < DI##_BITS	\
+					? BIL_TYPE_SIZE : 0);		\
+	      iv |= msb;						\
+	      n -= BIL_TYPE_SIZE;					\
+	    }								\
+	  else								\
+	    {								\
+	      iv = (U##DI##type) iv << n;				\
+	      iv |= msb >> (BIL_TYPE_SIZE - n);				\
+	      shift = BIL_TYPE_SIZE - n;				\
+	      break;							\
+	    }								\
+	}								\
+									\
+      UBILtype low_bits = 0;						\
+      if (shift)							\
+	low_bits = msb & (((UBILtype) 1 << shift) - 1);			\
+      shift += BITINT_END (in - 1 - idx, idx) * BIL_TYPE_SIZE;		\
+      while (!low_bits && BITINT_END (idx < in - 1, idx))		\
+	{								\
+	  idx -= BITINT_INC;						\
+	  low_bits |= i[idx];						\
+	}								\
+      iv |= (low_bits != 0);						\
+    }									\
+  while (0)
+
+extern void __mulbitint3 (UBILtype *, SItype, const UBILtype *, SItype,
+			  const UBILtype *, SItype);
+extern void __divmodbitint4 (UBILtype *, SItype, UBILtype *, SItype,
+			     const UBILtype *, SItype,
+			     const UBILtype *, SItype);
+
+extern USItype __bid_pow10bitint (UBILtype *, SItype, USItype);
+
+#endif /* __BITINT_MAXWIDTH__ */
+
+#endif /* GCC_SOFT_FP_BITINT_H */
--- libgcc/soft-fp/fixdfbitint.c.jj	2023-08-08 16:12:02.348939532 +0200
+++ libgcc/soft-fp/fixdfbitint.c	2023-08-08 16:12:02.348939532 +0200
@@ -0,0 +1,71 @@
+/* Software floating-point emulation.
+   Convert IEEE double to signed or unsigned _BitInt.
+
+   Copyright (C) 2023 Free Software Foundation, Inc.
+
+This file is part of GCC.
+
+GCC is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free
+Software Foundation; either version 3, or (at your option) any later
+version.
+
+GCC 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 General Public License
+for more details.
+
+Under Section 7 of GPL version 3, you are granted additional
+permissions described in the GCC Runtime Library Exception, version
+3.1, as published by the Free Software Foundation.
+
+You should have received a copy of the GNU General Public License and
+a copy of the GCC Runtime Library Exception along with this program;
+see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+<http://www.gnu.org/licenses/>.  */
+
+#include "soft-fp.h"
+#include "double.h"
+#include "bitint.h"
+
+#ifdef __BITINT_MAXWIDTH__
+void
+__fixdfbitint (UBILtype *r, SItype rprec, DFtype a)
+{
+  FP_DECL_EX;
+  FP_DECL_D (A);
+  USItype arprec = rprec < 0 ? -rprec : rprec;
+  USItype rn = ((USItype) arprec + BIL_TYPE_SIZE - 1) / BIL_TYPE_SIZE;
+  UDItype rv;
+  USItype rsize = arprec > DI_BITS ? DI_BITS : arprec;
+  USItype rsigned = rprec < 0;
+  USItype ovf = 0;
+  USItype shift = 0;
+
+  FP_INIT_EXCEPTIONS;
+  FP_UNPACK_RAW_D (A, a);
+  if (arprec > DI_BITS)
+    {
+      if (A_e < _FP_EXPBIAS_D || (A_s && !rsigned))
+	ovf = 1;
+      else if (A_e >= (_FP_EXPMAX_D < _FP_EXPBIAS_D + arprec
+		       ? _FP_EXPMAX_D
+		       : _FP_EXPBIAS_D + arprec - rsigned))
+	{
+	  ovf = 1;
+	  if (A_s
+	      && A_e == _FP_EXPBIAS_D + arprec - 1
+	      && A_e < _FP_EXPMAX_D)
+	    A_e -= arprec - DI_BITS;
+	}
+      else if (A_e >= _FP_EXPBIAS_D + DI_BITS - rsigned)
+	{
+	  shift = A_e - (_FP_EXPBIAS_D + DI_BITS - rsigned - 1);
+	  A_e -= shift;
+	}
+    }
+  FP_TO_INT_D (rv, A, rsize, rsigned);
+  FP_HANDLE_EXCEPTIONS;
+  FP_TO_BITINT (r, rn, arprec, shift, rv, rsize, rsigned, ovf, DI);
+}
+#endif
--- libgcc/soft-fp/fixsfbitint.c.jj	2023-08-08 16:12:02.348939532 +0200
+++ libgcc/soft-fp/fixsfbitint.c	2023-08-08 16:12:02.348939532 +0200
@@ -0,0 +1,71 @@
+/* Software floating-point emulation.
+   Convert IEEE single to signed or unsigned _BitInt.
+
+   Copyright (C) 2023 Free Software Foundation, Inc.
+
+This file is part of GCC.
+
+GCC is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free
+Software Foundation; either version 3, or (at your option) any later
+version.
+
+GCC 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 General Public License
+for more details.
+
+Under Section 7 of GPL version 3, you are granted additional
+permissions described in the GCC Runtime Library Exception, version
+3.1, as published by the Free Software Foundation.
+
+You should have received a copy of the GNU General Public License and
+a copy of the GCC Runtime Library Exception along with this program;
+see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+<http://www.gnu.org/licenses/>.  */
+
+#include "soft-fp.h"
+#include "single.h"
+#include "bitint.h"
+
+#ifdef __BITINT_MAXWIDTH__
+void
+__fixsfbitint (UBILtype *r, SItype rprec, SFtype a)
+{
+  FP_DECL_EX;
+  FP_DECL_S (A);
+  USItype arprec = rprec < 0 ? -rprec : rprec;
+  USItype rn = ((USItype) arprec + BIL_TYPE_SIZE - 1) / BIL_TYPE_SIZE;
+  USItype rv;
+  USItype rsize = arprec > SI_BITS ? SI_BITS : arprec;
+  USItype rsigned = rprec < 0;
+  USItype ovf = 0;
+  USItype shift = 0;
+
+  FP_INIT_EXCEPTIONS;
+  FP_UNPACK_RAW_S (A, a);
+  if (arprec > SI_BITS)
+    {
+      if (A_e < _FP_EXPBIAS_S || (A_s && !rsigned))
+	ovf = 1;
+      else if (A_e >= (_FP_EXPMAX_S < _FP_EXPBIAS_S + arprec
+		       ? _FP_EXPMAX_S
+		       : _FP_EXPBIAS_S + arprec - rsigned))
+	{
+	  ovf = 1;
+	  if (A_s
+	      && A_e == _FP_EXPBIAS_S + arprec - 1
+	      && A_e < _FP_EXPMAX_S)
+	    A_e -= arprec - SI_BITS;
+	}
+      else if (A_e >= _FP_EXPBIAS_S + SI_BITS - rsigned)
+	{
+	  shift = A_e - (_FP_EXPBIAS_S + SI_BITS - rsigned - 1);
+	  A_e -= shift;
+	}
+    }
+  FP_TO_INT_S (rv, A, rsize, rsigned);
+  FP_HANDLE_EXCEPTIONS;
+  FP_TO_BITINT (r, rn, arprec, shift, rv, rsize, rsigned, ovf, SI);
+}
+#endif
--- libgcc/soft-fp/fixtfbitint.c.jj	2023-08-08 16:12:02.349939518 +0200
+++ libgcc/soft-fp/fixtfbitint.c	2023-08-08 16:12:02.349939518 +0200
@@ -0,0 +1,81 @@
+/* Software floating-point emulation.
+   Convert IEEE quad to signed or unsigned _BitInt.
+
+   Copyright (C) 2023 Free Software Foundation, Inc.
+
+This file is part of GCC.
+
+GCC is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free
+Software Foundation; either version 3, or (at your option) any later
+version.
+
+GCC 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 General Public License
+for more details.
+
+Under Section 7 of GPL version 3, you are granted additional
+permissions described in the GCC Runtime Library Exception, version
+3.1, as published by the Free Software Foundation.
+
+You should have received a copy of the GNU General Public License and
+a copy of the GCC Runtime Library Exception along with this program;
+see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+<http://www.gnu.org/licenses/>.  */
+
+#include "soft-fp.h"
+#include "quad.h"
+#include "bitint.h"
+
+#ifdef __BITINT_MAXWIDTH__
+
+#ifndef TI_BITS
+/* As mantissa is 112 bits + 1 implicit bit, we need 128-bit
+   type, but on most 32-bit architectures TImode isn't supported.
+   Use _BitInt(128) instead.  */
+typedef _BitInt(128) TItype;
+typedef unsigned _BitInt(128) UTItype;
+#define TI_BITS 128
+#endif
+
+void
+__fixtfbitint (UBILtype *r, SItype rprec, TFtype a)
+{
+  FP_DECL_EX;
+  FP_DECL_Q (A);
+  USItype arprec = rprec < 0 ? -rprec : rprec;
+  USItype rn = ((USItype) arprec + BIL_TYPE_SIZE - 1) / BIL_TYPE_SIZE;
+  UTItype rv;
+  USItype rsize = arprec > TI_BITS ? TI_BITS : arprec;
+  USItype rsigned = rprec < 0;
+  USItype ovf = 0;
+  USItype shift = 0;
+
+  FP_INIT_EXCEPTIONS;
+  FP_UNPACK_RAW_Q (A, a);
+  if (arprec > TI_BITS)
+    {
+      if (A_e < _FP_EXPBIAS_Q || (A_s && !rsigned))
+	ovf = 1;
+      else if (A_e >= (_FP_EXPMAX_Q < _FP_EXPBIAS_Q + arprec
+		       ? _FP_EXPMAX_Q
+		       : _FP_EXPBIAS_Q + arprec - rsigned))
+	{
+	  ovf = 1;
+	  if (A_s
+	      && A_e == _FP_EXPBIAS_Q + arprec - 1
+	      && A_e < _FP_EXPMAX_Q)
+	    A_e -= arprec - TI_BITS;
+	}
+      else if (A_e >= _FP_EXPBIAS_Q + TI_BITS - rsigned)
+	{
+	  shift = A_e - (_FP_EXPBIAS_Q + TI_BITS - rsigned - 1);
+	  A_e -= shift;
+	}
+    }
+  FP_TO_INT_Q (rv, A, rsize, rsigned);
+  FP_HANDLE_EXCEPTIONS;
+  FP_TO_BITINT (r, rn, arprec, shift, rv, rsize, rsigned, ovf, TI);
+}
+#endif
--- libgcc/soft-fp/fixxfbitint.c.jj	2023-08-08 16:12:02.349939518 +0200
+++ libgcc/soft-fp/fixxfbitint.c	2023-08-08 16:12:02.349939518 +0200
@@ -0,0 +1,82 @@
+/* Software floating-point emulation.
+   Convert IEEE extended to signed or unsigned _BitInt.
+
+   Copyright (C) 2023 Free Software Foundation, Inc.
+
+This file is part of GCC.
+
+GCC is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free
+Software Foundation; either version 3, or (at your option) any later
+version.
+
+GCC 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 General Public License
+for more details.
+
+Under Section 7 of GPL version 3, you are granted additional
+permissions described in the GCC Runtime Library Exception, version
+3.1, as published by the Free Software Foundation.
+
+You should have received a copy of the GNU General Public License and
+a copy of the GCC Runtime Library Exception along with this program;
+see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+<http://www.gnu.org/licenses/>.  */
+
+#include "soft-fp.h"
+#include "extended.h"
+#include "bitint.h"
+
+#ifdef __BITINT_MAXWIDTH__
+
+#ifndef TI_BITS
+/* While mantissa is 64 bits including 1 explicit bit, extended.h uses
+   op-2.h for W_TYPE_SIZE 64 and op-4.h for W_TYPE_SIZE 32, so we have
+   to use 128-bit type here.  On most 32-bit architectures TImode isn't
+   supported, so use _BitInt(128) instead.  */
+typedef _BitInt(128) TItype;
+typedef unsigned _BitInt(128) UTItype;
+#define TI_BITS 128
+#endif
+
+void
+__fixxfbitint (UBILtype *r, SItype rprec, XFtype a)
+{
+  FP_DECL_EX;
+  FP_DECL_E (A);
+  USItype arprec = rprec < 0 ? -rprec : rprec;
+  USItype rn = ((USItype) arprec + BIL_TYPE_SIZE - 1) / BIL_TYPE_SIZE;
+  UTItype rv;
+  USItype rsize = arprec > TI_BITS ? TI_BITS : arprec;
+  USItype rsigned = rprec < 0;
+  USItype ovf = 0;
+  USItype shift = 0;
+
+  FP_INIT_EXCEPTIONS;
+  FP_UNPACK_RAW_E (A, a);
+  if (arprec > TI_BITS)
+    {
+      if (A_e < _FP_EXPBIAS_E || (A_s && !rsigned))
+	ovf = 1;
+      else if (A_e >= (_FP_EXPMAX_E < _FP_EXPBIAS_E + arprec
+		       ? _FP_EXPMAX_E
+		       : _FP_EXPBIAS_E + arprec - rsigned))
+	{
+	  ovf = 1;
+	  if (A_s
+	      && A_e == _FP_EXPBIAS_E + arprec - 1
+	      && A_e < _FP_EXPMAX_E)
+	    A_e -= arprec - TI_BITS;
+	}
+      else if (A_e >= _FP_EXPBIAS_E + TI_BITS - rsigned)
+	{
+	  shift = A_e - (_FP_EXPBIAS_E + TI_BITS - rsigned - 1);
+	  A_e -= shift;
+	}
+    }
+  FP_TO_INT_E (rv, A, rsize, rsigned);
+  FP_HANDLE_EXCEPTIONS;
+  FP_TO_BITINT (r, rn, arprec, shift, rv, rsize, rsigned, ovf, TI);
+}
+#endif
--- libgcc/soft-fp/floatbitintbf.c.jj	2023-08-08 16:12:02.349939518 +0200
+++ libgcc/soft-fp/floatbitintbf.c	2023-08-08 16:12:02.349939518 +0200
@@ -0,0 +1,59 @@
+/* Software floating-point emulation.
+   Convert a _BitInt to bfloat16.
+
+   Copyright (C) 2023 Free Software Foundation, Inc.
+
+This file is part of GCC.
+
+GCC is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free
+Software Foundation; either version 3, or (at your option) any later
+version.
+
+GCC 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 General Public License
+for more details.
+
+Under Section 7 of GPL version 3, you are granted additional
+permissions described in the GCC Runtime Library Exception, version
+3.1, as published by the Free Software Foundation.
+
+You should have received a copy of the GNU General Public License and
+a copy of the GCC Runtime Library Exception along with this program;
+see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+<http://www.gnu.org/licenses/>.  */
+
+#include "soft-fp.h"
+#include "brain.h"
+#include "bitint.h"
+
+#ifdef __BITINT_MAXWIDTH__
+BFtype
+__floatbitintbf (const UBILtype *i, SItype iprec)
+{
+  SItype iv;
+  USItype shift = 0;
+  FP_DECL_EX;
+  FP_DECL_B (A);
+  BFtype a;
+
+  FP_FROM_BITINT (i, iprec, iv, shift, SI);
+  FP_INIT_ROUNDMODE;
+  FP_FROM_INT_B (A, iv, SI_BITS, USItype);
+  if (shift)
+    {
+      A_e += shift;
+      if (A_e >= _FP_EXPMAX_B)
+	{
+	  /* Exponent too big; overflow to infinity.  */
+	  _FP_OVERFLOW_SEMIRAW (B, 1, A);
+	  _FP_PACK_SEMIRAW (B, 1, A);
+	}
+    }
+  FP_PACK_RAW_B (a, A);
+  FP_HANDLE_EXCEPTIONS;
+
+  return a;
+}
+#endif
--- libgcc/soft-fp/floatbitintdf.c.jj	2023-08-08 16:12:02.349939518 +0200
+++ libgcc/soft-fp/floatbitintdf.c	2023-08-08 16:12:02.349939518 +0200
@@ -0,0 +1,64 @@
+/* Software floating-point emulation.
+   Convert a _BitInt to IEEE double.
+
+   Copyright (C) 2023 Free Software Foundation, Inc.
+
+This file is part of GCC.
+
+GCC is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free
+Software Foundation; either version 3, or (at your option) any later
+version.
+
+GCC 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 General Public License
+for more details.
+
+Under Section 7 of GPL version 3, you are granted additional
+permissions described in the GCC Runtime Library Exception, version
+3.1, as published by the Free Software Foundation.
+
+You should have received a copy of the GNU General Public License and
+a copy of the GCC Runtime Library Exception along with this program;
+see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+<http://www.gnu.org/licenses/>.  */
+
+#include "soft-fp.h"
+#include "double.h"
+#include "bitint.h"
+
+#ifdef __BITINT_MAXWIDTH__
+DFtype
+__floatbitintdf (const UBILtype *i, SItype iprec)
+{
+  DItype iv;
+  USItype shift = 0;
+  FP_DECL_EX;
+  FP_DECL_D (A);
+  DFtype a;
+
+  FP_FROM_BITINT (i, iprec, iv, shift, DI);
+  FP_INIT_ROUNDMODE;
+  FP_FROM_INT_D (A, iv, DI_BITS, UDItype);
+  if (shift)
+    {
+      A_e += shift;
+      if (A_e >= _FP_EXPMAX_D)
+	{
+	  /* Exponent too big; overflow to infinity.  */
+#if _FP_W_TYPE_SIZE < 64
+	  _FP_OVERFLOW_SEMIRAW (D, 2, A);
+	  _FP_PACK_SEMIRAW (D, 2, A);
+#else
+	  _FP_OVERFLOW_SEMIRAW (D, 1, A);
+	  _FP_PACK_SEMIRAW (D, 1, A);
+#endif
+	}
+    }
+  FP_PACK_RAW_D (a, A);
+  FP_HANDLE_EXCEPTIONS;
+
+  return a;
+}
+#endif
--- libgcc/soft-fp/floatbitinthf.c.jj	2023-08-08 16:12:02.349939518 +0200
+++ libgcc/soft-fp/floatbitinthf.c	2023-08-08 16:12:02.349939518 +0200
@@ -0,0 +1,59 @@
+/* Software floating-point emulation.
+   Convert a _BitInt to IEEE half.
+
+   Copyright (C) 2023 Free Software Foundation, Inc.
+
+This file is part of GCC.
+
+GCC is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free
+Software Foundation; either version 3, or (at your option) any later
+version.
+
+GCC 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 General Public License
+for more details.
+
+Under Section 7 of GPL version 3, you are granted additional
+permissions described in the GCC Runtime Library Exception, version
+3.1, as published by the Free Software Foundation.
+
+You should have received a copy of the GNU General Public License and
+a copy of the GCC Runtime Library Exception along with this program;
+see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+<http://www.gnu.org/licenses/>.  */
+
+#include "soft-fp.h"
+#include "half.h"
+#include "bitint.h"
+
+#ifdef __BITINT_MAXWIDTH__
+HFtype
+__floatbitinthf (const UBILtype *i, SItype iprec)
+{
+  SItype iv;
+  USItype shift = 0;
+  FP_DECL_EX;
+  FP_DECL_H (A);
+  HFtype a;
+
+  FP_FROM_BITINT (i, iprec, iv, shift, SI);
+  FP_INIT_ROUNDMODE;
+  FP_FROM_INT_H (A, iv, SI_BITS, USItype);
+  if (shift)
+    {
+      A_e += shift;
+      if (A_e >= _FP_EXPMAX_H)
+	{
+	  /* Exponent too big; overflow to infinity.  */
+	  _FP_OVERFLOW_SEMIRAW (H, 1, A);
+	  _FP_PACK_SEMIRAW (H, 1, A);
+	}
+    }
+  FP_PACK_RAW_H (a, A);
+  FP_HANDLE_EXCEPTIONS;
+
+  return a;
+}
+#endif
--- libgcc/soft-fp/floatbitintsf.c.jj	2023-08-08 16:12:02.349939518 +0200
+++ libgcc/soft-fp/floatbitintsf.c	2023-08-08 16:12:02.349939518 +0200
@@ -0,0 +1,59 @@
+/* Software floating-point emulation.
+   Convert a _BitInt to IEEE single.
+
+   Copyright (C) 2023 Free Software Foundation, Inc.
+
+This file is part of GCC.
+
+GCC is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free
+Software Foundation; either version 3, or (at your option) any later
+version.
+
+GCC 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 General Public License
+for more details.
+
+Under Section 7 of GPL version 3, you are granted additional
+permissions described in the GCC Runtime Library Exception, version
+3.1, as published by the Free Software Foundation.
+
+You should have received a copy of the GNU General Public License and
+a copy of the GCC Runtime Library Exception along with this program;
+see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+<http://www.gnu.org/licenses/>.  */
+
+#include "soft-fp.h"
+#include "single.h"
+#include "bitint.h"
+
+#ifdef __BITINT_MAXWIDTH__
+SFtype
+__floatbitintsf (const UBILtype *i, SItype iprec)
+{
+  SItype iv;
+  USItype shift = 0;
+  FP_DECL_EX;
+  FP_DECL_S (A);
+  SFtype a;
+
+  FP_FROM_BITINT (i, iprec, iv, shift, SI);
+  FP_INIT_ROUNDMODE;
+  FP_FROM_INT_S (A, iv, SI_BITS, USItype);
+  if (shift)
+    {
+      A_e += shift;
+      if (A_e >= _FP_EXPMAX_S)
+	{
+	  /* Exponent too big; overflow to infinity.  */
+	  _FP_OVERFLOW_SEMIRAW (S, 1, A);
+	  _FP_PACK_SEMIRAW (S, 1, A);
+	}
+    }
+  FP_PACK_RAW_S (a, A);
+  FP_HANDLE_EXCEPTIONS;
+
+  return a;
+}
+#endif
--- libgcc/soft-fp/floatbitinttf.c.jj	2023-08-08 16:12:02.349939518 +0200
+++ libgcc/soft-fp/floatbitinttf.c	2023-08-08 16:12:02.349939518 +0200
@@ -0,0 +1,73 @@
+/* Software floating-point emulation.
+   Convert a _BitInt to IEEE quad.
+
+   Copyright (C) 2023 Free Software Foundation, Inc.
+
+This file is part of GCC.
+
+GCC is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free
+Software Foundation; either version 3, or (at your option) any later
+version.
+
+GCC 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 General Public License
+for more details.
+
+Under Section 7 of GPL version 3, you are granted additional
+permissions described in the GCC Runtime Library Exception, version
+3.1, as published by the Free Software Foundation.
+
+You should have received a copy of the GNU General Public License and
+a copy of the GCC Runtime Library Exception along with this program;
+see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+<http://www.gnu.org/licenses/>.  */
+
+#include "soft-fp.h"
+#include "quad.h"
+#include "bitint.h"
+
+#ifdef __BITINT_MAXWIDTH__
+#ifndef TI_BITS
+/* As mantissa is 112 bits + 1 implicit bit, we need 128-bit
+   type, but on most 32-bit architectures TImode isn't supported.
+   Use _BitInt(128) instead.  */
+typedef _BitInt(128) TItype;
+typedef unsigned _BitInt(128) UTItype;
+#define TI_BITS 128
+#endif
+
+TFtype
+__floatbitinttf (const UBILtype *i, SItype iprec)
+{
+  TItype iv;
+  USItype shift = 0;
+  FP_DECL_EX;
+  FP_DECL_Q (A);
+  TFtype a;
+
+  FP_FROM_BITINT (i, iprec, iv, shift, TI);
+  FP_INIT_ROUNDMODE;
+  FP_FROM_INT_Q (A, iv, TI_BITS, UTItype);
+  if (shift)
+    {
+      A_e += shift;
+      if (A_e >= _FP_EXPMAX_Q)
+	{
+	  /* Exponent too big; overflow to infinity.  */
+#if _FP_W_TYPE_SIZE < 64
+	  _FP_OVERFLOW_SEMIRAW (Q, 4, A);
+	  _FP_PACK_SEMIRAW (Q, 4, A);
+#else
+	  _FP_OVERFLOW_SEMIRAW (Q, 2, A);
+	  _FP_PACK_SEMIRAW (Q, 2, A);
+#endif
+	}
+    }
+  FP_PACK_RAW_Q (a, A);
+  FP_HANDLE_EXCEPTIONS;
+
+  return a;
+}
+#endif
--- libgcc/soft-fp/floatbitintxf.c.jj	2023-08-08 16:12:02.349939518 +0200
+++ libgcc/soft-fp/floatbitintxf.c	2023-08-08 16:12:02.349939518 +0200
@@ -0,0 +1,74 @@
+/* Software floating-point emulation.
+   Convert a _BitInt to IEEE extended.
+
+   Copyright (C) 2023 Free Software Foundation, Inc.
+
+This file is part of GCC.
+
+GCC is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free
+Software Foundation; either version 3, or (at your option) any later
+version.
+
+GCC 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 General Public License
+for more details.
+
+Under Section 7 of GPL version 3, you are granted additional
+permissions described in the GCC Runtime Library Exception, version
+3.1, as published by the Free Software Foundation.
+
+You should have received a copy of the GNU General Public License and
+a copy of the GCC Runtime Library Exception along with this program;
+see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+<http://www.gnu.org/licenses/>.  */
+
+#include "soft-fp.h"
+#include "extended.h"
+#include "bitint.h"
+
+#ifdef __BITINT_MAXWIDTH__
+#ifndef TI_BITS
+/* While mantissa is 64 bits including 1 explicit bit, extended.h uses
+   op-2.h for W_TYPE_SIZE 64 and op-4.h for W_TYPE_SIZE 32, so we have
+   to use 128-bit type here.  On most 32-bit architectures TImode isn't
+   supported, so use _BitInt(128) instead.  */
+typedef _BitInt(128) TItype;
+typedef unsigned _BitInt(128) UTItype;
+#define TI_BITS 128
+#endif
+
+XFtype
+__floatbitintxf (const UBILtype *i, SItype iprec)
+{
+  TItype iv;
+  USItype shift = 0;
+  FP_DECL_EX;
+  FP_DECL_E (A);
+  XFtype a;
+
+  FP_FROM_BITINT (i, iprec, iv, shift, TI);
+  FP_INIT_ROUNDMODE;
+  FP_FROM_INT_E (A, iv, TI_BITS, UTItype);
+  if (shift)
+    {
+      A_e += shift;
+      if (A_e >= _FP_EXPMAX_E)
+	{
+	  /* Exponent too big; overflow to infinity.  */
+#if _FP_W_TYPE_SIZE < 64
+	  _FP_OVERFLOW_SEMIRAW (E, 4, A);
+	  _FP_PACK_SEMIRAW (E, 4, A);
+#else
+	  _FP_OVERFLOW_SEMIRAW (E, 2, A);
+	  _FP_PACK_SEMIRAW (E, 2, A);
+#endif
+	}
+    }
+  FP_PACK_RAW_E (a, A);
+  FP_HANDLE_EXCEPTIONS;
+
+  return a;
+}
+#endif
--- libgcc/soft-fp/op-common.h.jj	2023-08-08 15:54:36.110590119 +0200
+++ libgcc/soft-fp/op-common.h	2023-08-08 16:12:02.349939518 +0200
@@ -1800,7 +1800,7 @@
 	  if ((X##_s = ((r) < 0)))					\
 	    _FP_FROM_INT_ur = -_FP_FROM_INT_ur;				\
 									\
-	  _FP_STATIC_ASSERT ((rsize) <= 2 * _FP_W_TYPE_SIZE,		\
+	  _FP_STATIC_ASSERT ((rsize) <= 4 * _FP_W_TYPE_SIZE,		\
 			     "rsize too large");			\
 	  (void) (((rsize) <= _FP_W_TYPE_SIZE)				\
 		  ? ({							\
@@ -1810,13 +1810,38 @@
 		      X##_e = (_FP_EXPBIAS_##fs + _FP_W_TYPE_SIZE - 1	\
 			       - _FP_FROM_INT_lz);			\
 		    })							\
-		  : ({						\
+		  : ((rsize) <= 2 * _FP_W_TYPE_SIZE)			\
+		  ? ({							\
 		      int _FP_FROM_INT_lz;				\
 		      __FP_CLZ_2 (_FP_FROM_INT_lz,			\
 				  (_FP_W_TYPE) (_FP_FROM_INT_ur		\
 						>> _FP_W_TYPE_SIZE),	\
 				  (_FP_W_TYPE) _FP_FROM_INT_ur);	\
-		      X##_e = (_FP_EXPBIAS_##fs + 2 * _FP_W_TYPE_SIZE - 1 \
+		      X##_e = (_FP_EXPBIAS_##fs				\
+			       + 2 * _FP_W_TYPE_SIZE - 1		\
+			       - _FP_FROM_INT_lz);			\
+		    })							\
+		  : ({							\
+		      int _FP_FROM_INT_lz;				\
+		      if (_FP_FROM_INT_ur >> (2 * _FP_W_TYPE_SIZE))	\
+			{						\
+			  rtype _FP_FROM_INT_uru			\
+			    = _FP_FROM_INT_ur >> (2 * _FP_W_TYPE_SIZE);	\
+			  __FP_CLZ_2 (_FP_FROM_INT_lz,			\
+				      (_FP_W_TYPE) (_FP_FROM_INT_uru	\
+						    >> _FP_W_TYPE_SIZE),\
+				      (_FP_W_TYPE) _FP_FROM_INT_uru);	\
+			}						\
+		      else						\
+			{						\
+			  __FP_CLZ_2 (_FP_FROM_INT_lz,			\
+				      (_FP_W_TYPE) (_FP_FROM_INT_ur	\
+						    >> _FP_W_TYPE_SIZE),\
+				      (_FP_W_TYPE) _FP_FROM_INT_ur);	\
+			  _FP_FROM_INT_lz += 2 * _FP_W_TYPE_SIZE;	\
+			}						\
+		      X##_e = (_FP_EXPBIAS_##fs				\
+			       + 4 * _FP_W_TYPE_SIZE - 1		\
 			       - _FP_FROM_INT_lz);			\
 		    }));						\
 									\
--- libgcc/soft-fp/bitintpow10.c.jj	2023-08-08 16:21:45.956768331 +0200
+++ libgcc/soft-fp/bitintpow10.c	2023-08-09 15:22:45.519805895 +0200
@@ -0,0 +1,132 @@
+/* Software floating-point emulation.
+   Compute powers of 10 into _BitInt.
+
+   Copyright (C) 2023 Free Software Foundation, Inc.
+
+This file is part of GCC.
+
+GCC is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free
+Software Foundation; either version 3, or (at your option) any later
+version.
+
+GCC 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 General Public License
+for more details.
+
+Under Section 7 of GPL version 3, you are granted additional
+permissions described in the GCC Runtime Library Exception, version
+3.1, as published by the Free Software Foundation.
+
+You should have received a copy of the GNU General Public License and
+a copy of the GCC Runtime Library Exception along with this program;
+see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+<http://www.gnu.org/licenses/>.  */
+
+#include "soft-fp.h"
+#include "bitint.h"
+
+#ifdef __BITINT_MAXWIDTH__
+# define BIL_VAL(x) ((UBILtype) (x))
+# if BIL_TYPE_SIZE == 64
+#  define BIL_PAIR(x, y) ((BIL_VAL (x) << 32) | BIL_VAL (y))
+#  define BIL_OFF(x, y) (x)
+# elif BIL_TYPE_SIZE == 32
+#  if __LIBGCC_BITINT_ORDER__ == __ORDER_BIG_ENDIAN__
+#   define BIL_PAIR(x, y) BIL_VAL (x), BIL_VAL (y)
+#  else
+#   define BIL_PAIR(x, y) BIL_VAL (y), BIL_VAL (x)
+#  endif
+#  define BIL_OFF(x, y) (y)
+# else
+#  error Unsupported _BitInt limb size
+# endif
+#if __LIBGCC_BITINT_ORDER__ == __ORDER_BIG_ENDIAN__
+# define BIL_SET2(a, b) a, b
+# define BIL_SET3(a, b, c) a, b, c
+# define BIL_SET4(a, b, c, d) a, b, c, d
+# define BIL_SET5(a, b, c, d, e) a, b, c, d, e
+# define BIL_SET6(a, b, c, d, e, f) a, b, c, d, e, f
+# define BIL_SET7(a, b, c, d, e, f, g) a, b, c, d, e, f, g
+# define BIL_SET8(a, b, c, d, e, f, g, h) a, b, c, d, e, f, g, h
+# define BIL_SET9(a, b, c, d, e, f, g, h, i) a, b, c, d, e, f, g, h, i
+# define BIL_SET10(a, b, c, d, e, f, g, h, i, j) a, b, c, d, e, f, g, h, i, j
+# define BIL_SET11(a, b, c, d, e, f, g, h, i, j, k) \
+  a, b, c, d, e, f, g, h, i, j, k
+# define BIL_SET12(a, b, c, d, e, f, g, h, i, j, k, l) \
+  a, b, c, d, e, f, g, h, i, j, k, l
+# define BIL_SET13(a, b, c, d, e, f, g, h, i, j, k, l, m) \
+  a, b, c, d, e, f, g, h, i, j, k, l, m
+# define BIL_SET14(a, b, c, d, e, f, g, h, i, j, k, l, m, n) \
+  a, b, c, d, e, f, g, h, i, j, k, l, m, n
+# define BIL_SET15(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) \
+  a, b, c, d, e, f, g, h, i, j, k, l, m, n, o
+#else
+# define BIL_SET2(a, b) b, a
+# define BIL_SET3(a, b, c) c, b, a
+# define BIL_SET4(a, b, c, d) d, c, b, a
+# define BIL_SET5(a, b, c, d, e) e, d, c, b, a
+# define BIL_SET6(a, b, c, d, e, f) f, e, d, c, b, a
+# define BIL_SET7(a, b, c, d, e, f, g) g, f, e, d, c, b, a
+# define BIL_SET8(a, b, c, d, e, f, g, h) h, g, f, e, d, c, b, a
+# define BIL_SET9(a, b, c, d, e, f, g, h, i) i, h, g, f, e, d, c, b, a
+# define BIL_SET10(a, b, c, d, e, f, g, h, i, j) j, i, h, g, f, e, d, c, b, a
+# define BIL_SET11(a, b, c, d, e, f, g, h, i, j, k) \
+  k, j, i, h, g, f, e, d, c, b, a
+# define BIL_SET12(a, b, c, d, e, f, g, h, i, j, k, l) \
+  l, k, j, i, h, g, f, e, d, c, b, a
+# define BIL_SET13(a, b, c, d, e, f, g, h, i, j, k, l, m) \
+  m, l, k, j, i, h, g, f, e, d, c, b, a
+# define BIL_SET14(a, b, c, d, e, f, g, h, i, j, k, l, m, n) \
+  n, m, l, k, j, i, h, g, f, e, d, c, b, a
+# define BIL_SET15(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) \
+  o, n, m, l, k, j, i, h, g, f, e, d, c, b, a
+#endif
+
+#include "bitintpow10.h"
+
+/* Set r (_BitInt limbs with rprec bits) to pow10 (n),
+   where n is in [0, 6111].  Returns number of least significant
+   limbs with just 0s in it.  */
+
+USItype
+__bid_pow10bitint (UBILtype *r, SItype rprec, USItype n)
+{
+  USItype rn = ((USItype) rprec + BIL_TYPE_SIZE - 1) / BIL_TYPE_SIZE;
+  if (n <= 256)
+    {
+      /* No need to multiply anything, just copy it from pow10_limbs
+	 array.  */
+      USItype low_zeros = (n / 64) * (64 / BIL_TYPE_SIZE);
+      UBILtype *p = &pow10_limbs[pow10_offs[n]];
+      USItype cnt = pow10_offs[n + 1] - pow10_offs[n];
+      if (low_zeros)
+	__builtin_memset (r + BITINT_END (rn - low_zeros, 0), '\0',
+			  low_zeros * sizeof (UBILtype));
+      __builtin_memcpy (r + BITINT_END (rn - low_zeros - cnt, low_zeros),
+			p, cnt * sizeof (UBILtype));
+      if (rn > low_zeros + cnt)
+	__builtin_memset (r + BITINT_END (0, low_zeros + cnt), '\0',
+			  (rn - low_zeros - cnt) * sizeof (UBILtype));
+      return low_zeros;
+    }
+  else
+    {
+      USItype m = n / 256;
+      n &= 255;
+      USItype low_zeros = ((n / 64) + (m * 4)) * (64 / BIL_TYPE_SIZE);
+      UBILtype *pm = &pow10_limbs[pow10_offs[m + 255]];
+      USItype cntm = pow10_offs[m + 256] - pow10_offs[m + 255];
+      UBILtype *pn = &pow10_limbs[pow10_offs[n]];
+      USItype cntn = pow10_offs[n + 1] - pow10_offs[n];
+      if (low_zeros)
+	__builtin_memset (r + BITINT_END (rn - low_zeros, 0), '\0',
+			  low_zeros * sizeof (UBILtype));
+      __mulbitint3 (r + BITINT_END (0, low_zeros),
+		    rprec - low_zeros * BIL_TYPE_SIZE,
+		    pm, cntm * BIL_TYPE_SIZE, pn, cntn * BIL_TYPE_SIZE);
+      return low_zeros;
+    }
+}
+#endif
--- libgcc/soft-fp/fixsdbitint.c.jj	2023-08-08 16:21:45.953768373 +0200
+++ libgcc/soft-fp/fixsdbitint.c	2023-08-08 16:21:45.953768373 +0200
@@ -0,0 +1,196 @@
+/* Software floating-point emulation.
+   Convert _Decimal32 to signed or unsigned _BitInt.
+
+   Copyright (C) 2023 Free Software Foundation, Inc.
+
+This file is part of GCC.
+
+GCC is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free
+Software Foundation; either version 3, or (at your option) any later
+version.
+
+GCC 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 General Public License
+for more details.
+
+Under Section 7 of GPL version 3, you are granted additional
+permissions described in the GCC Runtime Library Exception, version
+3.1, as published by the Free Software Foundation.
+
+You should have received a copy of the GNU General Public License and
+a copy of the GCC Runtime Library Exception along with this program;
+see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+<http://www.gnu.org/licenses/>.  */
+
+#include "soft-fp.h"
+#include "bitint.h"
+
+#ifdef __BITINT_MAXWIDTH__
+extern void __bid_fixsdbitint (UBILtype *, SItype, _Decimal32);
+
+void
+__bid_fixsdbitint (UBILtype *r, SItype rprec, _Decimal32 a)
+{
+  FP_DECL_EX;
+  USItype arprec = rprec < 0 ? -rprec : rprec;
+  USItype rn = (arprec + BIL_TYPE_SIZE - 1) / BIL_TYPE_SIZE;
+  union { _Decimal32 d; USItype u; } u;
+  USItype mantissa, t;
+  SItype sgn;
+  SItype exponent;
+  USItype exp_bits, mant_bits;
+  UBILtype *pow10v, *resv;
+  USItype pow10_limbs, res_limbs, min_limbs, mant_limbs, low_zeros;
+
+  FP_INIT_EXCEPTIONS;
+  u.d = a;
+  t = u.u >> 21;
+  sgn = (SItype) u.u < 0;
+  if ((t & (3 << 8)) != (3 << 8))
+    {
+      mantissa = u.u & ((((USItype) 1) << 23) - 1);
+      exponent = (t >> 2) & 0xff;
+    }
+  else if ((t & (3 << 6)) != (3 << 6))
+    {
+      mantissa = u.u & ((((USItype) 1) << 21) - 1);
+      mantissa |= ((USItype) 1) << 23;
+      exponent = t & 0xff;
+      if (mantissa > (USItype) 9999999)
+	mantissa = 0;
+    }
+  else
+    {
+      FP_SET_EXCEPTION (FP_EX_INVALID
+			| FP_EX_INVALID_CVI
+			| ((FP_EX_INVALID_SNAN
+			    && ((t & 0x20)) != 0)
+			   ? FP_EX_INVALID_SNAN : 0));
+    ovf:
+      if (!sgn)
+	__builtin_memset (r, -1, rn * sizeof (UBILtype));
+      else
+	__builtin_memset (r, 0, rn * sizeof (UBILtype));
+      if (sgn ^ (rprec >= 0))
+	r[BITINT_END (0, rn - 1)]
+	  |= (UBILtype) -1 << ((arprec - 1) % BIL_TYPE_SIZE);
+      else
+	r[BITINT_END (0, rn - 1)]
+	  &= ~((UBILtype) -1 << ((arprec - 1) % BIL_TYPE_SIZE));
+      goto done;
+    }
+  exponent -= 101;
+
+  if (mantissa == 0)
+    {
+      /* Zero (with any exponent).  */
+    zero:
+      __builtin_memset (r, 0, rn * sizeof (UBILtype));
+      goto done;
+    }
+  if (exponent <= -7)
+    {
+      FP_SET_EXCEPTION (FP_EX_INEXACT);
+      goto zero;
+    }
+  else if (exponent < 0)
+    {
+      UBILtype limbs[64 / BIL_TYPE_SIZE];
+      USItype rem;
+      UDItype d;
+      __bid_pow10bitint (limbs, 64, -exponent);
+#if BIL_TYPE_SIZE == 64
+      d = limbs[0];
+#elif BIL_TYPE_SIZE == 32
+      d = (limbs[BITINT_END (0, 1)] << 32) | limbs[BITINT_END (1, 0)];
+#else
+# error Unsupported BIL_TYPE_SIZE
+#endif
+      rem = mantissa % (USItype) d;
+      mantissa /= (USItype) d;
+      if (rem)
+	FP_SET_EXCEPTION (FP_EX_INEXACT);
+      if (mantissa == 0)
+	goto zero;
+      exponent = 0;
+    }
+
+  if (rprec >= 0 && sgn)
+    {
+    ovf_ex:
+      FP_SET_EXCEPTION (FP_EX_INVALID | FP_EX_INVALID_CVI);
+      goto ovf;
+    }
+
+  /* Lower estimate for number of bits needed for pow10 (exponent).  */
+  exp_bits = exponent / 3;
+  exp_bits = exp_bits * 10 - exp_bits / 29;
+  mant_bits = sizeof (0ULL) * __CHAR_BIT__ - __builtin_clzll (mantissa);
+  if (exp_bits + mant_bits > arprec + 1)
+    goto ovf_ex;
+  /* Upper estimate for number of bits needed for pow10 (exponent).  */
+  exp_bits = (exponent + 2) / 3;
+  exp_bits = exp_bits * 10 - exp_bits / 30;
+  if (exp_bits == 0)
+    exp_bits = 1;
+  pow10_limbs = (exp_bits + BIL_TYPE_SIZE - 1) / BIL_TYPE_SIZE;
+  pow10v = __builtin_alloca (pow10_limbs * sizeof (UBILtype));
+  low_zeros = __bid_pow10bitint (pow10v, exp_bits, exponent);
+
+  res_limbs = ((exp_bits + mant_bits + BIL_TYPE_SIZE - 1)
+	       / BIL_TYPE_SIZE) - low_zeros;
+  mant_limbs = 1;
+  resv = __builtin_alloca ((res_limbs + mant_limbs) * sizeof (UBILtype));
+  resv[res_limbs] = mantissa;
+  __mulbitint3 (resv, exp_bits + mant_bits - low_zeros * BIL_TYPE_SIZE,
+		resv + res_limbs, mant_bits,
+		pow10v + BITINT_END (0, low_zeros),
+		exp_bits - low_zeros * BIL_TYPE_SIZE);
+  if (res_limbs + low_zeros >= rn)
+    {
+      if (res_limbs + low_zeros > rn && resv[BITINT_END (0, res_limbs - 1)])
+	goto ovf_ex;
+      if ((arprec % BIL_TYPE_SIZE) != 0
+	  && (resv[BITINT_END (rn - res_limbs, rn - 1) - low_zeros]
+	      & ((UBILtype) -1 << (arprec % BIL_TYPE_SIZE))) != 0)
+	goto ovf_ex;
+      min_limbs = rn - low_zeros;
+    }
+  else
+    min_limbs = res_limbs;
+  if (low_zeros)
+    __builtin_memset (r + BITINT_END (rn - low_zeros, 0), '\0',
+		      low_zeros * sizeof (UBILtype));
+  if (sgn)
+    bitint_negate (r + BITINT_END (rn - low_zeros - 1, low_zeros),
+		   resv + BITINT_END (res_limbs - 1, 0), min_limbs);
+  else
+    __builtin_memcpy (r + BITINT_END (rn - low_zeros - min_limbs, low_zeros),
+		      resv + BITINT_END (res_limbs - min_limbs, 0),
+		      min_limbs * sizeof (UBILtype));
+  if (res_limbs + low_zeros < rn)
+    {
+      if (sgn)
+	__builtin_memset (r + BITINT_END (0, res_limbs + low_zeros), -1,
+			  (rn - res_limbs - low_zeros) * sizeof (UBILtype));
+      else
+	__builtin_memset (r + BITINT_END (0, res_limbs + low_zeros), '\0',
+			  (rn - res_limbs - low_zeros) * sizeof (UBILtype));
+    }
+  else if (sgn)
+    {
+      if ((r[BITINT_END (0, rn - 1)]
+	   & ((UBILtype) 1 << ((arprec - 1) % BIL_TYPE_SIZE))) == 0)
+	goto ovf_ex;
+    }
+  else if (rprec < 0
+	   && (r[BITINT_END (0, rn - 1)]
+	       & ((UBILtype) 1 << ((arprec - 1) % BIL_TYPE_SIZE))) != 0)
+    goto ovf_ex;
+
+done:
+  FP_HANDLE_EXCEPTIONS;
+}
+#endif
--- libgcc/soft-fp/fixddbitint.c.jj	2023-08-08 16:21:45.953768373 +0200
+++ libgcc/soft-fp/fixddbitint.c	2023-08-08 16:21:45.953768373 +0200
@@ -0,0 +1,205 @@
+/* Software floating-point emulation.
+   Convert _Decimal64 to signed or unsigned _BitInt.
+
+   Copyright (C) 2023 Free Software Foundation, Inc.
+
+This file is part of GCC.
+
+GCC is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free
+Software Foundation; either version 3, or (at your option) any later
+version.
+
+GCC 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 General Public License
+for more details.
+
+Under Section 7 of GPL version 3, you are granted additional
+permissions described in the GCC Runtime Library Exception, version
+3.1, as published by the Free Software Foundation.
+
+You should have received a copy of the GNU General Public License and
+a copy of the GCC Runtime Library Exception along with this program;
+see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+<http://www.gnu.org/licenses/>.  */
+
+#include "soft-fp.h"
+#include "bitint.h"
+
+#ifdef __BITINT_MAXWIDTH__
+extern void __bid_fixddbitint (UBILtype *, SItype, _Decimal64);
+
+void
+__bid_fixddbitint (UBILtype *r, SItype rprec, _Decimal64 a)
+{
+  FP_DECL_EX;
+  USItype arprec = rprec < 0 ? -rprec : rprec;
+  USItype rn = (arprec + BIL_TYPE_SIZE - 1) / BIL_TYPE_SIZE;
+  union { _Decimal64 d; UDItype u; } u;
+  UDItype mantissa, t;
+  SItype sgn;
+  SItype exponent;
+  USItype exp_bits, mant_bits;
+  UBILtype *pow10v, *resv;
+  USItype pow10_limbs, res_limbs, min_limbs, mant_limbs, low_zeros;
+
+  FP_INIT_EXCEPTIONS;
+  u.d = a;
+  t = u.u >> 51;
+  sgn = (DItype) u.u < 0;
+  if ((t & (3 << 10)) != (3 << 10))
+    {
+      mantissa = u.u & ((((UDItype) 1) << 53) - 1);
+      exponent = (t >> 2) & 0x3ff;
+    }
+  else if ((t & (3 << 8)) != (3 << 8))
+    {
+      mantissa = u.u & ((((UDItype) 1) << 51) - 1);
+      mantissa |= ((UDItype) 1) << 53;
+      exponent = t & 0x3ff;
+      if (mantissa > (UDItype) 9999999999999999)
+	mantissa = 0;
+    }
+  else
+    {
+      FP_SET_EXCEPTION (FP_EX_INVALID
+			| FP_EX_INVALID_CVI
+			| ((FP_EX_INVALID_SNAN
+			    && ((t & 0x80)) != 0)
+			   ? FP_EX_INVALID_SNAN : 0));
+    ovf:
+      if (!sgn)
+	__builtin_memset (r, -1, rn * sizeof (UBILtype));
+      else
+	__builtin_memset (r, 0, rn * sizeof (UBILtype));
+      if (sgn ^ (rprec >= 0))
+	r[BITINT_END (0, rn - 1)]
+	  |= (UBILtype) -1 << ((arprec - 1) % BIL_TYPE_SIZE);
+      else
+	r[BITINT_END (0, rn - 1)]
+	  &= ~((UBILtype) -1 << ((arprec - 1) % BIL_TYPE_SIZE));
+      goto done;
+    }
+  exponent -= 398;
+
+  if (mantissa == 0)
+    {
+      /* Zero (with any exponent).  */
+    zero:
+      __builtin_memset (r, 0, rn * sizeof (UBILtype));
+      goto done;
+    }
+  if (exponent <= -16)
+    {
+      FP_SET_EXCEPTION (FP_EX_INEXACT);
+      goto zero;
+    }
+  else if (exponent < 0)
+    {
+      UBILtype limbs[64 / BIL_TYPE_SIZE];
+      UDItype d, rem;
+      __bid_pow10bitint (limbs, 64, -exponent);
+#if BIL_TYPE_SIZE == 64
+      d = limbs[0];
+#elif BIL_TYPE_SIZE == 32
+      d = (limbs[BITINT_END (0, 1)] << 32) | limbs[BITINT_END (1, 0)];
+#else
+# error Unsupported BIL_TYPE_SIZE
+#endif
+      rem = mantissa % d;
+      mantissa /= d;
+      if (rem)
+	FP_SET_EXCEPTION (FP_EX_INEXACT);
+      if (mantissa == 0)
+	goto zero;
+      exponent = 0;
+    }
+
+  if (rprec >= 0 && sgn)
+    {
+    ovf_ex:
+      FP_SET_EXCEPTION (FP_EX_INVALID | FP_EX_INVALID_CVI);
+      goto ovf;
+    }
+
+  /* Lower estimate for number of bits needed for pow10 (exponent).  */
+  exp_bits = exponent / 3;
+  exp_bits = exp_bits * 10 - exp_bits / 29;
+  mant_bits = sizeof (0ULL) * __CHAR_BIT__ - __builtin_clzll (mantissa);
+  if (exp_bits + mant_bits > arprec + 1)
+    goto ovf_ex;
+  /* Upper estimate for number of bits needed for pow10 (exponent).  */
+  exp_bits = (exponent + 2) / 3;
+  exp_bits = exp_bits * 10 - exp_bits / 30;
+  if (exp_bits == 0)
+    exp_bits = 1;
+  pow10_limbs = (exp_bits + BIL_TYPE_SIZE - 1) / BIL_TYPE_SIZE;
+  pow10v = __builtin_alloca (pow10_limbs * sizeof (UBILtype));
+  low_zeros = __bid_pow10bitint (pow10v, exp_bits, exponent);
+
+  res_limbs = ((exp_bits + mant_bits + BIL_TYPE_SIZE - 1)
+	       / BIL_TYPE_SIZE) - low_zeros;
+  mant_limbs = (mant_bits + BIL_TYPE_SIZE - 1) / BIL_TYPE_SIZE;
+  resv = __builtin_alloca ((res_limbs + mant_limbs) * sizeof (UBILtype));
+#if BIL_TYPE_SIZE >= 64
+  resv[res_limbs] = mantissa;
+#else
+  if (mant_limbs == 1)
+    resv[res_limbs] = mantissa;
+  else
+    {
+      resv[res_limbs + BITINT_END (1, 0)] = mantissa;
+      resv[res_limbs + BITINT_END (0, 1)] = mantissa >> 32;
+    }
+#endif
+  __mulbitint3 (resv, exp_bits + mant_bits - low_zeros * BIL_TYPE_SIZE,
+		resv + res_limbs, mant_bits,
+		pow10v + BITINT_END (0, low_zeros),
+		exp_bits - low_zeros * BIL_TYPE_SIZE);
+  if (res_limbs + low_zeros >= rn)
+    {
+      if (res_limbs + low_zeros > rn && resv[BITINT_END (0, res_limbs - 1)])
+	goto ovf_ex;
+      if ((arprec % BIL_TYPE_SIZE) != 0
+	  && (resv[BITINT_END (rn - res_limbs, rn - 1) - low_zeros]
+	      & ((UBILtype) -1 << (arprec % BIL_TYPE_SIZE))) != 0)
+	goto ovf_ex;
+      min_limbs = rn - low_zeros;
+    }
+  else
+    min_limbs = res_limbs;
+  if (low_zeros)
+    __builtin_memset (r + BITINT_END (rn - low_zeros, 0), '\0',
+		      low_zeros * sizeof (UBILtype));
+  if (sgn)
+    bitint_negate (r + BITINT_END (rn - low_zeros - 1, low_zeros),
+		   resv + BITINT_END (res_limbs - 1, 0), min_limbs);
+  else
+    __builtin_memcpy (r + BITINT_END (rn - low_zeros - min_limbs, low_zeros),
+		      resv + BITINT_END (res_limbs - min_limbs, 0),
+		      min_limbs * sizeof (UBILtype));
+  if (res_limbs + low_zeros < rn)
+    {
+      if (sgn)
+	__builtin_memset (r + BITINT_END (0, res_limbs + low_zeros), -1,
+			  (rn - res_limbs - low_zeros) * sizeof (UBILtype));
+      else
+	__builtin_memset (r + BITINT_END (0, res_limbs + low_zeros), '\0',
+			  (rn - res_limbs - low_zeros) * sizeof (UBILtype));
+    }
+  else if (sgn)
+    {
+      if ((r[BITINT_END (0, rn - 1)]
+	   & ((UBILtype) 1 << ((arprec - 1) % BIL_TYPE_SIZE))) == 0)
+	goto ovf_ex;
+    }
+  else if (rprec < 0
+	   && (r[BITINT_END (0, rn - 1)]
+	       & ((UBILtype) 1 << ((arprec - 1) % BIL_TYPE_SIZE))) != 0)
+    goto ovf_ex;
+
+done:
+  FP_HANDLE_EXCEPTIONS;
+}
+#endif
--- libgcc/soft-fp/fixtdbitint.c.jj	2023-08-08 16:21:45.953768373 +0200
+++ libgcc/soft-fp/fixtdbitint.c	2023-08-08 16:21:45.953768373 +0200
@@ -0,0 +1,242 @@
+/* Software floating-point emulation.
+   Convert _Decimal128 to signed or unsigned _BitInt.
+
+   Copyright (C) 2023 Free Software Foundation, Inc.
+
+This file is part of GCC.
+
+GCC is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free
+Software Foundation; either version 3, or (at your option) any later
+version.
+
+GCC 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 General Public License
+for more details.
+
+Under Section 7 of GPL version 3, you are granted additional
+permissions described in the GCC Runtime Library Exception, version
+3.1, as published by the Free Software Foundation.
+
+You should have received a copy of the GNU General Public License and
+a copy of the GCC Runtime Library Exception along with this program;
+see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+<http://www.gnu.org/licenses/>.  */
+
+#include "soft-fp.h"
+#include "bitint.h"
+
+#ifdef __BITINT_MAXWIDTH__
+extern void __bid_fixtdbitint (UBILtype *, SItype, _Decimal128);
+
+void
+__bid_fixtdbitint (UBILtype *r, SItype rprec, _Decimal128 a)
+{
+  FP_DECL_EX;
+  USItype arprec = rprec < 0 ? -rprec : rprec;
+  USItype rn = (arprec + BIL_TYPE_SIZE - 1) / BIL_TYPE_SIZE;
+  union { _Decimal128 d; UDItype u[2]; } u;
+  UDItype mantissahi, mantissalo, t;
+  SItype sgn;
+  SItype exponent;
+  USItype exp_bits, mant_bits;
+  UBILtype *pow10v, *resv;
+  USItype pow10_limbs, res_limbs, min_limbs, mant_limbs, low_zeros;
+
+  FP_INIT_EXCEPTIONS;
+  u.d = a;
+  mantissahi = u.u[__FLOAT_WORD_ORDER__ != __ORDER_BIG_ENDIAN__];
+  mantissalo = u.u[__FLOAT_WORD_ORDER__ == __ORDER_BIG_ENDIAN__];
+  t = mantissahi >> 47;
+  sgn = (DItype) mantissahi < 0;
+  if ((t & (3 << 14)) != (3 << 14))
+    {
+      mantissahi &= ((((UDItype) 1) << 49) - 1);
+      exponent = (t >> 2) & 0x3fff;
+    }
+  else if ((t & (3 << 12)) != (3 << 12))
+    {
+      mantissahi &= ((((UDItype) 1) << 47) - 1);
+      mantissahi |= ((UDItype) 1) << 49;
+      exponent = t & 0x3fff;
+      if (mantissahi > (UDItype) 0x1ed09bead87c0
+	  || (mantissahi == (UDItype) 0x1ed09bead87c0
+	      && mantissalo > 0x378d8e63ffffffff))
+	{
+	  mantissahi = 0;
+	  mantissalo = 0;
+	}
+    }
+  else
+    {
+      FP_SET_EXCEPTION (FP_EX_INVALID
+			| FP_EX_INVALID_CVI
+			| ((FP_EX_INVALID_SNAN
+			    && ((t & 0x800)) != 0)
+			   ? FP_EX_INVALID_SNAN : 0));
+    ovf:
+      if (!sgn)
+	__builtin_memset (r, -1, rn * sizeof (UBILtype));
+      else
+	__builtin_memset (r, 0, rn * sizeof (UBILtype));
+      if (sgn ^ (rprec >= 0))
+	r[BITINT_END (0, rn - 1)]
+	  |= (UBILtype) -1 << ((arprec - 1) % BIL_TYPE_SIZE);
+      else
+	r[BITINT_END (0, rn - 1)]
+	  &= ~((UBILtype) -1 << ((arprec - 1) % BIL_TYPE_SIZE));
+      goto done;
+    }
+  exponent -= 6176;
+
+  if (mantissahi == 0 && mantissalo == 0)
+    {
+      /* Zero (with any exponent).  */
+    zero:
+      __builtin_memset (r, 0, rn * sizeof (UBILtype));
+      goto done;
+    }
+  if (exponent <= -34)
+    {
+      FP_SET_EXCEPTION (FP_EX_INEXACT);
+      goto zero;
+    }
+  if (exponent < 0)
+    {
+      UBILtype limbs[4 * 128 / BIL_TYPE_SIZE];
+#if BIL_TYPE_SIZE == 64
+      limbs[BITINT_END (0, 1)] = mantissahi;
+      limbs[BITINT_END (1, 0)] = mantissalo;
+#elif BIL_TYPE_SIZE == 32
+      limbs[BITINT_END (0, 3)] = mantissahi >> 32;
+      limbs[BITINT_END (1, 2)] = mantissahi;
+      limbs[BITINT_END (2, 1)] = mantissalo >> 32;
+      limbs[BITINT_END (3, 0)] = mantissalo;
+#elif
+# error Unhandled BIL_TYPE_SIZE
+#endif
+      __bid_pow10bitint (&limbs[128 / BIL_TYPE_SIZE], 128, -exponent);
+      __divmodbitint4 (&limbs[2 * 128 / BIL_TYPE_SIZE], 128,
+		       &limbs[3 * 128 / BIL_TYPE_SIZE], 128,
+		       &limbs[0], 128, &limbs[128 / BIL_TYPE_SIZE], 128);
+      UDItype rem;
+#if BIL_TYPE_SIZE == 64
+      mantissahi = limbs[BITINT_END (4, 5)];
+      mantissalo = limbs[BITINT_END (5, 4)];
+      rem = limbs[6] | limbs[7];
+#elif BIL_TYPE_SIZE == 32
+      mantissahi = limbs[BITINT_END (8, 11)] << 32;
+      mantissahi |= limbs[BITINT_END (9, 10)];
+      mantissalo = limbs[BITINT_END (10, 9)] << 32;
+      mantissalo |= limbs[BITINT_END (11, 8)];
+      rem = limbs[12] | limbs[13] | limbs[14] | limbs[15];
+#endif
+      if (rem)
+	FP_SET_EXCEPTION (FP_EX_INEXACT);
+      if (mantissahi == 0 && mantissalo == 0)
+	goto zero;
+      exponent = 0;
+    }
+
+  if (rprec >= 0 && sgn)
+    {
+    ovf_ex:
+      FP_SET_EXCEPTION (FP_EX_INVALID | FP_EX_INVALID_CVI);
+      goto ovf;
+    }
+
+  /* Lower estimate for number of bits needed for pow10 (exponent).  */
+  exp_bits = exponent / 3;
+  exp_bits = exp_bits * 10 - exp_bits / 29;
+  if (mantissahi)
+    mant_bits = sizeof (0ULL) * __CHAR_BIT__ - __builtin_clzll (mantissahi)
+		+ 64;
+  else
+    mant_bits = sizeof (0ULL) * __CHAR_BIT__ - __builtin_clzll (mantissalo);
+  if (exp_bits + mant_bits > arprec + 1)
+    goto ovf_ex;
+  /* Upper estimate for number of bits needed for pow10 (exponent).  */
+  exp_bits = (exponent + 2) / 3;
+  exp_bits = exp_bits * 10 - exp_bits / 30;
+  if (exp_bits == 0)
+    exp_bits = 1;
+  pow10_limbs = (exp_bits + BIL_TYPE_SIZE - 1) / BIL_TYPE_SIZE;
+  pow10v = __builtin_alloca (pow10_limbs * sizeof (UBILtype));
+  low_zeros = __bid_pow10bitint (pow10v, exp_bits, exponent);
+
+  res_limbs = ((exp_bits + mant_bits + BIL_TYPE_SIZE - 1)
+	       / BIL_TYPE_SIZE) - low_zeros;
+  mant_limbs = (mant_bits + BIL_TYPE_SIZE - 1) / BIL_TYPE_SIZE;
+  resv = __builtin_alloca ((res_limbs + mant_limbs) * sizeof (UBILtype));
+#if BIL_TYPE_SIZE >= 64
+  if (mant_limbs == 1)
+    resv[res_limbs] = mantissalo;
+  else
+    {
+      resv[res_limbs + BITINT_END (1, 0)] = mantissalo;
+      resv[res_limbs + BITINT_END (0, 1)] = mantissahi;
+    }
+#else
+  resv[res_limbs + BITINT_END (mant_limbs - 1, 0)] = mantissalo;
+  if (mant_limbs >= 2)
+    {
+      resv[res_limbs + BITINT_END (mant_limbs - 2, 1)] = mantissalo >> 32;
+      if (mant_limbs >= 3)
+	{
+	  resv[res_limbs + BITINT_END (mant_limbs - 3, 2)] = mantissahi;
+	  if (mant_limbs == 4)
+	    resv[res_limbs + BITINT_END (0, 3)] = mantissahi >> 32;
+	}
+    }
+#endif
+  __mulbitint3 (resv, exp_bits + mant_bits - low_zeros * BIL_TYPE_SIZE,
+		resv + res_limbs, mant_bits,
+		pow10v + BITINT_END (0, low_zeros),
+		exp_bits - low_zeros * BIL_TYPE_SIZE);
+  if (res_limbs + low_zeros >= rn)
+    {
+      if (res_limbs + low_zeros > rn && resv[BITINT_END (0, res_limbs - 1)])
+	goto ovf_ex;
+      if ((arprec % BIL_TYPE_SIZE) != 0
+	  && (resv[BITINT_END (rn - res_limbs, rn - 1) - low_zeros]
+	      & ((UBILtype) -1 << (arprec % BIL_TYPE_SIZE))) != 0)
+	goto ovf_ex;
+      min_limbs = rn - low_zeros;
+    }
+  else
+    min_limbs = res_limbs;
+  if (low_zeros)
+    __builtin_memset (r + BITINT_END (rn - low_zeros, 0), '\0',
+		      low_zeros * sizeof (UBILtype));
+  if (sgn)
+    bitint_negate (r + BITINT_END (rn - low_zeros - 1, low_zeros),
+		   resv + BITINT_END (res_limbs - 1, 0), min_limbs);
+  else
+    __builtin_memcpy (r + BITINT_END (rn - low_zeros - min_limbs, low_zeros),
+		      resv + BITINT_END (res_limbs - min_limbs, 0),
+		      min_limbs * sizeof (UBILtype));
+  if (res_limbs + low_zeros < rn)
+    {
+      if (sgn)
+	__builtin_memset (r + BITINT_END (0, res_limbs + low_zeros), -1,
+			  (rn - res_limbs - low_zeros) * sizeof (UBILtype));
+      else
+	__builtin_memset (r + BITINT_END (0, res_limbs + low_zeros), '\0',
+			  (rn - res_limbs - low_zeros) * sizeof (UBILtype));
+    }
+  else if (sgn)
+    {
+      if ((r[BITINT_END (0, rn - 1)]
+	   & ((UBILtype) 1 << ((arprec - 1) % BIL_TYPE_SIZE))) == 0)
+	goto ovf_ex;
+    }
+  else if (rprec < 0
+	   && (r[BITINT_END (0, rn - 1)]
+	       & ((UBILtype) 1 << ((arprec - 1) % BIL_TYPE_SIZE))) != 0)
+    goto ovf_ex;
+
+done:
+  FP_HANDLE_EXCEPTIONS;
+}
+#endif
--- libgcc/soft-fp/floatbitintsd.c.jj	2023-08-08 16:22:09.405440134 +0200
+++ libgcc/soft-fp/floatbitintsd.c	2023-08-08 16:22:09.405440134 +0200
@@ -0,0 +1,235 @@
+/* Software floating-point emulation.
+   Convert a _BitInt to _Decimal32.
+
+   Copyright (C) 2023 Free Software Foundation, Inc.
+
+This file is part of GCC.
+
+GCC is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free
+Software Foundation; either version 3, or (at your option) any later
+version.
+
+GCC 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 General Public License
+for more details.
+
+Under Section 7 of GPL version 3, you are granted additional
+permissions described in the GCC Runtime Library Exception, version
+3.1, as published by the Free Software Foundation.
+
+You should have received a copy of the GNU General Public License and
+a copy of the GCC Runtime Library Exception along with this program;
+see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+<http://www.gnu.org/licenses/>.  */
+
+#include "soft-fp.h"
+#include "bitint.h"
+
+#ifdef __BITINT_MAXWIDTH__
+extern _Decimal32 __bid_floatbitintsd (const UBILtype *, SItype);
+
+_Decimal32
+__bid_floatbitintsd (const UBILtype *i, SItype iprec)
+{
+  iprec = bitint_reduce_prec (&i, iprec);
+  USItype aiprec = iprec < 0 ? -iprec : iprec;
+  USItype in = (aiprec + BIL_TYPE_SIZE - 1) / BIL_TYPE_SIZE;
+  USItype idx = BITINT_END (0, in - 1);
+  UBILtype msb = i[idx];
+  USItype mantissa;
+  SItype exponent = 0;
+  UBILtype inexact = 0;
+  union { _Decimal32 d; USItype u; } u, ui;
+  if (aiprec % BIL_TYPE_SIZE)
+    {
+      if (iprec > 0)
+	msb &= ((UBILtype) 1 << (aiprec % BIL_TYPE_SIZE)) - 1;
+      else
+	msb |= (UBILtype) -1 << (aiprec % BIL_TYPE_SIZE);
+    }
+  if (iprec < 0)
+    {
+      SItype n = sizeof (0ULL) * __CHAR_BIT__ + 1 - __builtin_clzll (~msb);
+      aiprec = (in - 1) * BIL_TYPE_SIZE + n;
+    }
+  else if (msb == 0)
+    aiprec = 1;
+  else
+    {
+      SItype n = sizeof (0ULL) * __CHAR_BIT__ - __builtin_clzll (msb);
+      aiprec = (in - 1) * BIL_TYPE_SIZE + n;
+    }
+  /* Number of bits in (_BitInt(2048)) 9999999e+90DF.  */
+  if (aiprec > 323 + (iprec < 0))
+    {
+    ovf:
+      if (iprec < 0)
+	u.d = -9000000e+90DF;
+      else
+	u.d = 9000000e+90DF;
+      __asm ("" : "+g" (u.d));
+      u.d += u.d;
+      __asm ("" : "+g" (u.d));
+      goto done;
+    }
+  /* Bit precision of 9999999uwb.  */
+  if (aiprec >= 24)
+    {
+      USItype pow10_limbs, q_limbs, q2_limbs, j;
+      USItype exp_bits = 0, e;
+      UDItype m;
+      UBILtype *buf;
+      /* First do a possibly large divide smaller enough such that
+	 we only need to check remainder for 0 or non-0 and then
+	 we'll do further division.  */
+      if (aiprec >= 24 + 4 + 10)
+	{
+	  exp_bits = (aiprec - 24 - 4) / 10;
+	  exponent = exp_bits * 3;
+	  /* Upper estimate for pow10 (exponent) bits.  */
+	  exp_bits = exp_bits * 10 - exp_bits / 30;
+	}
+      pow10_limbs = (exp_bits + BIL_TYPE_SIZE - 1) / BIL_TYPE_SIZE;
+      /* 38 is the highest number of quotient bits needed on
+	 aiprec range of [38, 323].  E.g. if aiprec is 317,
+	 exponent will be 84 and exp_bits 280.  317 - 280 + 1
+	 is 38.  */
+      q_limbs = (38 + BIL_TYPE_SIZE - 1) / BIL_TYPE_SIZE;
+      q2_limbs = (32 + BIL_TYPE_SIZE - 1) / BIL_TYPE_SIZE;
+      buf = __builtin_alloca ((q_limbs + pow10_limbs * 2 + q2_limbs + 2)
+			      * sizeof (UBILtype));
+      if (exponent)
+	{
+	  __bid_pow10bitint (buf + q_limbs, exp_bits, exponent);
+	  __divmodbitint4 (buf, q_limbs * BIL_TYPE_SIZE,
+			   buf + q_limbs + pow10_limbs,
+			   pow10_limbs * BIL_TYPE_SIZE,
+			   i, iprec < 0 ? -aiprec : aiprec,
+			   buf + q_limbs, exp_bits);
+	  if (iprec < 0)
+	    bitint_negate (buf + BITINT_END (q_limbs - 1, 0),
+			   buf + BITINT_END (q_limbs - 1, 0), q_limbs);
+	  inexact = buf[q_limbs + pow10_limbs];
+	  for (j = 1; j < pow10_limbs; ++j)
+	    inexact |= buf[q_limbs + pow10_limbs + 1];
+	}
+      else
+	{
+	  __builtin_memcpy (buf + BITINT_END (q_limbs - in + 1, 0), i,
+			    (in - 1) * sizeof (UBILtype));
+	  buf[BITINT_END (q_limbs - in, in - 1)] = msb;
+	  if (iprec < 0)
+	    bitint_negate (buf + BITINT_END (q_limbs - 1, 0),
+			   buf + BITINT_END (q_limbs - 1, 0), in);
+	  if (q_limbs > in)
+	    __builtin_memset (buf + BITINT_END (0, in), '\0',
+			      (q_limbs - in) * sizeof (UBILtype));
+	}
+      e = 0;
+#if BIL_TYPE_SIZE == 64
+      m = buf[0];
+#elif BIL_TYPE_SIZE == 32
+      m = ((UDItype) buf[BITINT_END (0, 1)] << 32) | buf[BITINT_END (1, 0)];
+#else
+# error Unsupported BIL_TYPE_SIZE
+#endif
+      if (m >= (UDItype) 10000000000)
+	{
+	  if (m >= (UDItype) 100000000000)
+	    e = 5;
+	  else
+	    e = 4;
+	}
+      else if (m >= (UDItype) 100000000)
+	{
+	  if (m >= (UDItype) 1000000000)
+	    e = 3;
+	  else
+	    e = 2;
+	}
+      else if (m >= (UDItype) 10000000)
+	e = 1;
+      exponent += e;
+      if (exponent > 90)
+	goto ovf;
+      if (e)
+	{
+	  UBILtype rem, half;
+	  __bid_pow10bitint (buf + q_limbs + pow10_limbs * 2,
+			     BIL_TYPE_SIZE, e);
+	  __divmodbitint4 (buf + q_limbs + pow10_limbs * 2 + 1,
+			   q2_limbs * BIL_TYPE_SIZE,
+			   buf + q_limbs + pow10_limbs * 2 + 1 + q2_limbs,
+			   BIL_TYPE_SIZE,
+			   buf, q_limbs * BIL_TYPE_SIZE,
+			   buf + q_limbs + pow10_limbs * 2, BIL_TYPE_SIZE);
+	  half = buf[q_limbs + pow10_limbs * 2] / 2;
+	  rem = buf[q_limbs + pow10_limbs * 2 + 1 + q2_limbs];
+	  if (inexact)
+	    {
+	      /* If first division discovered some non-0 digits
+		 and this second division is by 10, e.g.
+		 for XXXXXX5499999999999 or XXXXXX5000000000001
+		 if first division is by 10^12 and second by 10^1,
+		 doing rem |= 1 wouldn't change the 5.  Similarly
+		 for rem 4 doing rem |= 1 would change it to 5,
+		 but we don't want to change it in that case.  */
+	      if (e == 1)
+		{
+		  if (rem == 5)
+		    rem = 6;
+		  else if (rem != 4)
+		    rem |= 1;
+		}
+	      else
+		rem |= 1;
+	    }
+	  /* Set inexact to 0, 1, 2, 3 depending on if remainder
+	     of the divisions is exact 0, smaller than 10^exponent / 2,
+	     exactly 10^exponent / 2 or greater than that.  */
+	  if (rem >= half)
+	    inexact = 2 + (rem > half);
+	  else
+	    inexact = (rem != 0);
+	  mantissa = buf[q_limbs + pow10_limbs * 2 + 1];
+	}
+      else
+#if BIL_TYPE_SIZE == 64
+	mantissa = buf[0];
+#else
+	mantissa = buf[BITINT_END (1, 0)];
+#endif
+    }
+  else
+    {
+      mantissa = msb;
+      if (iprec < 0)
+	mantissa = -mantissa;
+    }
+
+  exponent += 101;
+  if (mantissa >= (USItype) 0x800000)
+    u.u = (((((iprec < 0) << 2) | (USItype) 3) << 29)
+	   | (((USItype) exponent) << 21)
+	   | (mantissa ^ (USItype) 0x800000));
+  else
+    u.u = ((((USItype) (iprec < 0)) << 31)
+	   | (((USItype) exponent) << 23)
+	   | mantissa);
+  if (inexact)
+    {
+      ui.u = ((((USItype) (iprec < 0)) << 31)
+	      | (((USItype) (exponent - 1)) << 23)
+	      | (inexact + 3));
+      __asm ("" : "+g" (u.d));
+      __asm ("" : "+g" (ui.d));
+      u.d += ui.d;
+      __asm ("" : "+g" (u.d));
+    }
+
+done:
+  return u.d;
+}
+#endif
--- libgcc/soft-fp/floatbitintdd.c.jj	2023-08-08 16:22:09.405440134 +0200
+++ libgcc/soft-fp/floatbitintdd.c	2023-08-08 16:22:09.405440134 +0200
@@ -0,0 +1,264 @@
+/* Software floating-point emulation.
+   Convert a _BitInt to _Decimal64.
+
+   Copyright (C) 2023 Free Software Foundation, Inc.
+
+This file is part of GCC.
+
+GCC is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free
+Software Foundation; either version 3, or (at your option) any later
+version.
+
+GCC 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 General Public License
+for more details.
+
+Under Section 7 of GPL version 3, you are granted additional
+permissions described in the GCC Runtime Library Exception, version
+3.1, as published by the Free Software Foundation.
+
+You should have received a copy of the GNU General Public License and
+a copy of the GCC Runtime Library Exception along with this program;
+see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+<http://www.gnu.org/licenses/>.  */
+
+#include "soft-fp.h"
+#include "bitint.h"
+
+#ifdef __BITINT_MAXWIDTH__
+extern _Decimal64 __bid_floatbitintdd (const UBILtype *, SItype);
+
+_Decimal64
+__bid_floatbitintdd (const UBILtype *i, SItype iprec)
+{
+  iprec = bitint_reduce_prec (&i, iprec);
+  USItype aiprec = iprec < 0 ? -iprec : iprec;
+  USItype in = (aiprec + BIL_TYPE_SIZE - 1) / BIL_TYPE_SIZE;
+  USItype idx = BITINT_END (0, in - 1);
+  UBILtype msb = i[idx];
+  UDItype mantissa;
+  SItype exponent = 0;
+  UBILtype inexact = 0;
+  union { _Decimal64 d; UDItype u; } u, ui;
+  if (aiprec % BIL_TYPE_SIZE)
+    {
+      if (iprec > 0)
+	msb &= ((UBILtype) 1 << (aiprec % BIL_TYPE_SIZE)) - 1;
+      else
+	msb |= (UBILtype) -1 << (aiprec % BIL_TYPE_SIZE);
+    }
+  if (iprec < 0)
+    {
+      SItype n = sizeof (0ULL) * __CHAR_BIT__ + 1 - __builtin_clzll (~msb);
+      aiprec = (in - 1) * BIL_TYPE_SIZE + n;
+    }
+  else if (msb == 0)
+    aiprec = 1;
+  else
+    {
+      SItype n = sizeof (0ULL) * __CHAR_BIT__ - __builtin_clzll (msb);
+      aiprec = (in - 1) * BIL_TYPE_SIZE + n;
+    }
+  /* Number of bits in (_BitInt(2048)) 9999999999999999e+369DD.  */
+  if (aiprec > 1279 + (iprec < 0))
+    {
+    ovf:
+      if (iprec < 0)
+	u.d = -9000000000000000e+369DD;
+      else
+	u.d = 9000000000000000e+369DD;
+      __asm ("" : "+g" (u.d));
+      u.d += u.d;
+      __asm ("" : "+g" (u.d));
+      goto done;
+    }
+  /* Bit precision of 9999999999999999uwb.  */
+  if (aiprec >= 54)
+    {
+      USItype pow10_limbs, q_limbs, q2_limbs, j;
+      USItype exp_bits = 0, e;
+      UDItype m;
+      UBILtype *buf;
+      /* First do a possibly large divide smaller enough such that
+	 we only need to check remainder for 0 or non-0 and then
+	 we'll do further division.  */
+      if (aiprec >= 54 + 4 + 10)
+	{
+	  exp_bits = (aiprec - 54 - 4) / 10;
+	  exponent = exp_bits * 3;
+	  /* Upper estimate for pow10 (exponent) bits.  */
+	  exp_bits = exp_bits * 10 - exp_bits / 30;
+	}
+      pow10_limbs = (exp_bits + BIL_TYPE_SIZE - 1) / BIL_TYPE_SIZE;
+      /* 72 is the highest number of quotient bits needed on
+	 aiprec range of [68, 1279].  E.g. if aiprec is 1277,
+	 exponent will be 363 and exp_bits 1206.  1277 - 1206 + 1
+	 is 72.  Unfortunately that means the result doesn't fit into
+	 UDItype...  */
+      q_limbs = (72 + BIL_TYPE_SIZE - 1) / BIL_TYPE_SIZE;
+      q2_limbs = 64 / BIL_TYPE_SIZE;
+      buf = __builtin_alloca ((q_limbs + pow10_limbs * 2 + q2_limbs + 2)
+			      * sizeof (UBILtype));
+      if (exponent)
+	{
+	  __bid_pow10bitint (buf + q_limbs, exp_bits, exponent);
+	  __divmodbitint4 (buf, q_limbs * BIL_TYPE_SIZE,
+			   buf + q_limbs + pow10_limbs,
+			   pow10_limbs * BIL_TYPE_SIZE,
+			   i, iprec < 0 ? -aiprec : aiprec,
+			   buf + q_limbs, exp_bits);
+	  if (iprec < 0)
+	    bitint_negate (buf + BITINT_END (q_limbs - 1, 0),
+			   buf + BITINT_END (q_limbs - 1, 0), q_limbs);
+	  inexact = buf[q_limbs + pow10_limbs];
+	  for (j = 1; j < pow10_limbs; ++j)
+	    inexact |= buf[q_limbs + pow10_limbs + 1];
+	}
+      else
+	{
+	  __builtin_memcpy (buf + BITINT_END (q_limbs - in + 1, 0), i,
+			    (in - 1) * sizeof (UBILtype));
+	  buf[BITINT_END (q_limbs - in, in - 1)] = msb;
+	  if (iprec < 0)
+	    bitint_negate (buf + BITINT_END (q_limbs - 1, 0),
+			   buf + BITINT_END (q_limbs - 1, 0), in);
+	  if (q_limbs > in)
+	    __builtin_memset (buf + BITINT_END (0, in), '\0',
+			      (q_limbs - in) * sizeof (UBILtype));
+	}
+      e = 0;
+#if BIL_TYPE_SIZE == 64
+      m = buf[BITINT_END (1, 0)];
+#elif BIL_TYPE_SIZE == 32
+      m = ((UDItype) buf[1] << 32) | buf[BITINT_END (2, 0)];
+#else
+# error Unsupported BIL_TYPE_SIZE
+#endif
+      if (buf[BITINT_END (0, q_limbs - 1)])
+	{
+	  if (buf[BITINT_END (0, q_limbs - 1)] > 0x5)
+	    {
+	      /* 1000000000000000000000wb */
+	      if (buf[BITINT_END (0, q_limbs - 1)] > 0x36
+		  || (buf[BITINT_END (0, q_limbs - 1)] == 0x36
+		      && m >= (UDItype) 0x35c9adc5dea00000))
+		e = 6;
+	      else
+		e = 5;
+	    }
+	  /* 100000000000000000000wb */
+	  else if (buf[BITINT_END (0, q_limbs - 1)] == 0x5
+		   && m >= (UDItype) 0x6bc75e2d63100000)
+	    e = 5;
+	  else
+	    e = 4;
+	}
+      else if (m >= (UDItype) 1000000000000000000)
+	{
+	  if (m >= (UDItype) 10000000000000000000ULL)
+	    e = 4;
+	  else
+	    e = 3;
+	}
+      else if (m >= (UDItype) 100000000000000000)
+	e = 2;
+      else if (m >= (UDItype) 10000000000000000)
+	e = 1;
+      exponent += e;
+      if (exponent > 369)
+	goto ovf;
+      if (e)
+	{
+	  UBILtype rem, half;
+	  __bid_pow10bitint (buf + q_limbs + pow10_limbs * 2,
+			     BIL_TYPE_SIZE, e);
+	  __divmodbitint4 (buf + q_limbs + pow10_limbs * 2 + 1,
+			   q2_limbs * BIL_TYPE_SIZE,
+			   buf + q_limbs + pow10_limbs * 2 + 1 + q2_limbs,
+			   BIL_TYPE_SIZE,
+			   buf, q_limbs * BIL_TYPE_SIZE,
+			   buf + q_limbs + pow10_limbs * 2, BIL_TYPE_SIZE);
+	  half = buf[q_limbs + pow10_limbs * 2] / 2;
+	  rem = buf[q_limbs + pow10_limbs * 2 + 1 + q2_limbs];
+	  if (inexact)
+	    {
+	      /* If first division discovered some non-0 digits
+		 and this second division is by 10, e.g.
+		 for XXXXXX5499999999999 or XXXXXX5000000000001
+		 if first division is by 10^12 and second by 10^1,
+		 doing rem |= 1 wouldn't change the 5.  Similarly
+		 for rem 4 doing rem |= 1 would change it to 5,
+		 but we don't want to change it in that case.  */
+	      if (e == 1)
+		{
+		  if (rem == 5)
+		    rem = 6;
+		  else if (rem != 4)
+		    rem |= 1;
+		}
+	      else
+		rem |= 1;
+	    }
+	  /* Set inexact to 0, 1, 2, 3 depending on if remainder
+	     of the divisions is exact 0, smaller than 10^exponent / 2,
+	     exactly 10^exponent / 2 or greater than that.  */
+	  if (rem >= half)
+	    inexact = 2 + (rem > half);
+	  else
+	    inexact = (rem != 0);
+#if BIL_TYPE_SIZE == 64
+	  mantissa = buf[q_limbs + pow10_limbs * 2 + 1];
+#else
+	  mantissa
+	    = ((buf[q_limbs + pow10_limbs * 2 + 1 + BITINT_END (0, 1)] << 32)
+	       | buf[q_limbs + pow10_limbs * 2 + 1 + BITINT_END (1, 0)]);
+#endif
+	}
+      else
+#if BIL_TYPE_SIZE == 64
+	mantissa = buf[BITINT_END (1, 0)];
+#else
+	mantissa
+	  = ((buf[1] << 32) | buf[BITINT_END (2, 0)]);
+#endif
+    }
+  else
+    {
+#if BIL_TYPE_SIZE == 64
+      mantissa = msb;
+#else
+      if (in == 1)
+	mantissa = iprec < 0 ? (UDItype) (BILtype) msb : (UDItype) msb;
+      else
+	mantissa = ((msb << 32) | i[BITINT_END (1, 0)]);
+#endif
+      if (iprec < 0)
+	mantissa = -mantissa;
+    }
+
+  exponent += 398;
+  if (mantissa >= (UDItype) 0x20000000000000)
+    u.u = (((((iprec < 0) << 2) | (UDItype) 3) << 61)
+	   | (((UDItype) exponent) << 51)
+	   | (mantissa ^ (UDItype) 0x20000000000000));
+  else
+    u.u = ((((UDItype) (iprec < 0)) << 63)
+	   | (((UDItype) exponent) << 53)
+	   | mantissa);
+  if (inexact)
+    {
+      ui.u = ((((UDItype) (iprec < 0)) << 63)
+	      | (((UDItype) (exponent - 1)) << 53)
+	      | (inexact + 3));
+      __asm ("" : "+g" (u.d));
+      __asm ("" : "+g" (ui.d));
+      u.d += ui.d;
+      __asm ("" : "+g" (u.d));
+    }
+
+done:
+  return u.d;
+}
+#endif
--- libgcc/soft-fp/floatbitinttd.c.jj	2023-08-08 16:22:09.405440134 +0200
+++ libgcc/soft-fp/floatbitinttd.c	2023-08-08 16:22:09.405440134 +0200
@@ -0,0 +1,271 @@
+/* Software floating-point emulation.
+   Convert a _BitInt to _Decimal128.
+
+   Copyright (C) 2023 Free Software Foundation, Inc.
+
+This file is part of GCC.
+
+GCC is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free
+Software Foundation; either version 3, or (at your option) any later
+version.
+
+GCC 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 General Public License
+for more details.
+
+Under Section 7 of GPL version 3, you are granted additional
+permissions described in the GCC Runtime Library Exception, version
+3.1, as published by the Free Software Foundation.
+
+You should have received a copy of the GNU General Public License and
+a copy of the GCC Runtime Library Exception along with this program;
+see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+<http://www.gnu.org/licenses/>.  */
+
+#include "soft-fp.h"
+#include "bitint.h"
+
+#ifdef __BITINT_MAXWIDTH__
+extern _Decimal128 __bid_floatbitinttd (const UBILtype *, SItype);
+
+_Decimal128
+__bid_floatbitinttd (const UBILtype *i, SItype iprec)
+{
+  iprec = bitint_reduce_prec (&i, iprec);
+  USItype aiprec = iprec < 0 ? -iprec : iprec;
+  USItype in = (aiprec + BIL_TYPE_SIZE - 1) / BIL_TYPE_SIZE;
+  USItype idx = BITINT_END (0, in - 1);
+  UBILtype msb = i[idx];
+  UDItype mantissahi, mantissalo;
+  SItype exponent = 0;
+  UBILtype inexact = 0;
+  union { _Decimal128 d; UDItype u[2]; } u, ui;
+  if (aiprec % BIL_TYPE_SIZE)
+    {
+      if (iprec > 0)
+	msb &= ((UBILtype) 1 << (aiprec % BIL_TYPE_SIZE)) - 1;
+      else
+	msb |= (UBILtype) -1 << (aiprec % BIL_TYPE_SIZE);
+    }
+  if (iprec < 0)
+    {
+      SItype n = sizeof (0ULL) * __CHAR_BIT__ + 1 - __builtin_clzll (~msb);
+      aiprec = (in - 1) * BIL_TYPE_SIZE + n;
+    }
+  else if (msb == 0)
+    aiprec = 1;
+  else
+    {
+      SItype n = sizeof (0ULL) * __CHAR_BIT__ - __builtin_clzll (msb);
+      aiprec = (in - 1) * BIL_TYPE_SIZE + n;
+    }
+  /* Number of bits in
+     (_BitInt(32768)) 9999999999999999999999999999999999e+6111DL.  */
+  if (aiprec > 20414 + (iprec < 0))
+    {
+    ovf:
+      if (iprec < 0)
+	u.d = -9000000000000000000000000000000000e+6111DL;
+      else
+	u.d = 9000000000000000000000000000000000e+6111DL;
+      __asm ("" : "+g" (u.d));
+      u.d += u.d;
+      __asm ("" : "+g" (u.d));
+      goto done;
+    }
+  /* Bit precision of 9999999999999999999999999999999999uwb.  */
+  if (aiprec >= 113)
+    {
+      USItype pow10_limbs, q_limbs, q2_limbs, j, k;
+      USItype exp_bits = 0, e;
+      UBILtype *buf;
+      /* First do a possibly large divide smaller enough such that
+	 we only need to check remainder for 0 or non-0 and then
+	 we'll do further division.  */
+      if (aiprec >= 113 + 4 + 10)
+	{
+	  exp_bits = ((aiprec - 113 - 4) * (UDItype) 30) / 299;
+	  exponent = exp_bits * 3;
+	  /* Upper estimate for pow10 (exponent) bits.  */
+	  exp_bits = exp_bits * 10 - exp_bits / 30;
+	}
+      pow10_limbs = (exp_bits + BIL_TYPE_SIZE - 1) / BIL_TYPE_SIZE;
+      /* 127 is the highest number of quotient bits needed on
+	 aiprec range of [127, 20414].  E.g. if aiprec is 20409,
+	 exponent will be 6105 and exp_bits 20283.  20409 - 20283 + 1
+	 is 127.  */
+      q_limbs = (127 + BIL_TYPE_SIZE - 1) / BIL_TYPE_SIZE;
+      q2_limbs = 128 / BIL_TYPE_SIZE;
+      buf = __builtin_alloca ((q_limbs + pow10_limbs * 2 + q2_limbs + 2)
+			      * sizeof (UBILtype));
+      if (exponent)
+	{
+	  __bid_pow10bitint (buf + q_limbs, exp_bits, exponent);
+	  __divmodbitint4 (buf, q_limbs * BIL_TYPE_SIZE,
+			   buf + q_limbs + pow10_limbs,
+			   pow10_limbs * BIL_TYPE_SIZE,
+			   i, iprec < 0 ? -aiprec : aiprec,
+			   buf + q_limbs, exp_bits);
+	  if (iprec < 0)
+	    bitint_negate (buf + BITINT_END (q_limbs - 1, 0),
+			   buf + BITINT_END (q_limbs - 1, 0), q_limbs);
+	  inexact = buf[q_limbs + pow10_limbs];
+	  for (j = 1; j < pow10_limbs; ++j)
+	    inexact |= buf[q_limbs + pow10_limbs + 1];
+	}
+      else
+	{
+	  __builtin_memcpy (buf + BITINT_END (q_limbs - in + 1, 0), i,
+			    (in - 1) * sizeof (UBILtype));
+	  buf[BITINT_END (q_limbs - in, in - 1)] = msb;
+	  if (iprec < 0)
+	    bitint_negate (buf + BITINT_END (q_limbs - 1, 0),
+			   buf + BITINT_END (q_limbs - 1, 0), in);
+	  if (q_limbs > in)
+	    __builtin_memset (buf + BITINT_END (0, in), '\0',
+			      (q_limbs - in) * sizeof (UBILtype));
+	}
+      e = 0;
+      for (j = 3; j; )
+	{
+	  USItype eprev = e;
+	  __bid_pow10bitint (buf + q_limbs + pow10_limbs * 2 + 1,
+			     128, 33 + e + j);
+	  for (k = BITINT_END (0, q_limbs - 1);
+	       k != BITINT_END (q_limbs, (USItype) -1); k -= BITINT_INC)
+	    if (buf[k] > buf[q_limbs + pow10_limbs * 2 + 1 + k])
+	      {
+		e += j;
+		break;
+	      }
+	    else if (buf[k] < buf[q_limbs + pow10_limbs * 2 + 1 + k])
+	      break;
+	  if (k == BITINT_END (q_limbs, (USItype) -1))
+	    e += j;
+	  if (j == 2 && e != eprev)
+	    break;
+	  else
+	    --j;
+	}
+      exponent += e;
+      if (exponent > 6111)
+	goto ovf;
+      if (e)
+	{
+	  UBILtype rem, half;
+	  __bid_pow10bitint (buf + q_limbs + pow10_limbs * 2,
+			     BIL_TYPE_SIZE, e);
+	  __divmodbitint4 (buf + q_limbs + pow10_limbs * 2 + 1,
+			   q2_limbs * BIL_TYPE_SIZE,
+			   buf + q_limbs + pow10_limbs * 2 + 1 + q2_limbs,
+			   BIL_TYPE_SIZE,
+			   buf, q_limbs * BIL_TYPE_SIZE,
+			   buf + q_limbs + pow10_limbs * 2, BIL_TYPE_SIZE);
+	  half = buf[q_limbs + pow10_limbs * 2] / 2;
+	  rem = buf[q_limbs + pow10_limbs * 2 + 1 + q2_limbs];
+	  if (inexact)
+	    {
+	      /* If first division discovered some non-0 digits
+		 and this second division is by 10, e.g.
+		 for XXXXXX5499999999999 or XXXXXX5000000000001
+		 if first division is by 10^12 and second by 10^1,
+		 doing rem |= 1 wouldn't change the 5.  Similarly
+		 for rem 4 doing rem |= 1 would change it to 5,
+		 but we don't want to change it in that case.  */
+	      if (e == 1)
+		{
+		  if (rem == 5)
+		    rem = 6;
+		  else if (rem != 4)
+		    rem |= 1;
+		}
+	      else
+		rem |= 1;
+	    }
+	  /* Set inexact to 0, 1, 2, 3 depending on if remainder
+	     of the divisions is exact 0, smaller than 10^exponent / 2,
+	     exactly 10^exponent / 2 or greater than that.  */
+	  if (rem >= half)
+	    inexact = 2 + (rem > half);
+	  else
+	    inexact = (rem != 0);
+#if BIL_TYPE_SIZE == 64
+	  mantissahi = buf[q_limbs + pow10_limbs * 2 + 1 + BITINT_END (0, 1)];
+	  mantissalo = buf[q_limbs + pow10_limbs * 2 + 1 + BITINT_END (1, 0)];
+#else
+	  mantissahi
+	    = ((buf[q_limbs + pow10_limbs * 2 + 1 + BITINT_END (0, 3)] << 32)
+	       | buf[q_limbs + pow10_limbs * 2 + 1 + BITINT_END (1, 2)]);
+	  mantissalo
+	    = ((buf[q_limbs + pow10_limbs * 2 + 1 + BITINT_END (2, 1)] << 32)
+	       | buf[q_limbs + pow10_limbs * 2 + 1 + BITINT_END (3, 0)]);
+#endif
+	}
+      else
+	{
+#if BIL_TYPE_SIZE == 64
+	  mantissahi = buf[BITINT_END (0, 1)];
+	  mantissalo = buf[BITINT_END (1, 0)];
+#else
+	  mantissahi = (buf[BITINT_END (0, 3)] << 32) | buf[BITINT_END (1, 2)];
+	  mantissalo = (buf[BITINT_END (2, 1)] << 32) | buf[BITINT_END (3, 0)];
+#endif
+	}
+    }
+  else
+    {
+      mantissahi = iprec < 0 ? -1 : 0;
+#if BIL_TYPE_SIZE == 64
+      if (in == 1)
+	mantissalo = msb;
+      else
+	{
+	  mantissahi = msb;
+	  mantissalo = i[BITINT_END (1, 0)];
+	}
+#else
+      if (in <= 2)
+	{
+	  if (in == 1)
+	    mantissalo = iprec < 0 ? (UDItype) (BILtype) msb : (UDItype) msb;
+	  else
+	    mantissalo = (msb << 32) | i[BITINT_END (1, 0)];
+	}
+      else
+	{
+	  if (in == 3)
+	    mantissahi = iprec < 0 ? (UDItype) (BILtype) msb : (UDItype) msb;
+	  else
+	    mantissahi = (msb << 32) | i[BITINT_END (1, 2)];
+	  mantissalo = ((i[BITINT_END (in - 2, 1)] << 32)
+			| i[BITINT_END (in - 1, 0)]);
+	}
+#endif
+      if (iprec < 0)
+	mantissahi
+	  = ~mantissahi + __builtin_add_overflow (~mantissalo, 1, &mantissalo);
+    }
+
+  exponent += 6176;
+  u.u[__FLOAT_WORD_ORDER__ != __ORDER_BIG_ENDIAN__]
+    = ((((UDItype) (iprec < 0)) << 63)
+       | (((UDItype) exponent) << 49)
+       | mantissahi);
+  u.u[__FLOAT_WORD_ORDER__ == __ORDER_BIG_ENDIAN__] = mantissalo;
+  if (inexact)
+    {
+      ui.u[__FLOAT_WORD_ORDER__ != __ORDER_BIG_ENDIAN__]
+	= (((UDItype) (iprec < 0)) << 63) | (((UDItype) exponent - 1) << 49);
+      ui.u[__FLOAT_WORD_ORDER__ == __ORDER_BIG_ENDIAN__] = inexact + 3;
+      __asm ("" : "+g" (u.d));
+      __asm ("" : "+g" (ui.d));
+      u.d += ui.d;
+      __asm ("" : "+g" (u.d));
+    }
+
+done:
+  return u.d;
+}
+#endif
