| /* |
| * Copyright (c) 2023, 2024, Intel Corporation. All rights reserved. |
| * Intel Math Library (LIBM) Source Code |
| * |
| * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| * |
| * This code is free software; you can redistribute it and/or modify it |
| * under the terms of the GNU General Public License version 2 only, as |
| * published by the Free Software Foundation. |
| * |
| * This code is distributed in the hope that it will be useful, but WITHOUT |
| * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
| * version 2 for more details (a copy is included in the LICENSE file that |
| * accompanied this code). |
| * |
| * You should have received a copy of the GNU General Public License version |
| * 2 along with this work; if not, write to the Free Software Foundation, |
| * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
| * |
| * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
| * or visit www.oracle.com if you need additional information or have any |
| * questions. |
| * |
| */ |
| |
| #include "macroAssembler_x86.hpp" |
| #include "stubGenerator_x86_64.hpp" |
| #include "runtime/stubRoutines.hpp" |
| |
| /******************************************************************************/ |
| // ALGORITHM DESCRIPTION - FMOD() |
| // --------------------- |
| // |
| // If either value1 or value2 is NaN, the result is NaN. |
| // |
| // If neither value1 nor value2 is NaN, the sign of the result equals the sign of the dividend. |
| // |
| // If the dividend is an infinity or the divisor is a zero or both, the result is NaN. |
| // |
| // If the dividend is finite and the divisor is an infinity, the result equals the dividend. |
| // |
| // If the dividend is a zero and the divisor is finite, the result equals the dividend. |
| // |
| // In the remaining cases, where neither operand is an infinity, a zero, or NaN, the floating-point |
| // remainder result from a dividend value1 and a divisor value2 is defined by the mathematical |
| // relation result = value1 - (value2 * q), where q is an integer that is negative only if |
| // value1 / value2 is negative, and positive only if value1 / value2 is positive, and whose magnitude |
| // is as large as possible without exceeding the magnitude of the true mathematical quotient of value1 and value2. |
| // |
| /******************************************************************************/ |
| |
| #define __ _masm-> |
| |
| ATTRIBUTE_ALIGNED(32) static const uint64_t CONST_NaN[] = { |
| 0x7FFFFFFFFFFFFFFFULL, 0x7FFFFFFFFFFFFFFFULL // NaN vector |
| }; |
| ATTRIBUTE_ALIGNED(32) static const uint64_t CONST_1p260[] = { |
| 0x5030000000000000ULL, // 0x1p+260 |
| }; |
| |
| ATTRIBUTE_ALIGNED(32) static const uint64_t CONST_MAX[] = { |
| 0x7FEFFFFFFFFFFFFFULL, // Max |
| }; |
| |
| ATTRIBUTE_ALIGNED(32) static const uint64_t CONST_INF[] = { |
| 0x7FF0000000000000ULL, // Inf |
| }; |
| |
| ATTRIBUTE_ALIGNED(32) static const uint64_t CONST_e307[] = { |
| 0x7FE0000000000000ULL |
| }; |
| |
| address StubGenerator::generate_libmFmod() { |
| __ align(CodeEntryAlignment); |
| StubGenStubId stub_id = StubGenStubId::fmod_id; |
| StubCodeMark mark(this, stub_id); |
| address start = __ pc(); |
| __ enter(); // required for proper stackwalking of RuntimeStub frame |
| |
| if (VM_Version::supports_avx512vlbwdq()) { // AVX512 version |
| |
| // Source used to generate the AVX512 fmod assembly below: |
| // |
| // #include <ia32intrin.h> |
| // #include <emmintrin.h> |
| // #pragma float_control(precise, on) |
| // |
| // #define UINT32 unsigned int |
| // #define SINT32 int |
| // #define UINT64 unsigned __int64 |
| // #define SINT64 __int64 |
| // |
| // #define DP_FMA(a, b, c) __fence(_mm_cvtsd_f64(_mm_fmadd_sd(_mm_set_sd(a), _mm_set_sd(b), _mm_set_sd(c)))) |
| // #define DP_FMA_RN(a, b, c) _mm_cvtsd_f64(_mm_fmadd_round_sd(_mm_set_sd(a), _mm_set_sd(b), _mm_set_sd(c), (_MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC))) |
| // #define DP_FMA_RZ(a, b, c) __fence(_mm_cvtsd_f64(_mm_fmadd_round_sd(_mm_set_sd(a), _mm_set_sd(b), _mm_set_sd(c), (_MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC)))) |
| // |
| // #define DP_ROUND_RZ(a) _mm_cvtsd_f64(_mm_roundscale_sd(_mm_setzero_pd(), _mm_set_sd(a), (_MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC))) |
| // |
| // #define DP_CONST(C) _castu64_f64(0x##C##ull) |
| // #define DP_AND(X, Y) _mm_cvtsd_f64(_mm_and_pd(_mm_set_sd(X), _mm_set_sd(Y))) |
| // #define DP_XOR(X, Y) _mm_cvtsd_f64(_mm_xor_pd(_mm_set_sd(X), _mm_set_sd(Y))) |
| // #define DP_OR(X, Y) _mm_cvtsd_f64(_mm_or_pd(_mm_set_sd(X), _mm_set_sd(Y))) |
| // #define DP_DIV_RZ(a, b) __fence(_mm_cvtsd_f64(_mm_div_round_sd(_mm_set_sd(a), _mm_set_sd(b), (_MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC)))) |
| // #define DP_FNMA(a, b, c) __fence(_mm_cvtsd_f64(_mm_fnmadd_sd(_mm_set_sd(a), _mm_set_sd(b), _mm_set_sd(c)))) |
| // #define DP_FNMA_RZ(a, b, c) __fence(_mm_cvtsd_f64(_mm_fnmadd_round_sd(_mm_set_sd(a), _mm_set_sd(b), _mm_set_sd(c), (_MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC)))) |
| // |
| // #define D2L(x) _mm_castpd_si128(x) |
| // // transfer highest 32 bits (of low 64b) to GPR |
| // #define TRANSFER_HIGH_INT32(X) _mm_extract_epi32(D2L(_mm_set_sd(X)), 1) |
| // |
| // double fmod(double x, double y) |
| // { |
| // double a, b, sgn_a, q, bs, bs2; |
| // unsigned eq; |
| |
| Label L_5280, L_52a0, L_5256, L_5300, L_5320, L_52c0, L_52d0, L_5360, L_5380, L_53b0, L_5390; |
| Label L_53c0, L_52a6, L_53d0, L_exit; |
| |
| __ movdqa(xmm2, xmm0); |
| // // |x|, |y| |
| // a = DP_AND(x, DP_CONST(7fffffffffffffff)); |
| __ movq(xmm0, xmm0); |
| __ mov64(rax, 0x7FFFFFFFFFFFFFFFULL); |
| __ evpbroadcastq(xmm3, rax, Assembler::AVX_128bit); |
| __ vpand(xmm6, xmm0, xmm3, Assembler::AVX_128bit); |
| // b = DP_AND(y, DP_CONST(7fffffffffffffff)); |
| __ vpand(xmm4, xmm1, xmm3, Assembler::AVX_128bit); |
| // // sign(x) |
| // sgn_a = DP_XOR(x, a); |
| __ vpxor(xmm3, xmm6, xmm0, Assembler::AVX_128bit); |
| // q = DP_DIV_RZ(a, b); |
| __ movq(xmm5, xmm4); |
| __ evdivsd(xmm0, xmm6, xmm5, Assembler::EVEX_RZ); |
| // q = DP_ROUND_RZ(q); |
| __ movq(xmm0, xmm0); |
| // a = DP_AND(x, DP_CONST(7fffffffffffffff)); |
| __ vxorpd(xmm7, xmm7, xmm7, Assembler::AVX_128bit); |
| // q = DP_ROUND_RZ(q); |
| __ vroundsd(xmm0, xmm7, xmm0, 0xb); |
| // eq = TRANSFER_HIGH_INT32(q); |
| __ extractps(rax, xmm0, 1); |
| // if (!eq) return x + sgn_a; |
| __ testl(rax, rax); |
| __ jcc(Assembler::equal, L_5280); |
| // if (eq >= 0x7fefffffu) goto SPECIAL_FMOD; |
| __ cmpl(rax, 0x7feffffe); |
| __ jcc(Assembler::belowEqual, L_52a0); |
| __ vpxor(xmm2, xmm2, xmm2, Assembler::AVX_128bit); |
| // SPECIAL_FMOD: |
| // |
| // // y==0 or x==Inf? |
| // if ((b == 0.0) || (!(a <= DP_CONST(7fefffffffffffff)))) |
| __ ucomisd(xmm4, xmm2); |
| __ jcc(Assembler::notEqual, L_5256); |
| __ jcc(Assembler::noParity, L_5300); |
| __ bind(L_5256); |
| __ movsd(xmm2, ExternalAddress((address)CONST_MAX), rax); |
| __ ucomisd(xmm2, xmm6); |
| __ jcc(Assembler::below, L_5300); |
| __ movsd(xmm0, ExternalAddress((address)CONST_INF), rax); |
| // return DP_FNMA(b, q, a); // NaN |
| // // y is NaN? |
| // if (!(b <= DP_CONST(7ff0000000000000))) return y + y; |
| __ ucomisd(xmm0, xmm4); |
| __ jcc(Assembler::aboveEqual, L_5320); |
| __ vaddsd(xmm0, xmm1, xmm1); |
| __ jmp(L_exit); |
| // if (!eq) return x + sgn_a; |
| __ align32(); |
| __ bind(L_5280); |
| __ vaddsd(xmm0, xmm3, xmm2); |
| __ jmp(L_exit); |
| // a = DP_FNMA_RZ(b, q, a); |
| __ align(8); |
| __ bind(L_52a0); |
| __ evfnmadd213sd(xmm0, xmm4, xmm6, Assembler::EVEX_RZ); |
| // while (b <= a) |
| __ bind(L_52a6); |
| __ ucomisd(xmm0, xmm4); |
| __ jcc(Assembler::aboveEqual, L_52c0); |
| // a = DP_XOR(a, sgn_a); |
| __ vpxor(xmm0, xmm3, xmm0, Assembler::AVX_128bit); |
| __ jmp(L_exit); |
| __ bind(L_52c0); |
| __ movq(xmm6, xmm0); |
| // q = DP_ROUND_RZ(q); |
| __ vpxor(xmm1, xmm1, xmm1, Assembler::AVX_128bit); |
| __ align32(); |
| __ bind(L_52d0); |
| // q = DP_DIV_RZ(a, b); |
| __ evdivsd(xmm2, xmm6, xmm5, Assembler::EVEX_RZ); |
| // q = DP_ROUND_RZ(q); |
| __ movq(xmm2, xmm2); |
| __ vroundsd(xmm2, xmm1, xmm2, 0xb); |
| // a = DP_FNMA_RZ(b, q, a); |
| __ evfnmadd213sd(xmm2, xmm4, xmm0, Assembler::EVEX_RZ); |
| // while (b <= a) |
| __ ucomisd(xmm2, xmm4); |
| __ movq(xmm6, xmm2); |
| __ movapd(xmm0, xmm2); |
| __ jcc(Assembler::aboveEqual, L_52d0); |
| // a = DP_XOR(a, sgn_a); |
| __ vpxor(xmm0, xmm3, xmm2, Assembler::AVX_128bit); |
| __ jmp(L_exit); |
| // return DP_FNMA(b, q, a); // NaN |
| __ bind(L_5300); |
| __ vfnmadd213sd(xmm0, xmm4, xmm6); |
| __ jmp(L_exit); |
| // bs = b * DP_CONST(7fe0000000000000); |
| __ bind(L_5320); |
| __ vmulsd(xmm1, xmm4, ExternalAddress((address)CONST_e307), rax); |
| // q = DP_DIV_RZ(a, bs); |
| __ movq(xmm2, xmm1); |
| __ evdivsd(xmm0, xmm6, xmm2, Assembler::EVEX_RZ); |
| // q = DP_ROUND_RZ(q); |
| __ movq(xmm0, xmm0); |
| __ vroundsd(xmm7, xmm7, xmm0, 0xb); |
| // eq = TRANSFER_HIGH_INT32(q); |
| __ extractps(rax, xmm7, 1); |
| // if (eq >= 0x7fefffffu) |
| __ cmpl(rax, 0x7fefffff); |
| __ jcc(Assembler::below, L_5360); |
| // // b* 2*1023 * 2^1023 |
| // bs2 = bs * DP_CONST(7fe0000000000000); |
| __ vmulsd(xmm0, xmm1, ExternalAddress((address)CONST_e307), rax); |
| // while (bs2 <= a) |
| __ ucomisd(xmm6, xmm0); |
| __ jcc(Assembler::aboveEqual, L_5380); |
| __ movapd(xmm7, xmm6); |
| __ jmp(L_53b0); |
| // a = DP_FNMA_RZ(b, q, a); |
| __ bind(L_5360); |
| __ evfnmadd213sd(xmm7, xmm1, xmm6, Assembler::EVEX_RZ); |
| __ jmp(L_53b0); |
| // q = DP_ROUND_RZ(q); |
| __ bind(L_5380); |
| __ vxorpd(xmm8, xmm8, xmm8, Assembler::AVX_128bit); |
| // q = DP_DIV_RZ(qa, bs2); |
| __ align32(); |
| __ bind(L_5390); |
| __ evdivsd(xmm7, xmm6, xmm0, Assembler::EVEX_RZ); |
| // q = DP_ROUND_RZ(q); |
| __ movq(xmm7, xmm7); |
| __ vroundsd(xmm7, xmm8, xmm7, 0xb); |
| // a = DP_FNMA_RZ(bs2, q, a); |
| __ evfnmadd213sd(xmm7, xmm0, xmm6, Assembler::EVEX_RZ); |
| // while (bs2 <= a) |
| __ ucomisd(xmm7, xmm0); |
| __ movapd(xmm6, xmm7); |
| __ jcc(Assembler::aboveEqual, L_5390); |
| // while (bs <= a) |
| __ bind(L_53b0); |
| __ ucomisd(xmm7, xmm1); |
| __ jcc(Assembler::aboveEqual, L_53c0); |
| __ movapd(xmm0, xmm7); |
| __ jmp(L_52a6); |
| // q = DP_ROUND_RZ(q); |
| __ bind(L_53c0); |
| __ vxorpd(xmm6, xmm6, xmm6, Assembler::AVX_128bit); |
| // q = DP_DIV_RZ(a, bs); |
| __ align32(); |
| __ bind(L_53d0); |
| __ evdivsd(xmm0, xmm7, xmm2, Assembler::EVEX_RZ); |
| // q = DP_ROUND_RZ(q); |
| __ movq(xmm0, xmm0); |
| __ vroundsd(xmm0, xmm6, xmm0, 0xb); |
| // a = DP_FNMA_RZ(bs, q, a); |
| __ evfnmadd213sd(xmm0, xmm1, xmm7, Assembler::EVEX_RZ); |
| // while (bs <= a) |
| __ ucomisd(xmm0, xmm1); |
| __ movapd(xmm7, xmm0); |
| __ jcc(Assembler::aboveEqual, L_53d0); |
| __ jmp(L_52a6); |
| |
| __ bind(L_exit); |
| |
| //////////////////////////////////////////////////////////////////////////////////////// |
| //////////////////////////////////////////////////////////////////////////////////////// |
| // AVX2 code |
| //////////////////////////////////////////////////////////////////////////////////////// |
| //////////////////////////////////////////////////////////////////////////////////////// |
| } else if (VM_Version::supports_fma()) { // AVX2 version |
| |
| Label L_104a, L_11bd, L_10c1, L_1090, L_11b9, L_10e7, L_11af, L_111c, L_10f3, L_116e, L_112a; |
| Label L_1173, L_1157, L_117f, L_11a0; |
| |
| // double fmod(double x, double y) |
| // { |
| // double a, b, sgn_a, q, bs, bs2, corr, res; |
| // unsigned eq; |
| |
| // // |x|, |y| |
| // a = DP_AND(x, DP_CONST(7fffffffffffffff)); |
| __ movq(xmm2, xmm0); |
| __ movdqu(xmm3, ExternalAddress((address)CONST_NaN), rcx); |
| __ vpand(xmm4, xmm2, xmm3, Assembler::AVX_128bit); |
| // b = DP_AND(y, DP_CONST(7fffffffffffffff)); |
| __ vpand(xmm3, xmm1, xmm3, Assembler::AVX_128bit); |
| // // sign(x) |
| // sgn_a = DP_XOR(x, a); |
| __ mov64(rcx, 0x8000000000000000ULL); |
| __ movq(xmm5, rcx); |
| __ vpand(xmm2, xmm2, xmm5, Assembler::AVX_128bit); |
| |
| // if (a < b) return x + sgn_a; |
| __ ucomisd(xmm3, xmm4); |
| __ jccb(Assembler::belowEqual, L_104a); |
| __ vaddsd(xmm0, xmm2, xmm0); |
| __ jmp(L_11bd); |
| |
| // if (a < b * 0x1p+260) |
| __ bind(L_104a); |
| |
| __ vmulsd(xmm0, xmm3, ExternalAddress((address)CONST_1p260), rax); |
| __ ucomisd(xmm0, xmm4); |
| __ jccb(Assembler::belowEqual, L_10c1); |
| // { |
| // q = DP_DIV(a, b); |
| __ vdivpd(xmm0, xmm4, xmm3, Assembler::AVX_128bit); |
| // corr = DP_SHR(DP_FNMA(b, q, a), 63); |
| __ movapd(xmm1, xmm0); |
| __ vfnmadd213sd(xmm1, xmm3, xmm4); |
| __ movq(xmm5, xmm1); |
| __ vpxor(xmm1, xmm1, xmm1, Assembler::AVX_128bit); |
| __ vpcmpgtq(xmm5, xmm1, xmm5, Assembler::AVX_128bit); |
| // q = DP_PSUBQ(q, corr); |
| __ vpaddq(xmm0, xmm5, xmm0, Assembler::AVX_128bit); |
| // q = DP_TRUNC(q); |
| __ vroundsd(xmm0, xmm0, xmm0, 3); |
| // a = DP_FNMA(b, q, a); |
| __ vfnmadd213sd(xmm0, xmm3, xmm4); |
| __ align(16); |
| // while (b <= a) |
| __ bind(L_1090); |
| __ ucomisd(xmm0, xmm3); |
| __ jcc(Assembler::below, L_11b9); |
| // { |
| // q = DP_DIV(a, b); |
| __ vdivsd(xmm4, xmm0, xmm3); |
| // corr = DP_SHR(DP_FNMA(b, q, a), 63); |
| __ movapd(xmm5, xmm4); |
| __ vfnmadd213sd(xmm5, xmm3, xmm0); |
| __ movq(xmm5, xmm5); |
| __ vpcmpgtq(xmm5, xmm1, xmm5, Assembler::AVX_128bit); |
| // q = DP_PSUBQ(q, corr); |
| __ vpaddq(xmm4, xmm5, xmm4, Assembler::AVX_128bit); |
| // q = DP_TRUNC(q); |
| __ vroundsd(xmm4, xmm4, xmm4, 3); |
| // a = DP_FNMA(b, q, a); |
| __ vfnmadd231sd(xmm0, xmm3, xmm4); |
| __ jmpb(L_1090); |
| // } |
| // return DP_XOR(a, sgn_a); |
| // } |
| |
| // __asm { ldmxcsr DWORD PTR [mxcsr_rz] } |
| __ bind(L_10c1); |
| __ ldmxcsr(ExternalAddress(StubRoutines::x86::addr_mxcsr_rz()), rax /*rscratch*/); |
| |
| // q = DP_DIV(a, b); |
| __ vdivpd(xmm0, xmm4, xmm3, Assembler::AVX_128bit); |
| // q = DP_TRUNC(q); |
| __ vroundsd(xmm0, xmm0, xmm0, 3); |
| |
| // eq = TRANSFER_HIGH_INT32(q); |
| __ extractps(rax, xmm0, 1); |
| |
| // if (__builtin_expect((eq >= 0x7fefffffu), (0==1))) goto SPECIAL_FMOD; |
| __ cmpl(rax, 0x7feffffe); |
| __ jccb(Assembler::above, L_10e7); |
| |
| // a = DP_FNMA(b, q, a); |
| __ vfnmadd213sd(xmm0, xmm3, xmm4); |
| __ jmp(L_11af); |
| |
| // SPECIAL_FMOD: |
| |
| // // y==0 or x==Inf? |
| // if ((b == 0.0) || (!(a <= DP_CONST(7fefffffffffffff)))) |
| __ bind(L_10e7); |
| __ vpxor(xmm5, xmm5, xmm5, Assembler::AVX_128bit); |
| __ ucomisd(xmm3, xmm5); |
| __ jccb(Assembler::notEqual, L_10f3); |
| __ jccb(Assembler::noParity, L_111c); |
| |
| __ bind(L_10f3); |
| __ movsd(xmm5, ExternalAddress((address)CONST_MAX), rax); |
| __ ucomisd(xmm5, xmm4); |
| __ jccb(Assembler::below, L_111c); |
| // return res; |
| // } |
| // // y is NaN? |
| // if (!(b <= DP_CONST(7ff0000000000000))) { |
| __ movsd(xmm0, ExternalAddress((address)CONST_INF), rax); |
| __ ucomisd(xmm0, xmm3); |
| __ jccb(Assembler::aboveEqual, L_112a); |
| // res = y + y; |
| __ vaddsd(xmm0, xmm1, xmm1); |
| // __asm { ldmxcsr DWORD PTR[mxcsr] } |
| __ ldmxcsr(ExternalAddress(StubRoutines::x86::addr_mxcsr_std()), rax /*rscratch*/); |
| __ jmp(L_11bd); |
| // { |
| // res = DP_FNMA(b, q, a); // NaN |
| __ bind(L_111c); |
| __ vfnmadd213sd(xmm0, xmm3, xmm4); |
| // __asm { ldmxcsr DWORD PTR[mxcsr] } |
| __ ldmxcsr(ExternalAddress(StubRoutines::x86::addr_mxcsr_std()), rax /*rscratch*/); |
| __ jmp(L_11bd); |
| // return res; |
| // } |
| |
| // // b* 2*1023 |
| // bs = b * DP_CONST(7fe0000000000000); |
| __ bind(L_112a); |
| __ vmulsd(xmm1, xmm3, ExternalAddress((address)CONST_e307), rax); |
| |
| // q = DP_DIV(a, bs); |
| __ vdivsd(xmm0, xmm4, xmm1); |
| // q = DP_TRUNC(q); |
| __ vroundsd(xmm0, xmm0, xmm0, 3); |
| |
| // eq = TRANSFER_HIGH_INT32(q); |
| __ extractps(rax, xmm0, 1); |
| |
| // if (eq >= 0x7fefffffu) |
| __ cmpl(rax, 0x7fefffff); |
| __ jccb(Assembler::below, L_116e); |
| // { |
| // // b* 2*1023 * 2^1023 |
| // bs2 = bs * DP_CONST(7fe0000000000000); |
| __ vmulsd(xmm0, xmm1, ExternalAddress((address)CONST_e307), rax); |
| // while (bs2 <= a) |
| __ ucomisd(xmm4, xmm0); |
| __ jccb(Assembler::below, L_1173); |
| // { |
| // q = DP_DIV(a, bs2); |
| __ bind(L_1157); |
| __ vdivsd(xmm5, xmm4, xmm0); |
| // q = DP_TRUNC(q); |
| __ vroundsd(xmm5, xmm5, xmm5, 3); |
| // a = DP_FNMA(bs2, q, a); |
| __ vfnmadd231sd(xmm4, xmm0, xmm5); |
| // while (bs2 <= a) |
| __ ucomisd(xmm4, xmm0); |
| __ jccb(Assembler::aboveEqual, L_1157); |
| __ jmpb(L_1173); |
| // } |
| // } |
| // else |
| // a = DP_FNMA(bs, q, a); |
| __ bind(L_116e); |
| __ vfnmadd231sd(xmm4, xmm1, xmm0); |
| |
| // while (bs <= a) |
| __ bind(L_1173); |
| __ ucomisd(xmm4, xmm1); |
| __ jccb(Assembler::aboveEqual, L_117f); |
| __ movapd(xmm0, xmm4); |
| __ jmpb(L_11af); |
| // { |
| // q = DP_DIV(a, bs); |
| __ bind(L_117f); |
| __ vdivsd(xmm0, xmm4, xmm1); |
| // q = DP_TRUNC(q); |
| __ vroundsd(xmm0, xmm0, xmm0, 3); |
| // a = DP_FNMA(bs, q, a); |
| __ vfnmadd213sd(xmm0, xmm1, xmm4); |
| |
| // while (bs <= a) |
| __ ucomisd(xmm0, xmm1); |
| __ movapd(xmm4, xmm0); |
| __ jccb(Assembler::aboveEqual, L_117f); |
| __ jmpb(L_11af); |
| __ align(16); |
| // { |
| // q = DP_DIV(a, b); |
| __ bind(L_11a0); |
| __ vdivsd(xmm1, xmm0, xmm3); |
| // q = DP_TRUNC(q); |
| __ vroundsd(xmm1, xmm1, xmm1, 3); |
| // a = DP_FNMA(b, q, a); |
| __ vfnmadd231sd(xmm0, xmm3, xmm1); |
| |
| // FMOD_CONT: |
| // while (b <= a) |
| __ bind(L_11af); |
| __ ucomisd(xmm0, xmm3); |
| __ jccb(Assembler::aboveEqual, L_11a0); |
| // } |
| |
| // __asm { ldmxcsr DWORD PTR[mxcsr] } |
| __ ldmxcsr(ExternalAddress(StubRoutines::x86::addr_mxcsr_std()), rax /*rscratch*/); |
| __ bind(L_11b9); |
| __ vpxor(xmm0, xmm2, xmm0, Assembler::AVX_128bit); |
| // } |
| |
| // goto FMOD_CONT; |
| |
| // } |
| __ bind(L_11bd); |
| |
| } else { // SSE version |
| Label x87_loop; |
| __ movsd(Address(rbp, -8), xmm1); |
| __ movsd(Address(rbp, -16), xmm0); |
| __ fld_d(Address(rbp, -8)); |
| __ fld_d(Address(rbp, -16)); |
| |
| __ bind(x87_loop); |
| __ fprem(); |
| __ fnstsw_ax(); |
| __ testb(rax, 0x4, false); |
| __ jcc(Assembler::notZero, x87_loop); |
| |
| __ fstp_d(1); |
| __ fstp_d(Address(rbp, -8)); |
| __ movsd(xmm0, Address(rbp, -8)); |
| } |
| |
| __ leave(); // required for proper stackwalking of RuntimeStub frame |
| __ ret(0); |
| |
| return start; |
| } |
| |
| #undef __ |
