URL https://opencores.org/ocsvn/openrisc/openrisc/trunk
Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [libgcc/] [config/] [xtensa/] [ieee754-df.S] - Blame information for rev 734

Details | Compare with Previous | View Log

/* IEEE-754 double-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_negdf2
 
        .align  4
        .global __negdf2
        .type   __negdf2, @function
__negdf2:
        leaf_entry sp, 16
        movi    a4, 0x80000000
        xor     xh, xh, a4
        leaf_return
 
#endif /* L_negdf2 */
 
#ifdef L_addsubdf3
 
        /* Addition */
__adddf3_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   yh, a6, 1f
        /* If x is a NaN, return it.  Otherwise, return y.  */
        slli    a7, xh, 12
        or      a7, a7, xl
        beqz    a7, .Ladd_ynan_or_inf
1:      leaf_return
 
.Ladd_ynan_or_inf:
        /* Return y.  */
        mov     xh, yh
        mov     xl, yl
        leaf_return
 
.Ladd_opposite_signs:
        /* Operand signs differ.  Do a subtraction.  */
        slli    a7, a6, 11
        xor     yh, yh, a7
        j       .Lsub_same_sign
 
        .align  4
        .global __adddf3
        .type   __adddf3, @function
__adddf3:
        leaf_entry sp, 16
        movi    a6, 0x7ff00000
 
        /* Check if the two operands have the same sign.  */
        xor     a7, xh, yh
        bltz    a7, .Ladd_opposite_signs
 
.Ladd_same_sign:
        /* Check if either exponent == 0x7ff (i.e., NaN or Infinity).  */
        ball    xh, a6, .Ladd_xnan_or_inf
        ball    yh, 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, xh, 20, 12
        extui   a8, yh, 20, 12
        bltu    a7, a8, .Ladd_shiftx
 
.Ladd_shifty:
        /* Check if the smaller (or equal) exponent is zero.  */
        bnone   yh, a6, .Ladd_yexpzero
 
        /* Replace yh sign/exponent with 0x001.  */
        or      yh, yh, a6
        slli    yh, yh, 11
        srli    yh, yh, 11
 
.Ladd_yexpdiff:
        /* Compute the exponent difference.  Optimize for difference < 32.  */
        sub     a10, a7, a8
        bgeui   a10, 32, .Ladd_bigshifty
 
        /* Shift yh/yl right by the exponent difference.  Any bits that are
           shifted out of yl are saved in a9 for rounding the result.  */
        ssr     a10
        movi    a9, 0
        src     a9, yl, a9
        src     yl, yh, yl
        srl     yh, yh
 
.Ladd_addy:
        /* Do the 64-bit addition.  */
        add     xl, xl, yl
        add     xh, xh, yh
        bgeu    xl, yl, 1f
        addi    xh, xh, 1
1:
        /* Check if the add overflowed into the exponent.  */
        extui   a10, xh, 20, 12
        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    yh, yh, 12
        srli    yh, yh, 12
        bnone   xh, 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     xl, xl, yl
        add     xh, xh, yh
        bgeu    xl, yl, 1f
        addi    xh, xh, 1
1:      leaf_return
 
.Ladd_bigshifty:
        /* Exponent difference > 64 -- just return the bigger value.  */
        bgeui   a10, 64, 1b
 
        /* Shift yh/yl right by the exponent difference.  Any bits that are
           shifted out are saved in a9 for rounding the result.  */
        ssr     a10
        sll     a11, yl         /* lost bits shifted out of yl */
        src     a9, yh, yl
        srl     yl, yh
        movi    yh, 0
        beqz    a11, .Ladd_addy
        or      a9, a9, a10     /* any positive, nonzero value will work */
        j       .Ladd_addy
 
.Ladd_xexpzero:
        /* Same as "yexpzero" except skip handling the case when both
           exponents are zero.  */
        slli    xh, xh, 12
        srli    xh, xh, 12
        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   xh, a6, .Ladd_xexpzero
 
        or      xh, xh, a6
        slli    xh, xh, 11
        srli    xh, xh, 11
 
.Ladd_xexpdiff:
        sub     a10, a8, a7
        bgeui   a10, 32, .Ladd_bigshiftx
 
        ssr     a10
        sll     a9, xl
        src     xl, xh, xl
        srl     xh, xh
 
.Ladd_addx:
        add     xl, xl, yl
        add     xh, xh, yh
        bgeu    xl, yl, 1f
        addi    xh, xh, 1
1:
        /* Check if the add overflowed into the exponent.  */
        extui   a10, xh, 20, 12
        bne     a10, a8, .Ladd_carry
 
.Ladd_round:
        /* Round up if the leftover fraction is >= 1/2.  */
        bgez    a9, 1f
        addi    xl, xl, 1
        beqz    xl, .Ladd_roundcarry
 
        /* Check if the leftover fraction is exactly 1/2.  */
        slli    a9, a9, 1
        beqz    a9, .Ladd_exactlyhalf
1:      leaf_return
 
.Ladd_bigshiftx:
        /* Mostly the same thing as "bigshifty"....  */
        bgeui   a10, 64, .Ladd_returny
 
        ssr     a10
        sll     a11, xl
        src     a9, xh, xl
        srl     xl, xh
        movi    xh, 0
        beqz    a11, .Ladd_addx
        or      a9, a9, a10
        j       .Ladd_addx
 
.Ladd_returny:
        mov     xh, yh
        mov     xl, yl
        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 0x100000 (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 << 19) + (1 << 19) + (x << 20)
           or:
               shifted mantissa + ((x + 1) << 19)
           Note that the exponent is incremented here by leaving the
           explicit "1.0" of the mantissa in the exponent field.  */
 
        /* Shift xh/xl right by one bit.  Save the lsb of xl.  */
        mov     a10, xl
        ssai    1
        src     xl, xh, xl
        srl     xh, xh
 
        /* See explanation above.  The original exponent is in a8.  */
        addi    a8, a8, 1
        slli    a8, a8, 19
        add     xh, xh, a8
 
        /* Return an Infinity if the exponent overflowed.  */
        ball    xh, 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    xl, xl, 1
        beqz    xl, .Ladd_roundcarry
        beqz    a9, .Ladd_exactlyhalf
1:      leaf_return
 
.Ladd_infinity:
        /* Clear the mantissa.  */
        movi    xl, 0
        srli    xh, xh, 20
        slli    xh, xh, 20
 
        /* The sign bit may have been lost in a carry-out.  Put it back.  */
        slli    a8, a8, 1
        or      xh, xh, a8
        leaf_return
 
.Ladd_exactlyhalf:
        /* Round down to the nearest even value.  */
        srli    xl, xl, 1
        slli    xl, xl, 1
        leaf_return
 
.Ladd_roundcarry:
        /* xl is always zero when the rounding increment overflows, so
           there's no need to round it to an even value.  */
        addi    xh, xh, 1
        /* Overflow to the exponent is OK.  */
        leaf_return
 
 
        /* Subtraction */
__subdf3_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   yh, a6, 1f
        /* Both x and y are either NaN or Inf, so the result is NaN.  */
        movi    a4, 0x80000     /* make it a quiet NaN */
        or      xh, xh, a4
1:      leaf_return
 
.Lsub_ynan_or_inf:
        /* Negate y and return it.  */
        slli    a7, a6, 11
        xor     xh, yh, a7
        mov     xl, yl
        leaf_return
 
.Lsub_opposite_signs:
        /* Operand signs differ.  Do an addition.  */
        slli    a7, a6, 11
        xor     yh, yh, a7
        j       .Ladd_same_sign
 
        .align  4
        .global __subdf3
        .type   __subdf3, @function
__subdf3:
        leaf_entry sp, 16
        movi    a6, 0x7ff00000
 
        /* Check if the two operands have the same sign.  */
        xor     a7, xh, yh
        bltz    a7, .Lsub_opposite_signs
 
.Lsub_same_sign:
        /* Check if either exponent == 0x7ff (i.e., NaN or Infinity).  */
        ball    xh, a6, .Lsub_xnan_or_inf
        ball    yh, a6, .Lsub_ynan_or_inf
 
        /* Compare the operands.  In contrast to addition, the entire
           value matters here.  */
        extui   a7, xh, 20, 11
        extui   a8, yh, 20, 11
        bltu    xh, yh, .Lsub_xsmaller
        beq     xh, yh, .Lsub_compare_low
 
