src/hotspot/cpu/x86/stubGenerator_x86_64_fmod.cpp - openjdk/jdk25u - Git at Google


            
            /*

            
             * 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 __
	/*
	* 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* 21023 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* 21023 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 __