glibc/sysdeps/ia64/fpu/s_atanl.S

2008 lines
44 KiB
ArmAsm

.file "atanl.s"
// Copyright (C) 2000, 2001, Intel Corporation
// All rights reserved.
//
// Contributed 2/2/2000 by John Harrison, Ted Kubaska, Bob Norin, Shane Story,
// and Ping Tak Peter Tang of the Computational Software Lab, Intel Corporation.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//
// * 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.
//
// * The name of Intel Corporation may not be used to endorse or promote
// products derived from this software without specific prior written
// permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 INTEL OR ITS
// 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.
//
// Intel Corporation is the author of this code, and requests that all
// problem reports or change requests be submitted to it directly at
// http://developer.intel.com/opensource.
//
//
// *********************************************************************
//
// History
// 2/02/00 (hand-optimized)
// 4/04/00 Unwind support added
// 8/15/00 Bundle added after call to __libm_error_support to properly
// set [the previously overwritten] GR_Parameter_RESULT.
//
// *********************************************************************
//
// Function: atanl(x) = inverse tangent(x), for double extended x values
// Function: atan2l(y,x) = atan(y/x), for double extended x values
//
// *********************************************************************
//
// Resources Used:
//
// Floating-Point Registers: f8 (Input and Return Value)
// f9-f15
// f32-f79
//
// General Purpose Registers:
// r32-r48
// r49,r50,r51,r52 (Arguments to error support for 0,0 case)
//
// Predicate Registers: p6-p15
//
// *********************************************************************
//
// IEEE Special Conditions:
//
// Denormal fault raised on denormal inputs
// Underflow exceptions may occur
// Special error handling for the y=0 and x=0 case
// Inexact raised when appropriate by algorithm
//
// atanl(SNaN) = QNaN
// atanl(QNaN) = QNaN
// atanl(+/-0) = +/- 0
// atanl(+/-Inf) = +/-pi/2
//
// atan2l(Any NaN for x or y) = QNaN
// atan2l(+/-0,x) = +/-0 for x > 0
// atan2l(+/-0,x) = +/-pi for x < 0
// atan2l(+/-0,+0) = +/-0
// atan2l(+/-0,-0) = +/-pi
// atan2l(y,+/-0) = pi/2 y > 0
// atan2l(y,+/-0) = -pi/2 y < 0
// atan2l(+/-y, Inf) = +/-0 for finite y > 0
// atan2l(+/-Inf, x) = +/-pi/2 for finite x
// atan2l(+/-y, -Inf) = +/-pi for finite y > 0
// atan2l(+/-Inf, Inf) = +/-pi/4
// atan2l(+/-Inf, -Inf) = +/-3pi/4
//
// *********************************************************************
//
// Mathematical Description
// ---------------------------
//
// The function ATANL( Arg_Y, Arg_X ) returns the "argument"
// or the "phase" of the complex number
//
// Arg_X + i Arg_Y
//
// or equivalently, the angle in radians from the positive
// x-axis to the line joining the origin and the point
// (Arg_X,Arg_Y)
//
//
// (Arg_X, Arg_Y) x
// \
// \
// \
// \
// \ angle between is ATANL(Arg_Y,Arg_X)
// \
// ------------------> X-axis
// Origin
//
// Moreover, this angle is reported in the range [-pi,pi] thus
//
// -pi <= ATANL( Arg_Y, Arg_X ) <= pi.
//
// From the geometry, it is easy to define ATANL when one of
// Arg_X or Arg_Y is +-0 or +-inf:
//
//
// \ Y |
// X \ | +0 | -0 | +inf | -inf | finite non-zero
// \ | | | | |
// ______________________________________________________
// | | | |
// +-0 | Invalid/ | pi/2 | -pi/2 | sign(Y)*pi/2
// | qNaN | | |
// --------------------------------------------------------
// | | | | |
// +inf | +0 | -0 | pi/4 | -pi/4 | sign(Y)*0
// --------------------------------------------------------
// | | | | |
// -inf | +pi | -pi | 3pi/4 | -3pi/4 | sign(Y)*pi
// --------------------------------------------------------
// finite | X>0? | pi/2 | -pi/2 | normal case
// non-zero| sign(Y)*0: | | |
// | sign(Y)*pi | | |
//
//
// One must take note that ATANL is NOT the arctangent of the
// value Arg_Y/Arg_X; but rather ATANL and arctan are related
// in a slightly more complicated way as follows:
//
// Let U := max(|Arg_X|, |Arg_Y|); V := min(|Arg_X|, |Arg_Y|);
// sign_X be the sign bit of Arg_X, i.e., sign_X is 0 or 1;
// s_X be the sign of Arg_X, i.e., s_X = (-1)^sign_X;
//
// sign_Y be the sign bit of Arg_Y, i.e., sign_Y is 0 or 1;
// s_Y be the sign of Arg_Y, i.e., s_Y = (-1)^sign_Y;
//
// swap be 0 if |Arg_X| >= |Arg_Y| and 1 otherwise.
//
// Then, ATANL(Arg_Y, Arg_X) =
//
// / arctan(V/U) \ sign_X = 0 & swap = 0
// | pi/2 - arctan(V/U) | sign_X = 0 & swap = 1
// s_Y * | |
// | pi - arctan(V/U) | sign_X = 1 & swap = 0
// \ pi/2 + arctan(V/U) / sign_X = 1 & swap = 1
//
//
// This relationship also suggest that the algorithm's major
// task is to calculate arctan(V/U) for 0 < V <= U; and the
// final Result is given by
//
// s_Y * { (P_hi + P_lo) + sigma * arctan(V/U) }
//
// where
//
// (P_hi,P_lo) represents M(sign_X,swap)*(pi/2) accurately
//
// M(sign_X,swap) = 0 for sign_X = 0 and swap = 0
// 1 for swap = 1
// 2 for sign_X = 1 and swap = 0
//
// and
//
// sigma = { (sign_X XOR swap) : -1.0 : 1.0 }
//
// = (-1) ^ ( sign_X XOR swap )
//
// Both (P_hi,P_lo) and sigma can be stored in a table and fetched
// using (sign_X,swap) as an index. (P_hi, P_lo) can be stored as a
// double-precision, and single-precision pair; and sigma can
// obviously be just a single-precision number.
//
// In the algorithm we propose, arctan(V/U) is calculated to high accuracy
// as A_hi + A_lo. Consequently, the Result ATANL( Arg_Y, Arg_X ) is
// given by
//
// s_Y*P_hi + s_Y*sigma*A_hi + s_Y*(sigma*A_lo + P_lo)
//
// We now discuss the calculation of arctan(V/U) for 0 < V <= U.
//
// For (V/U) < 2^(-3), we use a simple polynomial of the form
//
// z + z^3*(P_1 + z^2*(P_2 + z^2*(P_3 + ... + P_8)))
//
// where z = V/U.
//
// For the sake of accuracy, the first term "z" must approximate V/U to
// extra precision. For z^3 and higher power, a working precision
// approximation to V/U suffices. Thus, we obtain:
//
// z_hi + z_lo = V/U to extra precision and
// z = V/U to working precision
//
// The value arctan(V/U) is delivered as two pieces (A_hi, A_lo)
//
// (A_hi,A_lo) = (z_hi, z^3*(P_1 + ... + P_8) + z_lo).
//
//
// For 2^(-3) <= (V/U) <= 1, we use a table-driven approach.
// Consider
//
// (V/U) = 2^k * 1.b_1 b_2 .... b_63 b_64 b_65 ....
//
// Define
//
// z_hi = 2^k * 1.b_1 b_2 b_3 b_4 1
//
// then
// / \
// | (V/U) - z_hi |
// arctan(V/U) = arctan(z_hi) + acrtan| -------------- |
// | 1 + (V/U)*z_hi |
// \ /
//
// / \
// | V - z_hi*U |
// = arctan(z_hi) + acrtan| -------------- |
// | U + V*z_hi |
// \ /
//
// = arctan(z_hi) + acrtan( V' / U' )
//
//
// where
//
// V' = V - U*z_hi; U' = U + V*z_hi.
//
// Let
//
// w_hi + w_lo = V'/U' to extra precision and
// w = V'/U' to working precision
//
// then we can approximate arctan(V'/U') by
//
// arctan(V'/U') = w_hi + w_lo
// + w^3*(Q_1 + w^2*(Q_2 + w^2*(Q_3 + w^2*Q_4)))
//
// = w_hi + w_lo + poly
//
// Finally, arctan(z_hi) is calculated beforehand and stored in a table
// as Tbl_hi, Tbl_lo. Thus,
//
// (A_hi, A_lo) = (Tbl_hi, w_hi+(poly+(w_lo+Tbl_lo)))
//
// This completes the mathematical description.
//
//
// Algorithm
// -------------
//
// Step 0. Check for unsupported format.
//
// If
// ( expo(Arg_X) not zero AND msb(Arg_X) = 0 ) OR
// ( expo(Arg_Y) not zero AND msb(Arg_Y) = 0 )
//
// then one of the arguments is unsupported. Generate an
// invalid and return qNaN.
//
// Step 1. Initialize
//
// Normalize Arg_X and Arg_Y and set the following
//
// sign_X := sign_bit(Arg_X)
// s_Y := (sign_bit(Arg_Y)==0? 1.0 : -1.0)
// swap := (|Arg_X| >= |Arg_Y|? 0 : 1 )
// U := max( |Arg_X|, |Arg_Y| )
// V := min( |Arg_X|, |Arg_Y| )
//
// execute: frcap E, pred, V, U
// If pred is 0, go to Step 5 for special cases handling.
//
// Step 2. Decide on branch.
//
// Q := E * V
// If Q < 2^(-3) go to Step 4 for simple polynomial case.
//
// Step 3. Table-driven algorithm.
//
// Q is represented as
//
// 2^(-k) * 1.b_1 b_2 b_3 ... b_63; k = 0,-1,-2,-3
//
// and that if k = 0, b_1 = b_2 = b_3 = b_4 = 0.
//
// Define
//
// z_hi := 2^(-k) * 1.b_1 b_2 b_3 b_4 1
//
// (note that there are 49 possible values of z_hi).
//
// ...We now calculate V' and U'. While V' is representable
// ...as a 64-bit number because of cancellation, U' is
// ...not in general a 64-bit number. Obtaining U' accurately
// ...requires two working precision numbers
//
// U_prime_hi := U + V * z_hi ...WP approx. to U'
// U_prime_lo := ( U - U_prime_hi ) + V*z_hi ...observe order
// V_prime := V - U * z_hi ...this is exact
//
// C_hi := frcpa (1.0, U_prime_hi) ...C_hi approx 1/U'_hi
//
// loop 3 times
// C_hi := C_hi + C_hi*(1.0 - C_hi*U_prime_hi)
//
// ...at this point C_hi is (1/U_prime_hi) to roughly 64 bits
//
// w_hi := V_prime * C_hi ...w_hi is V_prime/U_prime to
// ...roughly working precision
//
// ...note that we want w_hi + w_lo to approximate
// ...V_prime/(U_prime_hi + U_prime_lo) to extra precision
// ...but for now, w_hi is good enough for the polynomial
// ...calculation.
//
// wsq := w_hi*w_hi
// poly := w_hi*wsq*(Q_1 + wsq*(Q_2 + wsq*(Q_3 + wsq*Q_4)))
//
// Fetch
// (Tbl_hi, Tbl_lo) = atan(z_hi) indexed by (k,b_1,b_2,b_3,b_4)
// ...Tbl_hi is a double-precision number
// ...Tbl_lo is a single-precision number
//
// (P_hi, P_lo) := M(sign_X,swap)*(Pi_by_2_hi, Pi_by_2_lo)
// ...as discussed previous. Again; the implementation can
// ...chose to fetch P_hi and P_lo from a table indexed by
// ...(sign_X, swap).
// ...P_hi is a double-precision number;
// ...P_lo is a single-precision number.
//
// ...calculate w_lo so that w_hi + w_lo is V'/U' accurately
// w_lo := ((V_prime - w_hi*U_prime_hi) -
// w_hi*U_prime_lo) * C_hi ...observe order
//
//
// ...Ready to deliver arctan(V'/U') as A_hi, A_lo
// A_hi := Tbl_hi
// A_lo := w_hi + (poly + (Tbl_lo + w_lo)) ...observe order
//
// ...Deliver final Result
// ...s_Y*P_hi + s_Y*sigma*A_hi + s_Y*(sigma*A_lo + P_lo)
//
// sigma := ( (sign_X XOR swap) ? -1.0 : 1.0 )
// ...sigma can be obtained by a table lookup using
// ...(sign_X,swap) as index and stored as single precision
// ...sigma should be calculated earlier
//
// P_hi := s_Y*P_hi
// A_hi := s_Y*A_hi
//
// Res_hi := P_hi + sigma*A_hi ...this is exact because
// ...both P_hi and Tbl_hi
// ...are double-precision
// ...and |Tbl_hi| > 2^(-4)
// ...P_hi is either 0 or
// ...between (1,4)
//
// Res_lo := sigma*A_lo + P_lo
//
// Return Res_hi + s_Y*Res_lo in user-defined rounding control
//
// Step 4. Simple polynomial case.
//
// ...E and Q are inherited from Step 2.
//
// A_hi := Q ...Q is inherited from Step 2 Q approx V/U
//
// loop 3 times
// E := E + E2(1.0 - E*U1
// ...at this point E approximates 1/U to roughly working precision
//
// z := V * E ...z approximates V/U to roughly working precision
// zsq := z * z
// z8 := zsq * zsq; z8 := z8 * z8
//
// poly1 := P_4 + zsq*(P_5 + zsq*(P_6 + zsq*(P_7 + zsq*P_8)))
// poly2 := zsq*(P_1 + zsq*(P_2 + zsq*P_3))
//
// poly := poly1 + z8*poly2
//
// z_lo := (V - A_hi*U)*E
//
// A_lo := z*poly + z_lo
// ...A_hi, A_lo approximate arctan(V/U) accurately
//
// (P_hi, P_lo) := M(sign_X,swap)*(Pi_by_2_hi, Pi_by_2_lo)
// ...one can store the M(sign_X,swap) as single precision
// ...values
//
// ...Deliver final Result
// ...s_Y*P_hi + s_Y*sigma*A_hi + s_Y*(sigma*A_lo + P_lo)
//
// sigma := ( (sign_X XOR swap) ? -1.0 : 1.0 )
// ...sigma can be obtained by a table lookup using
// ...(sign_X,swap) as index and stored as single precision
// ...sigma should be calculated earlier
//
// P_hi := s_Y*P_hi
// A_hi := s_Y*A_hi
//
// Res_hi := P_hi + sigma*A_hi ...need to compute
// ...P_hi + sigma*A_hi
// ...exactly
//
// tmp := (P_hi - Res_hi) + sigma*A_hi
//
// Res_lo := s_Y*(sigma*A_lo + P_lo) + tmp
//
// Return Res_hi + Res_lo in user-defined rounding control
//
// Step 5. Special Cases
//
// If pred is 0 where pred is obtained in
// frcap E, pred, V, U
//
// we are in one of those special cases of 0,+-inf or NaN
//
// If one of U and V is NaN, return U+V (which will generate
// invalid in case one is a signaling NaN). Otherwise,
// return the Result as described in the table
//
//
//
// \ Y |
// X \ | +0 | -0 | +inf | -inf | finite non-zero
// \ | | | | |
// ______________________________________________________
// | | | |
// +-0 | Invalid/ | pi/2 | -pi/2 | sign(Y)*pi/2
// | qNaN | | |
// --------------------------------------------------------
// | | | | |
// +inf | +0 | -0 | pi/4 | -pi/4 | sign(Y)*0
// --------------------------------------------------------
// | | | | |
// -inf | +pi | -pi | 3pi/4 | -3pi/4 | sign(Y)*pi
// --------------------------------------------------------
// finite | X>0? | pi/2 | -pi/2 |
// non-zero| sign(Y)*0: | | | N/A
// | sign(Y)*pi | | |
//
//
#include "libm_support.h"
ArgY_orig = f8
Result = f8
FR_RESULT = f8
ArgX_orig = f9
ArgX = f10
FR_X = f10
ArgY = f11
FR_Y = f11
s_Y = f12
U = f13
V = f14
E = f15
Q = f32
z_hi = f33
U_prime_hi = f34
U_prime_lo = f35
V_prime = f36
C_hi = f37
w_hi = f38
w_lo = f39
wsq = f40
poly = f41
Tbl_hi = f42
Tbl_lo = f43
P_hi = f44
P_lo = f45
A_hi = f46
A_lo = f47
sigma = f48
Res_hi = f49
Res_lo = f50
Z = f52
zsq = f53
z8 = f54
poly1 = f55
poly2 = f56
z_lo = f57
tmp = f58
P_1 = f59
Q_1 = f60
P_2 = f61
Q_2 = f62
P_3 = f63
Q_3 = f64
P_4 = f65
Q_4 = f66
P_5 = f67
P_6 = f68
P_7 = f69
P_8 = f70
TWO_TO_NEG3 = f71
U_hold = f72
C_hi_hold = f73
E_hold = f74
M = f75
ArgX_abs = f76
ArgY_abs = f77
Result_lo = f78
A_temp = f79
GR_SAVE_PFS = r33
GR_SAVE_B0 = r34
GR_SAVE_GP = r35
sign_X = r36
sign_Y = r37
swap = r38
table_ptr1 = r39
table_ptr2 = r40
k = r41
lookup = r42
exp_ArgX = r43
exp_ArgY = r44
exponent_Q = r45
significand_Q = r46
special = r47
special1 = r48
GR_Parameter_X = r49
GR_Parameter_Y = r50
GR_Parameter_RESULT = r51
GR_Parameter_TAG = r52
int_temp = r52
#ifdef _LIBC
.rodata
#else
.data
#endif
.align 64
Constants_atan:
ASM_TYPE_DIRECTIVE(Constants_atan,@object)
data4 0x54442D18, 0x3FF921FB, 0x248D3132, 0x3E000000
// double pi/2, single lo_pi/2, two**(-3)
data4 0xAAAAAAA3, 0xAAAAAAAA, 0x0000BFFD, 0x00000000 // P_1
data4 0xCCCC54B2, 0xCCCCCCCC, 0x00003FFC, 0x00000000 // P_2
data4 0x47E4D0C2, 0x92492492, 0x0000BFFC, 0x00000000 // P_3
data4 0x58870889, 0xE38E38E0, 0x00003FFB, 0x00000000 // P_4
data4 0x290149F8, 0xBA2E895B, 0x0000BFFB, 0x00000000 // P_5
data4 0x250F733D, 0x9D88E6D4, 0x00003FFB, 0x00000000 // P_6
data4 0xFB8745A0, 0x884E51FF, 0x0000BFFB, 0x00000000 // P_7
data4 0x394396BD, 0xE1C7412B, 0x00003FFA, 0x00000000 // P_8
data4 0xAAAAA52F, 0xAAAAAAAA, 0x0000BFFD, 0x00000000 // Q_1
data4 0xC75B60D3, 0xCCCCCCCC, 0x00003FFC, 0x00000000 // Q_2
data4 0x011F1940, 0x924923AD, 0x0000BFFC, 0x00000000 // Q_3
data4 0x2A5F89BD, 0xE36F716D, 0x00003FFB, 0x00000000 // Q_4
//
// Entries Tbl_hi (double precision)
// B = 1+Index/16+1/32 Index = 0
// Entries Tbl_lo (single precision)
// B = 1+Index/16+1/32 Index = 0
//
data4 0xA935BD8E, 0x3FE9A000, 0x23ACA08F, 0x00000000
//
// Entries Tbl_hi (double precision) Index = 0,1,...,15
// B = 2^(-1)*(1+Index/16+1/32)
// Entries Tbl_lo (single precision)
// Index = 0,1,...,15 B = 2^(-1)*(1+Index/16+1/32)
//
data4 0x7F175A34, 0x3FDE77EB, 0x238729EE, 0x00000000
data4 0x73C1A40B, 0x3FE0039C, 0x249334DB, 0x00000000
data4 0x5B5B43DA, 0x3FE0C614, 0x22CBA7D1, 0x00000000
data4 0x88BE7C13, 0x3FE1835A, 0x246310E7, 0x00000000
data4 0xE2CC9E6A, 0x3FE23B71, 0x236210E5, 0x00000000
data4 0x8406CBCA, 0x3FE2EE62, 0x2462EAF5, 0x00000000
data4 0x1CD41719, 0x3FE39C39, 0x24B73EF3, 0x00000000
data4 0x5B795B55, 0x3FE44506, 0x24C11260, 0x00000000
data4 0x5BB6EC04, 0x3FE4E8DE, 0x242519EE, 0x00000000
data4 0x1F732FBA, 0x3FE587D8, 0x24D4346C, 0x00000000
data4 0x115D7B8D, 0x3FE6220D, 0x24ED487B, 0x00000000
data4 0x920B3D98, 0x3FE6B798, 0x2495FF1E, 0x00000000
data4 0x8FBA8E0F, 0x3FE74897, 0x223D9531, 0x00000000
data4 0x289FA093, 0x3FE7D528, 0x242B0411, 0x00000000
data4 0x576CC2C5, 0x3FE85D69, 0x2335B374, 0x00000000
data4 0xA99CC05D, 0x3FE8E17A, 0x24C27CFB, 0x00000000
//
// Entries Tbl_hi (double precision) Index = 0,1,...,15
// B = 2^(-2)*(1+Index/16+1/32)
// Entries Tbl_lo (single precision)
// Index = 0,1,...,15 B = 2^(-2)*(1+Index/16+1/32)
//
data4 0x510665B5, 0x3FD025FA, 0x24263482, 0x00000000
data4 0x362431C9, 0x3FD1151A, 0x242C8DC9, 0x00000000
data4 0x67E47C95, 0x3FD20255, 0x245CF9BA, 0x00000000
data4 0x7A823CFE, 0x3FD2ED98, 0x235C892C, 0x00000000
data4 0x29271134, 0x3FD3D6D1, 0x2389BE52, 0x00000000
data4 0x586890E6, 0x3FD4BDEE, 0x24436471, 0x00000000
data4 0x175E0F4E, 0x3FD5A2E0, 0x2389DBD4, 0x00000000
data4 0x9F5FA6FD, 0x3FD68597, 0x2476D43F, 0x00000000
data4 0x52817501, 0x3FD76607, 0x24711774, 0x00000000
data4 0xB8DF95D7, 0x3FD84422, 0x23EBB501, 0x00000000
data4 0x7CD0C662, 0x3FD91FDE, 0x23883A0C, 0x00000000
data4 0x66168001, 0x3FD9F930, 0x240DF63F, 0x00000000
data4 0x5422058B, 0x3FDAD00F, 0x23FE261A, 0x00000000
data4 0x378624A5, 0x3FDBA473, 0x23A8CD0E, 0x00000000
data4 0x0AAD71F8, 0x3FDC7655, 0x2422D1D0, 0x00000000
data4 0xC9EC862B, 0x3FDD45AE, 0x2344A109, 0x00000000
//
// Entries Tbl_hi (double precision) Index = 0,1,...,15
// B = 2^(-3)*(1+Index/16+1/32)
// Entries Tbl_lo (single precision)
// Index = 0,1,...,15 B = 2^(-3)*(1+Index/16+1/32)
//
data4 0x84212B3D, 0x3FC068D5, 0x239874B6, 0x00000000
data4 0x41060850, 0x3FC16465, 0x2335E774, 0x00000000
data4 0x171A535C, 0x3FC25F6E, 0x233E36BE, 0x00000000
data4 0xEDEB99A3, 0x3FC359E8, 0x239680A3, 0x00000000
data4 0xC6092A9E, 0x3FC453CE, 0x230FB29E, 0x00000000
data4 0xBA11570A, 0x3FC54D18, 0x230C1418, 0x00000000
data4 0xFFB3AA73, 0x3FC645BF, 0x23F0564A, 0x00000000
data4 0xE8A7D201, 0x3FC73DBD, 0x23D4A5E1, 0x00000000
data4 0xE398EBC7, 0x3FC8350B, 0x23D4ADDA, 0x00000000
data4 0x7D050271, 0x3FC92BA3, 0x23BCB085, 0x00000000
data4 0x601081A5, 0x3FCA217E, 0x23BC841D, 0x00000000
data4 0x574D780B, 0x3FCB1696, 0x23CF4A8E, 0x00000000
data4 0x4D768466, 0x3FCC0AE5, 0x23BECC90, 0x00000000
data4 0x4E1D5395, 0x3FCCFE65, 0x2323DCD2, 0x00000000
data4 0x864C9D9D, 0x3FCDF110, 0x23F53F3A, 0x00000000
data4 0x451D980C, 0x3FCEE2E1, 0x23CCB11F, 0x00000000
data4 0x54442D18, 0x400921FB, 0x33145C07, 0x3CA1A626 // PI two doubles
data4 0x54442D18, 0x3FF921FB, 0x33145C07, 0x3C91A626 // PI_by_2 two dbles
data4 0x54442D18, 0x3FE921FB, 0x33145C07, 0x3C81A626 // PI_by_4 two dbles
data4 0x7F3321D2, 0x4002D97C, 0x4C9E8A0A, 0x3C9A7939 // 3PI_by_4 two dbles
ASM_SIZE_DIRECTIVE(Constants_atan)
.text
.proc atanl#
.global atanl#
.align 64
atanl:
{ .mfb
nop.m 999
(p0) mov ArgX_orig = f1
(p0) br.cond.sptk atan2l ;;
}
.endp atanl
ASM_SIZE_DIRECTIVE(atanl)
.text
.proc atan2l#
.global atan2l#
#ifdef _LIBC
.proc __atan2l#
.global __atan2l#
.proc __ieee754_atan2l#
.global __ieee754_atan2l#
#endif
.align 64
atan2l:
#ifdef _LIBC
__atan2l:
__ieee754_atan2l:
#endif
{ .mfi
alloc r32 = ar.pfs, 0, 17 , 4, 0
(p0) mov ArgY = ArgY_orig
}
{ .mfi
nop.m 999
(p0) mov ArgX = ArgX_orig
nop.i 999
};;
{ .mfi
nop.m 999
(p0) fclass.m.unc p7,p0 = ArgY_orig, 0x103
nop.i 999
}
{ .mfi
nop.m 999
//
//
// Save original input args and load table ptr.
//
(p0) fclass.m.unc p6,p0 = ArgX_orig, 0x103
nop.i 999
};;
{ .mfi
(p0) addl table_ptr1 = @ltoff(Constants_atan#), gp
(p0) fclass.m.unc p0,p9 = ArgY_orig, 0x1FF
nop.i 999 ;;
}
{ .mfi
ld8 table_ptr1 = [table_ptr1]
(p0) fclass.m.unc p0,p8 = ArgX_orig, 0x1FF
nop.i 999
}
{ .mfi
nop.m 999
(p0) fclass.m.unc p13,p0 = ArgY_orig, 0x0C3
nop.i 999 ;;
}
{ .mfi
(p0) fclass.m.unc p12,p0 = ArgX_orig, 0x0C3
nop.i 999
}
//
// Check for NatVals.
// Check for everything - if false, then must be pseudo-zero
// or pseudo-nan (IA unsupporteds).
//
{ .mib
nop.m 999
nop.i 999
(p6) br.cond.spnt L(ATANL_NATVAL) ;;
}
{ .mib
nop.m 999
nop.i 999
(p7) br.cond.spnt L(ATANL_NATVAL) ;;
}
{ .mib
(p0) ldfd P_hi = [table_ptr1],8
nop.i 999
(p8) br.cond.spnt L(ATANL_UNSUPPORTED) ;;
}
{ .mbb
(p0) add table_ptr2 = 96, table_ptr1
(p9) br.cond.spnt L(ATANL_UNSUPPORTED)
//
// Load double precision high-order part of pi
//
(p12) br.cond.spnt L(ATANL_NAN) ;;
}
{ .mfb
nop.m 999
(p0) fnorm.s1 ArgX = ArgX
(p13) br.cond.spnt L(ATANL_NAN) ;;
}
//
// Normalize the input argument.
// Branch out if NaN inputs
//
{ .mmf
(p0) ldfs P_lo = [table_ptr1], 4
nop.m 999
(p0) fnorm.s1 ArgY = ArgY ;;
}
{ .mmf
nop.m 999
(p0) ldfs TWO_TO_NEG3 = [table_ptr1], 180
//
// U = max(ArgX_abs,ArgY_abs)
// V = min(ArgX_abs,ArgY_abs)
// if PR1, swap = 0
// if PR2, swap = 1
//
(p0) mov M = f1 ;;
}
{ .mfi
nop.m 999
//
// Get exp and sign of ArgX
// Get exp and sign of ArgY
// Load 2**(-3) and increment ptr to Q_4.
//
(p0) fmerge.s ArgX_abs = f1, ArgX
nop.i 999 ;;
}
//
// load single precision low-order part of pi = P_lo
//
{ .mfi
(p0) getf.exp sign_X = ArgX
(p0) fmerge.s ArgY_abs = f1, ArgY
nop.i 999 ;;
}
{ .mii
(p0) getf.exp sign_Y = ArgY
nop.i 999 ;;
(p0) shr sign_X = sign_X, 17 ;;
}
{ .mii
nop.m 999
(p0) shr sign_Y = sign_Y, 17 ;;
(p0) cmp.eq.unc p8, p9 = 0x00000, sign_Y ;;
}
{ .mfi
nop.m 999
//
// Is ArgX_abs >= ArgY_abs
// Is sign_Y == 0?
//
(p0) fmax.s1 U = ArgX_abs, ArgY_abs
nop.i 999
}
{ .mfi
nop.m 999
//
// ArgX_abs = |ArgX|
// ArgY_abs = |ArgY|
// sign_X is sign bit of ArgX
// sign_Y is sign bit of ArgY
//
(p0) fcmp.ge.s1 p6, p7 = ArgX_abs, ArgY_abs
nop.i 999 ;;
}
{ .mfi
nop.m 999
(p0) fmin.s1 V = ArgX_abs, ArgY_abs
nop.i 999 ;;
}
{ .mfi
nop.m 999
(p8) fadd.s1 s_Y = f0, f1
(p6) cmp.eq.unc p10, p11 = 0x00000, sign_X
}
{ .mii
(p6) add swap = r0, r0
nop.i 999 ;;
(p7) add swap = 1, r0
}
{ .mfi
nop.m 999
//
// Let M = 1.0
// if p8, s_Y = 1.0
// if p9, s_Y = -1.0
//
(p10) fsub.s1 M = M, f1
nop.i 999 ;;
}
{ .mfi
nop.m 999
(p9) fsub.s1 s_Y = f0, f1
nop.i 999 ;;
}
{ .mfi
nop.m 999
(p0) frcpa.s1 E, p6 = V, U
nop.i 999 ;;
}
{ .mbb
nop.m 999
//
// E = frcpa(V,U)
//
(p6) br.cond.sptk L(ATANL_STEP2)
(p0) br.cond.spnt L(ATANL_SPECIAL_HANDLING) ;;
}
L(ATANL_STEP2):
{ .mfi
nop.m 999
(p0) fmpy.s1 Q = E, V
nop.i 999
}
{ .mfi
nop.m 999
(p0) fcmp.eq.s0 p0, p9 = f1, ArgY_orig
nop.i 999 ;;
}
{ .mfi
nop.m 999
//
// Is Q < 2**(-3)?
//
(p0) fcmp.eq.s0 p0, p8 = f1, ArgX_orig
nop.i 999
}
{ .mfi
nop.m 999
(p11) fadd.s1 M = M, f1
nop.i 999 ;;
}
{ .mlx
nop.m 999
// *************************************************
// ********************* STEP2 *********************
// *************************************************
(p0) movl special = 0x8400000000000000
}
{ .mlx
nop.m 999
//
// lookup = b_1 b_2 b_3 B_4
//
(p0) movl special1 = 0x0000000000000100 ;;
}
{ .mfi
nop.m 999
//
// Do fnorms to raise any denormal operand
// exceptions.
//
(p0) fmpy.s1 P_hi = M, P_hi
nop.i 999
}
{ .mfi
nop.m 999
(p0) fmpy.s1 P_lo = M, P_lo
nop.i 999 ;;
}
{ .mfi
nop.m 999
//
// Q = E * V
//
(p0) fcmp.lt.unc.s1 p6, p7 = Q, TWO_TO_NEG3
nop.i 999 ;;
}
{ .mmb
(p0) getf.sig significand_Q = Q
(p0) getf.exp exponent_Q = Q
nop.b 999 ;;
}
{ .mmi
nop.m 999 ;;
(p0) andcm k = 0x0003, exponent_Q
(p0) extr.u lookup = significand_Q, 59, 4 ;;
}
{ .mib
nop.m 999
(p0) dep special = lookup, special, 59, 4
//
// Generate 1.b_1 b_2 b_3 b_4 1 0 0 0 ... 0
//
(p6) br.cond.spnt L(ATANL_POLY) ;;
}
{ .mfi
(p0) cmp.eq.unc p8, p9 = 0x0000, k
(p0) fmpy.s1 P_hi = s_Y, P_hi
//
// We waited a few extra cycles so P_lo and P_hi could be calculated.
// Load the constant 256 for loading up table entries.
//
// *************************************************
// ******************** STEP3 **********************
// *************************************************
(p0) add table_ptr2 = 16, table_ptr1
}
//
// Let z_hi have exponent and sign of original Q
// Load the Tbl_hi(0) else, increment pointer.
//
{ .mii
(p0) ldfe Q_4 = [table_ptr1], -16
(p0) xor swap = sign_X, swap ;;
(p9) sub k = k, r0, 1
}
{ .mmi
(p0) setf.sig z_hi = special
(p0) ldfe Q_3 = [table_ptr1], -16
(p9) add table_ptr2 = 16, table_ptr2 ;;
}
//
// U_hold = U - U_prime_hi
// k = k * 256 - Result can be 0, 256, or 512.
//
{ .mmb
(p0) ldfe Q_2 = [table_ptr1], -16
(p8) ldfd Tbl_hi = [table_ptr2], 8
nop.b 999 ;;
}
//
// U_prime_lo = U_hold + V * z_hi
// lookup -> lookup * 16 + k
//
{ .mmi
(p0) ldfe Q_1 = [table_ptr1], -16 ;;
(p8) ldfs Tbl_lo = [table_ptr2], 8
//
// U_prime_hi = U + V * z_hi
// Load the Tbl_lo(0)
//
(p9) pmpy2.r k = k, special1 ;;
}
{ .mii
nop.m 999
nop.i 999
nop.i 999 ;;
}
{ .mii
nop.m 999
nop.i 999
nop.i 999 ;;
}
{ .mii
nop.m 999
nop.i 999
nop.i 999 ;;
}
{ .mii
nop.m 999
nop.i 999 ;;
(p9) shladd lookup = lookup, 0x0004, k ;;
}
{ .mmi
(p9) add table_ptr2 = table_ptr2, lookup ;;
//
// V_prime = V - U * z_hi
//
(p9) ldfd Tbl_hi = [table_ptr2], 8
nop.i 999 ;;
}
{ .mmf
nop.m 999
//
// C_hi = frcpa(1,U_prime_hi)
//
(p9) ldfs Tbl_lo = [table_ptr2], 8
//
// z_hi = s exp 1.b_1 b_2 b_3 b_4 1 0 0 0 ... 0
// Point to beginning of Tbl_hi entries - k = 0.
//
(p0) fmerge.se z_hi = Q, z_hi ;;
}
{ .mfi
nop.m 999
(p0) fma.s1 U_prime_hi = V, z_hi, U
nop.i 999
}
{ .mfi
nop.m 999
(p0) fnma.s1 V_prime = U, z_hi, V
nop.i 999 ;;
}
{ .mfi
nop.m 999
(p0) mov A_hi = Tbl_hi
nop.i 999 ;;
}
{ .mfi
nop.m 999
(p0) fsub.s1 U_hold = U, U_prime_hi
nop.i 999 ;;
}
{ .mfi
nop.m 999
(p0) frcpa.s1 C_hi, p6 = f1, U_prime_hi
nop.i 999 ;;
}
{ .mfi
(p0) cmp.eq.unc p7, p6 = 0x00000, swap
(p0) fmpy.s1 A_hi = s_Y, A_hi
nop.i 999 ;;
}
{ .mfi
nop.m 999
//
// poly = wsq * poly
//
(p7) fadd.s1 sigma = f0, f1
nop.i 999 ;;
}
{ .mfi
nop.m 999
(p0) fma.s1 U_prime_lo = z_hi, V, U_hold
nop.i 999
}
{ .mfi
nop.m 999
(p6) fsub.s1 sigma = f0, f1
nop.i 999 ;;
}
{ .mfi
nop.m 999
(p0) fnma.s1 C_hi_hold = C_hi, U_prime_hi, f1
nop.i 999 ;;
}
{ .mfi
nop.m 999
//
// A_lo = A_lo + w_hi
// A_hi = s_Y * A_hi
//
(p0) fma.s1 Res_hi = sigma, A_hi, P_hi
nop.i 999 ;;
}
{ .mfi
nop.m 999
//
// C_hi_hold = 1 - C_hi * U_prime_hi (1)
//
(p0) fma.s1 C_hi = C_hi_hold, C_hi, C_hi
nop.i 999 ;;
}
{ .mfi
nop.m 999
//
// C_hi = C_hi + C_hi * C_hi_hold (1)
//
(p0) fnma.s1 C_hi_hold = C_hi, U_prime_hi, f1
nop.i 999 ;;
}
{ .mfi
nop.m 999
//
// C_hi_hold = 1 - C_hi * U_prime_hi (2)
//
(p0) fma.s1 C_hi = C_hi_hold, C_hi, C_hi
nop.i 999 ;;
}
{ .mfi
nop.m 999
//
// C_hi = C_hi + C_hi * C_hi_hold (2)
//
(p0) fnma.s1 C_hi_hold = C_hi, U_prime_hi, f1
nop.i 999 ;;
}
{ .mfi
nop.m 999
//
// C_hi_hold = 1 - C_hi * U_prime_hi (3)
//
(p0) fma.s1 C_hi = C_hi_hold, C_hi, C_hi
nop.i 999 ;;
}
{ .mfi
nop.m 999
//
// C_hi = C_hi + C_hi * C_hi_hold (3)
//
(p0) fmpy.s1 w_hi = V_prime, C_hi
nop.i 999 ;;
}
{ .mfi
nop.m 999
//
// w_hi = V_prime * C_hi
//
(p0) fmpy.s1 wsq = w_hi, w_hi
nop.i 999
}
{ .mfi
nop.m 999
(p0) fnma.s1 w_lo = w_hi, U_prime_hi, V_prime
nop.i 999 ;;
}
{ .mfi
nop.m 999
//
// wsq = w_hi * w_hi
// w_lo = = V_prime - w_hi * U_prime_hi
//
(p0) fma.s1 poly = wsq, Q_4, Q_3
nop.i 999
}
{ .mfi
nop.m 999
(p0) fnma.s1 w_lo = w_hi, U_prime_lo, w_lo
nop.i 999 ;;
}
{ .mfi
nop.m 999
//
// poly = Q_3 + wsq * Q_4
// w_lo = = w_lo - w_hi * U_prime_lo
//
(p0) fma.s1 poly = wsq, poly, Q_2
nop.i 999
}
{ .mfi
nop.m 999
(p0) fmpy.s1 w_lo = C_hi, w_lo
nop.i 999 ;;
}
{ .mfi
nop.m 999
//
// poly = Q_2 + wsq * poly
// w_lo = = w_lo * C_hi
//
(p0) fma.s1 poly = wsq, poly, Q_1
nop.i 999
}
{ .mfi
nop.m 999
(p0) fadd.s1 A_lo = Tbl_lo, w_lo
nop.i 999 ;;
}
{ .mfi
nop.m 999
//
// Result = Res_hi + Res_lo * s_Y (User Supplied Rounding Mode)
//
(p0) fmpy.s0 Q_1 = Q_1, Q_1
nop.i 999 ;;
}
{ .mfi
nop.m 999
//
// poly = Q_1 + wsq * poly
// A_lo = Tbl_lo + w_lo
// swap = xor(swap,sign_X)
//
(p0) fmpy.s1 poly = wsq, poly
nop.i 999 ;;
}
{ .mfi
nop.m 999
//
// Is (swap) != 0 ?
// poly = wsq * poly
// A_hi = Tbl_hi
//
(p0) fmpy.s1 poly = w_hi, poly
nop.i 999 ;;
}
{ .mfi
nop.m 999
//
// if (PR_1) sigma = -1.0
// if (PR_2) sigma = 1.0
//
(p0) fadd.s1 A_lo = A_lo, poly
nop.i 999 ;;
}
{ .mfi
nop.m 999
//
// P_hi = s_Y * P_hi
// A_lo = A_lo + poly
//
(p0) fadd.s1 A_lo = A_lo, w_hi
nop.i 999 ;;
}
{ .mfi
nop.m 999
(p0) fma.s1 Res_lo = sigma, A_lo, P_lo
nop.i 999 ;;
}
{ .mfb
nop.m 999
//
// Res_hi = P_hi + sigma * A_hi
// Res_lo = P_lo + sigma * A_lo
//
(p0) fma.s0 Result = Res_lo, s_Y, Res_hi
//
// Raise inexact.
//
br.ret.sptk b0 ;;
}
//
// poly1 = P_5 + zsq * poly1
// poly2 = zsq * poly2
//
L(ATANL_POLY):
{ .mmf
(p0) xor swap = sign_X, swap
nop.m 999
(p0) fnma.s1 E_hold = E, U, f1 ;;
}
{ .mfi
nop.m 999
(p0) mov A_temp = Q
//
// poly1 = P_4 + zsq * poly1
// swap = xor(swap,sign_X)
//
// sign_X gr_002
// swap gr_004
// poly1 = poly1 <== Done with poly1
// poly1 = P_4 + zsq * poly1
// swap = xor(swap,sign_X)
//
(p0) cmp.eq.unc p7, p6 = 0x00000, swap
}
{ .mfi
nop.m 999
(p0) fmpy.s1 P_hi = s_Y, P_hi
nop.i 999 ;;
}
{ .mfi
nop.m 999
(p6) fsub.s1 sigma = f0, f1
nop.i 999
}
{ .mfi
nop.m 999
(p7) fadd.s1 sigma = f0, f1
nop.i 999 ;;
}
// ***********************************************
// ******************** STEP4 ********************
// ***********************************************
{ .mmi
nop.m 999
(p0) addl table_ptr1 = @ltoff(Constants_atan#), gp
nop.i 999
}
;;
{ .mmi
ld8 table_ptr1 = [table_ptr1]
nop.m 999
nop.i 999
}
;;
{ .mfi
nop.m 999
(p0) fma.s1 E = E, E_hold, E
//
// Following:
// Iterate 3 times E = E + E*(1.0 - E*U)
// Also load P_8, P_7, P_6, P_5, P_4
// E_hold = 1.0 - E * U (1)
// A_temp = Q
//
(p0) add table_ptr1 = 128, table_ptr1 ;;
}
{ .mmf
nop.m 999
//
// E = E + E_hold*E (1)
// Point to P_8.
//
(p0) ldfe P_8 = [table_ptr1], -16
//
// poly = z8*poly1 + poly2 (Typo in writeup)
// Is (swap) != 0 ?
//
(p0) fnma.s1 z_lo = A_temp, U, V ;;
}
{ .mmb
nop.m 999
//
// E_hold = 1.0 - E * U (2)
//
(p0) ldfe P_7 = [table_ptr1], -16
nop.b 999 ;;
}
{ .mmb
nop.m 999
//
// E = E + E_hold*E (2)
//
(p0) ldfe P_6 = [table_ptr1], -16
nop.b 999 ;;
}
{ .mmb
nop.m 999
//
// E_hold = 1.0 - E * U (3)
//
(p0) ldfe P_5 = [table_ptr1], -16
nop.b 999 ;;
}
{ .mmf
nop.m 999
//
// E = E + E_hold*E (3)
//
//
// At this point E approximates 1/U to roughly working precision
// z = V*E approximates V/U
//
(p0) ldfe P_4 = [table_ptr1], -16
(p0) fnma.s1 E_hold = E, U, f1 ;;
}
{ .mmb
nop.m 999
//
// Z = V * E
//
(p0) ldfe P_3 = [table_ptr1], -16
nop.b 999 ;;
}
{ .mmb
nop.m 999
//
// zsq = Z * Z
//
(p0) ldfe P_2 = [table_ptr1], -16
nop.b 999 ;;
}
{ .mmb
nop.m 999
//
// z8 = zsq * zsq
//
(p0) ldfe P_1 = [table_ptr1], -16
nop.b 999 ;;
}
{ .mlx
nop.m 999
(p0) movl int_temp = 0x24005
}
{ .mfi
nop.m 999
(p0) fma.s1 E = E, E_hold, E
nop.i 999 ;;
}
{ .mfi
nop.m 999
(p0) fnma.s1 E_hold = E, U, f1
nop.i 999 ;;
}
{ .mfi
nop.m 999
(p0) fma.s1 E = E, E_hold, E
nop.i 999 ;;
}
{ .mfi
nop.m 999
(p0) fmpy.s1 Z = V, E
nop.i 999
}
{ .mfi
nop.m 999
//
// z_lo = V - A_temp * U
// if (PR_2) sigma = 1.0
//
(p0) fmpy.s1 z_lo = z_lo, E
nop.i 999 ;;
}
{ .mfi
nop.m 999
(p0) fmpy.s1 zsq = Z, Z
nop.i 999
}
{ .mfi
nop.m 999
//
// z_lo = z_lo * E
// if (PR_1) sigma = -1.0
//
(p0) fadd.s1 A_hi = A_temp, z_lo
nop.i 999 ;;
}
{ .mfi
nop.m 999
//
// z8 = z8 * z8
//
//
// Now what we want to do is
// poly1 = P_4 + zsq*(P_5 + zsq*(P_6 + zsq*(P_7 + zsq*P_8)))
// poly2 = zsq*(P_1 + zsq*(P_2 + zsq*P_3))
//
(p0) fma.s1 poly1 = zsq, P_8, P_7
nop.i 999
}
{ .mfi
nop.m 999
(p0) fma.s1 poly2 = zsq, P_3, P_2
nop.i 999 ;;
}
{ .mfi
nop.m 999
(p0) fmpy.s1 z8 = zsq, zsq
nop.i 999
}
{ .mfi
nop.m 999
(p0) fsub.s1 A_temp = A_temp, A_hi
nop.i 999 ;;
}
{ .mfi
nop.m 999
//
// A_lo = Z * poly + z_lo
//
(p0) fmerge.s tmp = A_hi, A_hi
nop.i 999 ;;
}
{ .mfi
nop.m 999
//
// poly1 = P_7 + zsq * P_8
// poly2 = P_2 + zsq * P_3
//
(p0) fma.s1 poly1 = zsq, poly1, P_6
nop.i 999
}
{ .mfi
nop.m 999
(p0) fma.s1 poly2 = zsq, poly2, P_1
nop.i 999 ;;
}
{ .mfi
nop.m 999
(p0) fmpy.s1 z8 = z8, z8
nop.i 999
}
{ .mfi
nop.m 999
(p0) fadd.s1 z_lo = A_temp, z_lo
nop.i 999 ;;
}
{ .mfi
nop.m 999
//
// poly1 = P_6 + zsq * poly1
// poly2 = P_2 + zsq * poly2
//
(p0) fma.s1 poly1 = zsq, poly1, P_5
nop.i 999
}
{ .mfi
nop.m 999
(p0) fmpy.s1 poly2 = poly2, zsq
nop.i 999 ;;
}
{ .mfi
nop.m 999
//
// Result = Res_hi + Res_lo (User Supplied Rounding Mode)
//
(p0) fmpy.s1 P_5 = P_5, P_5
nop.i 999 ;;
}
{ .mfi
nop.m 999
(p0) fma.s1 poly1 = zsq, poly1, P_4
nop.i 999 ;;
}
{ .mfi
nop.m 999
(p0) fma.s1 poly = z8, poly1, poly2
nop.i 999 ;;
}
{ .mfi
nop.m 999
//
// Fixup added to force inexact later -
// A_hi = A_temp + z_lo
// z_lo = (A_temp - A_hi) + z_lo
//
(p0) fma.s1 A_lo = Z, poly, z_lo
nop.i 999 ;;
}
{ .mfi
nop.m 999
(p0) fadd.s1 A_hi = tmp, A_lo
nop.i 999 ;;
}
{ .mfi
nop.m 999
(p0) fsub.s1 tmp = tmp, A_hi
nop.i 999
}
{ .mfi
nop.m 999
(p0) fmpy.s1 A_hi = s_Y, A_hi
nop.i 999 ;;
}
{ .mfi
nop.m 999
(p0) fadd.s1 A_lo = tmp, A_lo
nop.i 999
}
{ .mfi
(p0) setf.exp tmp = int_temp
//
// P_hi = s_Y * P_hi
// A_hi = s_Y * A_hi
//
(p0) fma.s1 Res_hi = sigma, A_hi, P_hi
nop.i 999 ;;
}
{ .mfi
nop.m 999
(p0) fclass.m.unc p6,p0 = A_lo, 0x007
nop.i 999 ;;
}
{ .mfi
nop.m 999
(p6) mov A_lo = tmp
nop.i 999
}
{ .mfi
nop.m 999
//
// Res_hi = P_hi + sigma * A_hi
//
(p0) fsub.s1 tmp = P_hi, Res_hi
nop.i 999 ;;
}
{ .mfi
nop.m 999
//
// tmp = P_hi - Res_hi
//
(p0) fma.s1 tmp = A_hi, sigma, tmp
nop.i 999
}
{ .mfi
nop.m 999
(p0) fma.s1 sigma = A_lo, sigma, P_lo
nop.i 999 ;;
}
{ .mfi
nop.m 999
//
// tmp = sigma * A_hi + tmp
// sigma = A_lo * sigma + P_lo
//
(p0) fma.s1 Res_lo = s_Y, sigma, tmp
nop.i 999 ;;
}
{ .mfb
nop.m 999
//
// Res_lo = s_Y * sigma + tmp
//
(p0) fadd.s0 Result = Res_lo, Res_hi
br.ret.sptk b0 ;;
}
L(ATANL_NATVAL):
L(ATANL_UNSUPPORTED):
L(ATANL_NAN):
{ .mfb
nop.m 999
(p0) fmpy.s0 Result = ArgX,ArgY
(p0) br.ret.sptk b0 ;;
}
L(ATANL_SPECIAL_HANDLING):
{ .mfi
nop.m 999
(p0) fcmp.eq.s0 p0, p6 = f1, ArgY_orig
nop.i 999
}
{ .mfi
nop.m 999
(p0) fcmp.eq.s0 p0, p5 = f1, ArgX_orig
nop.i 999 ;;
}
{ .mfi
nop.m 999
(p0) fclass.m.unc p6, p7 = ArgY, 0x007
nop.i 999
}
{ .mlx
nop.m 999
(p0) movl special = 992
}
;;
{ .mmi
nop.m 999
(p0) addl table_ptr1 = @ltoff(Constants_atan#), gp
nop.i 999
}
;;
{ .mmi
ld8 table_ptr1 = [table_ptr1]
nop.m 999
nop.i 999
}
;;
{ .mib
(p0) add table_ptr1 = table_ptr1, special
nop.i 999
(p7) br.cond.spnt L(ATANL_ArgY_Not_ZERO) ;;
}
{ .mmf
(p0) ldfd Result = [table_ptr1], 8
nop.m 999
(p6) fclass.m.unc p14, p0 = ArgX, 0x035 ;;
}
{ .mmf
nop.m 999
(p0) ldfd Result_lo = [table_ptr1], -8
(p6) fclass.m.unc p15, p0 = ArgX, 0x036 ;;
}
{ .mfi
nop.m 999
(p14) fmerge.s Result = ArgY, f0
nop.i 999
}
{ .mfi
nop.m 999
(p6) fclass.m.unc p13, p0 = ArgX, 0x007
nop.i 999 ;;
}
{ .mfi
nop.m 999
(p14) fmerge.s Result_lo = ArgY, f0
nop.i 999 ;;
}
{ .mfi
(p13) mov GR_Parameter_TAG = 36
nop.f 999
nop.i 999 ;;
}
{ .mfi
nop.m 999
//
// Return sign_Y * 0 when ArgX > +0
//
(p15) fmerge.s Result = ArgY, Result
nop.i 999 ;;
}
{ .mfi
nop.m 999
(p15) fmerge.s Result_lo = ArgY, Result_lo
nop.i 999 ;;
}
{ .mfb
nop.m 999
//
// Return sign_Y * 0 when ArgX < -0
//
(p0) fadd.s0 Result = Result, Result_lo
(p13) br.cond.spnt __libm_error_region ;;
}
{ .mib
nop.m 999
nop.i 999
//
// Call error support funciton for atan(0,0)
//
(p0) br.ret.sptk b0 ;;
}
L(ATANL_ArgY_Not_ZERO):
{ .mfi
nop.m 999
(p0) fclass.m.unc p9, p10 = ArgY, 0x023
nop.i 999 ;;
}
{ .mib
nop.m 999
nop.i 999
(p10) br.cond.spnt L(ATANL_ArgY_Not_INF) ;;
}
{ .mfi
nop.m 999
(p9) fclass.m.unc p6, p0 = ArgX, 0x017
nop.i 999
}
{ .mfi
nop.m 999
(p9) fclass.m.unc p7, p0 = ArgX, 0x021
nop.i 999 ;;
}
{ .mfi
nop.m 999
(p9) fclass.m.unc p8, p0 = ArgX, 0x022
nop.i 999 ;;
}
{ .mmi
(p6) add table_ptr1 = 16, table_ptr1 ;;
(p0) ldfd Result = [table_ptr1], 8
nop.i 999 ;;
}
{ .mfi
(p0) ldfd Result_lo = [table_ptr1], -8
nop.f 999
nop.i 999 ;;
}
{ .mfi
nop.m 999
(p6) fmerge.s Result = ArgY, Result
nop.i 999 ;;
}
{ .mfi
nop.m 999
(p6) fmerge.s Result_lo = ArgY, Result_lo
nop.i 999 ;;
}
{ .mfb
nop.m 999
(p6) fadd.s0 Result = Result, Result_lo
(p6) br.ret.sptk b0 ;;
}
//
// Load PI/2 and adjust its sign.
// Return +PI/2 when ArgY = +Inf and ArgX = +/-0 or normal
// Return -PI/2 when ArgY = -Inf and ArgX = +/-0 or normal
//
{ .mmi
(p7) add table_ptr1 = 32, table_ptr1 ;;
(p7) ldfd Result = [table_ptr1], 8
nop.i 999 ;;
}
{ .mfi
(p7) ldfd Result_lo = [table_ptr1], -8
nop.f 999
nop.i 999 ;;
}
{ .mfi
nop.m 999
(p7) fmerge.s Result = ArgY, Result
nop.i 999 ;;
}
{ .mfi
nop.m 999
(p7) fmerge.s Result_lo = ArgY, Result_lo
nop.i 999 ;;
}
{ .mfb
nop.m 999
(p7) fadd.s0 Result = Result, Result_lo
(p7) br.ret.sptk b0 ;;
}
//
// Load PI/4 and adjust its sign.
// Return +PI/4 when ArgY = +Inf and ArgX = +Inf
// Return -PI/4 when ArgY = -Inf and ArgX = +Inf
//
{ .mmi
(p8) add table_ptr1 = 48, table_ptr1 ;;
(p8) ldfd Result = [table_ptr1], 8
nop.i 999 ;;
}
{ .mfi
(p8) ldfd Result_lo = [table_ptr1], -8
nop.f 999
nop.i 999 ;;
}
{ .mfi
nop.m 999
(p8) fmerge.s Result = ArgY, Result
nop.i 999 ;;
}
{ .mfi
nop.m 999
(p8) fmerge.s Result_lo = ArgY, Result_lo
nop.i 999 ;;
}
{ .mfb
nop.m 999
(p8) fadd.s0 Result = Result, Result_lo
(p8) br.ret.sptk b0 ;;
}
L(ATANL_ArgY_Not_INF):
{ .mfi
nop.m 999
//
// Load PI/4 and adjust its sign.
// Return +3PI/4 when ArgY = +Inf and ArgX = -Inf
// Return -3PI/4 when ArgY = -Inf and ArgX = -Inf
//
(p0) fclass.m.unc p6, p0 = ArgX, 0x007
nop.i 999
}
{ .mfi
nop.m 999
(p0) fclass.m.unc p7, p0 = ArgX, 0x021
nop.i 999 ;;
}
{ .mfi
nop.m 999
(p0) fclass.m.unc p8, p0 = ArgX, 0x022
nop.i 999 ;;
}
{ .mmi
(p6) add table_ptr1 = 16, table_ptr1 ;;
(p6) ldfd Result = [table_ptr1], 8
nop.i 999 ;;
}
{ .mfi
(p6) ldfd Result_lo = [table_ptr1], -8
nop.f 999
nop.i 999 ;;
}
{ .mfi
nop.m 999
(p6) fmerge.s Result = ArgY, Result
nop.i 999 ;;
}
{ .mfi
nop.m 999
(p6) fmerge.s Result_lo = ArgY, Result_lo
nop.i 999 ;;
}
{ .mfb
nop.m 999
(p6) fadd.s0 Result = Result, Result_lo
(p6) br.ret.spnt b0 ;;
}
{ .mfi
nop.m 999
//
// return = sign_Y * PI/2 when ArgX = 0
//
(p7) fmerge.s Result = ArgY, f0
nop.i 999 ;;
}
{ .mfb
nop.m 999
(p7) fnorm.s0 Result = Result
(p7) br.ret.spnt b0 ;;
}
//
// return = sign_Y * 0 when ArgX = Inf
//
{ .mmi
(p8) ldfd Result = [table_ptr1], 8 ;;
(p8) ldfd Result_lo = [table_ptr1], -8
nop.i 999 ;;
}
{ .mfi
nop.m 999
(p8) fmerge.s Result = ArgY, Result
nop.i 999 ;;
}
{ .mfi
nop.m 999
(p8) fmerge.s Result_lo = ArgY, Result_lo
nop.i 999 ;;
}
{ .mfb
nop.m 999
(p8) fadd.s0 Result = Result, Result_lo
(p8) br.ret.sptk b0 ;;
}
//
// return = sign_Y * PI when ArgX = -Inf
//
.endp atan2l
ASM_SIZE_DIRECTIVE(atan2l)
ASM_SIZE_DIRECTIVE(__atan2l)
ASM_SIZE_DIRECTIVE(__ieee754_atan2l)
.proc __libm_error_region
__libm_error_region:
.prologue
{ .mfi
add GR_Parameter_Y=-32,sp // Parameter 2 value
nop.f 0
.save ar.pfs,GR_SAVE_PFS
mov GR_SAVE_PFS=ar.pfs // Save ar.pfs
}
{ .mfi
.fframe 64
add sp=-64,sp // Create new stack
nop.f 0
mov GR_SAVE_GP=gp // Save gp
};;
{ .mmi
stfe [GR_Parameter_Y] = FR_Y,16 // Save Parameter 2 on stack
add GR_Parameter_X = 16,sp // Parameter 1 address
.save b0, GR_SAVE_B0
mov GR_SAVE_B0=b0 // Save b0
};;
.body
{ .mib
stfe [GR_Parameter_X] = FR_X // Store Parameter 1 on stack
add GR_Parameter_RESULT = 0,GR_Parameter_Y
nop.b 0 // Parameter 3 address
}
{ .mib
stfe [GR_Parameter_Y] = FR_RESULT // Store Parameter 3 on stack
add GR_Parameter_Y = -16,GR_Parameter_Y
br.call.sptk b0=__libm_error_support# // Call error handling function
};;
{ .mmi
nop.m 0
nop.m 0
add GR_Parameter_RESULT = 48,sp
};;
{ .mmi
ldfe f8 = [GR_Parameter_RESULT] // Get return result off stack
.restore sp
add sp = 64,sp // Restore stack pointer
mov b0 = GR_SAVE_B0 // Restore return address
};;
{ .mib
mov gp = GR_SAVE_GP // Restore gp
mov ar.pfs = GR_SAVE_PFS // Restore ar.pfs
br.ret.sptk b0 // Return
};;
.endp __libm_error_region
ASM_SIZE_DIRECTIVE(__libm_error_region)
.type __libm_error_support#,@function
.global __libm_error_support#