.Lsub_ysmaller:
        /* Check if the smaller (or equal) exponent is zero.  */
        bnone   yh, a6, .Lsub_yexpzero
 
        /* Replace yh sign/exponent with 0x001.  */
        or      yh, yh, a6
        slli    yh, yh, 11
        srli    yh, yh, 11
 
.Lsub_yexpdiff:
        /* Compute the exponent difference.  Optimize for difference < 32.  */
        sub     a10, a7, a8
        bgeui   a10, 32, .Lsub_bigshifty
 
        /* Shift yh/yl right by the exponent difference.  Any bits that are
           shifted out of yl are saved in a9 for rounding the result.  */
        ssr     a10
        movi    a9, 0
        src     a9, yl, a9
        src     yl, yh, yl
        srl     yh, yh
 
.Lsub_suby:
        /* Do the 64-bit subtraction.  */
        sub     xh, xh, yh
        bgeu    xl, yl, 1f
        addi    xh, xh, -1
1:      sub     xl, xl, yl
 
        /* Subtract the leftover bits in a9 from zero and propagate any
           borrow from xh/xl.  */
        neg     a9, a9
        beqz    a9, 1f
        addi    a5, xh, -1
        moveqz  xh, a5, xl
        addi    xl, xl, -1
1:
        /* Check if the subtract underflowed into the exponent.  */
        extui   a10, xh, 20, 11
        beq     a10, a7, .Lsub_round
        j       .Lsub_borrow
 
.Lsub_compare_low:
        /* The high words are equal.  Compare the low words.  */
        bltu    xl, yl, .Lsub_xsmaller
        bltu    yl, xl, .Lsub_ysmaller
        /* The operands are equal.  Return 0.0.  */
        movi    xh, 0
        movi    xl, 0
1:      leaf_return
 
.Lsub_yexpzero:
        /* 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    yh, yh, 12
        srli    yh, yh, 12
        bnone   xh, a6, .Lsub_yexpdiff
        addi    a8, a8, 1
        j       .Lsub_yexpdiff
 
.Lsub_bigshifty:
        /* Exponent difference > 64 -- just return the bigger value.  */
        bgeui   a10, 64, 1b
 
        /* Shift yh/yl right by the exponent difference.  Any bits that are
           shifted out are saved in a9 for rounding the result.  */
        ssr     a10
        sll     a11, yl         /* lost bits shifted out of yl */
        src     a9, yh, yl
        srl     yl, yh
        movi    yh, 0
        beqz    a11, .Lsub_suby
        or      a9, a9, a10     /* any positive, nonzero value will work */
        j       .Lsub_suby
 
.Lsub_xsmaller:
        /* Same thing as the "ysmaller" code, but with x and y swapped and
           with y negated.  */
        bnone   xh, a6, .Lsub_xexpzero
 
        or      xh, xh, a6
        slli    xh, xh, 11
        srli    xh, xh, 11
 
.Lsub_xexpdiff:
        sub     a10, a8, a7
        bgeui   a10, 32, .Lsub_bigshiftx
 
        ssr     a10
        movi    a9, 0
        src     a9, xl, a9
        src     xl, xh, xl
        srl     xh, xh
 
        /* Negate y.  */
        slli    a11, a6, 11
        xor     yh, yh, a11
 
.Lsub_subx:
        sub     xl, yl, xl
        sub     xh, yh, xh
        bgeu    yl, xl, 1f
        addi    xh, xh, -1
1:
        /* Subtract the leftover bits in a9 from zero and propagate any
           borrow from xh/xl.  */
        neg     a9, a9
        beqz    a9, 1f
        addi    a5, xh, -1
        moveqz  xh, a5, xl
        addi    xl, xl, -1
1:
        /* Check if the subtract underflowed into the exponent.  */
        extui   a10, xh, 20, 11
        bne     a10, a8, .Lsub_borrow
 
.Lsub_round:
        /* Round up if the leftover fraction is >= 1/2.  */
        bgez    a9, 1f
        addi    xl, xl, 1
        beqz    xl, .Lsub_roundcarry
 
        /* 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".  */
        slli    xh, xh, 12
        srli    xh, xh, 12
        bnone   yh, a6, .Lsub_xexpdiff
        addi    a7, a7, 1
        j       .Lsub_xexpdiff
 
.Lsub_bigshiftx:
        /* Mostly the same thing as "bigshifty", but with the sign bit of the
           shifted value set so that the subsequent subtraction flips the
           sign of y.  */
        bgeui   a10, 64, .Lsub_returny
 
        ssr     a10
        sll     a11, xl
        src     a9, xh, xl
        srl     xl, xh
        slli    xh, a6, 11      /* set sign bit of xh */
        beqz    a11, .Lsub_subx
        or      a9, a9, a10
        j       .Lsub_subx
 
.Lsub_returny:
        /* Negate and return y.  */
        slli    a7, a6, 11
        xor     xh, yh, a7
        mov     xl, yl
        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, xh, 12
        beqz    a8, .Lsub_xhzero
        do_nsau a6, a8, a7, a11
        srli    a8, a8, 12
        bge     a6, a10, .Lsub_subnormal
        addi    a6, a6, 1
 
.Lsub_shift_lt32:
        /* Shift the mantissa (a8/xl/a9) left by a6.  */
        ssl     a6
        src     a8, a8, xl
        src     xl, xl, 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    xh, xh, 20
        sub     xh, xh, a6
        slli    xh, xh, 20
        add     xh, xh, a8
        j       .Lsub_round
 
.Lsub_exactlyhalf:
        /* Round down to the nearest even value.  */
        srli    xl, xl, 1
        slli    xl, xl, 1
        leaf_return
 
.Lsub_roundcarry:
        /* xl is always zero when the rounding increment overflows, so
           there's no need to round it to an even value.  */
        addi    xh, xh, 1
        /* Overflow to the exponent is OK.  */
        leaf_return
 
.Lsub_xhzero:
        /* When normalizing the result, all the mantissa bits in the high
           word are zero.  Shift by "20 + (leading zero count of xl) + 1".  */
        do_nsau a6, xl, a7, a11
        addi    a6, a6, 21
        blt     a10, a6, .Lsub_subnormal
 
.Lsub_normalize_shift:
        bltui   a6, 32, .Lsub_shift_lt32
 
        ssl     a6
        src     a8, xl, a9
        sll     xl, a9
        movi    a9, 0
 
        srli    xh, xh, 20
        sub     xh, xh, a6
        slli    xh, xh, 20
        add     xh, xh, a8
        j       .Lsub_round
 
.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_addsubdf3 */
 
#ifdef L_muldf3
 
        /* Multiplication */
#if !XCHAL_HAVE_MUL16 && !XCHAL_HAVE_MUL32 && !XCHAL_HAVE_MAC16
#define XCHAL_NO_MUL 1
#endif
 
__muldf3_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    xh, xh, 1
        srli    xh, xh, 1
 
        /* If x is zero, return zero.  */
        or      a10, xh, xl
        beqz    a10, .Lmul_return_zero
 
        /* Normalize x.  Adjust the exponent in a8.  */
        beqz    xh, .Lmul_xh_zero
        do_nsau a10, xh, a11, a12
        addi    a10, a10, -11
        ssl     a10
        src     xh, xh, xl
        sll     xl, xl
        movi    a8, 1
        sub     a8, a8, a10
        j       .Lmul_xnormalized
.Lmul_xh_zero:
        do_nsau a10, xl, a11, a12
        addi    a10, a10, -11
        movi    a8, -31
        sub     a8, a8, a10
        ssl     a10
        bltz    a10, .Lmul_xl_srl
        sll     xh, xl
        movi    xl, 0
        j       .Lmul_xnormalized
.Lmul_xl_srl:
        srl     xh, xl
        sll     xl, xl
        j       .Lmul_xnormalized
 
.Lmul_yexpzero:
        /* Clear the sign bit of y.  */
        slli    yh, yh, 1
        srli    yh, yh, 1
 
        /* If y is zero, return zero.  */
        or      a10, yh, yl
        beqz    a10, .Lmul_return_zero
 
        /* Normalize y.  Adjust the exponent in a9.  */
        beqz    yh, .Lmul_yh_zero
        do_nsau a10, yh, a11, a12
        addi    a10, a10, -11
        ssl     a10
        src     yh, yh, yl
        sll     yl, yl
        movi    a9, 1
        sub     a9, a9, a10
        j       .Lmul_ynormalized
