* stdlib/stdlib.h: Replace __CONSTVALUE by attribute.
* stdlib/abs.c, stdlib/div.c, stdlib/labs.c, stdlib/ldiv.c,
sysdeps/generic/hypot.c: Remove obsolete __CONSTVALUE.
* stdio-common/printf_fp.c (__printf_fp): Fix parameter
declaration.
* sysdeps/generic/putenv.c (putenv): Fix second argument of
setenv.
* sysdeps/ieee754/hypot.c: New file, extracted out of cabs.c.
* sysdeps/ieee754/cabs.c: Don't define hypot here.
* sysdeps/ieee754/ieee754.h (union ieee854_long_double): Fix
definition of ieee_nan alternative.
* sysdeps/m68k/__longjmp.c, sysdeps/m68k/setjmp.c: Add register
prefix spec.
* sysdeps/m68k/ffs.c (ffs): Fix register constraint.
* sysdeps/m68k/fpu/__math.h: Include <errno.h>. Replace obsolete
__CONSTVALUE by attribute.
(floor): Round to negative infinity.
(rint, expm1) [__NO_MATH_INLINES]: Don't define, to avoid type
clash when compiling source.
(pow): Handle x == 0 and x < 0.
(ceil, __isinf, __isnan): Fix register constraints.
(__isinfl, __isnanl): Added.
* sysdeps/m68k/fpu/acos.c, sysdeps/m68k/fpu/atan2.c,
sysdeps/m68k/fpu/fmod.c, sysdeps/m68k/fpu/ldexp.c,
sysdeps/m68k/fpu/pow.c: Remove obsolete __CONSTVALUE.
* sysdeps/m68k/bsd-_setjmp.S, sysdeps/m68k/bsd-setjmp.S: Fix
assembler syntax.
* sysdeps/unix/bsd/bsd4.4/fchdir.S (fchdir): Take only one
argument.
* sysdeps/unix/bsd/clock.c (timeval_to_clock_t): Fix timeval to
clock_t conversion.
(clock): Don't multiply by CLOCKS_PER_SEC.
* sysdeps/unix/bsd/poll.c (poll): Fix msec to timeval conversion.
* sysdeps/unix/bsd/sun/m68k/brk.S (brk): Compare with address of
__end.
* sysdeps/unix/bsd/sun/m68k/vfork.S: Fix assembler syntax.
* sysdeps/unix/bsd/ualarm.c (ualarm): Fix timeval calculation.
* sysdeps/unix/bsd/vax/vfork.S: Remove duplicate label.
memory_error): Add cast to void to avoid gcc warning.
(vfscanf): Rewrite character class parsing to make it more efficient.
+ * misc/efgcvt_r.c (ecvt_r): Handle negative values.
+
+ * stdlib/stdlib.h: Replace __CONSTVALUE by attribute.
+ * stdlib/abs.c, stdlib/div.c, stdlib/labs.c, stdlib/ldiv.c,
+ sysdeps/generic/hypot.c: Remove obsolete __CONSTVALUE.
+
+ * stdio-common/printf_fp.c (__printf_fp): Fix parameter
+ declaration.
+
+ * sysdeps/generic/putenv.c (putenv): Fix second argument of
+ setenv.
+
+ * sysdeps/ieee754/hypot.c: New file, extracted out of cabs.c.
+ * sysdeps/ieee754/cabs.c: Don't define hypot here.
+
+ * sysdeps/ieee754/ieee754.h (union ieee854_long_double): Fix
+ definition of ieee_nan alternative.
+
+ * sysdeps/m68k/__longjmp.c, sysdeps/m68k/setjmp.c: Add register
+ prefix spec.
+
+ * sysdeps/m68k/ffs.c (ffs): Fix register constraint.
+
+ * sysdeps/m68k/fpu/__math.h: Include <errno.h>. Replace obsolete
+ __CONSTVALUE by attribute.
+ (floor): Round to negative infinity.
+ (rint, expm1) [__NO_MATH_INLINES]: Don't define, to avoid type
+ clash when compiling source.
+ (pow): Handle x == 0 and x < 0.
+ (ceil, __isinf, __isnan): Fix register constraints.
+ (__isinfl, __isnanl): Added.
+ * sysdeps/m68k/fpu/acos.c, sysdeps/m68k/fpu/atan2.c,
+ sysdeps/m68k/fpu/fmod.c, sysdeps/m68k/fpu/ldexp.c,
+ sysdeps/m68k/fpu/pow.c: Remove obsolete __CONSTVALUE.
+
+ * sysdeps/m68k/bsd-_setjmp.S, sysdeps/m68k/bsd-setjmp.S: Fix
+ assembler syntax.
+
+ * sysdeps/unix/bsd/bsd4.4/fchdir.S (fchdir): Take only one
+ argument.
+
+ * sysdeps/unix/bsd/clock.c (timeval_to_clock_t): Fix timeval to
+ clock_t conversion.
+ (clock): Don't multiply by CLOCKS_PER_SEC.
+
+ * sysdeps/unix/bsd/poll.c (poll): Fix msec to timeval conversion.
+
+ * sysdeps/unix/bsd/sun/m68k/brk.S (brk): Compare with address of
+ __end.
+
+ * sysdeps/unix/bsd/sun/m68k/vfork.S: Fix assembler syntax.
+
+ * sysdeps/unix/bsd/ualarm.c (ualarm): Fix timeval calculation.
+
+ * sysdeps/unix/bsd/vax/vfork.S: Remove duplicate label.
+
Sun Jan 14 01:01:10 1996 Ulrich Drepper <drepper@ipd.info.uni-karlsruhe.de>
* stdlib/strtol.c: Return correct pointer for strings
char *buf;
size_t len;
{
- ndigit -= (int) floor (log10 (value));
+ ndigit -= (int) floor (log10 (value < 0.0 ? -value : value));
if (ndigit < 0)
ndigit = 0;
return fcvt_r (value, ndigit, decpt, sign, buf, len);
__printf_fp (fp, info, args)
FILE *fp;
const struct printf_info *info;
- const **const args;
+ const *const *args;
{
/* The floating-point value to output. */
union
#undef abs
/* Return the absolute value of I. */
-__CONSTVALUE
int
DEFUN(abs, (i), int i)
{
/* Return the `div_t' representation of NUMER over DENOM. */
-__CONSTVALUE
div_t
DEFUN(div, (numer, denom), int numer AND int denom)
{
/* Return the absolute value of I. */
-__CONSTVALUE
long int
DEFUN(labs, (i), long int i)
{
/* Return the `ldiv_t' representation of NUMER over DENOM. */
-__CONSTVALUE
ldiv_t
DEFUN(ldiv, (numer, denom), long int numer AND long int denom)
{
__compar_fn_t __compar));
-#ifndef __CONSTVALUE
-#ifdef __GNUC__
-/* The `const' keyword tells GCC that a function's return value is
- based solely on its arguments, and there are no side-effects. */
-#define __CONSTVALUE __const
-#else
-#define __CONSTVALUE
-#endif /* GCC. */
-#endif /* __CONSTVALUE not defined. */
-
/* Return the absolute value of X. */
-extern __CONSTVALUE int abs __P ((int __x));
-extern __CONSTVALUE long int labs __P ((long int __x));
+extern int abs __P ((int __x)) __attribute__ ((__const__));
+extern long int labs __P ((long int __x)) __attribute__ ((__const__));
/* Return the `div_t' or `ldiv_t' representation
of the value of NUMER over DENOM. */
/* GCC may have built-ins for these someday. */
-extern __CONSTVALUE div_t div __P ((int __numer, int __denom));
-extern __CONSTVALUE ldiv_t ldiv __P ((long int __numer, long int __denom));
+extern div_t div __P ((int __numer, int __denom)) __attribute__ ((__const__));
+extern ldiv_t ldiv __P ((long int __numer, long int __denom)) __attribute__ ((__const__));
#ifdef __USE_SVID
#include <math.h>
/* Return `sqrt(x*x + y*y)'. */
-__CONSTVALUE double
+double
DEFUN(hypot, (x, y), double x AND double y)
{
return sqrt(x*x + y*y);
char *name = alloca (name_end - string + 1);
memcpy (name, string, name_end - string);
name[name_end - string] = '\0';
- return setenv (name, string + 1, 1);
+ return setenv (name, name_end + 1, 1);
}
unsetenv (string);
*/
#include "mathimpl.h"
+#if 0 /* Moved to separate file. */
+
vc(r2p1hi, 2.4142135623730950345E0 ,8279,411a,ef32,99fc, 2, .9A827999FCEF32)
vc(r2p1lo, 1.4349369327986523769E-17 ,597d,2484,754b,89b3, -55, .84597D89B3754B)
vc(sqrt2, 1.4142135623730950622E0 ,04f3,40b5,de65,33f9, 1, .B504F333F9DE65)
else return(copysign(y,one)); /* y is INF */
}
+#endif /* 0 */
+
/* CABS(Z)
* RETURN THE ABSOLUTE VALUE OF THE COMPLEX NUMBER Z = X + iY
* DOUBLE PRECISION (VAX D format 56 bits, IEEE DOUBLE 53 BITS)
--- /dev/null
+/*
+ * Copyright (c) 1985 Regents of the University of California.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ * must display the following acknowledgement:
+ * This product includes software developed by the University of
+ * California, Berkeley and its contributors.
+ * 4. Neither the name of the University nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+/* HYPOT(X,Y)
+ * RETURN THE SQUARE ROOT OF X^2 + Y^2 WHERE Z=X+iY
+ * DOUBLE PRECISION (VAX D format 56 bits, IEEE DOUBLE 53 BITS)
+ * CODED IN C BY K.C. NG, 11/28/84;
+ * REVISED BY K.C. NG, 7/12/85.
+ *
+ * Required system supported functions :
+ * copysign(x,y)
+ * finite(x)
+ * scalb(x,N)
+ * sqrt(x)
+ *
+ * Method :
+ * 1. replace x by |x| and y by |y|, and swap x and
+ * y if y > x (hence x is never smaller than y).
+ * 2. Hypot(x,y) is computed by:
+ * Case I, x/y > 2
+ *
+ * y
+ * hypot = x + -----------------------------
+ * 2
+ * sqrt ( 1 + [x/y] ) + x/y
+ *
+ * Case II, x/y <= 2
+ * y
+ * hypot = x + --------------------------------------------------
+ * 2
+ * [x/y] - 2
+ * (sqrt(2)+1) + (x-y)/y + -----------------------------
+ * 2
+ * sqrt ( 1 + [x/y] ) + sqrt(2)
+ *
+ *
+ *
+ * Special cases:
+ * hypot(x,y) is INF if x or y is +INF or -INF; else
+ * hypot(x,y) is NAN if x or y is NAN.
+ *
+ * Accuracy:
+ * hypot(x,y) returns the sqrt(x^2+y^2) with error less than 1 ulps (units
+ * in the last place). See Kahan's "Interval Arithmetic Options in the
+ * Proposed IEEE Floating Point Arithmetic Standard", Interval Mathematics
+ * 1980, Edited by Karl L.E. Nickel, pp 99-128. (A faster but less accurate
+ * code follows in comments.) In a test run with 500,000 random arguments
+ * on a VAX, the maximum observed error was .959 ulps.
+ *
+ * Constants:
+ * The hexadecimal values are the intended ones for the following constants.
+ * The decimal values may be used, provided that the compiler will convert
+ * from decimal to binary accurately enough to produce the hexadecimal values
+ * shown.
+ */
+#include "mathimpl.h"
+
+vc(r2p1hi, 2.4142135623730950345E0 ,8279,411a,ef32,99fc, 2, .9A827999FCEF32)
+vc(r2p1lo, 1.4349369327986523769E-17 ,597d,2484,754b,89b3, -55, .84597D89B3754B)
+vc(sqrt2, 1.4142135623730950622E0 ,04f3,40b5,de65,33f9, 1, .B504F333F9DE65)
+
+ic(r2p1hi, 2.4142135623730949234E0 , 1, 1.3504F333F9DE6)
+ic(r2p1lo, 1.2537167179050217666E-16 , -53, 1.21165F626CDD5)
+ic(sqrt2, 1.4142135623730951455E0 , 0, 1.6A09E667F3BCD)
+
+#ifdef vccast
+#define r2p1hi vccast(r2p1hi)
+#define r2p1lo vccast(r2p1lo)
+#define sqrt2 vccast(sqrt2)
+#endif
+
+double
+hypot(x,y)
+double x, y;
+{
+ static const double zero=0, one=1,
+ small=1.0E-18; /* fl(1+small)==1 */
+ static const ibig=30; /* fl(1+2**(2*ibig))==1 */
+ double t,r;
+ int exp;
+
+ if(finite(x))
+ if(finite(y))
+ {
+ x=copysign(x,one);
+ y=copysign(y,one);
+ if(y > x)
+ { t=x; x=y; y=t; }
+ if(x == zero) return(zero);
+ if(y == zero) return(x);
+ exp= logb(x);
+ if(exp-(int)logb(y) > ibig )
+ /* raise inexact flag and return |x| */
+ { one+small; return(x); }
+
+ /* start computing sqrt(x^2 + y^2) */
+ r=x-y;
+ if(r>y) { /* x/y > 2 */
+ r=x/y;
+ r=r+sqrt(one+r*r); }
+ else { /* 1 <= x/y <= 2 */
+ r/=y; t=r*(r+2.0);
+ r+=t/(sqrt2+sqrt(2.0+t));
+ r+=r2p1lo; r+=r2p1hi; }
+
+ r=y/r;
+ return(x+r);
+
+ }
+
+ else if(y==y) /* y is +-INF */
+ return(copysign(y,one));
+ else
+ return(y); /* y is NaN and x is finite */
+
+ else if(x==x) /* x is +-INF */
+ return (copysign(x,one));
+ else if(finite(y))
+ return(x); /* x is NaN, y is finite */
+#if !defined(vax)&&!defined(tahoe)
+ else if(y!=y) return(y); /* x and y is NaN */
+#endif /* !defined(vax)&&!defined(tahoe) */
+ else return(copysign(y,one)); /* y is INF */
+}
+
+/* A faster but less accurate version of cabs(x,y) */
+#if 0
+double hypot(x,y)
+double x, y;
+{
+ static const double zero=0, one=1;
+ small=1.0E-18; /* fl(1+small)==1 */
+ static const ibig=30; /* fl(1+2**(2*ibig))==1 */
+ double temp;
+ int exp;
+
+ if(finite(x))
+ if(finite(y))
+ {
+ x=copysign(x,one);
+ y=copysign(y,one);
+ if(y > x)
+ { temp=x; x=y; y=temp; }
+ if(x == zero) return(zero);
+ if(y == zero) return(x);
+ exp= logb(x);
+ x=scalb(x,-exp);
+ if(exp-(int)logb(y) > ibig )
+ /* raise inexact flag and return |x| */
+ { one+small; return(scalb(x,exp)); }
+ else y=scalb(y,-exp);
+ return(scalb(sqrt(x*x+y*y),exp));
+ }
+
+ else if(y==y) /* y is +-INF */
+ return(copysign(y,one));
+ else
+ return(y); /* y is NaN and x is finite */
+
+ else if(x==x) /* x is +-INF */
+ return (copysign(x,one));
+ else if(finite(y))
+ return(x); /* x is NaN, y is finite */
+ else if(y!=y) return(y); /* x and y is NaN */
+ else return(copysign(y,one)); /* y is INF */
+}
+#endif
unsigned int negative:1;
unsigned int exponent:15;
unsigned int empty:16;
+ unsigned int one:1;
unsigned int quiet_nan:1;
- unsigned int mantissa0:31;
+ unsigned int mantissa0:30;
unsigned int mantissa1:32;
#endif
#if __BYTE_ORDER == __LITTLE_ENDIAN
unsigned int mantissa1:32;
- unsigned int mantissa0:31;
+ unsigned int mantissa0:30;
unsigned int quiet_nan:1;
+ unsigned int one:1
unsigned int exponent:15;
unsigned int negative:1;
unsigned int empty:16;
#if defined(__HAVE_68881__) || defined(__HAVE_FPU__)
/* Restore the floating-point registers. */
- asm volatile("fmovem%.x %0, fp0-fp7" :
- /* No outputs. */ : "g" (env[0].__fpregs[0]) :
- "fp0", "fp1", "fp2", "fp3", "fp4", "fp5", "fp6", "fp7");
+ asm volatile("fmovem%.x %0, %/fp0-%/fp7" :
+ /* No outputs. */ : "g" (env[0].__fpregs[0]));
#endif
/* Put VAL in D0. */
- asm volatile("move%.l %0, d0" : /* No outputs. */ :
+ asm volatile("move%.l %0, %/d0" : /* No outputs. */ :
"g" (val == 0 ? 1 : val) : "d0");
asm volatile(/* Restore the data and address registers. */
- "movem%.l %0, d1-d7/a0-a7\n"
+ "movem%.l %0, %/d1-%/d7/%/a0-%/a7\n"
/* Return to setjmp's caller. */
#ifdef __motorola__
- "jmp (a0)"
+ "jmp (%/a0)"
#else
- "jmp a0@"
+ "jmp %/a0@"
#endif
: /* No outputs. */ : "g" (env[0].__dregs[0])
/* We don't bother with the clobbers,
#ifdef MOTOROLA_SYNTAX
#define d0 %d0
#define d1 %d1
-#define PUSH(reg) move.l reg, -(%esp)
-#define POP(reg) move.l (%esp)+, reg
+#define PUSH(reg) move.l reg, -(%sp)
+#define POP(reg) move.l (%sp)+, reg
+#define PUSH0 clr.l -(%sp)
#else
#define PUSH(reg) movel reg, sp@-
#define POP(reg) movel sp@+, reg
+#define PUSH0 clrl sp@-
#endif
ENTRY (_setjmp)
POP (d0) /* Pop return PC. */
POP (d1) /* Pop jmp_buf argument. */
- PUSH (#0) /* Push second argument of zero. */
+ PUSH0 /* Push second argument of zero. */
PUSH (d1) /* Push back first argument. */
PUSH (d0) /* Push back return PC. */
+#ifdef PIC
+ bra.l C_SYMBOL_NAME (__sigsetjmp@PLTPC)
+#else
jmp C_SYMBOL_NAME (__sigsetjmp)
+#endif
#ifdef MOTOROLA_SYNTAX
#define d0 %d0
#define d1 %d1
-#define PUSH(reg) move.l reg, -(%esp)
-#define POP(reg) move.l (%esp)+, reg
+#define PUSH(reg) move.l reg, -(%sp)
+#define POP(reg) move.l (%sp)+, reg
#else
#define PUSH(reg) movel reg, sp@-
#define POP(reg) movel sp@+, reg
ENTRY (setjmp)
POP (d0) /* Pop return PC. */
POP (d1) /* Pop jmp_buf argument. */
- PUSH (#1) /* Push second argument of one. */
+ pea 1 /* Push second argument of one. */
PUSH (d1) /* Push back first argument. */
PUSH (d0) /* Push back return PC. */
+#ifdef PIC
+ bra.l C_SYMBOL_NAME (__sigsetjmp@PLTPC)
+#else
jmp C_SYMBOL_NAME (__sigsetjmp)
+#endif
{
int cnt;
- asm("bfffo %1{#0:#0},%0" : "=d" (cnt) : "rm" (x & -x));
+ asm("bfffo %1{#0:#0},%0" : "=d" (cnt) : "dm" (x & -x));
return 32 - cnt;
}
#ifdef __GNUC__
#include <sys/cdefs.h>
+#define __need_Emath
+#include <errno.h>
#ifdef __NO_MATH_INLINES
/* This is used when defining the functions themselves. Define them with
#define __m81_inline static __inline
#else
#define __m81_u(x) x
-#define __m81_inline exter __inline
+#define __m81_inline extern __inline
#define __MATH_INLINES 1
#endif
#define __inline_mathop2(func, op) \
- __m81_inline __CONSTVALUE double \
+ __m81_inline double \
+ __m81_u(func)(double __mathop_x) __attribute__((__const__)); \
+ __m81_inline double \
__m81_u(func)(double __mathop_x) \
{ \
double __result; \
__inline_mathop2(fabs, abs)
__inline_mathop(log10)
__inline_mathop2(log, logn)
-__inline_mathop2(floor, intrz)
__inline_mathop(sqrt)
__inline_mathop2(__rint, int)
__inline_mathop2(__expm1, etoxm1)
#ifdef __USE_MISC
+#ifndef __NO_MATH_INLINES
__inline_mathop2(rint, int)
__inline_mathop2(expm1, etoxm1)
+#endif
__inline_mathop2(log1p, lognp1)
__inline_mathop(atanh)
#endif
-__m81_inline __CONSTVALUE double
+__m81_inline double
+__m81_u(__drem)(double __x, double __y) __attribute__ ((__const__));
+__m81_inline double
__m81_u(__drem)(double __x, double __y)
{
double __result;
return __result;
}
-__m81_inline __CONSTVALUE double
+__m81_inline double
+__m81_u(ldexp)(double __x, int __e) __attribute__ ((__const__));
+__m81_inline double
__m81_u(ldexp)(double __x, int __e)
{
double __result;
return __result;
}
-__m81_inline __CONSTVALUE double
+__m81_inline double
+__m81_u(fmod)(double __x, double __y) __attribute__ ((__const__));
+__m81_inline double
__m81_u(fmod)(double __x, double __y)
{
double __result;
return __mantissa;
}
-__m81_inline __CONSTVALUE double
+__m81_inline double
+__m81_u(floor)(double __x) __attribute__ ((__const__));
+__m81_inline double
+__m81_u(floor)(double __x)
+{
+ double __result;
+ unsigned long int __ctrl_reg;
+ __asm __volatile__ ("fmove%.l %!, %0" : "=dm" (__ctrl_reg));
+ /* Set rounding towards negative infinity. */
+ __asm __volatile__ ("fmove%.l %0, %!" : /* No outputs. */
+ : "dmi" ((__ctrl_reg & ~0x10) | 0x20));
+ /* Convert X to an integer, using -Inf rounding. */
+ __asm __volatile__ ("fint%.x %1, %0" : "=f" (__result) : "f" (__x));
+ /* Restore the previous rounding mode. */
+ __asm __volatile__ ("fmove%.l %0, %!" : /* No outputs. */
+ : "dmi" (__ctrl_reg));
+ return __result;
+}
+
+__m81_inline double
+__m81_u(pow)(double __x, double __y) __attribute__ ((__const__));
+__m81_inline double
__m81_u(pow)(double __x, double __y)
{
double __result;
- if (__y == 0.0 || __x == 1.0)
+ if (__x == 0.0)
+ {
+ if (__y <= 0.0)
+ __result = __infnan (EDOM);
+ else
+ __result = 0.0;
+ }
+ else if (__y == 0.0 || __x == 1.0)
__result = 1.0;
else if (__y == 1.0)
__result = __x;
__asm("ftentox%.x %1, %0" : "=f" (__result) : "f" (__y));
else if (__x == 2.0)
__asm("ftwotox%.x %1, %0" : "=f" (__result) : "f" (__y));
+ else if (__x < 0.0)
+ {
+ double __temp = __m81_u (__rint) (__y);
+ if (__y == __temp)
+ {
+ int i = (int) __y;
+ __result = __m81_u (exp) (__y * __m81_u (log) (-__x));
+ if (i & 1)
+ __result = -__result;
+ }
+ else
+ __result = __infnan (EDOM);
+ }
else
__result = __m81_u(exp)(__y * __m81_u(log)(__x));
return __result;
}
-__m81_inline __CONSTVALUE double
+__m81_inline double
+__m81_u(ceil)(double __x) __attribute__ ((__const__));
+__m81_inline double
__m81_u(ceil)(double __x)
{
double __result;
unsigned long int __ctrl_reg;
- __asm("fmove%.l fpcr, %0" : "=g" (__ctrl_reg));
+ __asm __volatile__ ("fmove%.l %!, %0" : "=dm" (__ctrl_reg));
/* Set rounding towards positive infinity. */
- __asm("fmove%.l %0, fpcr" : /* No outputs. */ : "g" (__ctrl_reg | 0x30));
+ __asm __volatile__ ("fmove%.l %0, %!" : /* No outputs. */
+ : "dmi" (__ctrl_reg | 0x30));
/* Convert X to an integer, using +Inf rounding. */
- __asm("fint%.x %1, %0" : "=f" (__result) : "f" (__x));
+ __asm __volatile__ ("fint%.x %1, %0" : "=f" (__result) : "f" (__x));
/* Restore the previous rounding mode. */
- __asm("fmove%.l %0, fpcr" : /* No outputs. */ : "g" (__ctrl_reg));
+ __asm __volatile__ ("fmove%.l %0, %!" : /* No outputs. */
+ : "dmi" (__ctrl_reg));
return __result;
}
return __value - __modf_int;
}
-__m81_inline __CONSTVALUE int
+__m81_inline int
+__m81_u(__isinf)(double __value) __attribute__ ((__const__));
+__m81_inline int
__m81_u(__isinf)(double __value)
{
/* There is no branch-condition for infinity,
so we must extract and examine the condition codes manually. */
unsigned long int __fpsr;
__asm("ftst%.x %1\n"
- "fmove%.l fpsr, %0" : "=g" (__fpsr) : "f" (__value));
+ "fmove%.l %/fpsr, %0" : "=dm" (__fpsr) : "f" (__value));
return (__fpsr & (2 << (3 * 8))) ? (__value < 0 ? -1 : 1) : 0;
}
-__m81_inline __CONSTVALUE int
+__m81_inline int
+__m81_u(__isnan)(double __value) __attribute__ ((__const__));
+__m81_inline int
__m81_u(__isnan)(double __value)
{
char __result;
__asm("ftst%.x %1\n"
- "fsun %0" : "=g" (__result) : "f" (__value));
+ "fsun %0" : "=dm" (__result) : "f" (__value));
+ return __result;
+}
+
+__m81_inline int
+__m81_u(__isinfl)(long double __value) __attribute__ ((__const__));
+__m81_inline int
+__m81_u(__isinfl)(long double __value)
+{
+ /* There is no branch-condition for infinity,
+ so we must extract and examine the condition codes manually. */
+ unsigned long int __fpsr;
+ __asm("ftst%.x %1\n"
+ "fmove%.l %/fpsr, %0" : "=dm" (__fpsr) : "f" (__value));
+ return (__fpsr & (2 << (3 * 8))) ? (__value < 0 ? -1 : 1) : 0;
+}
+
+__m81_inline int
+__m81_u(__isnanl)(long double __value) __attribute__ ((__const__));
+__m81_inline int
+__m81_u(__isnanl)(long double __value)
+{
+ char __result;
+ __asm("ftst%.x %1\n"
+ "fsun %0" : "=dm" (__result) : "f" (__value));
return __result;
}
#endif
-__CONSTVALUE double
+double
DEFUN(FUNC, (x), double x)
{
return __m81_u(FUNC)(x);
#ifdef __GNUC__
-__CONSTVALUE double
+double
DEFUN(atan2, (y, x), double y AND double x)
{
static CONST double one = 1.0, zero = 0.0;
#define __NO_MATH_INLINES
#include <math.h>
-__CONSTVALUE double
+double
DEFUN(fmod, (x, y), double x AND double y)
{
return __fmod(x, y);
#define __NO_MATH_INLINES
#include <math.h>
-__CONSTVALUE double
+double
DEFUN(ldexp, (x, exp), double x AND int exp)
{
return __ldexp(x, exp);
#define __NO_MATH_INLINES
#include <math.h>
-__CONSTVALUE double
+double
DEFUN(pow, (x, y), double x AND double y)
{
return __pow(x, y);
__sigsetjmp (jmp_buf env, int savemask)
{
/* Save data registers D1 through D7. */
- asm volatile ("movem%.l d1-d7, %0" : : "m" (env[0].__jmpbuf[0].__dregs[0]));
+ asm volatile ("movem%.l %/d1-%/d7, %0"
+ : : "m" (env[0].__jmpbuf[0].__dregs[0]));
/* Save return address in place of register A0. */
env[0].__jmpbuf[0].__aregs[0] = ((void **) &env)[-1];
/* Save address registers A1 through A5. */
- asm volatile ("movem%.l a1-a5, %0" : : "m" (env[0].__jmpbuf[0].__aregs[1]));
+ asm volatile ("movem%.l %/a1-%/a5, %0"
+ : : "m" (env[0].__jmpbuf[0].__aregs[1]));
/* Save caller's FP, not our own. */
env[0].__jmpbuf[0].__fp = ((void **) &env)[-2];
#if defined(__HAVE_68881__) || defined(__HAVE_FPU__)
/* Save floating-point (68881) registers FP0 through FP7. */
- asm volatile ("fmovem%.x fp0-fp7, %0"
+ asm volatile ("fmovem%.x %/fp0-%/fp7, %0"
: : "m" (env[0].__jmpbuf[0].__fpregs[0]));
#endif
#include <sysdep.h>
-SYSCALL (fchdir, 2)
+SYSCALL (fchdir, 1)
ret
DEFUN(timeval_to_clock_t, (tv), CONST struct timeval *tv)
{
return (clock_t) ((tv->tv_sec * CLK_TCK) +
- (tv->tv_usec * CLK_TCK / 1000));
+ (tv->tv_usec * CLK_TCK / 1000000));
}
/* Return the time used by the program so far (user time + system time). */
return (clock_t) -1;
return (timeval_to_clock_t(&usage.ru_stime) +
- timeval_to_clock_t(&usage.ru_utime)) * CLOCKS_PER_SEC;
+ timeval_to_clock_t(&usage.ru_utime));
}
.text
ENTRY (__brk)
- movel __end, d0
+ movel #__end, d0
cmpl sp@(4), d0
ble 0f
movel d0, sp@(4)
bits set) for the parent, and 0 (no bits set) for the child.
Then AND it with D0, so the parent gets D0&-1==R0, and the child
gets D0&0==0. */
- decl d1
+ subql #1, d1
andl d1, d0
/* Jump to the return PC. */
if (setitimer(ITIMER_REAL, &timer, &otimer) < 0)
return -1;
- return (otimer.it_value.tv_sec * 1000) + otimer.it_value.tv_usec;
+ return (otimer.it_value.tv_sec * 1000000) + otimer.it_value.tv_usec;
}
replaced by a call to `execve'. Return -1 for errors, 0 to the new process,
and the process ID of the new process to the old process. */
.globl ___vfork
-error: jmp syscall_error
___vfork:
.word 0
/* Save our return address in R2, and return to code below. */
projects / thirdparty / glibc.git / commitdiff
