path: root/sys-libs/glibc/files/glibc-divdi3.diff

--- libc/sysdeps/i386/Makefile.jj       Fri Sep 17 18:59:13 1999
+++ libc/sysdeps/i386/Makefile  Thu Feb 28 19:04:03 2002
@@ -9,6 +9,12 @@ ifeq ($(subdir),csu)
 # On i686 we must avoid generating the trampoline functions generated
 # to get the GOT pointer.
 CFLAGS-initfini.s += -march=i386 -mcpu=i386
+
+ifeq (yes,$(build-shared))
+# Compatibility
+sysdep_routines += divdi3
+shared-only-routines += divdi3
+endif
 endif
 
 ifeq ($(subdir),db2)
--- libc/sysdeps/m68k/Makefile.jj       Thu Aug 23 18:49:59 2001
+++ libc/sysdeps/m68k/Makefile  Thu Feb 28 19:04:29 2002
@@ -33,6 +33,14 @@ CFLAGS-setjmp.c := -fno-omit-frame-point
 # The 68k `long double' is a distinct type we support.
 long-double-fcts = yes
 
+ifeq ($(subdir),csu)
+ifeq (yes,$(build-shared))
+# Compatibility
+sysdep_routines += divdi3
+shared-only-routines += divdi3
+endif
+endif
+
 ifeq ($(subdir),elf)
 CFLAGS-rtld.c += -Wno-uninitialized -Wno-unused
 endif
--- libc/sysdeps/s390/s390-32/Makefile.jj       Fri Mar 16 09:59:44 2001
+++ libc/sysdeps/s390/s390-32/Makefile  Thu Feb 28 19:04:44 2002
@@ -1,5 +1,13 @@
 pic-ccflag = -fpic
 
+ifeq ($(subdir),csu)
+ifeq (yes,$(build-shared))
+# Compatibility
+sysdep_routines += divdi3
+shared-only-routines += divdi3
+endif
+endif
+
 ifeq ($(subdir),gmon)
 sysdep_routines += s390-mcount
 endif