.Lmul_yh_zero:
        do_nsau a10, yl, a11, a12
        addi    a10, a10, -11
        movi    a9, -31
        sub     a9, a9, a10
        ssl     a10
        bltz    a10, .Lmul_yl_srl
        sll     yh, yl
        movi    yl, 0
        j       .Lmul_ynormalized
.Lmul_yl_srl:
        srl     yh, yl
        sll     yl, yl
        j       .Lmul_ynormalized
 
.Lmul_return_zero:
        /* Return zero with the appropriate sign bit.  */
        srli    xh, a7, 31
        slli    xh, xh, 31
        movi    xl, 0
        j       .Lmul_done
 
.Lmul_xnan_or_inf:
        /* If y is zero, return NaN.  */
        bnez    yl, 1f
        slli    a8, yh, 1
        bnez    a8, 1f
        movi    a4, 0x80000     /* make it a quiet NaN */
        or      xh, xh, a4
        j       .Lmul_done
1:
        /* If y is NaN, return y.  */
        bnall   yh, a6, .Lmul_returnx
        slli    a8, yh, 12
        or      a8, a8, yl
        beqz    a8, .Lmul_returnx
 
.Lmul_returny:
        mov     xh, yh
        mov     xl, yl
 
.Lmul_returnx:
        /* Set the sign bit and return.  */
        extui   a7, a7, 31, 1
        slli    xh, xh, 1
        ssai    1
        src     xh, a7, xh
        j       .Lmul_done
 
.Lmul_ynan_or_inf:
        /* If x is zero, return NaN.  */
        bnez    xl, .Lmul_returny
        slli    a8, xh, 1
        bnez    a8, .Lmul_returny
        movi    a7, 0x80000     /* make it a quiet NaN */
        or      xh, yh, a7
        j       .Lmul_done
 
        .align  4
        .global __muldf3
        .type   __muldf3, @function
__muldf3:
#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, 0x7ff00000
 
        /* Get the sign of the result.  */
        xor     a7, xh, yh
 
        /* Check for NaN and infinity.  */
        ball    xh, a6, .Lmul_xnan_or_inf
        ball    yh, a6, .Lmul_ynan_or_inf
 
        /* Extract the exponents.  */
        extui   a8, xh, 20, 11
        extui   a9, yh, 20, 11
 
        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, 0x1fffff
        or      xh, xh, a6
        and     xh, xh, a10
        or      yh, yh, a6
        and     yh, yh, a10
 
        /* Multiply 64x64 to 128 bits.  The result ends up in xh/xl/a6.
           The least-significant word of the result is thrown away except
           that if it is nonzero, the lsb of a6 is set to 1.  */
#if XCHAL_HAVE_MUL32_HIGH
 
        /* Compute a6 with any carry-outs in a10.  */
        movi    a10, 0
        mull    a6, xl, yh
        mull    a11, xh, yl
        add     a6, a6, a11
        bgeu    a6, a11, 1f
        addi    a10, a10, 1
1:
        muluh   a11, xl, yl
        add     a6, a6, a11
        bgeu    a6, a11, 1f
        addi    a10, a10, 1
1:
        /* If the low word of the result is nonzero, set the lsb of a6.  */
        mull    a11, xl, yl
        beqz    a11, 1f
        movi    a9, 1
        or      a6, a6, a9
1:
        /* Compute xl with any carry-outs in a9.  */
        movi    a9, 0
        mull    a11, xh, yh
        add     a10, a10, a11
        bgeu    a10, a11, 1f
        addi    a9, a9, 1
1:
        muluh   a11, xh, yl
        add     a10, a10, a11
        bgeu    a10, a11, 1f
        addi    a9, a9, 1
1:
        muluh   xl, xl, yh
        add     xl, xl, a10
        bgeu    xl, a10, 1f
        addi    a9, a9, 1
1:
        /* Compute xh.  */
        muluh   xh, xh, yh
        add     xh, xh, a9
 
#else /* ! XCHAL_HAVE_MUL32_HIGH */
 
        /* Break the inputs into 16-bit chunks and compute 16 32-bit partial
           products.  These partial products are:
 
 
 
                1 xll * ylh
                2 xlh * yll
 
                3 xll * yhl
                4 xlh * ylh
                5 xhl * yll
 
                6 xll * yhh
                7 xlh * yhl
                8 xhl * ylh
                9 xhh * yll
 
                10 xlh * yhh
                11 xhl * yhl
                12 xhh * ylh
 
                13 xhl * yhh
                14 xhh * yhl
 
                15 xhh * yhh
 
           where the input chunks are (hh, hl, lh, ll).  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.  */
 
        /* Save a7 since it is needed to hold a temporary value.  */
        s32i    a7, sp, 4
#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, 8
#endif
 
#if XCHAL_HAVE_MUL16 || XCHAL_HAVE_MUL32
 
#define xlh a12
#define ylh a13
#define xhh a14
#define yhh a15
 
        /* Get the high halves of the inputs into registers.  */
        srli    xlh, xl, 16
        srli    ylh, yl, 16
        srli    xhh, xh, 16
        srli    yhh, yh, 16
 
#define xll xl
#define yll yl
#define xhl xh
#define yhl yh
 
#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   xl, xl, 0, 16
        extui   xh, xh, 0, 16
        extui   yl, yl, 0, 16
        extui   yh, yh, 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 a10 with carry-out in a9.  */
        do_mul(a10, xl, l, yl, h)       /* pp 1 */
        do_mul(a11, xl, h, yl, l)       /* pp 2 */
        movi    a9, 0
        add     a10, a10, a11
        bgeu    a10, a11, 1f
        addi    a9, a9, 1
1:
        /* Initialize a6 with a9/a10 shifted into position.  Note that
           this value can be safely incremented without any carry-outs.  */
        ssai    16
        src     a6, a9, a10
 
        /* Compute the low word into a10.  */
        do_mul(a11, xl, l, yl, l)       /* pp 0 */
        sll     a10, a10
        add     a10, a10, a11
        bgeu    a10, a11, 1f
        addi    a6, a6, 1
1:
        /* Compute the contributions of pp0-5 to a6, with carry-outs in a9.
           This is good enough to determine the low half of a6, so that any
           nonzero bits from the low word of the result can be collapsed
           into a6, freeing up a register.  */
        movi    a9, 0
        do_mul(a11, xl, l, yh, l)       /* pp 3 */
        add     a6, a6, a11
        bgeu    a6, a11, 1f
        addi    a9, a9, 1
1:
        do_mul(a11, xl, h, yl, h)       /* pp 4 */
        add     a6, a6, a11
        bgeu    a6, a11, 1f
        addi    a9, a9, 1
1:
        do_mul(a11, xh, l, yl, l)       /* pp 5 */
        add     a6, a6, a11
        bgeu    a6, a11, 1f
        addi    a9, a9, 1
1:
        /* Collapse any nonzero bits from the low word into a6.  */
        beqz    a10, 1f
        movi    a11, 1
        or      a6, a6, a11
1:
        /* Add pp6-9 into a11 with carry-outs in a10.  */
        do_mul(a7, xl, l, yh, h)        /* pp 6 */
        do_mul(a11, xh, h, yl, l)       /* pp 9 */
        movi    a10, 0
        add     a11, a11, a7
        bgeu    a11, a7, 1f
        addi    a10, a10, 1
1:
        do_mul(a7, xl, h, yh, l)        /* pp 7 */
        add     a11, a11, a7
        bgeu    a11, a7, 1f
        addi    a10, a10, 1
1:
        do_mul(a7, xh, l, yl, h)        /* pp 8 */
        add     a11, a11, a7
        bgeu    a11, a7, 1f
        addi    a10, a10, 1
1:
        /* Shift a10/a11 into position, and add low half of a11 to a6.  */
        src     a10, a10, a11
        add     a10, a10, a9
        sll     a11, a11
        add     a6, a6, a11
        bgeu    a6, a11, 1f
        addi    a10, a10, 1
