AuroraMiddleware/glibc
1
0
Fork 0
mirror of https://sourceware.org/git/glibc.git synced 2025-01-15 05:20:05 +00:00
Code Issues Packages Projects Releases Wiki Activity

x86_64: Fix svml_d_asinh2_core_sse4.S code formatting

Browse Source 
This commit contains following formatting changes

1. Instructions proceeded by a tab.
2. Instruction less than 8 characters in length have a tab
   between it and the first operand.
3. Instruction greater than 7 characters in length have a
   space between it and the first operand.
4. Tabs after `#define`d names and their value.
5. 8 space at the beginning of line replaced by tab.
6. Indent comments with code.
7. Remove redundent .text section.
8. 1 space between line content and line comment.
9. Space after all commas.

Reviewed-by: Noah Goldstein <goldstein.w.n@gmail.com>
This commit is contained in:
Sunil K Pandey 2022-03-07 10:47:09 -08:00
parent 9908822338
commit a7ab967662
1 changed files with 1551 additions and 1552 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

175
sysdeps/x86_64/fpu/multiarch/svml_d_asinh2_core_sse4.S
View File

@ -68,8 +68,7 @@
#include <sysdep.h> #include <sysdep.h>
.text .section .text.sse4, "ax", @progbits
.section .text.sse4,"ax",@progbits
ENTRY(_ZGVbN2v_asinh_sse4) ENTRY(_ZGVbN2v_asinh_sse4)
pushq %rbp pushq %rbp
cfi_def_cfa_offset(16) cfi_def_cfa_offset(16)
@ -80,7 +79,7 @@ ENTRY(_ZGVbN2v_asinh_sse4)
subq $64, %rsp subq $64, %rsp
movaps %xmm0, %xmm13 movaps %xmm0, %xmm13
/* /*
* Split X into high and low parts, XHi (<= 26 bits) and XLo (<= 27 bits) * Split X into high and low parts, XHi (<= 26 bits) and XLo (<= 27 bits)
* We could use either X or |X| here, but it doesn't seem to matter * We could use either X or |X| here, but it doesn't seem to matter
*/ */
@ -89,7 +88,7 @@ ENTRY(_ZGVbN2v_asinh_sse4)
andps %xmm13, %xmm15 andps %xmm13, %xmm15
lea Table_Lookup_Bias+__svml_dasinh_data_internal(%rip), %rsi lea Table_Lookup_Bias+__svml_dasinh_data_internal(%rip), %rsi
/* /*
* Compute X^2 = (XHi + XLo)^2 = XHi^2 + XLo * (X + XHi) * Compute X^2 = (XHi + XLo)^2 = XHi^2 + XLo * (X + XHi)
* The two parts are shifted off by around 26 bits. So even though * The two parts are shifted off by around 26 bits. So even though
* the low bit will not in general be exact, it's near enough * the low bit will not in general be exact, it's near enough
@ -99,10 +98,10 @@ ENTRY(_ZGVbN2v_asinh_sse4)
subpd %xmm15, %xmm7 subpd %xmm15, %xmm7
addpd %xmm13, %xmm15 addpd %xmm13, %xmm15
/* Load the constant 1 and a sign mask */ /* Load the constant 1 and a sign mask */
movups One+__svml_dasinh_data_internal(%rip), %xmm12 movups One+__svml_dasinh_data_internal(%rip), %xmm12
/* /*
* Finally, express Y + W = X^2 + 1 accurately where Y has <= 29 bits. * Finally, express Y + W = X^2 + 1 accurately where Y has <= 29 bits.
* If |X| <= 1 then |XHi| <= 1 and so |X2Hi| <= 1, so we can treat 1 * If |X| <= 1 then |XHi| <= 1 and so |X2Hi| <= 1, so we can treat 1
* as the dominant component in the compensated summation. Otherwise, * as the dominant component in the compensated summation. Otherwise,
@ -120,7 +119,7 @@ ENTRY(_ZGVbN2v_asinh_sse4)
movups dTopMask29+__svml_dasinh_data_internal(%rip), %xmm6 movups dTopMask29+__svml_dasinh_data_internal(%rip), %xmm6
andps %xmm3, %xmm6 andps %xmm3, %xmm6
/* /*
* Compute R = 1/sqrt(Y + W) * (1 + d) * Compute R = 1/sqrt(Y + W) * (1 + d)
* Force R to <= 12 significant bits in case it isn't already * Force R to <= 12 significant bits in case it isn't already
* This means that R * Y and R^2 * Y are exactly representable. * This means that R * Y and R^2 * Y are exactly representable.
@ -129,7 +128,7 @@ ENTRY(_ZGVbN2v_asinh_sse4)
addpd %xmm8, %xmm5 addpd %xmm8, %xmm5
subpd %xmm6, %xmm3 subpd %xmm6, %xmm3
/* /*
* Unfortunately, we can still be in trouble if |X| <= 2^-10, since * Unfortunately, we can still be in trouble if |X| <= 2^-10, since
* the absolute error 2^-(12+53)-ish in sqrt(1 + X^2) gets scaled up * the absolute error 2^-(12+53)-ish in sqrt(1 + X^2) gets scaled up
* by 1/X and comes close to our threshold. Hence if |X| <= 2^-9, * by 1/X and comes close to our threshold. Hence if |X| <= 2^-9,
@ -145,14 +144,14 @@ ENTRY(_ZGVbN2v_asinh_sse4)
cvtps2pd %xmm4, %xmm2 cvtps2pd %xmm4, %xmm2
andps dTopMask12+__svml_dasinh_data_internal(%rip), %xmm2 andps dTopMask12+__svml_dasinh_data_internal(%rip), %xmm2
/* /*
* Compute e = -(2 * d + d^2) * Compute e = -(2 * d + d^2)
* The first FMR is exact, and the rounding error in the other is acceptable * The first FMR is exact, and the rounding error in the other is acceptable
* since d and e are ~ 2^-12 * since d and e are ~ 2^-12
*/ */
movaps %xmm12, %xmm1 movaps %xmm12, %xmm1
/* /*
* Compute S = (Y/sqrt(Y + W)) * (1 + d) * Compute S = (Y/sqrt(Y + W)) * (1 + d)
* and T = (W/sqrt(Y + W)) * (1 + d) * and T = (W/sqrt(Y + W)) * (1 + d)
* so that S + T = sqrt(Y + W) * (1 + d) * so that S + T = sqrt(Y + W) * (1 + d)
@ -162,7 +161,7 @@ ENTRY(_ZGVbN2v_asinh_sse4)
mulpd %xmm2, %xmm5 mulpd %xmm2, %xmm5
movaps %xmm2, %xmm0 movaps %xmm2, %xmm0
/* /*
* Obtain sqrt(1 + X^2) - 1 in two pieces * Obtain sqrt(1 + X^2) - 1 in two pieces
* sqrt(1 + X^2) - 1 * sqrt(1 + X^2) - 1
* = sqrt(Y + W) - 1 * = sqrt(Y + W) - 1
@ -183,21 +182,21 @@ ENTRY(_ZGVbN2v_asinh_sse4)
movups SgnMask+__svml_dasinh_data_internal(%rip), %xmm9 movups SgnMask+__svml_dasinh_data_internal(%rip), %xmm9
movaps %xmm12, %xmm4 movaps %xmm12, %xmm4
/* /*
* Get the absolute value of the input, since we will exploit antisymmetry * Get the absolute value of the input, since we will exploit antisymmetry
* and mostly assume X >= 0 in the core computation * and mostly assume X >= 0 in the core computation
*/ */
movaps %xmm9, %xmm10 movaps %xmm9, %xmm10
andps %xmm13, %xmm10 andps %xmm13, %xmm10
/* /*
* Check whether the input is finite, by checking |X| <= MaxFloat * Check whether the input is finite, by checking |X| <= MaxFloat
* Otherwise set the rangemask so that the callout will get used. * Otherwise set the rangemask so that the callout will get used.
* Note that this will also use the callout for NaNs since not(NaN <= MaxFloat) * Note that this will also use the callout for NaNs since not(NaN <= MaxFloat)
*/ */
movaps %xmm10, %xmm14 movaps %xmm10, %xmm14
/* /*
* The following computation can go wrong for very large X, basically * The following computation can go wrong for very large X, basically
* because X^2 overflows. But for large X we have * because X^2 overflows. But for large X we have
* asinh(X) / log(2 X) - 1 =~= 1/(4 * X^2), so for X >= 2^30 * asinh(X) / log(2 X) - 1 =~= 1/(4 * X^2), so for X >= 2^30
@ -211,7 +210,7 @@ ENTRY(_ZGVbN2v_asinh_sse4)
cmpltpd dBigThreshold+__svml_dasinh_data_internal(%rip), %xmm11 cmpltpd dBigThreshold+__svml_dasinh_data_internal(%rip), %xmm11
movmskpd %xmm14, %edx movmskpd %xmm14, %edx
/* /*
* Now 1 / (1 + d) * Now 1 / (1 + d)
* = 1 / (1 + (sqrt(1 - e) - 1)) * = 1 / (1 + (sqrt(1 - e) - 1))
* = 1 / sqrt(1 - e) * = 1 / sqrt(1 - e)
@ -229,7 +228,7 @@ ENTRY(_ZGVbN2v_asinh_sse4)
movups dHalf+__svml_dasinh_data_internal(%rip), %xmm15 movups dHalf+__svml_dasinh_data_internal(%rip), %xmm15
mulpd %xmm1, %xmm14 mulpd %xmm1, %xmm14
/* dX2over2 = X^2/2 */ /* dX2over2 = X^2/2 */
mulpd %xmm15, %xmm8 mulpd %xmm15, %xmm8
addpd dC4+__svml_dasinh_data_internal(%rip), %xmm14 addpd dC4+__svml_dasinh_data_internal(%rip), %xmm14
mulpd %xmm1, %xmm14 mulpd %xmm1, %xmm14
@ -243,19 +242,19 @@ ENTRY(_ZGVbN2v_asinh_sse4)
addpd %xmm1, %xmm5 addpd %xmm1, %xmm5
addpd %xmm6, %xmm5 addpd %xmm6, %xmm5
/* dX4over4 = X^4/4 */ /* dX4over4 = X^4/4 */
movaps %xmm8, %xmm6 movaps %xmm8, %xmm6
/* dX46 = -X^4/4 + X^6/8 */ /* dX46 = -X^4/4 + X^6/8 */
movaps %xmm8, %xmm7 movaps %xmm8, %xmm7
mulpd %xmm8, %xmm6 mulpd %xmm8, %xmm6
mulpd %xmm6, %xmm7 mulpd %xmm6, %xmm7
subpd %xmm6, %xmm7 subpd %xmm6, %xmm7
/* dX46over2 = -X^4/8 + x^6/16 */ /* dX46over2 = -X^4/8 + x^6/16 */
mulpd %xmm7, %xmm15 mulpd %xmm7, %xmm15
/* Now multiplex the two possible computations */ /* Now multiplex the two possible computations */
movaps %xmm10, %xmm3 movaps %xmm10, %xmm3
cmplepd dLittleThreshold+__svml_dasinh_data_internal(%rip), %xmm3 cmplepd dLittleThreshold+__svml_dasinh_data_internal(%rip), %xmm3
addpd %xmm15, %xmm8 addpd %xmm15, %xmm8
@ -263,7 +262,7 @@ ENTRY(_ZGVbN2v_asinh_sse4)
andps %xmm3, %xmm8 andps %xmm3, %xmm8
andnps %xmm5, %xmm1 andnps %xmm5, %xmm1
/* /*
* Now we feed into the log1p code, using H in place of _VARG1 and * Now we feed into the log1p code, using H in place of _VARG1 and
* also adding L into Xl. * also adding L into Xl.
* compute 1+x as high, low parts * compute 1+x as high, low parts
@ -272,7 +271,7 @@ ENTRY(_ZGVbN2v_asinh_sse4)
orps %xmm8, %xmm1 orps %xmm8, %xmm1
movaps %xmm11, %xmm3 movaps %xmm11, %xmm3
/* /*
* Now do another compensated sum to add |X| + [sqrt(1 + X^2) - 1]. * Now do another compensated sum to add |X| + [sqrt(1 + X^2) - 1].
* It's always safe to assume |X| is larger. * It's always safe to assume |X| is larger.
* This is the final 2-part argument to the log1p function * This is the final 2-part argument to the log1p function
@ -281,7 +280,7 @@ ENTRY(_ZGVbN2v_asinh_sse4)
maxpd %xmm1, %xmm5 maxpd %xmm1, %xmm5
minpd %xmm1, %xmm4 minpd %xmm1, %xmm4
/* Now multiplex to the case X = 2^-30 * |input|, Xl = dL = 0 in the "big" case. */ /* Now multiplex to the case X = 2^-30 * |input|, Xl = dL = 0 in the "big" case. */
movups XScale+__svml_dasinh_data_internal(%rip), %xmm8 movups XScale+__svml_dasinh_data_internal(%rip), %xmm8
andps %xmm9, %xmm1 andps %xmm9, %xmm1
mulpd %xmm8, %xmm10 mulpd %xmm8, %xmm10
@ -294,19 +293,19 @@ ENTRY(_ZGVbN2v_asinh_sse4)
subpd %xmm9, %xmm5 subpd %xmm9, %xmm5
andps %xmm11, %xmm9 andps %xmm11, %xmm9
/* Now resume the main code. */ /* Now resume the main code. */
movups ExpMask+__svml_dasinh_data_internal(%rip), %xmm10 movups ExpMask+__svml_dasinh_data_internal(%rip), %xmm10
orps %xmm9, %xmm3 orps %xmm9, %xmm3
/* preserve mantissa, set input exponent to 2^(-10) */ /* preserve mantissa, set input exponent to 2^(-10) */
andps %xmm3, %xmm10 andps %xmm3, %xmm10
/* exponent bits */ /* exponent bits */
movaps %xmm3, %xmm7 movaps %xmm3, %xmm7
orps Two10+__svml_dasinh_data_internal(%rip), %xmm10 orps Two10+__svml_dasinh_data_internal(%rip), %xmm10
psrlq $20, %xmm7 psrlq $20, %xmm7
/* reciprocal approximation good to at least 11 bits */ /* reciprocal approximation good to at least 11 bits */
cvtpd2ps %xmm10, %xmm1 cvtpd2ps %xmm10, %xmm1
addpd %xmm5, %xmm4 addpd %xmm5, %xmm4
movlhps %xmm1, %xmm1 movlhps %xmm1, %xmm1
@ -314,51 +313,51 @@ ENTRY(_ZGVbN2v_asinh_sse4)
rcpps %xmm1, %xmm0 rcpps %xmm1, %xmm0
cvtps2pd %xmm0, %xmm0 cvtps2pd %xmm0, %xmm0
/* round reciprocal to nearest integer, will have 1+9 mantissa bits */ /* round reciprocal to nearest integer, will have 1+9 mantissa bits */
movups .FLT_30(%rip), %xmm6 movups .FLT_30(%rip), %xmm6
movaps %xmm11, %xmm1 movaps %xmm11, %xmm1
addpd %xmm6, %xmm0 addpd %xmm6, %xmm0
subpd %xmm6, %xmm0 subpd %xmm6, %xmm0
/* exponent of X needed to scale Xl */ /* exponent of X needed to scale Xl */
movdqu ExpMask0+__svml_dasinh_data_internal(%rip), %xmm5 movdqu ExpMask0+__svml_dasinh_data_internal(%rip), %xmm5
/* 2^ (-10-exp(X) ) */ /* 2^ (-10-exp(X) ) */
movdqu ExpMask2+__svml_dasinh_data_internal(%rip), %xmm2 movdqu ExpMask2+__svml_dasinh_data_internal(%rip), %xmm2
pand %xmm3, %xmm5 pand %xmm3, %xmm5
psubq %xmm5, %xmm2 psubq %xmm5, %xmm2
/* scale DblRcp */ /* scale DblRcp */
mulpd %xmm0, %xmm2 mulpd %xmm0, %xmm2
/* argument reduction */ /* argument reduction */
mulpd %xmm2, %xmm3 mulpd %xmm2, %xmm3
mulpd %xmm2, %xmm4 mulpd %xmm2, %xmm4
subpd %xmm12, %xmm3 subpd %xmm12, %xmm3
addpd %xmm4, %xmm3 addpd %xmm4, %xmm3
/* polynomial */ /* polynomial */
movups poly_coeff+__svml_dasinh_data_internal(%rip), %xmm12 movups poly_coeff+__svml_dasinh_data_internal(%rip), %xmm12
movaps %xmm3, %xmm2 movaps %xmm3, %xmm2
pshufd $221, %xmm7, %xmm8 pshufd $221, %xmm7, %xmm8
mulpd %xmm3, %xmm12 mulpd %xmm3, %xmm12
/* biased exponent in DP format */ /* biased exponent in DP format */
cvtdq2pd %xmm8, %xmm14 cvtdq2pd %xmm8, %xmm14
addpd poly_coeff+16+__svml_dasinh_data_internal(%rip), %xmm12 addpd poly_coeff+16+__svml_dasinh_data_internal(%rip), %xmm12
mulpd %xmm3, %xmm2 mulpd %xmm3, %xmm2
/* Add 31 to the exponent in the "large" case to get log(2 * input) */ /* Add 31 to the exponent in the "large" case to get log(2 * input) */
movups dThirtyOne+__svml_dasinh_data_internal(%rip), %xmm9 movups dThirtyOne+__svml_dasinh_data_internal(%rip), %xmm9
/* exponent*log(2.0) */ /* exponent*log(2.0) */
movups Threshold+__svml_dasinh_data_internal(%rip), %xmm5 movups Threshold+__svml_dasinh_data_internal(%rip), %xmm5
addpd %xmm14, %xmm9 addpd %xmm14, %xmm9
cmpltpd %xmm0, %xmm5 cmpltpd %xmm0, %xmm5
mulpd %xmm2, %xmm12 mulpd %xmm2, %xmm12
andps %xmm11, %xmm14 andps %xmm11, %xmm14
/* /*
* prepare table index * prepare table index
* table lookup * table lookup
*/ */
@ -369,7 +368,7 @@ ENTRY(_ZGVbN2v_asinh_sse4)
addpd poly_coeff+48+__svml_dasinh_data_internal(%rip), %xmm0 addpd poly_coeff+48+__svml_dasinh_data_internal(%rip), %xmm0
addpd %xmm12, %xmm0 addpd %xmm12, %xmm0
/* reconstruction */ /* reconstruction */
mulpd %xmm0, %xmm2 mulpd %xmm0, %xmm2
andps Bias+__svml_dasinh_data_internal(%rip), %xmm5 andps Bias+__svml_dasinh_data_internal(%rip), %xmm5
psrlq $40, %xmm11 psrlq $40, %xmm11
@ -378,7 +377,7 @@ ENTRY(_ZGVbN2v_asinh_sse4)
movd %xmm11, %eax movd %xmm11, %eax
pshufd $2, %xmm11, %xmm11 pshufd $2, %xmm11, %xmm11
/* Finally, reincorporate the original sign. */ /* Finally, reincorporate the original sign. */
movups dSign+__svml_dasinh_data_internal(%rip), %xmm0 movups dSign+__svml_dasinh_data_internal(%rip), %xmm0
subpd %xmm5, %xmm1 subpd %xmm5, %xmm1
addpd %xmm2, %xmm3 addpd %xmm2, %xmm3
@ -387,18 +386,18 @@ ENTRY(_ZGVbN2v_asinh_sse4)
movslq %eax, %rax movslq %eax, %rax
andps %xmm13, %xmm0 andps %xmm13, %xmm0
movslq %ecx, %rcx movslq %ecx, %rcx
movsd (%rsi,%rax), %xmm6 movsd (%rsi, %rax), %xmm6
movhpd (%rsi,%rcx), %xmm6 movhpd (%rsi, %rcx), %xmm6
addpd %xmm3, %xmm6 addpd %xmm3, %xmm6
addpd %xmm6, %xmm1 addpd %xmm6, %xmm1
pxor %xmm1, %xmm0 pxor %xmm1, %xmm0
testl %edx, %edx testl %edx, %edx
/* Go to special inputs processing branch */ /* Go to special inputs processing branch */
jne L(SPECIAL_VALUES_BRANCH) jne L(SPECIAL_VALUES_BRANCH)
# LOE rbx r12 r13 r14 r15 edx xmm0 xmm13 # LOE rbx r12 r13 r14 r15 edx xmm0 xmm13
/* Restore registers /* Restore registers
* and exit the function * and exit the function
*/ */
@ -411,7 +410,7 @@ L(EXIT):
cfi_def_cfa(6, 16) cfi_def_cfa(6, 16)
cfi_offset(6, -16) cfi_offset(6, -16)
/* Branch to process /* Branch to process
* special inputs * special inputs
*/ */
@ -434,18 +433,18 @@ L(SPECIAL_VALUES_BRANCH):
.cfi_escape 0x10, 0x0e, 0x0e, 0x38, 0x1c, 0x0d, 0xe0, 0xff, 0xff, 0xff, 0x1a, 0x0d, 0xc0, 0xff, 0xff, 0xff, 0x22 .cfi_escape 0x10, 0x0e, 0x0e, 0x38, 0x1c, 0x0d, 0xe0, 0xff, 0xff, 0xff, 0x1a, 0x0d, 0xc0, 0xff, 0xff, 0xff, 0x22
# LOE rbx r15 r12d r13d # LOE rbx r15 r12d r13d
/* Range mask /* Range mask
* bits check * bits check
*/ */
L(RANGEMASK_CHECK): L(RANGEMASK_CHECK):
btl %r12d, %r13d btl %r12d, %r13d
/* Call scalar math function */ /* Call scalar math function */
jc L(SCALAR_MATH_CALL) jc L(SCALAR_MATH_CALL)
# LOE rbx r15 r12d r13d # LOE rbx r15 r12d r13d
/* Special inputs /* Special inputs
* processing loop * processing loop
*/ */
@ -453,7 +452,7 @@ L(SPECIAL_VALUES_LOOP):
incl %r12d incl %r12d
cmpl $2, %r12d cmpl $2, %r12d
/* Check bits in range mask */ /* Check bits in range mask */
jl L(RANGEMASK_CHECK) jl L(RANGEMASK_CHECK)
# LOE rbx r15 r12d r13d # LOE rbx r15 r12d r13d
@ -465,7 +464,7 @@ L(SPECIAL_VALUES_LOOP):
cfi_restore(14) cfi_restore(14)
movups 48(%rsp), %xmm0 movups 48(%rsp), %xmm0
/* Go to exit */ /* Go to exit */
jmp L(EXIT) jmp L(EXIT)
/* DW_CFA_expression: r12 (r12) (DW_OP_lit8; DW_OP_minus; DW_OP_const4s: -32; DW_OP_and; DW_OP_const4s: -48; DW_OP_plus) */ /* DW_CFA_expression: r12 (r12) (DW_OP_lit8; DW_OP_minus; DW_OP_const4s: -32; DW_OP_and; DW_OP_const4s: -48; DW_OP_plus) */
.cfi_escape 0x10, 0x0c, 0x0e, 0x38, 0x1c, 0x0d, 0xe0, 0xff, 0xff, 0xff, 0x1a, 0x0d, 0xd0, 0xff, 0xff, 0xff, 0x22 .cfi_escape 0x10, 0x0c, 0x0e, 0x38, 0x1c, 0x0d, 0xe0, 0xff, 0xff, 0xff, 0x1a, 0x0d, 0xd0, 0xff, 0xff, 0xff, 0x22
@ -475,19 +474,19 @@ L(SPECIAL_VALUES_LOOP):
.cfi_escape 0x10, 0x0e, 0x0e, 0x38, 0x1c, 0x0d, 0xe0, 0xff, 0xff, 0xff, 0x1a, 0x0d, 0xc0, 0xff, 0xff, 0xff, 0x22 .cfi_escape 0x10, 0x0e, 0x0e, 0x38, 0x1c, 0x0d, 0xe0, 0xff, 0xff, 0xff, 0x1a, 0x0d, 0xc0, 0xff, 0xff, 0xff, 0x22
# LOE rbx r12 r13 r14 r15 xmm0 # LOE rbx r12 r13 r14 r15 xmm0
/* Scalar math fucntion call /* Scalar math fucntion call
* to process special input * to process special input
*/ */
L(SCALAR_MATH_CALL): L(SCALAR_MATH_CALL):
movl %r12d, %r14d movl %r12d, %r14d
movsd 32(%rsp,%r14,8), %xmm0 movsd 32(%rsp, %r14, 8), %xmm0
call asinh@PLT call asinh@PLT
# LOE rbx r14 r15 r12d r13d xmm0 # LOE rbx r14 r15 r12d r13d xmm0
movsd %xmm0, 48(%rsp,%r14,8) movsd %xmm0, 48(%rsp, %r14, 8)
/* Process special inputs in loop */ /* Process special inputs in loop */
jmp L(SPECIAL_VALUES_LOOP) jmp L(SPECIAL_VALUES_LOOP)
# LOE rbx r15 r12d r13d # LOE rbx r15 r12d r13d
END(_ZGVbN2v_asinh_sse4) END(_ZGVbN2v_asinh_sse4)
@ -1046,7 +1045,7 @@ __svml_dasinh_data_internal:
.quad 0xc08628b36d39ec08, 0xbe1cf1abc231f7b2 .quad 0xc08628b36d39ec08, 0xbe1cf1abc231f7b2
.quad 0xc08628b56dfa36d0, 0xbe1cf2074d5ba303 .quad 0xc08628b56dfa36d0, 0xbe1cf2074d5ba303
.quad 0xc08628b76e3a4180, 0xbe1cf05cd5eed880 .quad 0xc08628b76e3a4180, 0xbe1cf05cd5eed880
/*== Log_LA_table ==*/ /* Log_LA_table */
.align 16 .align 16
.quad 0x8000000000000000 .quad 0x8000000000000000
.quad 0xbf5ff802a9ab10e6 .quad 0xbf5ff802a9ab10e6
@ -1561,102 +1560,102 @@ __svml_dasinh_data_internal:
.quad 0x3f60040155d5889e .quad 0x3f60040155d5889e
.quad 0x3f50020055655889 .quad 0x3f50020055655889
.quad 0x0000000000000000 .quad 0x0000000000000000
/*== poly_coeff[4] ==*/ /* poly_coeff[4] */
.align 16 .align 16
.quad 0x3fc9999CACDB4D0A, 0x3fc9999CACDB4D0A /* coeff4 */ .quad 0x3fc9999CACDB4D0A, 0x3fc9999CACDB4D0A /* coeff4 */
.quad 0xbfd0000148058EE1, 0xbfd0000148058EE1 /* coeff3 */ .quad 0xbfd0000148058EE1, 0xbfd0000148058EE1 /* coeff3 */
.quad 0x3fd55555555543C5, 0x3fd55555555543C5 /* coeff2 */ .quad 0x3fd55555555543C5, 0x3fd55555555543C5 /* coeff2 */
.quad 0xbfdFFFFFFFFFF81F, 0xbfdFFFFFFFFFF81F /* coeff1 */ .quad 0xbfdFFFFFFFFFF81F, 0xbfdFFFFFFFFFF81F /* coeff1 */
/*== ExpMask ==*/ /* ExpMask */
.align 16 .align 16
.quad 0x000fffffffffffff, 0x000fffffffffffff .quad 0x000fffffffffffff, 0x000fffffffffffff
/*== Two10 ==*/ /* Two10 */
.align 16 .align 16
.quad 0x3f50000000000000, 0x3f50000000000000 .quad 0x3f50000000000000, 0x3f50000000000000
/*== MinLog1p = -1+2^(-53) ==*/ /* MinLog1p = -1+2^(-53) */
.align 16 .align 16
.quad 0xbfefffffffffffff, 0xbfefffffffffffff .quad 0xbfefffffffffffff, 0xbfefffffffffffff
/*== MaxLog1p ==*/ /* MaxLog1p */
.align 16 .align 16
.quad 0x7f3ffffffffff000, 0x7f3ffffffffff000 .quad 0x7f3ffffffffff000, 0x7f3ffffffffff000
/*== One ==*/ /* One */
.align 16 .align 16
.quad 0x3ff0000000000000, 0x3ff0000000000000 .quad 0x3ff0000000000000, 0x3ff0000000000000
/*== SgnMask ==*/ /* SgnMask */
.align 16 .align 16
.quad 0x7fffffffffffffff, 0x7fffffffffffffff .quad 0x7fffffffffffffff, 0x7fffffffffffffff
/*== XThreshold ==*/ /* XThreshold */
.align 16 .align 16
.quad 0x3e00000000000000, 0x3e00000000000000 .quad 0x3e00000000000000, 0x3e00000000000000
/*== XhMask ==*/ /* XhMask */
.align 16 .align 16
.quad 0xfffffffffffffc00, 0xfffffffffffffc00 .quad 0xfffffffffffffc00, 0xfffffffffffffc00
/*== Threshold ==*/ /* Threshold */
.align 16 .align 16
.quad 0x4086a00000000000, 0x4086a00000000000 .quad 0x4086a00000000000, 0x4086a00000000000
/*== Bias ==*/ /* Bias */
.align 16 .align 16
.quad 0x408ff80000000000, 0x408ff80000000000 .quad 0x408ff80000000000, 0x408ff80000000000
/*== Bias1 ==*/ /* Bias1 */
.align 16 .align 16
.quad 0x408ff00000000000, 0x408ff00000000000 .quad 0x408ff00000000000, 0x408ff00000000000
/*== ExpMask ==*/ /* ExpMask */
.align 16 .align 16
.quad 0x7ff0000000000000, 0x7ff0000000000000 .quad 0x7ff0000000000000, 0x7ff0000000000000
/*== ExpMask2 ==*/ /* ExpMask2 */
.align 16 .align 16
.quad 0x7f40000000000000, 0x7f40000000000000 .quad 0x7f40000000000000, 0x7f40000000000000
/*== L2L ==*/ /* L2L */
.align 16 .align 16
.quad 0x3fe62E42FEFA39EF, 0x3fe62E42FEFA39EF .quad 0x3fe62E42FEFA39EF, 0x3fe62E42FEFA39EF
/*== dBigThreshold ==*/ /* dBigThreshold */
.align 16 .align 16
.quad 0x41D0000000000000, 0x41D0000000000000 .quad 0x41D0000000000000, 0x41D0000000000000
/*== dC2 ==*/ /* dC2 */
.align 16 .align 16
.quad 0x3FD8000000000000, 0x3FD8000000000000 .quad 0x3FD8000000000000, 0x3FD8000000000000
/*== dC3 ==*/ /* dC3 */
.align 16 .align 16
.quad 0x3FD4000000000000, 0x3FD4000000000000 .quad 0x3FD4000000000000, 0x3FD4000000000000
/*== dC4 ==*/ /* dC4 */
.align 16 .align 16
.quad 0x3FD1800000000000, 0x3FD1800000000000 .quad 0x3FD1800000000000, 0x3FD1800000000000
/*== dC5 ==*/ /* dC5 */
.align 16 .align 16
.quad 0x3FCF800000000000, 0x3FCF800000000000 .quad 0x3FCF800000000000, 0x3FCF800000000000
/*== dHalf ==*/ /* dHalf */
.align 16 .align 16
.quad 0x3FE0000000000000, 0x3FE0000000000000 .quad 0x3FE0000000000000, 0x3FE0000000000000
/*== dLargestFinite ==*/ /* dLargestFinite */
.align 16 .align 16
.quad 0x7FEFFFFFFFFFFFFF, 0x7FEFFFFFFFFFFFFF .quad 0x7FEFFFFFFFFFFFFF, 0x7FEFFFFFFFFFFFFF
/*== dLittleThreshold ==*/ /* dLittleThreshold */
.align 16 .align 16
.quad 0x3F60000000000000, 0x3F60000000000000 .quad 0x3F60000000000000, 0x3F60000000000000
/*== dSign ==*/ /* dSign */
.align 16 .align 16
.quad 0x8000000000000000, 0x8000000000000000 .quad 0x8000000000000000, 0x8000000000000000
/*== dThirtyOne ==*/ /* dThirtyOne */
.align 16 .align 16
.quad 0x403F000000000000, 0x403F000000000000 .quad 0x403F000000000000, 0x403F000000000000
/*== dTopMask12 ==*/ /* dTopMask12 */
.align 16 .align 16
.quad 0xFFFFFE0000000000, 0xFFFFFE0000000000 .quad 0xFFFFFE0000000000, 0xFFFFFE0000000000
/*== dTopMask26 ==*/ /* dTopMask26 */
.align 16 .align 16
.quad 0xFFFFFFFFF8000000, 0xFFFFFFFFF8000000 .quad 0xFFFFFFFFF8000000, 0xFFFFFFFFF8000000
/*== dTopMask29 ==*/ /* dTopMask29 */
.align 16 .align 16
.quad 0xFFFFFFFFFF000000, 0xFFFFFFFFFF000000 .quad 0xFFFFFFFFFF000000, 0xFFFFFFFFFF000000
/*== XScale ==*/ /* XScale */
.align 16 .align 16
.quad 0x3E10000000000000, 0x3E10000000000000 .quad 0x3E10000000000000, 0x3E10000000000000
.align 16 .align 16
.type __svml_dasinh_data_internal,@object .type __svml_dasinh_data_internal, @object
.size __svml_dasinh_data_internal,.-__svml_dasinh_data_internal .size __svml_dasinh_data_internal, .-__svml_dasinh_data_internal
.align 16 .align 16
.FLT_30: .FLT_30:
.long 0x00000000,0x43380000,0x00000000,0x43380000 .long 0x00000000, 0x43380000, 0x00000000, 0x43380000
.type .FLT_30,@object .type .FLT_30, @object
.size .FLT_30,16 .size .FLT_30, 16