Wed Feb 14 00:21:17 1996 David Mosberger-Tang <davidm@azstarnet.com>
authorroland <roland>
Tue, 19 Mar 1996 19:52:52 +0000 (19:52 +0000)
committerroland <roland>
Tue, 19 Mar 1996 19:52:52 +0000 (19:52 +0000)
* sysdeps/alpha/divl.S, sysdeps/alpha/divlu.S, sysdeps/alpha/divq.S,
sysdeps/alpha/divqu.S, sysdeps/alpha/divrem.m4,
sysdeps/alpha/macros.m4, sysdeps/alpha/ reml.S, sysdeps/alpha/remlu.S,
sysdeps/alpha/remq.S, sysdeps/alpha/remqu.S, sysdeps/alpha/strlen.c:
  Removed.

sysdeps/alpha/divl.S
sysdeps/alpha/divlu.S
sysdeps/alpha/divq.S
sysdeps/alpha/divqu.S
sysdeps/alpha/divrem.m4 [deleted file]
sysdeps/alpha/macros.m4 [deleted file]
sysdeps/alpha/remlu.S
sysdeps/alpha/remq.S
sysdeps/alpha/remqu.S
sysdeps/alpha/strlen.c [deleted file]

index 5c94362..7dbb504 100644 (file)
@@ -1,57 +1,6 @@
-      /* 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))
+#define IS_REM         0
+#define SIZE           4
+#define SIGNED         1
+#define FUNC_NAME      __divl
 
-   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>
-
-/* Avoid the definition of ret that we set in the alpha sysdep.h.  */
-#undef ret
-
-
-
-
-
-
-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)
+#include "divrem.S"
index 3a7589d..9cc71da 100644 (file)
@@ -1,57 +1,6 @@
-      /* 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))
+#define IS_REM         0
+#define SIZE           4
+#define SIGNED         0
+#define FUNC_NAME      __divlu
 
-   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>
-
-/* Avoid the definition of ret that we set in the alpha sysdep.h.  */
-#undef ret
-
-
-
-
-
-
-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)
+#include "divrem.S"
index 730a338..f7af8d6 100644 (file)
@@ -1,54 +1,6 @@
-      /* 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))
+#define IS_REM         0
+#define SIZE           8
+#define SIGNED         1
+#define FUNC_NAME      __divq
 
-   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>
-
-/* Avoid the definition of ret that we set in the alpha sysdep.h.  */
-#undef ret
-
-
-
-
-
-
-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)
+#include "divrem.S"
index 7614742..faf2932 100644 (file)
@@ -1,60 +1,6 @@
-      /* 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))
+#define IS_REM         0
+#define SIZE           8
+#define SIGNED         0
+#define FUNC_NAME      __divqu
 
-   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>
-
-/* Avoid the definition of ret that we set in the alpha sysdep.h.  */
-#undef ret
-
-
-
-
-
-
-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)
+#include "divrem.S"
diff --git a/sysdeps/alpha/divrem.m4 b/sysdeps/alpha/divrem.m4
deleted file mode 100644 (file)
index d2f3638..0000000
+++ /dev/null
@@ -1,51 +0,0 @@
-/* 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>
-
-/* Avoid the definition of ret that we set in the alpha sysdep.h.  */
-#undef ret
-
-define(path, `SYSDEP_DIR/macros.m4')dnl
-include(path)
-
-FUNC__(OP)
-       /* First set up the dividend.  */
-       EXTEND(t10)
-       stq t10,0(sp)
-       ldt $f10,0(sp)
-       cvtqt $f10,$f10
-       ADJQU($f10)
-
-       /* Then set up the divisor.  */
-       EXTEND(t11)
-       stq t11,0(sp)
-       ldt $f1,0(sp)
-       cvtqt $f1,$f1
-       ADJQU($f1)
-
-       /* Do the division.  */
-       divt $f10,$f1,$f10
-       cvttqc $f10,$f10
-
-       /* Put the result in t12.  */
-       stt $f10,0(sp)
-       ldq t12,0(sp)
-       FULLEXTEND(t12)
-
-       DOREM
-
-       lda sp,16(sp)
-       ret zero,(t9),1
-       .end NAME__(OP)
diff --git a/sysdeps/alpha/macros.m4 b/sysdeps/alpha/macros.m4
deleted file mode 100644 (file)
index f8c1fe9..0000000
+++ /dev/null
@@ -1,34 +0,0 @@
-dnl NOTE: The $1 below is the argument to EXTEND, not register $1.
-define(EXTEND,
-`ifelse(SIZE, `l',
-`ifelse(SIGNED, `true',
-`      sextl $1, $1
-',dnl
-`      zapnot $1, 0xf, $1
-')')')dnl
-
-dnl FULLEXTEND -- extend the register named in the first argument
-define(FULLEXTEND,
-`ifelse(SIZE, `l',
-`      sextl $1, $1
-')')dnl
-
-dnl This is used by divqu.
-define(ADJQU,
-`ifelse(MODE, `qu',
-`      ldit    $f26, 18446744073709551616.0
-       addt    $f26, $1, $f26
-       fcmovlt $1, $f26, $1
-')')dnl
-
-define(DOREM,
-`ifelse(BASEOP, `rem',
-`      /* Compute the remainder.  */
-ifelse(SIZE, `l',
-`      mull t11, t12, t11
-       subl t10, t11, t12
-',dnl Note mulq/subq were only really used in remq, but we will find out
-dnl   if assuming they apply to remqu as well is wrong or not.
-`      mulq t11, t12, t11
-       subq t10, t11, t12
-')')')dnl
index 24e07cf..3658d92 100644 (file)
@@ -1,60 +1,6 @@
-      /* 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))
+#define IS_REM         1
+#define SIZE           4
+#define SIGNED         0
+#define FUNC_NAME      __remlu
 
-   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>
-
-/* Avoid the definition of ret that we set in the alpha sysdep.h.  */
-#undef ret
-
-
-
-
-
-
-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)
+#include "divrem.S"
index ce38c24..61f2067 100644 (file)
@@ -1,57 +1,6 @@
-      /* 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))
+#define IS_REM         1
+#define SIZE           8
+#define SIGNED         1
+#define FUNC_NAME      __remq
 
-   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>
-
-/* Avoid the definition of ret that we set in the alpha sysdep.h.  */
-#undef ret
-
-
-
-
-
-
-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)
+#include "divrem.S"
index 26bdd3b..e22d5ac 100644 (file)
@@ -1,63 +1,6 @@
-      /* 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))
+#define IS_REM         1
+#define SIZE           8
+#define SIGNED         0
+#define FUNC_NAME      __remqu
 
-   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>
-
-/* Avoid the definition of ret that we set in the alpha sysdep.h.  */
-#undef ret
-
-
-
-
-
-
-FUNC__(remqu)
-       /* 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)
-       
-
-               /* Compute the remainder.  */
-       mulq t11, t12, t11
-       subq t10, t11, t12
-
-
-       lda sp,16(sp)
-       ret zero,(t9),1
-       .end NAME__(remqu)
+#include "divrem.S"
diff --git a/sysdeps/alpha/strlen.c b/sysdeps/alpha/strlen.c
deleted file mode 100644 (file)
index 36f106c..0000000
+++ /dev/null
@@ -1,55 +0,0 @@
-/* Copyright (C) 1992 Free Software Foundation, Inc.
-
-The GNU C Library is free software; you can redistribute it and/or
-modify it under the terms of the GNU Library General Public License as
-published by the Free Software Foundation; either version 2 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
-Library General Public License for more details.
-
-You should have received a copy of the GNU Library General Public
-License along with the GNU C Library; see the file COPYING.LIB.  If
-not, write to the Free Software Foundation, Inc., 675 Mass Ave,
-Cambridge, MA 02139, USA.  */
-
-#include <string.h>
-
-/* Return the length of the null-terminated string STR.  Scan for
-   the null terminator quickly by testing eight bytes at a time.  */
-
-size_t
-strlen (const char *str)
-{
-  const char *char_ptr;
-  const unsigned long int *longword_ptr;
-
-  /* Handle the first few characters by reading one character at a time.
-     Do this until STR is aligned on a 8-byte border.  */
-  for (char_ptr = str; ((unsigned long int) char_ptr & 7) != 0; ++char_ptr)
-    if (*char_ptr == '\0')
-      return char_ptr - str;
-
-  longword_ptr = (unsigned long int *) char_ptr;
-
-  for (;;)
-    {
-      const unsigned long int longword = *longword_ptr++;
-      int mask;
-
-      /* Set bits in MASK if bytes in LONGWORD are zero.  */
-      asm ("cmpbge $31, %1, %0" : "=r" (mask) : "r" (longword));
-      if (mask)
-       {
-         /* Which of the bytes was the zero?  */
-         const char *cp = (const char *) (longword_ptr - 1);
-         int i;
-
-         for (i = 0; i < 8; i++)
-           if (cp[i] == 0)
-             return cp - str + i;
-       }
-    }
-}