1:
        /* Add pp10-12 into xl with carry-outs in a9.  */
        movi    a9, 0
        do_mul(xl, xl, h, yh, h)        /* pp 10 */
        add     xl, xl, a10
        bgeu    xl, a10, 1f
        addi    a9, a9, 1
1:
        do_mul(a10, xh, l, yh, l)       /* pp 11 */
        add     xl, xl, a10
        bgeu    xl, a10, 1f
        addi    a9, a9, 1
1:
        do_mul(a10, xh, h, yl, h)       /* pp 12 */
        add     xl, xl, a10
        bgeu    xl, a10, 1f
        addi    a9, a9, 1
1:
        /* Add pp13-14 into a11 with carry-outs in a10.  */
        do_mul(a11, xh, l, yh, h)       /* pp 13 */
        do_mul(a7, xh, h, yh, l)        /* pp 14 */
        movi    a10, 0
        add     a11, a11, a7
        bgeu    a11, a7, 1f
        addi    a10, a10, 1
1:
        /* Shift a10/a11 into position, and add low half of a11 to a6.  */
        src     a10, a10, a11
        add     a10, a10, a9
        sll     a11, a11
        add     xl, xl, a11
        bgeu    xl, a11, 1f
        addi    a10, a10, 1
1:
        /* Compute xh.  */
        do_mul(xh, xh, h, yh, h)        /* pp 15 */
        add     xh, xh, a10
 
        /* Restore values saved on the stack during the multiplication.  */
        l32i    a7, sp, 4
#if __XTENSA_CALL0_ABI__ && XCHAL_NO_MUL
        l32i    a0, sp, 0
        l32i    a8, sp, 8
#endif
#endif /* ! XCHAL_HAVE_MUL32_HIGH */
 
        /* Shift left by 12 bits, unless there was a carry-out from the
           multiply, in which case, shift by 11 bits and increment the
           exponent.  Note: It is convenient to use the constant 0x3ff
           instead of 0x400 when removing the extra exponent bias (so that
           it is easy to construct 0x7fe for the overflow check).  Reverse
           the logic here to decrement the exponent sum by one unless there
           was a carry-out.  */
        movi    a4, 11
        srli    a5, xh, 21 - 12
        bnez    a5, 1f
        addi    a4, a4, 1
        addi    a8, a8, -1
1:      ssl     a4
        src     xh, xh, xl
        src     xl, xl, 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, 0x3ff
        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..7fd are OK here.  */
        slli    a4, a4, 1       /* 0x7fe */
        bgeu    a8, a4, .Lmul_overflow
 
.Lmul_round:
        /* Round.  */
        bgez    a6, .Lmul_rounded
        addi    xl, xl, 1
        beqz    xl, .Lmul_roundcarry
        slli    a6, a6, 1
        beqz    a6, .Lmul_exactlyhalf
 
.Lmul_rounded:
        /* Add the exponent to the mantissa.  */
        slli    a8, a8, 20
        add     xh, xh, a8
 
.Lmul_addsign:
        /* Add the sign bit.  */
        srli    a7, a7, 31
        slli    a7, a7, 31
        or      xh, xh, 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    xl, xl, 1
        slli    xl, xl, 1
        j       .Lmul_rounded
 
.Lmul_roundcarry:
        /* xl is always zero when the rounding increment overflows, so
           there's no need to round it to an even value.  */
        addi    xh, xh, 1
        /* Overflow is OK -- it will be added to the exponent.  */
        j       .Lmul_rounded
 
.Lmul_overflow:
        bltz    a8, .Lmul_underflow
        /* Return +/- Infinity.  */
        addi    a8, a4, 1       /* 0x7ff */
        slli    xh, a8, 20
        movi    xl, 0
        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_bigshift
 
        /* Shift xh/xl right.  Any bits that are shifted out of xl are saved
           in a6 (combined with the shifted-out bits currently in a6) for
           rounding the result.  */
        sll     a6, xl
        src     xl, xh, xl
        srl     xh, xh
        j       1f
 
.Lmul_bigshift:
        bgeui   a8, 64, .Lmul_flush_to_zero
        sll     a10, xl         /* lost bits shifted out of xl */
        src     a6, xh, xl
        srl     xl, xh
        movi    xh, 0
        or      a9, a9, a10
 
        /* Set the exponent to zero.  */
1:      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    xh, a7, 31
        slli    xh, xh, 31
        movi    xl, 0
        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_muldf3 */
 
#ifdef L_divdf3
 
        /* Division */
__divdf3_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    yh, yh, 1
        srli    yh, yh, 1
 
        /* Check for division by zero.  */
        or      a10, yh, yl
        beqz    a10, .Ldiv_yzero
 
        /* Normalize y.  Adjust the exponent in a9.  */
        beqz    yh, .Ldiv_yh_zero
        do_nsau a10, yh, a11, a9
        addi    a10, a10, -11
        ssl     a10
        src     yh, yh, yl
        sll     yl, yl
        movi    a9, 1
        sub     a9, a9, a10
        j       .Ldiv_ynormalized
.Ldiv_yh_zero:
        do_nsau a10, yl, a11, a9
        addi    a10, a10, -11
        movi    a9, -31
        sub     a9, a9, a10
        ssl     a10
        bltz    a10, .Ldiv_yl_srl
        sll     yh, yl
        movi    yl, 0
        j       .Ldiv_ynormalized
.Ldiv_yl_srl:
        srl     yh, yl
        sll     yl, yl
        j       .Ldiv_ynormalized
 
.Ldiv_yzero:
        /* y is zero.  Return NaN if x is also zero; otherwise, infinity.  */
        slli    xh, xh, 1
        srli    xh, xh, 1
        or      xl, xl, xh
        srli    xh, a7, 31
        slli    xh, xh, 31
        or      xh, xh, a6
        bnez    xl, 1f
        movi    a4, 0x80000     /* make it a quiet NaN */
        or      xh, xh, a4
1:      movi    xl, 0
        leaf_return
 
.Ldiv_xexpzero:
        /* Clear the sign bit of x.  */
        slli    xh, xh, 1
        srli    xh, xh, 1
 
        /* If x is zero, return zero.  */
        or      a10, xh, xl
        beqz    a10, .Ldiv_return_zero
 
        /* Normalize x.  Adjust the exponent in a8.  */
        beqz    xh, .Ldiv_xh_zero
        do_nsau a10, xh, a11, a8
        addi    a10, a10, -11
        ssl     a10
        src     xh, xh, xl
        sll     xl, xl
        movi    a8, 1
        sub     a8, a8, a10
        j       .Ldiv_xnormalized
.Ldiv_xh_zero:
        do_nsau a10, xl, a11, a8
        addi    a10, a10, -11
        movi    a8, -31
        sub     a8, a8, a10
        ssl     a10
        bltz    a10, .Ldiv_xl_srl
        sll     xh, xl
        movi    xl, 0
        j       .Ldiv_xnormalized
.Ldiv_xl_srl:
        srl     xh, xl
        sll     xl, xl
        j       .Ldiv_xnormalized
 
.Ldiv_return_zero:
        /* Return zero with the appropriate sign bit.  */
        srli    xh, a7, 31
        slli    xh, xh, 31
        movi    xl, 0
        leaf_return
 
.Ldiv_xnan_or_inf:
        /* Set the sign bit of the result.  */
        srli    a7, yh, 31
        slli    a7, a7, 31
        xor     xh, xh, a7
        /* If y is NaN or Inf, return NaN.  */
        bnall   yh, a6, 1f
        movi    a4, 0x80000     /* make it a quiet NaN */
        or      xh, xh, a4
1:      leaf_return
 
.Ldiv_ynan_or_inf:
        /* If y is Infinity, return zero.  */
        slli    a8, yh, 12
        or      a8, a8, yl
        beqz    a8, .Ldiv_return_zero
        /* y is NaN; return it.  */
        mov     xh, yh
        mov     xl, yl
        leaf_return
 
.Ldiv_highequal1:
        bltu    xl, yl, 2f
        j       3f
 
        .align  4
        .global __divdf3
        .type   __divdf3, @function
