Files generated from divrem.m4.

diff --git a/sysdeps/alpha/divl.S b/sysdeps/alpha/divl.S
new file mode 100644 (file)
index 0000000..7ae3e0c
--- /dev/null
+++ b/sysdeps/alpha/divl.S
@@ -0,0 +1,54 @@
+      /* This file is generated from divrem.m4; DO NOT EDIT! */
+/* For each N divided by D, we do:
+      result = (double) N / (double) D
+   Then, for each N mod D, we do:
+      result = N - (D * divMODE (N, D))
+
+   FIXME:
+   The q and qu versions won't deal with operands > 50 bits.  We also
+   don't check for divide by zero.  */
+
+#include "DEFS.h"
+#if 0
+/* We do not handle div by zero yet.  */
+#include <machine/pal.h>
+#endif
+#include <sysdep.h>
+
+
+
+
+
+
+FUNC__(divl)
+       /* First set up the dividend.  */
+               sextl t10, t10
+
+       stq t10,0(sp)
+       ldt $f10,0(sp)
+       cvtqt $f10,$f10
+       
+
+       /* Then set up the divisor.  */
+               sextl t11, t11
+
+       stq t11,0(sp)
+       ldt $f1,0(sp)
+       cvtqt $f1,$f1
+       
+
+       /* Do the division.  */
+       divt $f10,$f1,$f10
+       cvttqc $f10,$f10
+
+       /* Put the result in t12.  */
+       stt $f10,0(sp)
+       ldq t12,0(sp)
+               sextl t12, t12
+
+
+       
+
+       lda sp,16(sp)
+       ret zero,(t9),1
+       .end NAME__(divl)

diff --git a/sysdeps/alpha/divlu.S b/sysdeps/alpha/divlu.S
new file mode 100644 (file)
index 0000000..9ae5950
--- /dev/null
+++ b/sysdeps/alpha/divlu.S
@@ -0,0 +1,54 @@
+      /* This file is generated from divrem.m4; DO NOT EDIT! */
+/* For each N divided by D, we do:
+      result = (double) N / (double) D
+   Then, for each N mod D, we do:
+      result = N - (D * divMODE (N, D))
+
+   FIXME:
+   The q and qu versions won't deal with operands > 50 bits.  We also
+   don't check for divide by zero.  */
+
+#include "DEFS.h"
+#if 0
+/* We do not handle div by zero yet.  */
+#include <machine/pal.h>
+#endif
+#include <sysdep.h>
+
+
+
+
+
+
+FUNC__(divlu)
+       /* First set up the dividend.  */
+               zapnot t10, 0xf, t10
+
+       stq t10,0(sp)
+       ldt $f10,0(sp)
+       cvtqt $f10,$f10
+       
+
+       /* Then set up the divisor.  */
+               zapnot t11, 0xf, t11
+
+       stq t11,0(sp)
+       ldt $f1,0(sp)
+       cvtqt $f1,$f1
+       
+
+       /* Do the division.  */
+       divt $f10,$f1,$f10
+       cvttqc $f10,$f10
+
+       /* Put the result in t12.  */
+       stt $f10,0(sp)
+       ldq t12,0(sp)
+               sextl t12, t12
+
+
+       
+
+       lda sp,16(sp)
+       ret zero,(t9),1
+       .end NAME__(divlu)

diff --git a/sysdeps/alpha/divq.S b/sysdeps/alpha/divq.S
new file mode 100644 (file)
index 0000000..79ff6ca
--- /dev/null
+++ b/sysdeps/alpha/divq.S
@@ -0,0 +1,51 @@
+      /* This file is generated from divrem.m4; DO NOT EDIT! */
+/* For each N divided by D, we do:
+      result = (double) N / (double) D
+   Then, for each N mod D, we do:
+      result = N - (D * divMODE (N, D))
+
+   FIXME:
+   The q and qu versions won't deal with operands > 50 bits.  We also
+   don't check for divide by zero.  */
+
+#include "DEFS.h"
+#if 0
+/* We do not handle div by zero yet.  */
+#include <machine/pal.h>
+#endif
+#include <sysdep.h>
+
+
+
+
+
+
+FUNC__(divq)
+       /* First set up the dividend.  */
+       
+       stq t10,0(sp)
+       ldt $f10,0(sp)
+       cvtqt $f10,$f10
+       
+
+       /* Then set up the divisor.  */
+       
+       stq t11,0(sp)
+       ldt $f1,0(sp)
+       cvtqt $f1,$f1
+       
+
+       /* Do the division.  */
+       divt $f10,$f1,$f10
+       cvttqc $f10,$f10
+
+       /* Put the result in t12.  */
+       stt $f10,0(sp)
+       ldq t12,0(sp)
+       
+
+       
+
+       lda sp,16(sp)
+       ret zero,(t9),1
+       .end NAME__(divq)

