gcc/libgcc/config/xtensa/ieee754-df.S

/* 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
   <http://www.gnu.org/licenses/>.  */

#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:

		0 xll * yll

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