__divdf3:
        leaf_entry sp, 16
        movi    a6, 0x7ff00000
 
        /* Get the sign of the result.  */
        xor     a7, xh, yh
 
        /* Check for NaN and infinity.  */
        ball    xh, a6, .Ldiv_xnan_or_inf
        ball    yh, a6, .Ldiv_ynan_or_inf
 
        /* Extract the exponents.  */
        extui   a8, xh, 20, 11
        extui   a9, yh, 20, 11
 
        beqz    a9, .Ldiv_yexpzero
.Ldiv_ynormalized:
        beqz    a8, .Ldiv_xexpzero
.Ldiv_xnormalized:
 
        /* Subtract the exponents.  */
        sub     a8, a8, a9
 
        /* Replace sign/exponent fields with explicit "1.0".  */
        movi    a10, 0x1fffff
        or      xh, xh, a6
        and     xh, xh, a10
        or      yh, yh, a6
        and     yh, yh, a10
 
        /* Set SAR for left shift by one.  */
        ssai    (32 - 1)
 
        /* The first digit of the mantissa division must be a one.
           Shift x (and adjust the exponent) as needed to make this true.  */
        bltu    yh, xh, 3f
        beq     yh, xh, .Ldiv_highequal1
2:      src     xh, xh, xl
        sll     xl, xl
        addi    a8, a8, -1
3:
        /* Do the first subtraction and shift.  */
        sub     xh, xh, yh
        bgeu    xl, yl, 1f
        addi    xh, xh, -1
1:      sub     xl, xl, yl
        src     xh, xh, xl
        sll     xl, xl
 
        /* Put the quotient into a10/a11.  */
        movi    a10, 0
        movi    a11, 1
 
        /* Divide one bit at a time for 52 bits.  */
        movi    a9, 52
#if XCHAL_HAVE_LOOPS
        loop    a9, .Ldiv_loopend
#endif
.Ldiv_loop:
        /* Shift the quotient << 1.  */
        src     a10, a10, a11
        sll     a11, a11
 
        /* Is this digit a 0 or 1?  */
        bltu    xh, yh, 3f
        beq     xh, yh, .Ldiv_highequal2
 
        /* Output a 1 and subtract.  */
2:      addi    a11, a11, 1
        sub     xh, xh, yh
        bgeu    xl, yl, 1f
        addi    xh, xh, -1
1:      sub     xl, xl, yl
 
        /* Shift the dividend << 1.  */
3:      src     xh, xh, xl
        sll     xl, xl
 
#if !XCHAL_HAVE_LOOPS
        addi    a9, a9, -1
        bnez    a9, .Ldiv_loop
#endif
.Ldiv_loopend:
 
        /* Add the exponent bias (less one to account for the explicit "1.0"
           of the mantissa that will be added to the exponent in the final
           result).  */
        movi    a9, 0x3fe
        add     a8, a8, a9
 
        /* Check for over/underflow.  The value in a8 is one less than the
           final exponent, so values in the range 0..7fd are OK here.  */
        addmi   a9, a9, 0x400   /* 0x7fe */
        bgeu    a8, a9, .Ldiv_overflow
 
.Ldiv_round:
        /* Round.  The remainder (<< 1) is in xh/xl.  */
        bltu    xh, yh, .Ldiv_rounded
        beq     xh, yh, .Ldiv_highequal3
.Ldiv_roundup:
        addi    a11, a11, 1
        beqz    a11, .Ldiv_roundcarry
 
.Ldiv_rounded:
        mov     xl, a11
        /* Add the exponent to the mantissa.  */
        slli    a8, a8, 20
        add     xh, a10, a8
 
.Ldiv_addsign:
        /* Add the sign bit.  */
        srli    a7, a7, 31
        slli    a7, a7, 31
        or      xh, xh, a7
        leaf_return
 
.Ldiv_highequal2:
        bgeu    xl, yl, 2b
        j       3b
 
.Ldiv_highequal3:
        bltu    xl, yl, .Ldiv_rounded
        bne     xl, yl, .Ldiv_roundup
 
        /* Remainder is exactly half the divisor.  Round even.  */
        addi    a11, a11, 1
        beqz    a11, .Ldiv_roundcarry
        srli    a11, a11, 1
        slli    a11, a11, 1
        j       .Ldiv_rounded
 
.Ldiv_overflow:
        bltz    a8, .Ldiv_underflow
        /* Return +/- Infinity.  */
        addi    a8, a9, 1       /* 0x7ff */
        slli    xh, a8, 20
        movi    xl, 0
        j       .Ldiv_addsign
 
.Ldiv_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
        ssr     a8
        bgeui   a8, 32, .Ldiv_bigshift
 
        /* Shift a10/a11 right.  Any bits that are shifted out of a11 are
           saved in a6 for rounding the result.  */
        sll     a6, a11
        src     a11, a10, a11
        srl     a10, a10
        j       1f
 
.Ldiv_bigshift:
        bgeui   a8, 64, .Ldiv_flush_to_zero
        sll     a9, a11         /* lost bits shifted out of a11 */
        src     a6, a10, a11
        srl     a11, a10
        movi    a10, 0
        or      xl, xl, a9
 
        /* Set the exponent to zero.  */
1:      movi    a8, 0
 
        /* Pack any nonzero remainder (in xh/xl) into a6.  */
        or      xh, xh, xl
        beqz    xh, 1f
        movi    a9, 1
        or      a6, a6, a9
 
        /* Round a10/a11 based on the bits shifted out into a6.  */
1:      bgez    a6, .Ldiv_rounded
        addi    a11, a11, 1
        beqz    a11, .Ldiv_roundcarry
        slli    a6, a6, 1
        bnez    a6, .Ldiv_rounded
        srli    a11, a11, 1
        slli    a11, a11, 1
        j       .Ldiv_rounded
 
.Ldiv_roundcarry:
        /* a11 is always zero when the rounding increment overflows, so
           there's no need to round it to an even value.  */
        addi    a10, a10, 1
        /* Overflow to the exponent field is OK.  */
        j       .Ldiv_rounded
 
.Ldiv_flush_to_zero:
        /* Return zero with the appropriate sign bit.  */
        srli    xh, a7, 31
        slli    xh, xh, 31
        movi    xl, 0
        leaf_return
 
#endif /* L_divdf3 */
 
#ifdef L_cmpdf2
 
        /* Equal and Not Equal */
 
        .align  4
        .global __eqdf2
        .global __nedf2
        .set    __nedf2, __eqdf2
        .type   __eqdf2, @function
__eqdf2:
        leaf_entry sp, 16
        bne     xl, yl, 2f
        bne     xh, yh, 4f
 
        /* The values are equal but NaN != NaN.  Check the exponent.  */
        movi    a6, 0x7ff00000
        ball    xh, a6, 3f
 
        /* Equal.  */
        movi    a2, 0
        leaf_return
 
        /* Not equal.  */
2:      movi    a2, 1
        leaf_return
 
        /* Check if the mantissas are nonzero.  */
3:      slli    a7, xh, 12
        or      a7, a7, xl
        j       5f
 
        /* Check if x and y are zero with different signs.  */
4:      or      a7, xh, yh
        slli    a7, a7, 1
        or      a7, a7, xl      /* xl == yl here */
 
        /* Equal if a7 == 0, where a7 is either abs(x | y) or the mantissa
           or x when exponent(x) = 0x7ff and x == y.  */
5:      movi    a2, 0
        movi    a3, 1
        movnez  a2, a3, a7
        leaf_return
 
 
        /* Greater Than */
 
        .align  4
        .global __gtdf2
        .type   __gtdf2, @function
__gtdf2:
        leaf_entry sp, 16
        movi    a6, 0x7ff00000
        ball    xh, a6, 2f
1:      bnall   yh, a6, .Lle_cmp
 
        /* Check if y is a NaN.  */
        slli    a7, yh, 12
        or      a7, a7, yl
        beqz    a7, .Lle_cmp
        movi    a2, 0
        leaf_return
 
        /* Check if x is a NaN.  */
2:      slli    a7, xh, 12
        or      a7, a7, xl
        beqz    a7, 1b
        movi    a2, 0
        leaf_return
 
 
        /* Less Than or Equal */
 
        .align  4
        .global __ledf2
        .type   __ledf2, @function
__ledf2:
        leaf_entry sp, 16
        movi    a6, 0x7ff00000
        ball    xh, a6, 2f