diff --git a/sysdeps/alpha/divqu.S b/sysdeps/alpha/divqu.S
new file mode 100644 (file)
index 0000000..7908b9f
--- /dev/null
+++ b/sysdeps/alpha/divqu.S
@@ -0,0 +1,57 @@
+      /* This file is generated from divrem.m4; DO NOT EDIT! */
+/* For each N divided by D, we do:
+      result = (double) N / (double) D
+   Then, for each N mod D, we do:
+      result = N - (D * divMODE (N, D))
+
+   FIXME:
+   The q and qu versions won't deal with operands > 50 bits.  We also
+   don't check for divide by zero.  */
+
+#include "DEFS.h"
+#if 0
+/* We do not handle div by zero yet.  */
+#include <machine/pal.h>
+#endif
+#include <sysdep.h>
+
+
+
+
+
+
+FUNC__(divqu)
+       /* First set up the dividend.  */
+       
+       stq t10,0(sp)
+       ldt $f10,0(sp)
+       cvtqt $f10,$f10
+               ldit    $f26, 18446744073709551616.0
+       addt    $f26, $f10, $f26
+       fcmovlt $f10, $f26, $f10
+
+
+       /* Then set up the divisor.  */
+       
+       stq t11,0(sp)
+       ldt $f1,0(sp)
+       cvtqt $f1,$f1
+               ldit    $f26, 18446744073709551616.0
+       addt    $f26, $f1, $f26
+       fcmovlt $f1, $f26, $f1
+
+
+       /* Do the division.  */
+       divt $f10,$f1,$f10
+       cvttqc $f10,$f10
+
+       /* Put the result in t12.  */
+       stt $f10,0(sp)
+       ldq t12,0(sp)
+       
+
+       
+
+       lda sp,16(sp)
+       ret zero,(t9),1
+       .end NAME__(divqu)

diff --git a/sysdeps/alpha/reml.S b/sysdeps/alpha/reml.S
new file mode 100644 (file)
index 0000000..2ece297
--- /dev/null
+++ b/sysdeps/alpha/reml.S
@@ -0,0 +1,57 @@
+      /* This file is generated from divrem.m4; DO NOT EDIT! */
+/* For each N divided by D, we do:
+      result = (double) N / (double) D
+   Then, for each N mod D, we do:
+      result = N - (D * divMODE (N, D))
+
+   FIXME:
+   The q and qu versions won't deal with operands > 50 bits.  We also
+   don't check for divide by zero.  */
+
+#include "DEFS.h"
+#if 0
+/* We do not handle div by zero yet.  */
+#include <machine/pal.h>
+#endif
+#include <sysdep.h>
+
+
+
+
+
+
+FUNC__(reml)
+       /* First set up the dividend.  */
+               sextl t10, t10
+
+       stq t10,0(sp)
+       ldt $f10,0(sp)
+       cvtqt $f10,$f10
+       
+
+       /* Then set up the divisor.  */
+               sextl t11, t11
+
+       stq t11,0(sp)
+       ldt $f1,0(sp)
+       cvtqt $f1,$f1
+       
+
+       /* Do the division.  */
+       divt $f10,$f1,$f10
+       cvttqc $f10,$f10
+
+       /* Put the result in t12.  */
+       stt $f10,0(sp)
+       ldq t12,0(sp)
+               sextl t12, t12
+
+
+               /* Compute the remainder.  */
+       mull t11, t12, t11
+       subl t10, t11, t12
+
+
+       lda sp,16(sp)
+       ret zero,(t9),1
+       .end NAME__(reml)

