mirror of
https://github.com/jart/cosmopolitan.git
synced 2025-05-22 21:32:31 +00:00
Make more code aarch64 friendly
This commit is contained in:
Justine Tunney
parent
ca2860947f
commit
2b73e72d59
568 changed files with 2197 additions and 1061 deletions
|
|
@ -1,9 +1,9 @@
|
|||
/*-*- mode:c;indent-tabs-mode:t;c-basic-offset:8;tab-width:8;coding:utf-8 -*-│
|
||||
│vi: set et ft=c ts=8 tw=8 fenc=utf-8 :vi│
|
||||
/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
|
||||
│vi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :vi│
|
||||
╚──────────────────────────────────────────────────────────────────────────────╝
|
||||
│ │
|
||||
│ Musl Libc │
|
||||
│ Copyright © 2005-2020 Rich Felker, et al. │
|
||||
│ Optimized Routines │
|
||||
│ Copyright (c) 1999-2022, Arm Limited. │
|
||||
│ │
|
||||
│ Permission is hereby granted, free of charge, to any person obtaining │
|
||||
│ a copy of this software and associated documentation files (the │
|
||||
|
|
@ -25,124 +25,150 @@
|
|||
│ SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. │
|
||||
│ │
|
||||
╚─────────────────────────────────────────────────────────────────────────────*/
|
||||
#include "libc/intrin/likely.h"
|
||||
#include "libc/math.h"
|
||||
#include "libc/tinymath/complex.internal.h"
|
||||
#include "libc/tinymath/atan_common.internal.h"
|
||||
#include "libc/tinymath/internal.h"
|
||||
|
||||
asm(".ident\t\"\\n\\n\
|
||||
fdlibm (fdlibm license)\\n\
|
||||
Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.\"");
|
||||
asm(".ident\t\"\\n\\n\
|
||||
Musl libc (MIT License)\\n\
|
||||
Copyright 2005-2014 Rich Felker, et. al.\"");
|
||||
Optimized Routines (MIT License)\\n\
|
||||
Copyright 2022 ARM Limited\"");
|
||||
asm(".include \"libc/disclaimer.inc\"");
|
||||
// clang-format off
|
||||
/* clang-format off */
|
||||
|
||||
/* origin: FreeBSD /usr/src/lib/msun/src/e_atan2.c */
|
||||
/*
|
||||
* ====================================================
|
||||
* Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
|
||||
*
|
||||
* Developed at SunSoft, a Sun Microsystems, Inc. business.
|
||||
* Permission to use, copy, modify, and distribute this
|
||||
* software is freely granted, provided that this notice
|
||||
* is preserved.
|
||||
* ====================================================
|
||||
*
|
||||
*/
|
||||
/* atan2(y,x)
|
||||
* Method :
|
||||
* 1. Reduce y to positive by atan2(y,x)=-atan2(-y,x).
|
||||
* 2. Reduce x to positive by (if x and y are unexceptional):
|
||||
* ARG (x+iy) = arctan(y/x) ... if x > 0,
|
||||
* ARG (x+iy) = pi - arctan[y/(-x)] ... if x < 0,
|
||||
*
|
||||
* Special cases:
|
||||
*
|
||||
* ATAN2((anything), NaN ) is NaN;
|
||||
* ATAN2(NAN , (anything) ) is NaN;
|
||||
* ATAN2(+-0, +(anything but NaN)) is +-0 ;
|
||||
* ATAN2(+-0, -(anything but NaN)) is +-pi ;
|
||||
* ATAN2(+-(anything but 0 and NaN), 0) is +-pi/2;
|
||||
* ATAN2(+-(anything but INF and NaN), +INF) is +-0 ;
|
||||
* ATAN2(+-(anything but INF and NaN), -INF) is +-pi;
|
||||
* ATAN2(+-INF,+INF ) is +-pi/4 ;
|
||||
* ATAN2(+-INF,-INF ) is +-3pi/4;
|
||||
* ATAN2(+-INF, (anything but,0,NaN, and INF)) is +-pi/2;
|
||||
*
|
||||
* 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.
|
||||
*/
|
||||
#define Pi (0x1.921fb54442d18p+1)
|
||||
#define PiOver2 (0x1.921fb54442d18p+0)
|
||||
#define PiOver4 (0x1.921fb54442d18p-1)
|
||||
#define SignMask (0x8000000000000000)
|
||||
#define ExpMask (0x7ff0000000000000)
|
||||
|
||||
static const double
|
||||
pi = 3.1415926535897931160E+00, /* 0x400921FB, 0x54442D18 */
|
||||
pi_lo = 1.2246467991473531772E-16; /* 0x3CA1A626, 0x33145C07 */
|
||||
/* We calculate atan2 by P(n/d), where n and d are similar to the input
|
||||
arguments, and P is a polynomial. Evaluating P(x) requires calculating x^8,
|
||||
which may underflow if n and d have very different magnitude.
|
||||
POW8_EXP_UFLOW_BOUND is the lower bound of the difference in exponents of n
|
||||
and d for which P underflows, and is used to special-case such inputs. */
|
||||
#define POW8_EXP_UFLOW_BOUND 62
|
||||
|
||||
/**
|
||||
* Returns arc tangent of 𝑦/𝑥.
|
||||
* @note the greatest of all libm functions
|
||||
*/
|
||||
double atan2(double y, double x)
|
||||
static inline int64_t
|
||||
biased_exponent (double f)
|
||||
{
|
||||
double z;
|
||||
uint32_t m,lx,ly,ix,iy;
|
||||
|
||||
if (isnan(x) || isnan(y))
|
||||
return x+y;
|
||||
EXTRACT_WORDS(ix, lx, x);
|
||||
EXTRACT_WORDS(iy, ly, y);
|
||||
if ((ix-0x3ff00000 | lx) == 0) /* x = 1.0 */
|
||||
return atan(y);
|
||||
m = ((iy>>31)&1) | ((ix>>30)&2); /* 2*sign(x)+sign(y) */
|
||||
ix = ix & 0x7fffffff;
|
||||
iy = iy & 0x7fffffff;
|
||||
|
||||
/* when y = 0 */
|
||||
if ((iy|ly) == 0) {
|
||||
switch(m) {
|
||||
case 0:
|
||||
case 1: return y; /* atan(+-0,+anything)=+-0 */
|
||||
case 2: return pi; /* atan(+0,-anything) = pi */
|
||||
case 3: return -pi; /* atan(-0,-anything) =-pi */
|
||||
}
|
||||
}
|
||||
/* when x = 0 */
|
||||
if ((ix|lx) == 0)
|
||||
return m&1 ? -pi/2 : pi/2;
|
||||
/* when x is INF */
|
||||
if (ix == 0x7ff00000) {
|
||||
if (iy == 0x7ff00000) {
|
||||
switch(m) {
|
||||
case 0: return pi/4; /* atan(+INF,+INF) */
|
||||
case 1: return -pi/4; /* atan(-INF,+INF) */
|
||||
case 2: return 3*pi/4; /* atan(+INF,-INF) */
|
||||
case 3: return -3*pi/4; /* atan(-INF,-INF) */
|
||||
}
|
||||
} else {
|
||||
switch(m) {
|
||||
case 0: return 0.0; /* atan(+...,+INF) */
|
||||
case 1: return -0.0; /* atan(-...,+INF) */
|
||||
case 2: return pi; /* atan(+...,-INF) */
|
||||
case 3: return -pi; /* atan(-...,-INF) */
|
||||
}
|
||||
}
|
||||
}
|
||||
/* |y/x| > 0x1p64 */
|
||||
if (ix+(64<<20) < iy || iy == 0x7ff00000)
|
||||
return m&1 ? -pi/2 : pi/2;
|
||||
|
||||
/* z = atan(|y/x|) without spurious underflow */
|
||||
if ((m&2) && iy+(64<<20) < ix) /* |y/x| < 0x1p-64, x<0 */
|
||||
z = 0;
|
||||
else
|
||||
z = atan(fabs(y/x));
|
||||
switch (m) {
|
||||
case 0: return z; /* atan(+,+) */
|
||||
case 1: return -z; /* atan(-,+) */
|
||||
case 2: return pi - (z-pi_lo); /* atan(+,-) */
|
||||
default: /* case 3 */
|
||||
return (z-pi_lo) - pi; /* atan(-,-) */
|
||||
}
|
||||
uint64_t fi = asuint64 (f);
|
||||
return (fi & ExpMask) >> 52;
|
||||
}
|
||||
|
||||
/* Fast implementation of scalar atan2. Largest errors are when y and x are
|
||||
close together. The greatest observed error is 2.28 ULP:
|
||||
atan2(-0x1.5915b1498e82fp+732, 0x1.54d11ef838826p+732)
|
||||
got -0x1.954f42f1fa841p-1 want -0x1.954f42f1fa843p-1. */
|
||||
double
|
||||
atan2 (double y, double x)
|
||||
{
|
||||
uint64_t ix = asuint64 (x);
|
||||
uint64_t iy = asuint64 (y);
|
||||
|
||||
uint64_t sign_x = ix & SignMask;
|
||||
uint64_t sign_y = iy & SignMask;
|
||||
|
||||
uint64_t iax = ix & ~SignMask;
|
||||
uint64_t iay = iy & ~SignMask;
|
||||
|
||||
bool xisnan = isnan (x);
|
||||
if (UNLIKELY (isnan (y) && !xisnan))
|
||||
return __math_invalid (y);
|
||||
if (UNLIKELY (xisnan))
|
||||
return __math_invalid (x);
|
||||
|
||||
/* m = 2 * sign(x) + sign(y). */
|
||||
uint32_t m = ((iy >> 63) & 1) | ((ix >> 62) & 2);
|
||||
|
||||
int64_t exp_diff = biased_exponent (x) - biased_exponent (y);
|
||||
|
||||
/* y = 0. */
|
||||
if (iay == 0)
|
||||
{
|
||||
switch (m)
|
||||
{
|
||||
case 0:
|
||||
case 1:
|
||||
return y; /* atan(+-0,+anything)=+-0. */
|
||||
case 2:
|
||||
return Pi; /* atan(+0,-anything) = pi. */
|
||||
case 3:
|
||||
return -Pi; /* atan(-0,-anything) =-pi. */
|
||||
}
|
||||
}
|
||||
/* Special case for (x, y) either on or very close to the y axis. Either x =
|
||||
0, or y is much larger than x (difference in exponents >=
|
||||
POW8_EXP_UFLOW_BOUND). */
|
||||
if (UNLIKELY (iax == 0 || exp_diff <= -POW8_EXP_UFLOW_BOUND))
|
||||
return sign_y ? -PiOver2 : PiOver2;
|
||||
|
||||
/* Special case for either x is INF or (x, y) is very close to x axis and x is
|
||||
negative. */
|
||||
if (UNLIKELY (iax == 0x7ff0000000000000
|
||||
|| (exp_diff >= POW8_EXP_UFLOW_BOUND && m >= 2)))
|
||||
{
|
||||
if (iay == 0x7ff0000000000000)
|
||||
{
|
||||
switch (m)
|
||||
{
|
||||
case 0:
|
||||
return PiOver4; /* atan(+INF,+INF). */
|
||||
case 1:
|
||||
return -PiOver4; /* atan(-INF,+INF). */
|
||||
case 2:
|
||||
return 3.0 * PiOver4; /* atan(+INF,-INF). */
|
||||
case 3:
|
||||
return -3.0 * PiOver4; /* atan(-INF,-INF). */
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
switch (m)
|
||||
{
|
||||
case 0:
|
||||
return 0.0; /* atan(+...,+INF). */
|
||||
case 1:
|
||||
return -0.0; /* atan(-...,+INF). */
|
||||
case 2:
|
||||
return Pi; /* atan(+...,-INF). */
|
||||
case 3:
|
||||
return -Pi; /* atan(-...,-INF). */
|
||||
}
|
||||
}
|
||||
}
|
||||
/* y is INF. */
|
||||
if (iay == 0x7ff0000000000000)
|
||||
return sign_y ? -PiOver2 : PiOver2;
|
||||
|
||||
uint64_t sign_xy = sign_x ^ sign_y;
|
||||
|
||||
double ax = asdouble (iax);
|
||||
double ay = asdouble (iay);
|
||||
uint64_t pred_aygtax = (ay > ax);
|
||||
|
||||
/* Set up z for call to atan. */
|
||||
double n = pred_aygtax ? -ax : ay;
|
||||
double d = pred_aygtax ? ay : ax;
|
||||
double z = n / d;
|
||||
|
||||
double ret;
|
||||
if (UNLIKELY (m < 2 && exp_diff >= POW8_EXP_UFLOW_BOUND))
|
||||
{
|
||||
/* If (x, y) is very close to x axis and x is positive, the polynomial
|
||||
will underflow and evaluate to z. */
|
||||
ret = z;
|
||||
}
|
||||
else
|
||||
{
|
||||
/* Work out the correct shift. */
|
||||
double shift = sign_x ? -2.0 : 0.0;
|
||||
shift = pred_aygtax ? shift + 1.0 : shift;
|
||||
shift *= PiOver2;
|
||||
|
||||
ret = eval_poly (z, z, shift);
|
||||
}
|
||||
|
||||
/* Account for the sign of x and y. */
|
||||
return asdouble (asuint64 (ret) ^ sign_xy);
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue