Subversion Repositories openrisc_me

/* IEEE-754 single-precision functions for Xtensa

   Copyright (C) 2006, 2007, 2009 Free Software Foundation, Inc.

   Contributed by Bob Wilson (bwilson@tensilica.com) at Tensilica.

   This file is part of GCC.

   GCC is free software; you can redistribute it and/or modify it

   under the terms of the GNU General Public License as published by

   the Free Software Foundation; either version 3, or (at your option)

   any later version.

   GCC 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 for more details.

   Under Section 7 of GPL version 3, you are granted additional

   permissions described in the GCC Runtime Library Exception, version

   3.1, as published by the Free Software Foundation.

   You should have received a copy of the GNU General Public License and

   a copy of the GCC Runtime Library Exception along with this program;

   see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see

   .  */

#ifdef __XTENSA_EB__

#define xh a2

#define xl a3

#define yh a4

#define yl a5

#else

#define xh a3

#define xl a2

#define yh a5

#define yl a4

#endif

/*  Warning!  The branch displacements for some Xtensa branch instructions

    are quite small, and this code has been carefully laid out to keep

    branch targets in range.  If you change anything, be sure to check that

    the assembler is not relaxing anything to branch over a jump.  */

#ifdef L_negsf2

        .align  4

        .global __negsf2

        .type   __negsf2, @function

__negsf2:

        leaf_entry sp, 16

        movi    a4, 0x80000000

        xor     a2, a2, a4

        leaf_return

#endif /* L_negsf2 */

#ifdef L_addsubsf3

        /* Addition */

__addsf3_aux:

        /* Handle NaNs and Infinities.  (This code is placed before the

           start of the function just to keep it in range of the limited

           branch displacements.)  */

.Ladd_xnan_or_inf:

        /* If y is neither Infinity nor NaN, return x.  */

        bnall   a3, a6, 1f

        /* If x is a NaN, return it.  Otherwise, return y.  */

        slli    a7, a2, 9

        beqz    a7, .Ladd_ynan_or_inf

1:      leaf_return

.Ladd_ynan_or_inf:

        /* Return y.  */

        mov     a2, a3

        leaf_return

.Ladd_opposite_signs:

        /* Operand signs differ.  Do a subtraction.  */

        slli    a7, a6, 8

        xor     a3, a3, a7

        j       .Lsub_same_sign

        .align  4

        .global __addsf3

        .type   __addsf3, @function

__addsf3:

        leaf_entry sp, 16

        movi    a6, 0x7f800000

        /* Check if the two operands have the same sign.  */

        xor     a7, a2, a3

        bltz    a7, .Ladd_opposite_signs

.Ladd_same_sign:

        /* Check if either exponent == 0x7f8 (i.e., NaN or Infinity).  */

        ball    a2, a6, .Ladd_xnan_or_inf

        ball    a3, a6, .Ladd_ynan_or_inf

        /* Compare the exponents.  The smaller operand will be shifted

           right by the exponent difference and added to the larger

           one.  */

        extui   a7, a2, 23, 9

        extui   a8, a3, 23, 9

        bltu    a7, a8, .Ladd_shiftx

.Ladd_shifty:

        /* Check if the smaller (or equal) exponent is zero.  */

        bnone   a3, a6, .Ladd_yexpzero

        /* Replace y sign/exponent with 0x008.  */

        or      a3, a3, a6

        slli    a3, a3, 8

        srli    a3, a3, 8

.Ladd_yexpdiff:

        /* Compute the exponent difference.  */

        sub     a10, a7, a8

        /* Exponent difference > 32 -- just return the bigger value.  */

        bgeui   a10, 32, 1f

        /* Shift y right by the exponent difference.  Any bits that are

           shifted out of y are saved in a9 for rounding the result.  */

        ssr     a10

        movi    a9, 0

        src     a9, a3, a9

        srl     a3, a3

        /* Do the addition.  */

        add     a2, a2, a3

        /* Check if the add overflowed into the exponent.  */

        extui   a10, a2, 23, 9

        beq     a10, a7, .Ladd_round

        mov     a8, a7

        j       .Ladd_carry

.Ladd_yexpzero:

        /* y is a subnormal value.  Replace its sign/exponent with zero,

           i.e., no implicit "1.0", and increment the apparent exponent

           because subnormals behave as if they had the minimum (nonzero)

           exponent.  Test for the case when both exponents are zero.  */

        slli    a3, a3, 9

        srli    a3, a3, 9

        bnone   a2, a6, .Ladd_bothexpzero

        addi    a8, a8, 1

        j       .Ladd_yexpdiff

.Ladd_bothexpzero:

        /* Both exponents are zero.  Handle this as a special case.  There

           is no need to shift or round, and the normal code for handling

           a carry into the exponent field will not work because it

           assumes there is an implicit "1.0" that needs to be added.  */

        add     a2, a2, a3

1:      leaf_return

.Ladd_xexpzero:

        /* Same as "yexpzero" except skip handling the case when both

           exponents are zero.  */

        slli    a2, a2, 9

        srli    a2, a2, 9

        addi    a7, a7, 1

        j       .Ladd_xexpdiff

.Ladd_shiftx:

        /* Same thing as the "shifty" code, but with x and y swapped.  Also,

           because the exponent difference is always nonzero in this version,

           the shift sequence can use SLL and skip loading a constant zero.  */

        bnone   a2, a6, .Ladd_xexpzero

        or      a2, a2, a6

        slli    a2, a2, 8

        srli    a2, a2, 8

.Ladd_xexpdiff:

        sub     a10, a8, a7

        bgeui   a10, 32, .Ladd_returny

        ssr     a10

        sll     a9, a2

        srl     a2, a2

        add     a2, a2, a3

        /* Check if the add overflowed into the exponent.  */

        extui   a10, a2, 23, 9

        bne     a10, a8, .Ladd_carry

.Ladd_round:

        /* Round up if the leftover fraction is >= 1/2.  */

        bgez    a9, 1f

        addi    a2, a2, 1

        /* Check if the leftover fraction is exactly 1/2.  */

        slli    a9, a9, 1

        beqz    a9, .Ladd_exactlyhalf

1:      leaf_return

.Ladd_returny:

        mov     a2, a3

        leaf_return

.Ladd_carry:

        /* The addition has overflowed into the exponent field, so the

           value needs to be renormalized.  The mantissa of the result

           can be recovered by subtracting the original exponent and

           adding 0x800000 (which is the explicit "1.0" for the

           mantissa of the non-shifted operand -- the "1.0" for the

           shifted operand was already added).  The mantissa can then

           be shifted right by one bit.  The explicit "1.0" of the

           shifted mantissa then needs to be replaced by the exponent,

           incremented by one to account for the normalizing shift.

           It is faster to combine these operations: do the shift first

           and combine the additions and subtractions.  If x is the

           original exponent, the result is:

               shifted mantissa - (x << 22) + (1 << 22) + (x << 23)

           or:

               shifted mantissa + ((x + 1) << 22)

           Note that the exponent is incremented here by leaving the

           explicit "1.0" of the mantissa in the exponent field.  */

        /* Shift x right by one bit.  Save the lsb.  */

        mov     a10, a2

        srli    a2, a2, 1

        /* See explanation above.  The original exponent is in a8.  */

        addi    a8, a8, 1

        slli    a8, a8, 22

        add     a2, a2, a8

        /* Return an Infinity if the exponent overflowed.  */

        ball    a2, a6, .Ladd_infinity

        /* Same thing as the "round" code except the msb of the leftover

           fraction is bit 0 of a10, with the rest of the fraction in a9.  */

        bbci.l  a10, 0, 1f

        addi    a2, a2, 1

        beqz    a9, .Ladd_exactlyhalf

1:      leaf_return

.Ladd_infinity:

        /* Clear the mantissa.  */

        srli    a2, a2, 23

        slli    a2, a2, 23

        /* The sign bit may have been lost in a carry-out.  Put it back.  */

        slli    a8, a8, 1

        or      a2, a2, a8

        leaf_return

.Ladd_exactlyhalf:

        /* Round down to the nearest even value.  */

        srli    a2, a2, 1

        slli    a2, a2, 1

        leaf_return

        /* Subtraction */

__subsf3_aux:

        /* Handle NaNs and Infinities.  (This code is placed before the

           start of the function just to keep it in range of the limited

           branch displacements.)  */

.Lsub_xnan_or_inf:

        /* If y is neither Infinity nor NaN, return x.  */

        bnall   a3, a6, 1f

        /* Both x and y are either NaN or Inf, so the result is NaN.  */

        movi    a4, 0x400000    /* make it a quiet NaN */

        or      a2, a2, a4

1:      leaf_return

.Lsub_ynan_or_inf:

        /* Negate y and return it.  */

        slli    a7, a6, 8

        xor     a2, a3, a7

        leaf_return

.Lsub_opposite_signs:

        /* Operand signs differ.  Do an addition.  */

        slli    a7, a6, 8

        xor     a3, a3, a7

        j       .Ladd_same_sign

        .align  4

        .global __subsf3

        .type   __subsf3, @function

__subsf3:

        leaf_entry sp, 16

        movi    a6, 0x7f800000

        /* Check if the two operands have the same sign.  */

        xor     a7, a2, a3

        bltz    a7, .Lsub_opposite_signs

.Lsub_same_sign:

        /* Check if either exponent == 0x7f8 (i.e., NaN or Infinity).  */

        ball    a2, a6, .Lsub_xnan_or_inf

        ball    a3, a6, .Lsub_ynan_or_inf

        /* Compare the operands.  In contrast to addition, the entire

           value matters here.  */

        extui   a7, a2, 23, 8

        extui   a8, a3, 23, 8

        bltu    a2, a3, .Lsub_xsmaller

.Lsub_ysmaller:

        /* Check if the smaller (or equal) exponent is zero.  */

        bnone   a3, a6, .Lsub_yexpzero

        /* Replace y sign/exponent with 0x008.  */

        or      a3, a3, a6

        slli    a3, a3, 8

        srli    a3, a3, 8

.Lsub_yexpdiff:

        /* Compute the exponent difference.  */

        sub     a10, a7, a8

        /* Exponent difference > 32 -- just return the bigger value.  */

        bgeui   a10, 32, 1f

        /* Shift y right by the exponent difference.  Any bits that are

           shifted out of y are saved in a9 for rounding the result.  */

        ssr     a10

        movi    a9, 0

        src     a9, a3, a9

        srl     a3, a3

        sub     a2, a2, a3

        /* Subtract the leftover bits in a9 from zero and propagate any

           borrow from a2.  */

        neg     a9, a9

        addi    a10, a2, -1

        movnez  a2, a10, a9

        /* Check if the subtract underflowed into the exponent.  */

        extui   a10, a2, 23, 8

        beq     a10, a7, .Lsub_round

        j       .Lsub_borrow

.Lsub_yexpzero:

        /* Return zero if the inputs are equal.  (For the non-subnormal

           case, subtracting the "1.0" will cause a borrow from the exponent

           and this case can be detected when handling the borrow.)  */

        beq     a2, a3, .Lsub_return_zero

        /* y is a subnormal value.  Replace its sign/exponent with zero,

           i.e., no implicit "1.0".  Unless x is also a subnormal, increment

           y's apparent exponent because subnormals behave as if they had

           the minimum (nonzero) exponent.  */

        slli    a3, a3, 9

        srli    a3, a3, 9

        bnone   a2, a6, .Lsub_yexpdiff

        addi    a8, a8, 1

        j       .Lsub_yexpdiff

.Lsub_returny:

        /* Negate and return y.  */

        slli    a7, a6, 8

        xor     a2, a3, a7

1:      leaf_return

.Lsub_xsmaller:

        /* Same thing as the "ysmaller" code, but with x and y swapped and

           with y negated.  */

        bnone   a2, a6, .Lsub_xexpzero

        or      a2, a2, a6

        slli    a2, a2, 8

        srli    a2, a2, 8

.Lsub_xexpdiff:

        sub     a10, a8, a7

        bgeui   a10, 32, .Lsub_returny

        ssr     a10

        movi    a9, 0

        src     a9, a2, a9

        srl     a2, a2

        /* Negate y.  */

        slli    a11, a6, 8

        xor     a3, a3, a11

        sub     a2, a3, a2

        neg     a9, a9

        addi    a10, a2, -1

        movnez  a2, a10, a9

        /* Check if the subtract underflowed into the exponent.  */

        extui   a10, a2, 23, 8

        bne     a10, a8, .Lsub_borrow

.Lsub_round:

        /* Round up if the leftover fraction is >= 1/2.  */

        bgez    a9, 1f

        addi    a2, a2, 1

        /* Check if the leftover fraction is exactly 1/2.  */

        slli    a9, a9, 1

        beqz    a9, .Lsub_exactlyhalf

1:      leaf_return

.Lsub_xexpzero:

        /* Same as "yexpzero".  */

        beq     a2, a3, .Lsub_return_zero

        slli    a2, a2, 9

        srli    a2, a2, 9

        bnone   a3, a6, .Lsub_xexpdiff

        addi    a7, a7, 1

        j       .Lsub_xexpdiff

.Lsub_return_zero:

        movi    a2, 0

        leaf_return

.Lsub_borrow:

        /* The subtraction has underflowed into the exponent field, so the

           value needs to be renormalized.  Shift the mantissa left as

           needed to remove any leading zeros and adjust the exponent

           accordingly.  If the exponent is not large enough to remove

           all the leading zeros, the result will be a subnormal value.  */

        slli    a8, a2, 9

        beqz    a8, .Lsub_xzero

        do_nsau a6, a8, a7, a11

        srli    a8, a8, 9

        bge     a6, a10, .Lsub_subnormal

        addi    a6, a6, 1

.Lsub_normalize_shift:

        /* Shift the mantissa (a8/a9) left by a6.  */

        ssl     a6

        src     a8, a8, a9

        sll     a9, a9

        /* Combine the shifted mantissa with the sign and exponent,

           decrementing the exponent by a6.  (The exponent has already

           been decremented by one due to the borrow from the subtraction,

           but adding the mantissa will increment the exponent by one.)  */

        srli    a2, a2, 23

        sub     a2, a2, a6

        slli    a2, a2, 23

        add     a2, a2, a8

        j       .Lsub_round

.Lsub_exactlyhalf:

        /* Round down to the nearest even value.  */

        srli    a2, a2, 1

        slli    a2, a2, 1

        leaf_return

.Lsub_xzero:

        /* If there was a borrow from the exponent, and the mantissa and

           guard digits are all zero, then the inputs were equal and the

           result should be zero.  */

        beqz    a9, .Lsub_return_zero

        /* Only the guard digit is nonzero.  Shift by min(24, a10).  */

        addi    a11, a10, -24

        movi    a6, 24

        movltz  a6, a10, a11

        j       .Lsub_normalize_shift

.Lsub_subnormal:

        /* The exponent is too small to shift away all the leading zeros.

           Set a6 to the current exponent (which has already been

           decremented by the borrow) so that the exponent of the result

           will be zero.  Do not add 1 to a6 in this case, because: (1)

           adding the mantissa will not increment the exponent, so there is

           no need to subtract anything extra from the exponent to

           compensate, and (2) the effective exponent of a subnormal is 1

           not 0 so the shift amount must be 1 smaller than normal. */

        mov     a6, a10

        j       .Lsub_normalize_shift

#endif /* L_addsubsf3 */

#ifdef L_mulsf3

        /* Multiplication */

#if !XCHAL_HAVE_MUL16 && !XCHAL_HAVE_MUL32 && !XCHAL_HAVE_MAC16

#define XCHAL_NO_MUL 1

#endif

__mulsf3_aux:

        /* Handle unusual cases (zeros, subnormals, NaNs and Infinities).

           (This code is placed before the start of the function just to

           keep it in range of the limited branch displacements.)  */

.Lmul_xexpzero:

        /* Clear the sign bit of x.  */

        slli    a2, a2, 1

        srli    a2, a2, 1

        /* If x is zero, return zero.  */

        beqz    a2, .Lmul_return_zero

        /* Normalize x.  Adjust the exponent in a8.  */

        do_nsau a10, a2, a11, a12

        addi    a10, a10, -8

        ssl     a10

        sll     a2, a2

        movi    a8, 1

        sub     a8, a8, a10

        j       .Lmul_xnormalized

.Lmul_yexpzero:

        /* Clear the sign bit of y.  */

        slli    a3, a3, 1

        srli    a3, a3, 1

        /* If y is zero, return zero.  */

        beqz    a3, .Lmul_return_zero

        /* Normalize y.  Adjust the exponent in a9.  */

        do_nsau a10, a3, a11, a12

        addi    a10, a10, -8

        ssl     a10

        sll     a3, a3

        movi    a9, 1

        sub     a9, a9, a10

        j       .Lmul_ynormalized

.Lmul_return_zero:

        /* Return zero with the appropriate sign bit.  */

        srli    a2, a7, 31

        slli    a2, a2, 31

        j       .Lmul_done

.Lmul_xnan_or_inf:

        /* If y is zero, return NaN.  */

        slli    a8, a3, 1

        bnez    a8, 1f

        movi    a4, 0x400000    /* make it a quiet NaN */

        or      a2, a2, a4

        j       .Lmul_done

1:

        /* If y is NaN, return y.  */

        bnall   a3, a6, .Lmul_returnx

        slli    a8, a3, 9

        beqz    a8, .Lmul_returnx

.Lmul_returny:

        mov     a2, a3

.Lmul_returnx:

        /* Set the sign bit and return.  */

        extui   a7, a7, 31, 1

        slli    a2, a2, 1

        ssai    1

        src     a2, a7, a2

        j       .Lmul_done

.Lmul_ynan_or_inf:

        /* If x is zero, return NaN.  */

        slli    a8, a2, 1

        bnez    a8, .Lmul_returny

        movi    a7, 0x400000    /* make it a quiet NaN */

        or      a2, a3, a7

        j       .Lmul_done

        .align  4

        .global __mulsf3

        .type   __mulsf3, @function

__mulsf3:

#if __XTENSA_CALL0_ABI__

        leaf_entry sp, 32

        addi    sp, sp, -32

        s32i    a12, sp, 16

        s32i    a13, sp, 20

        s32i    a14, sp, 24

        s32i    a15, sp, 28

#elif XCHAL_NO_MUL

        /* This is not really a leaf function; allocate enough stack space

           to allow CALL12s to a helper function.  */

        leaf_entry sp, 64

#else

        leaf_entry sp, 32

#endif

        movi    a6, 0x7f800000

        /* Get the sign of the result.  */

        xor     a7, a2, a3

        /* Check for NaN and infinity.  */

        ball    a2, a6, .Lmul_xnan_or_inf

        ball    a3, a6, .Lmul_ynan_or_inf

        /* Extract the exponents.  */

        extui   a8, a2, 23, 8

        extui   a9, a3, 23, 8

        beqz    a8, .Lmul_xexpzero

.Lmul_xnormalized:

        beqz    a9, .Lmul_yexpzero

.Lmul_ynormalized:

        /* Add the exponents.  */

        add     a8, a8, a9

        /* Replace sign/exponent fields with explicit "1.0".  */

        movi    a10, 0xffffff

        or      a2, a2, a6

        and     a2, a2, a10

        or      a3, a3, a6

        and     a3, a3, a10

        /* Multiply 32x32 to 64 bits.  The result ends up in a2/a6.  */

#if XCHAL_HAVE_MUL32_HIGH

        mull    a6, a2, a3

        muluh   a2, a2, a3

#else

        /* Break the inputs into 16-bit chunks and compute 4 32-bit partial

           products.  These partial products are:

                1 xl * yh

                2 xh * yl

                3 xh * yh

           If using the Mul16 or Mul32 multiplier options, these input

           chunks must be stored in separate registers.  For Mac16, the

           UMUL.AA.* opcodes can specify that the inputs come from either

           half of the registers, so there is no need to shift them out

           ahead of time.  If there is no multiply hardware, the 16-bit

           chunks can be extracted when setting up the arguments to the

           separate multiply function.  */

#if __XTENSA_CALL0_ABI__ && XCHAL_NO_MUL

        /* Calling a separate multiply function will clobber a0 and requires

           use of a8 as a temporary, so save those values now.  (The function

           uses a custom ABI so nothing else needs to be saved.)  */

        s32i    a0, sp, 0

        s32i    a8, sp, 4

#endif

#if XCHAL_HAVE_MUL16 || XCHAL_HAVE_MUL32

#define a2h a4

#define a3h a5

        /* Get the high halves of the inputs into registers.  */

        srli    a2h, a2, 16

        srli    a3h, a3, 16

#define a2l a2

#define a3l a3

#if XCHAL_HAVE_MUL32 && !XCHAL_HAVE_MUL16

        /* Clear the high halves of the inputs.  This does not matter

           for MUL16 because the high bits are ignored.  */

        extui   a2, a2, 0, 16

        extui   a3, a3, 0, 16

#endif

#endif /* MUL16 || MUL32 */

#if XCHAL_HAVE_MUL16

#define do_mul(dst, xreg, xhalf, yreg, yhalf) \

        mul16u  dst, xreg ## xhalf, yreg ## yhalf

#elif XCHAL_HAVE_MUL32

#define do_mul(dst, xreg, xhalf, yreg, yhalf) \

        mull    dst, xreg ## xhalf, yreg ## yhalf

#elif XCHAL_HAVE_MAC16

/* The preprocessor insists on inserting a space when concatenating after

   a period in the definition of do_mul below.  These macros are a workaround

   using underscores instead of periods when doing the concatenation.  */

#define umul_aa_ll umul.aa.ll

#define umul_aa_lh umul.aa.lh

#define umul_aa_hl umul.aa.hl

#define umul_aa_hh umul.aa.hh

#define do_mul(dst, xreg, xhalf, yreg, yhalf) \

        umul_aa_ ## xhalf ## yhalf      xreg, yreg; \

        rsr     dst, ACCLO

#else /* no multiply hardware */

#define set_arg_l(dst, src) \

        extui   dst, src, 0, 16

#define set_arg_h(dst, src) \

        srli    dst, src, 16

#if __XTENSA_CALL0_ABI__

#define do_mul(dst, xreg, xhalf, yreg, yhalf) \

        set_arg_ ## xhalf (a13, xreg); \

        set_arg_ ## yhalf (a14, yreg); \

        call0   .Lmul_mulsi3; \

        mov     dst, a12

#else

#define do_mul(dst, xreg, xhalf, yreg, yhalf) \

        set_arg_ ## xhalf (a14, xreg); \

        set_arg_ ## yhalf (a15, yreg); \

        call12  .Lmul_mulsi3; \

        mov     dst, a14

#endif /* __XTENSA_CALL0_ABI__ */

#endif /* no multiply hardware */

        /* Add pp1 and pp2 into a6 with carry-out in a9.  */

        do_mul(a6, a2, l, a3, h)        /* pp 1 */

        do_mul(a11, a2, h, a3, l)       /* pp 2 */

        movi    a9, 0

        add     a6, a6, a11

        bgeu    a6, a11, 1f

        addi    a9, a9, 1

1:

        /* Shift the high half of a9/a6 into position in a9.  Note that

           this value can be safely incremented without any carry-outs.  */

        ssai    16

        src     a9, a9, a6

        /* Compute the low word into a6.  */

        do_mul(a11, a2, l, a3, l)       /* pp 0 */

        sll     a6, a6

        add     a6, a6, a11

        bgeu    a6, a11, 1f

        addi    a9, a9, 1

1:

        /* Compute the high word into a2.  */

        do_mul(a2, a2, h, a3, h)        /* pp 3 */

        add     a2, a2, a9

#if __XTENSA_CALL0_ABI__ && XCHAL_NO_MUL

        /* Restore values saved on the stack during the multiplication.  */

        l32i    a0, sp, 0

        l32i    a8, sp, 4

#endif

#endif /* ! XCHAL_HAVE_MUL32_HIGH */

        /* Shift left by 9 bits, unless there was a carry-out from the

           multiply, in which case, shift by 8 bits and increment the

           exponent.  */

        movi    a4, 9

        srli    a5, a2, 24 - 9

        beqz    a5, 1f

        addi    a4, a4, -1

        addi    a8, a8, 1

1:      ssl     a4

        src     a2, a2, a6

        sll     a6, a6

        /* Subtract the extra bias from the exponent sum (plus one to account

           for the explicit "1.0" of the mantissa that will be added to the

           exponent in the final result).  */

        movi    a4, 0x80

        sub     a8, a8, a4

        /* Check for over/underflow.  The value in a8 is one less than the

           final exponent, so values in the range 0..fd are OK here.  */

        movi    a4, 0xfe

        bgeu    a8, a4, .Lmul_overflow

.Lmul_round:

        /* Round.  */

        bgez    a6, .Lmul_rounded

        addi    a2, a2, 1

        slli    a6, a6, 1

        beqz    a6, .Lmul_exactlyhalf

.Lmul_rounded:

        /* Add the exponent to the mantissa.  */

        slli    a8, a8, 23

        add     a2, a2, a8

.Lmul_addsign:

        /* Add the sign bit.  */

        srli    a7, a7, 31

        slli    a7, a7, 31

        or      a2, a2, a7

.Lmul_done:

#if __XTENSA_CALL0_ABI__

        l32i    a12, sp, 16

        l32i    a13, sp, 20

        l32i    a14, sp, 24

        l32i    a15, sp, 28

        addi    sp, sp, 32

#endif

        leaf_return

.Lmul_exactlyhalf:

        /* Round down to the nearest even value.  */

        srli    a2, a2, 1

        slli    a2, a2, 1

        j       .Lmul_rounded

.Lmul_overflow:

        bltz    a8, .Lmul_underflow

        /* Return +/- Infinity.  */

        movi    a8, 0xff

        slli    a2, a8, 23

        j       .Lmul_addsign

.Lmul_underflow:

        /* Create a subnormal value, where the exponent field contains zero,

           but the effective exponent is 1.  The value of a8 is one less than

           the actual exponent, so just negate it to get the shift amount.  */

        neg     a8, a8

        mov     a9, a6

        ssr     a8

        bgeui   a8, 32, .Lmul_flush_to_zero

        /* Shift a2 right.  Any bits that are shifted out of a2 are saved

           in a6 (combined with the shifted-out bits currently in a6) for

           rounding the result.  */

        sll     a6, a2

        srl     a2, a2

        /* Set the exponent to zero.  */

        movi    a8, 0

        /* Pack any nonzero bits shifted out into a6.  */

        beqz    a9, .Lmul_round

        movi    a9, 1

        or      a6, a6, a9

        j       .Lmul_round

.Lmul_flush_to_zero:

        /* Return zero with the appropriate sign bit.  */

        srli    a2, a7, 31

        slli    a2, a2, 31

        j       .Lmul_done

#if XCHAL_NO_MUL

        /* For Xtensa processors with no multiply hardware, this simplified

           version of _mulsi3 is used for multiplying 16-bit chunks of

           the floating-point mantissas.  When using CALL0, this function

           uses a custom ABI: the inputs are passed in a13 and a14, the

           result is returned in a12, and a8 and a15 are clobbered.  */

        .align  4

.Lmul_mulsi3:

        leaf_entry sp, 16

        .macro mul_mulsi3_body dst, src1, src2, tmp1, tmp2

        movi    \dst, 0

1:      add     \tmp1, \src2, \dst

        extui   \tmp2, \src1, 0, 1

        movnez  \dst, \tmp1, \tmp2

        do_addx2 \tmp1, \src2, \dst, \tmp1

        extui   \tmp2, \src1, 1, 1

        movnez  \dst, \tmp1, \tmp2

        do_addx4 \tmp1, \src2, \dst, \tmp1

        extui   \tmp2, \src1, 2, 1

        movnez  \dst, \tmp1, \tmp2

        do_addx8 \tmp1, \src2, \dst, \tmp1

        extui   \tmp2, \src1, 3, 1

        movnez  \dst, \tmp1, \tmp2

        srli    \src1, \src1, 4

        slli    \src2, \src2, 4

        bnez    \src1, 1b

        .endm

#if __XTENSA_CALL0_ABI__

        mul_mulsi3_body a12, a13, a14, a15, a8

#else

        /* The result will be written into a2, so save that argument in a4.  */

        mov     a4, a2

        mul_mulsi3_body a2, a4, a3, a5, a6

#endif

        leaf_return

#endif /* XCHAL_NO_MUL */

#endif /* L_mulsf3 */

#ifdef L_divsf3

        /* Division */

__divsf3_aux:

        /* Handle unusual cases (zeros, subnormals, NaNs and Infinities).

           (This code is placed before the start of the function just to

           keep it in range of the limited branch displacements.)  */

.Ldiv_yexpzero:

        /* Clear the sign bit of y.  */

        slli    a3, a3, 1

        srli    a3, a3, 1

        /* Check for division by zero.  */

        beqz    a3, .Ldiv_yzero

        /* Normalize y.  Adjust the exponent in a9.  */

        do_nsau a10, a3, a4, a5

        addi    a10, a10, -8

        ssl     a10

        sll     a3, a3

        movi    a9, 1

        sub     a9, a9, a10

        j       .Ldiv_ynormalized

.Ldiv_yzero:

        /* y is zero.  Return NaN if x is also zero; otherwise, infinity.  */

        slli    a4, a2, 1

        srli    a4, a4, 1

        srli    a2, a7, 31

        slli    a2, a2, 31

        or      a2, a2, a6

        bnez    a4, 1f

        movi    a4, 0x400000    /* make it a quiet NaN */

        or      a2, a2, a4

1:      leaf_return

.Ldiv_xexpzero:

        /* Clear the sign bit of x.  */

        slli    a2, a2, 1

        srli    a2, a2, 1

        /* If x is zero, return zero.  */

        beqz    a2, .Ldiv_return_zero

        /* Normalize x.  Adjust the exponent in a8.  */

        do_nsau a10, a2, a4, a5

        addi    a10, a10, -8

        ssl     a10

        sll     a2, a2

        movi    a8, 1

        sub     a8, a8, a10

        j       .Ldiv_xnormalized