1:      bnall   yh, a6, .Lle_cmp
 
        /* Check if y is a NaN.  */
        slli    a7, yh, 12
        or      a7, a7, yl
        beqz    a7, .Lle_cmp
        movi    a2, 1
        leaf_return
 
        /* Check if x is a NaN.  */
2:      slli    a7, xh, 12
        or      a7, a7, xl
        beqz    a7, 1b
        movi    a2, 1
        leaf_return
 
.Lle_cmp:
        /* Check if x and y have different signs.  */
        xor     a7, xh, yh
        bltz    a7, .Lle_diff_signs
 
        /* Check if x is negative.  */
        bltz    xh, .Lle_xneg
 
        /* Check if x <= y.  */
        bltu    xh, yh, 4f
        bne     xh, yh, 5f
        bltu    yl, xl, 5f
4:      movi    a2, 0
        leaf_return
 
.Lle_xneg:
        /* Check if y <= x.  */
        bltu    yh, xh, 4b
        bne     yh, xh, 5f
        bgeu    xl, yl, 4b
5:      movi    a2, 1
        leaf_return
 
.Lle_diff_signs:
        bltz    xh, 4b
 
        /* Check if both x and y are zero.  */
        or      a7, xh, yh
        slli    a7, a7, 1
        or      a7, a7, xl
        or      a7, a7, yl
        movi    a2, 1
        movi    a3, 0
        moveqz  a2, a3, a7
        leaf_return
 
 
        /* Greater Than or Equal */
 
        .align  4
        .global __gedf2
        .type   __gedf2, @function
__gedf2:
        leaf_entry sp, 16
        movi    a6, 0x7ff00000
        ball    xh, a6, 2f
1:      bnall   yh, a6, .Llt_cmp
 
        /* Check if y is a NaN.  */
        slli    a7, yh, 12
        or      a7, a7, yl
        beqz    a7, .Llt_cmp
        movi    a2, -1
        leaf_return
 
        /* Check if x is a NaN.  */
2:      slli    a7, xh, 12
        or      a7, a7, xl
        beqz    a7, 1b
        movi    a2, -1
        leaf_return
 
 
        /* Less Than */
 
        .align  4
        .global __ltdf2
        .type   __ltdf2, @function
__ltdf2:
        leaf_entry sp, 16
        movi    a6, 0x7ff00000
        ball    xh, a6, 2f
1:      bnall   yh, a6, .Llt_cmp
 
        /* Check if y is a NaN.  */
        slli    a7, yh, 12
        or      a7, a7, yl
        beqz    a7, .Llt_cmp
        movi    a2, 0
        leaf_return
 
        /* Check if x is a NaN.  */
2:      slli    a7, xh, 12
        or      a7, a7, xl
        beqz    a7, 1b
        movi    a2, 0
        leaf_return
 
.Llt_cmp:
        /* Check if x and y have different signs.  */
        xor     a7, xh, yh
        bltz    a7, .Llt_diff_signs
 
        /* Check if x is negative.  */
        bltz    xh, .Llt_xneg
 
        /* Check if x < y.  */
        bltu    xh, yh, 4f
        bne     xh, yh, 5f
        bgeu    xl, yl, 5f
4:      movi    a2, -1
        leaf_return
 
.Llt_xneg:
        /* Check if y < x.  */
        bltu    yh, xh, 4b
        bne     yh, xh, 5f
        bltu    yl, xl, 4b
5:      movi    a2, 0
        leaf_return
 
.Llt_diff_signs:
        bgez    xh, 5b
 
        /* Check if both x and y are nonzero.  */
        or      a7, xh, yh
        slli    a7, a7, 1
        or      a7, a7, xl
        or      a7, a7, yl
        movi    a2, 0
        movi    a3, -1
        movnez  a2, a3, a7
        leaf_return
 
 
        /* Unordered */
 
        .align  4
        .global __unorddf2
        .type   __unorddf2, @function
__unorddf2:
        leaf_entry sp, 16
        movi    a6, 0x7ff00000
        ball    xh, a6, 3f
1:      ball    yh, a6, 4f
2:      movi    a2, 0
        leaf_return
 
3:      slli    a7, xh, 12
        or      a7, a7, xl
        beqz    a7, 1b
        movi    a2, 1
        leaf_return
 
4:      slli    a7, yh, 12
        or      a7, a7, yl
        beqz    a7, 2b
        movi    a2, 1
        leaf_return
 
#endif /* L_cmpdf2 */
 
#ifdef L_fixdfsi
 
        .align  4
        .global __fixdfsi
        .type   __fixdfsi, @function
__fixdfsi:
        leaf_entry sp, 16
 
        /* Check for NaN and Infinity.  */
        movi    a6, 0x7ff00000
        ball    xh, a6, .Lfixdfsi_nan_or_inf
 
        /* Extract the exponent and check if 0 < (exp - 0x3fe) < 32.  */
        extui   a4, xh, 20, 11
        extui   a5, a6, 19, 10  /* 0x3fe */
        sub     a4, a4, a5
        bgei    a4, 32, .Lfixdfsi_maxint
        blti    a4, 1, .Lfixdfsi_zero
 
        /* Add explicit "1.0" and shift << 11.  */
        or      a7, xh, a6
        ssai    (32 - 11)
        src     a5, a7, xl
 
        /* Shift back to the right, based on the exponent.  */
        ssl     a4              /* shift by 32 - a4 */
        srl     a5, a5
 
        /* Negate the result if sign != 0.  */
        neg     a2, a5
        movgez  a2, a5, a7
        leaf_return
 
.Lfixdfsi_nan_or_inf:
        /* Handle Infinity and NaN.  */
        slli    a4, xh, 12
        or      a4, a4, xl
        beqz    a4, .Lfixdfsi_maxint
 
        /* Translate NaN to +maxint.  */
        movi    xh, 0
 
.Lfixdfsi_maxint:
        slli    a4, a6, 11      /* 0x80000000 */
        addi    a5, a4, -1      /* 0x7fffffff */
        movgez  a4, a5, xh
        mov     a2, a4
        leaf_return
 
.Lfixdfsi_zero:
        movi    a2, 0
        leaf_return
 
#endif /* L_fixdfsi */
 
#ifdef L_fixdfdi
 
        .align  4
        .global __fixdfdi
        .type   __fixdfdi, @function
__fixdfdi:
        leaf_entry sp, 16
 
        /* Check for NaN and Infinity.  */
        movi    a6, 0x7ff00000
        ball    xh, a6, .Lfixdfdi_nan_or_inf
 
        /* Extract the exponent and check if 0 < (exp - 0x3fe) < 64.  */
        extui   a4, xh, 20, 11
        extui   a5, a6, 19, 10  /* 0x3fe */
        sub     a4, a4, a5
        bgei    a4, 64, .Lfixdfdi_maxint
        blti    a4, 1, .Lfixdfdi_zero
 
        /* Add explicit "1.0" and shift << 11.  */
        or      a7, xh, a6
        ssai    (32 - 11)
        src     xh, a7, xl
        sll     xl, xl
 
        /* Shift back to the right, based on the exponent.  */
        ssl     a4              /* shift by 64 - a4 */
        bgei    a4, 32, .Lfixdfdi_smallshift
        srl     xl, xh
        movi    xh, 0
 
.Lfixdfdi_shifted:
        /* Negate the result if sign != 0.  */
        bgez    a7, 1f
        neg     xl, xl
        neg     xh, xh
        beqz    xl, 1f
        addi    xh, xh, -1
1:      leaf_return
 
.Lfixdfdi_smallshift:
        src     xl, xh, xl
        srl     xh, xh
        j       .Lfixdfdi_shifted
 
.Lfixdfdi_nan_or_inf:
        /* Handle Infinity and NaN.  */
        slli    a4, xh, 12
        or      a4, a4, xl
        beqz    a4, .Lfixdfdi_maxint
 
        /* Translate NaN to +maxint.  */
        movi    xh, 0
 
.Lfixdfdi_maxint:
        slli    a7, a6, 11      /* 0x80000000 */
        bgez    xh, 1f
        mov     xh, a7
        movi    xl, 0
        leaf_return
 
1:      addi    xh, a7, -1      /* 0x7fffffff */
        movi    xl, -1
        leaf_return
 