--- libc/sysdeps/wordsize-32/divdi3.c.jj        Thu Feb 28 18:53:16 2002
+++ libc/sysdeps/wordsize-32/divdi3.c   Thu Feb 28 19:02:18 2002
@@ -0,0 +1,327 @@
+/* 64-bit multiplication and division
+   Copyright (C) 1989, 1992-1999, 2000, 2001, 2002
+   Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   The GNU C Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library; if not, write to the Free
+   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+   02111-1307 USA.  */
+
+#include <endian.h>
+#include <stdlib.h>
+#include <bits/wordsize.h>
+
+#if __WORDSIZE != 32
+#error This is for 32-bit targets only
+#endif
+
+typedef unsigned int UQItype   __attribute__ ((mode (QI)));
+typedef          int SItype    __attribute__ ((mode (SI)));
+typedef unsigned int USItype   __attribute__ ((mode (SI)));
+typedef          int DItype    __attribute__ ((mode (DI)));
+typedef unsigned int UDItype   __attribute__ ((mode (DI)));
+#define Wtype SItype
+#define HWtype SItype
+#define DWtype DItype
+#define UWtype USItype
+#define UHWtype USItype
+#define UDWtype UDItype
+#define W_TYPE_SIZE 32
+
+#include <stdlib/longlong.h>
+
+#if __BYTE_ORDER == __BIG_ENDIAN
+struct DWstruct { Wtype high, low;};
+#elif __BYTE_ORDER == __LITTLE_ENDIAN
+struct DWstruct { Wtype low, high;};
+#else
+#error Unhandled endianity
+#endif
+typedef union { struct DWstruct s; DWtype ll; } DWunion;
+
+static UDWtype
+__udivmoddi4 (UDWtype n, UDWtype d, UDWtype *rp)
+{
+  DWunion ww;
+  DWunion nn, dd;
+  DWunion rr;
+  UWtype d0, d1, n0, n1, n2;
+  UWtype q0, q1;
+  UWtype b, bm;
+
+  nn.ll = n;
+  dd.ll = d;
+
+  d0 = dd.s.low;
+  d1 = dd.s.high;
+  n0 = nn.s.low;
+  n1 = nn.s.high;
+
+#if !UDIV_NEEDS_NORMALIZATION
+  if (d1 == 0)
+    {
+      if (d0 > n1)
+       {
+         /* 0q = nn / 0D */
+
+         udiv_qrnnd (q0, n0, n1, n0, d0);
+         q1 = 0;
+
+         /* Remainder in n0.  */
+       }
+      else
+       {
+         /* qq = NN / 0d */
+
+         if (d0 == 0)
+           d0 = 1 / d0;        /* Divide intentionally by zero.  */
+
+         udiv_qrnnd (q1, n1, 0, n1, d0);
+         udiv_qrnnd (q0, n0, n1, n0, d0);
+
+         /* Remainder in n0.  */
+       }
+
+      if (rp != 0)
+       {
+         rr.s.low = n0;
+         rr.s.high = 0;
+         *rp = rr.ll;
+       }
+    }
+
+#else /* UDIV_NEEDS_NORMALIZATION */
+
+  if (d1 == 0)
+    {
+      if (d0 > n1)
+       {
+         /* 0q = nn / 0D */
+
+         count_leading_zeros (bm, d0);
+
+         if (bm != 0)
+           {
+             /* Normalize, i.e. make the most significant bit of the
+                denominator set.  */
+
+             d0 = d0 << bm;
+             n1 = (n1 << bm) | (n0 >> (W_TYPE_SIZE - bm));
+             n0 = n0 << bm;
+           }
+
+         udiv_qrnnd (q0, n0, n1, n0, d0);
+         q1 = 0;
+
+         /* Remainder in n0 >> bm.  */
+       }
+      else
+       {
+         /* qq = NN / 0d */
+
+         if (d0 == 0)
+           d0 = 1 / d0;        /* Divide intentionally by zero.  */
+
+         count_leading_zeros (bm, d0);
+
+         if (bm == 0)
+           {
+             /* From (n1 >= d0) /\ (the most significant bit of d0 is set),
+                conclude (the most significant bit of n1 is set) /\ (the
+                leading quotient digit q1 = 1).
+
+                This special case is necessary, not an optimization.
+                (Shifts counts of W_TYPE_SIZE are undefined.)  */
+
+             n1 -= d0;
+             q1 = 1;
+           }
+         else
+           {
+             /* Normalize.  */
+
+             b = W_TYPE_SIZE - bm;
+
+             d0 = d0 << bm;
+             n2 = n1 >> b;
+             n1 = (n1 << bm) | (n0 >> b);
+             n0 = n0 << bm;
+
+             udiv_qrnnd (q1, n1, n2, n1, d0);
+           }
+
+         /* n1 != d0...  */
+
+         udiv_qrnnd (q0, n0, n1, n0, d0);
+
+         /* Remainder in n0 >> bm.  */
+       }
+
+      if (rp != 0)
+       {
+         rr.s.low = n0 >> bm;
+         rr.s.high = 0;
+         *rp = rr.ll;
+       }
+    }
+#endif /* UDIV_NEEDS_NORMALIZATION */
+
+  else
+    {
+      if (d1 > n1)
+       {
+         /* 00 = nn / DD */
+
+         q0 = 0;
+         q1 = 0;
+
+         /* Remainder in n1n0.  */
+         if (rp != 0)
+           {
+             rr.s.low = n0;
+             rr.s.high = n1;
+             *rp = rr.ll;
+           }
+       }
+      else
+       {
+         /* 0q = NN / dd */
+
+         count_leading_zeros (bm, d1);
+         if (bm == 0)
+           {
+             /* From (n1 >= d1) /\ (the most significant bit of d1 is set),
+                conclude (the most significant bit of n1 is set) /\ (the
+                quotient digit q0 = 0 or 1).
+
+                This special case is necessary, not an optimization.  */
+
+             /* The condition on the next line takes advantage of that
+                n1 >= d1 (true due to program flow).  */
+             if (n1 > d1 || n0 >= d0)
+               {
+                 q0 = 1;
+                 sub_ddmmss (n1, n0, n1, n0, d1, d0);
+               }
+             else
+               q0 = 0;
+
+             q1 = 0;
+
+             if (rp != 0)
+               {
+                 rr.s.low = n0;
+                 rr.s.high = n1;
+                 *rp = rr.ll;
+               }
+           }
+         else
+           {
+             UWtype m1, m0;
+             /* Normalize.  */
+
+             b = W_TYPE_SIZE - bm;
+
+             d1 = (d1 << bm) | (d0 >> b);
+             d0 = d0 << bm;
+             n2 = n1 >> b;
+             n1 = (n1 << bm) | (n0 >> b);
+             n0 = n0 << bm;
+
+             udiv_qrnnd (q0, n1, n2, n1, d1);
+             umul_ppmm (m1, m0, q0, d0);
+
+             if (m1 > n1 || (m1 == n1 && m0 > n0))
+               {
+                 q0--;
+                 sub_ddmmss (m1, m0, m1, m0, d1, d0);
+               }
+
+             q1 = 0;
+
+             /* Remainder in (n1n0 - m1m0) >> bm.  */
+             if (rp != 0)
+               {
+                 sub_ddmmss (n1, n0, n1, n0, m1, m0);
+                 rr.s.low = (n1 << b) | (n0 >> bm);
+                 rr.s.high = n1 >> bm;
+                 *rp = rr.ll;
+               }
+           }
+       }
+    }
+
+  ww.s.low = q0;
+  ww.s.high = q1;
+  return ww.ll;
+}
+
+DWtype
+__divdi3 (DWtype u, DWtype v)
+{
+  Wtype c = 0;
+  DWtype w;
+
+  if (u < 0)
+    {
+      c = ~c;
+      u = -u;
+    }
+  if (v < 0)
+    {
+      c = ~c;
+      v = -v;
+    }
+  w = __udivmoddi4 (u, v, NULL);
+  if (c)
+    w = -w;
+  return w;
+}
+
+DWtype
+__moddi3 (DWtype u, DWtype v)
+{
+  Wtype c = 0;
+  DWtype w;
+
+  if (u < 0)
+    {
+      c = ~c;
+      u = -u;
+    }
+  if (v < 0)
+    {
+      c = ~c;
+      v = -v;
+    }
+  __udivmoddi4 (u, v, &w);
+  if (c)
+    w = -w;
+  return w;
+}
+
+UDWtype
+__udivdi3 (UDWtype u, UDWtype v)
+{
+  return __udivmoddi4 (u, v, NULL);
+}
+
+UDWtype
+__umoddi3 (UDWtype u, UDWtype v)
+{
+  UDWtype w;
+
+  __udivmoddi4 (u, v, &w);
+  return w;
+}