diff --git a/sysdeps/alpha/remlu.S b/sysdeps/alpha/remlu.S
new file mode 100644 (file)
index 0000000..d7700e6
--- /dev/null
+++ b/sysdeps/alpha/remlu.S
@@ -0,0 +1,57 @@
+      /* This file is generated from divrem.m4; DO NOT EDIT! */
+/* For each N divided by D, we do:
+      result = (double) N / (double) D
+   Then, for each N mod D, we do:
+      result = N - (D * divMODE (N, D))
+
+   FIXME:
+   The q and qu versions won't deal with operands > 50 bits.  We also
+   don't check for divide by zero.  */
+
+#include "DEFS.h"
+#if 0
+/* We do not handle div by zero yet.  */
+#include <machine/pal.h>
+#endif
+#include <sysdep.h>
+
+
+
+
+
+
+FUNC__(remlu)
+       /* First set up the dividend.  */
+               zapnot t10, 0xf, t10
+
+       stq t10,0(sp)
+       ldt $f10,0(sp)
+       cvtqt $f10,$f10
+       
+
+       /* Then set up the divisor.  */
+               zapnot t11, 0xf, t11
+
+       stq t11,0(sp)
+       ldt $f1,0(sp)
+       cvtqt $f1,$f1
+       
+
+       /* Do the division.  */
+       divt $f10,$f1,$f10
+       cvttqc $f10,$f10
+
+       /* Put the result in t12.  */
+       stt $f10,0(sp)
+       ldq t12,0(sp)
+               sextl t12, t12
+
+
+               /* Compute the remainder.  */
+       mull t11, t12, t11
+       subl t10, t11, t12
+
+
+       lda sp,16(sp)
+       ret zero,(t9),1
+       .end NAME__(remlu)

diff --git a/sysdeps/alpha/remq.S b/sysdeps/alpha/remq.S
new file mode 100644 (file)
index 0000000..47510cb
--- /dev/null
+++ b/sysdeps/alpha/remq.S
@@ -0,0 +1,54 @@
+      /* This file is generated from divrem.m4; DO NOT EDIT! */
+/* For each N divided by D, we do:
+      result = (double) N / (double) D
+   Then, for each N mod D, we do:
+      result = N - (D * divMODE (N, D))
+
+   FIXME:
+   The q and qu versions won't deal with operands > 50 bits.  We also
+   don't check for divide by zero.  */
+
+#include "DEFS.h"
+#if 0
+/* We do not handle div by zero yet.  */
+#include <machine/pal.h>
+#endif
+#include <sysdep.h>
+
+
+
+
+
+
+FUNC__(remq)
+       /* First set up the dividend.  */
+       
+       stq t10,0(sp)
+       ldt $f10,0(sp)
+       cvtqt $f10,$f10
+       
+
+       /* Then set up the divisor.  */
+       
+       stq t11,0(sp)
+       ldt $f1,0(sp)
+       cvtqt $f1,$f1
+       
+
+       /* Do the division.  */
+       divt $f10,$f1,$f10
+       cvttqc $f10,$f10
+
+       /* Put the result in t12.  */
+       stt $f10,0(sp)
+       ldq t12,0(sp)
+       
+
+               /* Compute the remainder.  */
+       mulq t11, t12, t11
+       subq t10, t11, t12
+
+
+       lda sp,16(sp)
+       ret zero,(t9),1
+       .end NAME__(remq)

diff --git a/sysdeps/alpha/remqu.S b/sysdeps/alpha/remqu.S
index 4bdc3db..ec9572d 100644 (file)
--- a/sysdeps/alpha/remqu.S
+++ b/sysdeps/alpha/remqu.S
@@ -13,7 +13,7 @@
 /* We do not handle div by zero yet.  */
 #include <machine/pal.h>
 #endif
-#include <regdef.h>
+#include <sysdep.h>
 
 
 
@@ -21,7 +21,7 @@
 
 
 FUNC__(remqu)
-       ! First set up the dividend.
+       /* First set up the dividend.  */
        
        stq t10,0(sp)
        ldt $f10,0(sp)
@@ -31,7 +31,7 @@ FUNC__(remqu)
        fcmovlt $f10, $f26, $f10
 
 
-       ! Then set up the divisor.
+       /* Then set up the divisor.  */
        
        stq t11,0(sp)
        ldt $f1,0(sp)
@@ -41,16 +41,16 @@ FUNC__(remqu)
        fcmovlt $f1, $f26, $f1
 
 
-       ! Do the division.
+       /* Do the division.  */
        divt $f10,$f1,$f10
        cvttqc $f10,$f10
 
-       ! Put the result in t12.
+       /* Put the result in t12.  */
        stt $f10,0(sp)
        ldq t12,0(sp)
        
 
-               ! Compute the remainder.
+               /* Compute the remainder.  */
        mulq t11, t12, t11
        subq t10, t11, t12