.Lfixdfdi_zero:
        movi    xh, 0
        movi    xl, 0
        leaf_return
 
#endif /* L_fixdfdi */
 
#ifdef L_fixunsdfsi
 
        .align  4
        .global __fixunsdfsi
        .type   __fixunsdfsi, @function
__fixunsdfsi:
        leaf_entry sp, 16
 
        /* Check for NaN and Infinity.  */
        movi    a6, 0x7ff00000
        ball    xh, a6, .Lfixunsdfsi_nan_or_inf
 
        /* Extract the exponent and check if 0 <= (exp - 0x3ff) < 32.  */
        extui   a4, xh, 20, 11
        extui   a5, a6, 20, 10  /* 0x3ff */
        sub     a4, a4, a5
        bgei    a4, 32, .Lfixunsdfsi_maxint
        bltz    a4, .Lfixunsdfsi_zero
 
        /* Add explicit "1.0" and shift << 11.  */
        or      a7, xh, a6
        ssai    (32 - 11)
        src     a5, a7, xl
 
        /* Shift back to the right, based on the exponent.  */
        addi    a4, a4, 1
        beqi    a4, 32, .Lfixunsdfsi_bigexp
        ssl     a4              /* shift by 32 - a4 */
        srl     a5, a5
 
        /* Negate the result if sign != 0.  */
        neg     a2, a5
        movgez  a2, a5, a7
        leaf_return
 
.Lfixunsdfsi_nan_or_inf:
        /* Handle Infinity and NaN.  */
        slli    a4, xh, 12
        or      a4, a4, xl
        beqz    a4, .Lfixunsdfsi_maxint
 
        /* Translate NaN to 0xffffffff.  */
        movi    a2, -1
        leaf_return
 
.Lfixunsdfsi_maxint:
        slli    a4, a6, 11      /* 0x80000000 */
        movi    a5, -1          /* 0xffffffff */
        movgez  a4, a5, xh
        mov     a2, a4
        leaf_return
 
.Lfixunsdfsi_zero:
        movi    a2, 0
        leaf_return
 
.Lfixunsdfsi_bigexp:
        /* Handle unsigned maximum exponent case.  */
        bltz    xh, 1f
        mov     a2, a5          /* no shift needed */
        leaf_return
 
        /* Return 0x80000000 if negative.  */
1:      slli    a2, a6, 11
        leaf_return
 
#endif /* L_fixunsdfsi */
 
#ifdef L_fixunsdfdi
 
        .align  4
        .global __fixunsdfdi
        .type   __fixunsdfdi, @function
__fixunsdfdi:
        leaf_entry sp, 16
 
        /* Check for NaN and Infinity.  */
        movi    a6, 0x7ff00000
        ball    xh, a6, .Lfixunsdfdi_nan_or_inf
 
        /* Extract the exponent and check if 0 <= (exp - 0x3ff) < 64.  */
        extui   a4, xh, 20, 11
        extui   a5, a6, 20, 10  /* 0x3ff */
        sub     a4, a4, a5
        bgei    a4, 64, .Lfixunsdfdi_maxint
        bltz    a4, .Lfixunsdfdi_zero
 
        /* Add explicit "1.0" and shift << 11.  */
        or      a7, xh, a6
        ssai    (32 - 11)
        src     xh, a7, xl
        sll     xl, xl
 
        /* Shift back to the right, based on the exponent.  */
        addi    a4, a4, 1
        beqi    a4, 64, .Lfixunsdfdi_bigexp
        ssl     a4              /* shift by 64 - a4 */
        bgei    a4, 32, .Lfixunsdfdi_smallshift
        srl     xl, xh
        movi    xh, 0
 
.Lfixunsdfdi_shifted:
        /* Negate the result if sign != 0.  */
        bgez    a7, 1f
        neg     xl, xl
        neg     xh, xh
        beqz    xl, 1f
        addi    xh, xh, -1
1:      leaf_return
 
.Lfixunsdfdi_smallshift:
        src     xl, xh, xl
        srl     xh, xh
        j       .Lfixunsdfdi_shifted
 
.Lfixunsdfdi_nan_or_inf:
        /* Handle Infinity and NaN.  */
        slli    a4, xh, 12
        or      a4, a4, xl
        beqz    a4, .Lfixunsdfdi_maxint
 
        /* Translate NaN to 0xffffffff.... */
1:      movi    xh, -1
        movi    xl, -1
        leaf_return
 
.Lfixunsdfdi_maxint:
        bgez    xh, 1b
2:      slli    xh, a6, 11      /* 0x80000000 */
        movi    xl, 0
        leaf_return
 
.Lfixunsdfdi_zero:
        movi    xh, 0
        movi    xl, 0
        leaf_return
 
.Lfixunsdfdi_bigexp:
        /* Handle unsigned maximum exponent case.  */
        bltz    a7, 2b
        leaf_return             /* no shift needed */
 
#endif /* L_fixunsdfdi */
 
#ifdef L_floatsidf
 
        .align  4
        .global __floatunsidf
        .type   __floatunsidf, @function
__floatunsidf:
        leaf_entry sp, 16
        beqz    a2, .Lfloatsidf_return_zero
 
        /* Set the sign to zero and jump to the floatsidf code.  */
        movi    a7, 0
        j       .Lfloatsidf_normalize
 
        .align  4
        .global __floatsidf
        .type   __floatsidf, @function
__floatsidf:
        leaf_entry sp, 16
 
        /* Check for zero.  */
        beqz    a2, .Lfloatsidf_return_zero
 
        /* Save the sign.  */
        extui   a7, a2, 31, 1
 
        /* Get the absolute value.  */
#if XCHAL_HAVE_ABS
        abs     a2, a2
#else
        neg     a4, a2
        movltz  a2, a4, a2
#endif
 
.Lfloatsidf_normalize:
        /* Normalize with the first 1 bit in the msb.  */
        do_nsau a4, a2, a5, a6
        ssl     a4
        sll     a5, a2
 
        /* Shift the mantissa into position.  */
        srli    xh, a5, 11
        slli    xl, a5, (32 - 11)
 
        /* Set the exponent.  */
        movi    a5, 0x41d       /* 0x3fe + 31 */
        sub     a5, a5, a4
        slli    a5, a5, 20
        add     xh, xh, a5
 
        /* Add the sign and return. */
        slli    a7, a7, 31
        or      xh, xh, a7
        leaf_return
 
.Lfloatsidf_return_zero:
        movi    a3, 0
        leaf_return
 
#endif /* L_floatsidf */
 
#ifdef L_floatdidf
 
        .align  4
        .global __floatundidf
        .type   __floatundidf, @function
__floatundidf:
        leaf_entry sp, 16
 
        /* Check for zero.  */
        or      a4, xh, xl
        beqz    a4, 2f
 
        /* Set the sign to zero and jump to the floatdidf code.  */
        movi    a7, 0
        j       .Lfloatdidf_normalize
 
        .align  4
        .global __floatdidf
        .type   __floatdidf, @function
__floatdidf:
        leaf_entry sp, 16
 
        /* Check for zero.  */
        or      a4, xh, xl
        beqz    a4, 2f
 
        /* Save the sign.  */
        extui   a7, xh, 31, 1
 
        /* Get the absolute value.  */
        bgez    xh, .Lfloatdidf_normalize
        neg     xl, xl
        neg     xh, xh
        beqz    xl, .Lfloatdidf_normalize
        addi    xh, xh, -1
 
.Lfloatdidf_normalize:
        /* Normalize with the first 1 bit in the msb of xh.  */
        beqz    xh, .Lfloatdidf_bigshift
        do_nsau a4, xh, a5, a6
        ssl     a4
        src     xh, xh, xl
        sll     xl, xl
 
.Lfloatdidf_shifted:
        /* Shift the mantissa into position, with rounding bits in a6.  */
        ssai    11
        sll     a6, xl
        src     xl, xh, xl
        srl     xh, xh
 
        /* Set the exponent.  */
        movi    a5, 0x43d       /* 0x3fe + 63 */
        sub     a5, a5, a4
        slli    a5, a5, 20
        add     xh, xh, a5
 
        /* Add the sign.  */
        slli    a7, a7, 31
        or      xh, xh, a7
 
        /* Round up if the leftover fraction is >= 1/2.  */
        bgez    a6, 2f
        addi    xl, xl, 1
        beqz    xl, .Lfloatdidf_roundcarry
 
        /* Check if the leftover fraction is exactly 1/2.  */
        slli    a6, a6, 1
        beqz    a6, .Lfloatdidf_exactlyhalf
2:      leaf_return
 
.Lfloatdidf_bigshift:
        /* xh is zero.  Normalize with first 1 bit of xl in the msb of xh.  */
        do_nsau a4, xl, a5, a6
        ssl     a4
        sll     xh, xl
        movi    xl, 0
        addi    a4, a4, 32
        j       .Lfloatdidf_shifted
 
.Lfloatdidf_exactlyhalf:
        /* Round down to the nearest even value.  */
        srli    xl, xl, 1
        slli    xl, xl, 1
        leaf_return
 
.Lfloatdidf_roundcarry:
        /* xl is always zero when the rounding increment overflows, so
           there's no need to round it to an even value.  */
        addi    xh, xh, 1
        /* Overflow to the exponent is OK.  */
        leaf_return
 
#endif /* L_floatdidf */
 
#ifdef L_truncdfsf2
 
        .align  4
        .global __truncdfsf2
        .type   __truncdfsf2, @function
__truncdfsf2:
        leaf_entry sp, 16
 
        /* Adjust the exponent bias.  */
        movi    a4, (0x3ff - 0x7f) << 20
        sub     a5, xh, a4
 
        /* Check for underflow.  */
        xor     a6, xh, a5
        bltz    a6, .Ltrunc_underflow
        extui   a6, a5, 20, 11
        beqz    a6, .Ltrunc_underflow
 
        /* Check for overflow.  */
        movi    a4, 255
        bge     a6, a4, .Ltrunc_overflow
 
        /* Shift a5/xl << 3 into a5/a4.  */
        ssai    (32 - 3)
        src     a5, a5, xl
        sll     a4, xl
 
.Ltrunc_addsign:
        /* Add the sign bit.  */
        extui   a6, xh, 31, 1
        slli    a6, a6, 31
        or      a2, a6, a5
 
        /* Round up if the leftover fraction is >= 1/2.  */
        bgez    a4, 1f
        addi    a2, a2, 1
        /* Overflow to the exponent is OK.  The answer will be correct.  */
 
        /* Check if the leftover fraction is exactly 1/2.  */
        slli    a4, a4, 1
        beqz    a4, .Ltrunc_exactlyhalf
1:      leaf_return
 
.Ltrunc_exactlyhalf:
        /* Round down to the nearest even value.  */
        srli    a2, a2, 1
        slli    a2, a2, 1
        leaf_return
 
.Ltrunc_overflow:
        /* Check if exponent == 0x7ff.  */
        movi    a4, 0x7ff00000
        bnall   xh, a4, 1f
 
        /* Check if mantissa is nonzero.  */
        slli    a5, xh, 12
        or      a5, a5, xl
        beqz    a5, 1f
 
        /* Shift a4 to set a bit in the mantissa, making a quiet NaN.  */
        srli    a4, a4, 1
 
1:      slli    a4, a4, 4       /* 0xff000000 or 0xff800000 */
        /* Add the sign bit.  */
        extui   a6, xh, 31, 1
        ssai    1
        src     a2, a6, a4
        leaf_return
 
.Ltrunc_underflow:
        /* Find shift count for a subnormal.  Flush to zero if >= 32.  */
        extui   a6, xh, 20, 11
        movi    a5, 0x3ff - 0x7f
        sub     a6, a5, a6
        addi    a6, a6, 1
        bgeui   a6, 32, 1f
 
        /* Replace the exponent with an explicit "1.0".  */
        slli    a5, a5, 13      /* 0x700000 */
        or      a5, a5, xh
        slli    a5, a5, 11
        srli    a5, a5, 11
 
        /* Shift the mantissa left by 3 bits (into a5/a4).  */
        ssai    (32 - 3)
        src     a5, a5, xl
        sll     a4, xl
 
        /* Shift right by a6.  */
        ssr     a6
        sll     a7, a4
        src     a4, a5, a4
        srl     a5, a5
        beqz    a7, .Ltrunc_addsign
        or      a4, a4, a6      /* any positive, nonzero value will work */
        j       .Ltrunc_addsign
 
        /* Return +/- zero.  */
1:      extui   a2, xh, 31, 1
        slli    a2, a2, 31
        leaf_return
 
#endif /* L_truncdfsf2 */
 
#ifdef L_extendsfdf2
 
        .align  4
        .global __extendsfdf2
        .type   __extendsfdf2, @function
__extendsfdf2:
        leaf_entry sp, 16
 
        /* Save the sign bit and then shift it off.  */
        extui   a5, a2, 31, 1
        slli    a5, a5, 31
        slli    a4, a2, 1
 
        /* Extract and check the exponent.  */
        extui   a6, a2, 23, 8
        beqz    a6, .Lextend_expzero
        addi    a6, a6, 1
        beqi    a6, 256, .Lextend_nan_or_inf
 
        /* Shift >> 3 into a4/xl.  */
        srli    a4, a4, 4
        slli    xl, a2, (32 - 3)
 
        /* Adjust the exponent bias.  */
        movi    a6, (0x3ff - 0x7f) << 20
        add     a4, a4, a6
 
        /* Add the sign bit.  */
        or      xh, a4, a5
        leaf_return
 
.Lextend_nan_or_inf:
        movi    a4, 0x7ff00000
 
        /* Check for NaN.  */
        slli    a7, a2, 9
        beqz    a7, 1f
 
        slli    a6, a6, 11      /* 0x80000 */
        or      a4, a4, a6
 
        /* Add the sign and return.  */
1:      or      xh, a4, a5
        movi    xl, 0
        leaf_return
 
.Lextend_expzero:
        beqz    a4, 1b
 
        /* Normalize it to have 8 zero bits before the first 1 bit.  */
        do_nsau a7, a4, a2, a3
        addi    a7, a7, -8
        ssl     a7
        sll     a4, a4
 
        /* Shift >> 3 into a4/xl.  */
        slli    xl, a4, (32 - 3)
        srli    a4, a4, 3
 
        /* Set the exponent.  */
        movi    a6, 0x3fe - 0x7f
        sub     a6, a6, a7
        slli    a6, a6, 20
        add     a4, a4, a6
 
        /* Add the sign and return.  */
        or      xh, a4, a5
        leaf_return
 
#endif /* L_extendsfdf2 */
 
 
Browse

Tools

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [libgcc/] [config/] [xtensa/] [ieee754-df.S] - Blame information for rev 734

Line No.	Rev	Author	Line
1	734	jeremybenn	`/* IEEE-754 double-precision functions for Xtensa`
2			`Copyright (C) 2006, 2007, 2009 Free Software Foundation, Inc.`
3			`Contributed by Bob Wilson (bwilson@tensilica.com) at Tensilica.`
4
5			`This file is part of GCC.`
6
7			`GCC is free software; you can redistribute it and/or modify it`
8			`under the terms of the GNU General Public License as published by`
9			`the Free Software Foundation; either version 3, or (at your option)`
10			`any later version.`
11
12			`GCC is distributed in the hope that it will be useful, but WITHOUT`
13			`ANY WARRANTY; without even the implied warranty of MERCHANTABILITY`
14			`or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public`
15			`License for more details.`
16
17			`Under Section 7 of GPL version 3, you are granted additional`
18			`permissions described in the GCC Runtime Library Exception, version`
19			`3.1, as published by the Free Software Foundation.`
20
21			`You should have received a copy of the GNU General Public License and`
22			`a copy of the GCC Runtime Library Exception along with this program;`
23			`see the files COPYING3 and COPYING.RUNTIME respectively. If not, see`
24			`. */`
25
26			`#ifdef __XTENSA_EB__`
27			`#define xh a2`
28			`#define xl a3`
29			`#define yh a4`
30			`#define yl a5`
31			`#else`
32			`#define xh a3`
33			`#define xl a2`
34			`#define yh a5`
35			`#define yl a4`
36			`#endif`
37
38			`/* Warning! The branch displacements for some Xtensa branch instructions`
39			`are quite small, and this code has been carefully laid out to keep`
40			`branch targets in range. If you change anything, be sure to check that`