compiler-rt/lib/builtins/hexagon/dfaddsub.S - llvm-project - Git at Google

 //===----------------------Hexagon builtin routine ------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//

 // Double Precision Multiply

 #define A r1:0
 #define AH r1
 #define AL r0
 #define B r3:2
 #define BH r3
 #define BL r2

 #define EXPA r4
 #define EXPB r5
 #define EXPB_A r5:4

 #define ZTMP r7:6
 #define ZTMPH r7
 #define ZTMPL r6

 #define ATMP r13:12
 #define ATMPH r13
 #define ATMPL r12

 #define BTMP r9:8
 #define BTMPH r9
 #define BTMPL r8

 #define ATMP2 r11:10
 #define ATMP2H r11
 #define ATMP2L r10

 #define EXPDIFF r15
 #define EXTRACTOFF r14
 #define EXTRACTAMT r15:14

 #define TMP r28

 #define MANTBITS 52
 #define HI_MANTBITS 20
 #define EXPBITS 11
 #define BIAS 1024
 #define MANTISSA_TO_INT_BIAS 52
 #define SR_BIT_INEXACT 5

 #ifndef SR_ROUND_OFF
 #define SR_ROUND_OFF 22
 #endif

 #define NORMAL p3
 #define BIGB p2

 #define Q6_ALIAS(TAG) .global __qdsp_##TAG ; .set __qdsp_##TAG, __hexagon_##TAG
 #define FAST_ALIAS(TAG) .global __hexagon_fast_##TAG ; .set __hexagon_fast_##TAG, __hexagon_##TAG
 #define FAST2_ALIAS(TAG) .global __hexagon_fast2_##TAG ; .set __hexagon_fast2_##TAG, __hexagon_##TAG
 #define END(TAG) .size TAG,.-TAG

 	.text
 	.global __hexagon_adddf3
 	.global __hexagon_subdf3
 	.type __hexagon_adddf3, @function
 	.type __hexagon_subdf3, @function

 Q6_ALIAS(adddf3)
 FAST_ALIAS(adddf3)
 FAST2_ALIAS(adddf3)
 Q6_ALIAS(subdf3)
 FAST_ALIAS(subdf3)
 FAST2_ALIAS(subdf3)

 	.p2align 5
 __hexagon_adddf3:
 	{
 		EXPA = extractu(AH,#EXPBITS,#HI_MANTBITS)
 		EXPB = extractu(BH,#EXPBITS,#HI_MANTBITS)
 		ATMP = combine(##0x20000000,#0)
 	}
 	{
 		NORMAL = dfclass(A,#2)
 		NORMAL = dfclass(B,#2)
 		BTMP = ATMP
 		BIGB = cmp.gtu(EXPB,EXPA)			// Is B substantially greater than A?
 	}
 	{
 		if (!NORMAL) jump .Ladd_abnormal		// If abnormal, go to special code
 		if (BIGB) A = B				// if B >> A, swap A and B
 		if (BIGB) B = A				// If B >> A, swap A and B
 		if (BIGB) EXPB_A = combine(EXPA,EXPB)	// swap exponents
 	}
 	{
 		ATMP = insert(A,#MANTBITS,#EXPBITS-2)	// Q1.62
 		BTMP = insert(B,#MANTBITS,#EXPBITS-2)	// Q1.62
 		EXPDIFF = sub(EXPA,EXPB)
 		ZTMP = combine(#62,#1)
 	}
 #undef BIGB
 #undef NORMAL
 #define B_POS p3
 #define A_POS p2
 #define NO_STICKIES p1
 .Ladd_continue:
 	{
 		EXPDIFF = min(EXPDIFF,ZTMPH)		// If exponent difference >= ~60,
 							// will collapse to sticky bit
 		ATMP2 = neg(ATMP)
 		A_POS = cmp.gt(AH,#-1)
 		EXTRACTOFF = #0
 	}
 	{
 		if (!A_POS) ATMP = ATMP2
 		ATMP2 = extractu(BTMP,EXTRACTAMT)
 		BTMP = ASR(BTMP,EXPDIFF)
 #undef EXTRACTAMT
 #undef EXPDIFF
 #undef EXTRACTOFF
 #define ZERO r15:14
 		ZERO = #0
 	}
 	{
 		NO_STICKIES = cmp.eq(ATMP2,ZERO)
 		if (!NO_STICKIES.new) BTMPL = or(BTMPL,ZTMPL)
 		EXPB = add(EXPA,#-BIAS-60)
 		B_POS = cmp.gt(BH,#-1)
 	}
 	{
 		ATMP = add(ATMP,BTMP)			// ADD!!!
 		ATMP2 = sub(ATMP,BTMP)			// Negate and ADD --> SUB!!!
 		ZTMP = combine(#54,##2045)
 	}
 	{
 		p0 = cmp.gtu(EXPA,ZTMPH)		// must be pretty high in case of large cancellation
 		p0 = !cmp.gtu(EXPA,ZTMPL)
 		if (!p0.new) jump:nt .Ladd_ovf_unf
 		if (!B_POS) ATMP = ATMP2		// if B neg, pick difference
 	}
 	{
 		A = convert_d2df(ATMP)			// Convert to Double Precision, taking care of flags, etc.  So nice!
 		p0 = cmp.eq(ATMPH,#0)
 		p0 = cmp.eq(ATMPL,#0)
 		if (p0.new) jump:nt .Ladd_zero		// or maybe conversion handles zero case correctly?
 	}
 	{
 		AH += asl(EXPB,#HI_MANTBITS)
 		jumpr r31
 	}
 	.falign
 __hexagon_subdf3:
 	{
 		BH = togglebit(BH,#31)
 		jump __qdsp_adddf3
 	}


 	.falign
 .Ladd_zero:
 	// True zero, full cancellation
 	// +0 unless round towards negative infinity
 	{
 		TMP = USR
 		A = #0
 		BH = #1
 	}
 	{
 		TMP = extractu(TMP,#2,#22)
 		BH = asl(BH,#31)
 	}
 	{
 		p0 = cmp.eq(TMP,#2)
 		if (p0.new) AH = xor(AH,BH)
 		jumpr r31
 	}
 	.falign
 .Ladd_ovf_unf:
 	// Overflow or Denormal is possible
 	// Good news: Underflow flag is not possible!

 	// ATMP has 2's complement value
 	//
 	// EXPA has A's exponent, EXPB has EXPA-BIAS-60
 	//
 	// Convert, extract exponent, add adjustment.
 	// If > 2046, overflow
 	// If <= 0, denormal
 	//
 	// Note that we've not done our zero check yet, so do that too

 	{
 		A = convert_d2df(ATMP)
 		p0 = cmp.eq(ATMPH,#0)
 		p0 = cmp.eq(ATMPL,#0)
 		if (p0.new) jump:nt .Ladd_zero
 	}
 	{
 		TMP = extractu(AH,#EXPBITS,#HI_MANTBITS)
 		AH += asl(EXPB,#HI_MANTBITS)
 	}
 	{
 		EXPB = add(EXPB,TMP)
 		B = combine(##0x00100000,#0)
 	}
 	{
 		p0 = cmp.gt(EXPB,##BIAS+BIAS-2)
 		if (p0.new) jump:nt .Ladd_ovf
 	}
 	{
 		p0 = cmp.gt(EXPB,#0)
 		if (p0.new) jumpr:t r31
 		TMP = sub(#1,EXPB)
 	}
 	{
 		B = insert(A,#MANTBITS,#0)
 		A = ATMP
 	}
 	{
 		B = lsr(B,TMP)
 	}
 	{
 		A = insert(B,#63,#0)
 		jumpr r31
 	}
 	.falign
 .Ladd_ovf:
 	// We get either max finite value or infinity.  Either way, overflow+inexact
 	{
 		A = ATMP				// 2's complement value
 		TMP = USR
 		ATMP = combine(##0x7fefffff,#-1)	// positive max finite
 	}
 	{
 		EXPB = extractu(TMP,#2,#SR_ROUND_OFF)	// rounding bits
 		TMP = or(TMP,#0x28)			// inexact + overflow
 		BTMP = combine(##0x7ff00000,#0)		// positive infinity
 	}
 	{
 		USR = TMP
 		EXPB ^= lsr(AH,#31)			// Does sign match rounding?
 		TMP = EXPB				// unmodified rounding mode
 	}
 	{
 		p0 = !cmp.eq(TMP,#1)			// If not round-to-zero and
 		p0 = !cmp.eq(EXPB,#2)			// Not rounding the other way,
 		if (p0.new) ATMP = BTMP			// we should get infinity
 	}
 	{
 		A = insert(ATMP,#63,#0)			// insert inf/maxfinite, leave sign
 	}
 	{
 		p0 = dfcmp.eq(A,A)
 		jumpr r31
 	}

 .Ladd_abnormal:
 	{
 		ATMP = extractu(A,#63,#0)		// strip off sign
 		BTMP = extractu(B,#63,#0)		// strip off sign
 	}
 	{
 		p3 = cmp.gtu(ATMP,BTMP)
 		if (!p3.new) A = B			// sort values
 		if (!p3.new) B = A			// sort values
 	}
 	{
 		// Any NaN --> NaN, possibly raise invalid if sNaN
 		p0 = dfclass(A,#0x0f)		// A not NaN?
 		if (!p0.new) jump:nt .Linvalid_nan_add
 		if (!p3) ATMP = BTMP
 		if (!p3) BTMP = ATMP
 	}
 	{
 		// Infinity + non-infinity number is infinity
 		// Infinity + infinity --> inf or nan
 		p1 = dfclass(A,#0x08)		// A is infinity
 		if (p1.new) jump:nt .Linf_add
 	}
 	{
 		p2 = dfclass(B,#0x01)		// B is zero
 		if (p2.new) jump:nt .LB_zero	// so return A or special 0+0
 		ATMP = #0
 	}
 	// We are left with adding one or more subnormals
 	{
 		p0 = dfclass(A,#4)
 		if (p0.new) jump:nt .Ladd_two_subnormal
 		ATMP = combine(##0x20000000,#0)
 	}
 	{
 		EXPA = extractu(AH,#EXPBITS,#HI_MANTBITS)
 		EXPB = #1
 		// BTMP already ABS(B)
 		BTMP = asl(BTMP,#EXPBITS-2)
 	}
 #undef ZERO
 #define EXTRACTOFF r14
 #define EXPDIFF r15
 	{
 		ATMP = insert(A,#MANTBITS,#EXPBITS-2)
 		EXPDIFF = sub(EXPA,EXPB)
 		ZTMP = combine(#62,#1)
 		jump .Ladd_continue
 	}

 .Ladd_two_subnormal:
 	{
 		ATMP = extractu(A,#63,#0)
 		BTMP = extractu(B,#63,#0)
 	}
 	{
 		ATMP = neg(ATMP)
 		BTMP = neg(BTMP)
 		p0 = cmp.gt(AH,#-1)
 		p1 = cmp.gt(BH,#-1)
 	}
 	{
 		if (p0) ATMP = A
 		if (p1) BTMP = B
 	}
 	{
 		ATMP = add(ATMP,BTMP)
 	}
 	{
 		BTMP = neg(ATMP)
 		p0 = cmp.gt(ATMPH,#-1)
 		B = #0
 	}
 	{
 		if (!p0) A = BTMP
 		if (p0) A = ATMP
 		BH = ##0x80000000
 	}
 	{
 		if (!p0) AH = or(AH,BH)
 		p0 = dfcmp.eq(A,B)
 		if (p0.new) jump:nt .Lzero_plus_zero
 	}
 	{
 		jumpr r31
 	}

 .Linvalid_nan_add:
 	{
 		TMP = convert_df2sf(A)			// will generate invalid if sNaN
 		p0 = dfclass(B,#0x0f)			// if B is not NaN
 		if (p0.new) B = A 			// make it whatever A is
 	}
 	{
 		BL = convert_df2sf(B)			// will generate invalid if sNaN
 		A = #-1
 		jumpr r31
 	}
 	.falign
 .LB_zero:
 	{
 		p0 = dfcmp.eq(ATMP,A)			// is A also zero?
 		if (!p0.new) jumpr:t r31		// If not, just return A
 	}
 	// 0 + 0 is special
 	// if equal integral values, they have the same sign, which is fine for all rounding
 	// modes.
 	// If unequal in sign, we get +0 for all rounding modes except round down
 .Lzero_plus_zero:
 	{
 		p0 = cmp.eq(A,B)
 		if (p0.new) jumpr:t r31
 	}
 	{
 		TMP = USR
 	}
 	{
 		TMP = extractu(TMP,#2,#SR_ROUND_OFF)
 		A = #0
 	}
 	{
 		p0 = cmp.eq(TMP,#2)
 		if (p0.new) AH = ##0x80000000
 		jumpr r31
 	}
 .Linf_add:
 	// adding infinities is only OK if they are equal
 	{
 		p0 = !cmp.eq(AH,BH)			// Do they have different signs
 		p0 = dfclass(B,#8)			// And is B also infinite?
 		if (!p0.new) jumpr:t r31		// If not, just a normal inf
 	}
 	{
 		BL = ##0x7f800001			// sNAN
 	}
 	{
 		A = convert_sf2df(BL)			// trigger invalid, set NaN
 		jumpr r31
 	}
 END(__hexagon_adddf3)
	//===----------------------Hexagon builtin routine ------------------------===//
	//
	// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
	// See https://llvm.org/LICENSE.txt for license information.
	// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
	//
	//===----------------------------------------------------------------------===//

	// Double Precision Multiply

	#define A r1:0
	#define AH r1
	#define AL r0
	#define B r3:2
	#define BH r3
	#define BL r2

	#define EXPA r4
	#define EXPB r5
	#define EXPB_A r5:4

	#define ZTMP r7:6
	#define ZTMPH r7
	#define ZTMPL r6

	#define ATMP r13:12
	#define ATMPH r13
	#define ATMPL r12

	#define BTMP r9:8
	#define BTMPH r9
	#define BTMPL r8

	#define ATMP2 r11:10
	#define ATMP2H r11
	#define ATMP2L r10

	#define EXPDIFF r15
	#define EXTRACTOFF r14
	#define EXTRACTAMT r15:14

	#define TMP r28

	#define MANTBITS 52
	#define HI_MANTBITS 20
	#define EXPBITS 11
	#define BIAS 1024
	#define MANTISSA_TO_INT_BIAS 52
	#define SR_BIT_INEXACT 5

	#ifndef SR_ROUND_OFF
	#define SR_ROUND_OFF 22
	#endif

	#define NORMAL p3
	#define BIGB p2

	#define Q6_ALIAS(TAG) .global __qdsp_##TAG ; .set __qdsp_##TAG, __hexagon_##TAG
	#define FAST_ALIAS(TAG) .global __hexagon_fast_##TAG ; .set __hexagon_fast_##TAG, __hexagon_##TAG
	#define FAST2_ALIAS(TAG) .global __hexagon_fast2_##TAG ; .set __hexagon_fast2_##TAG, __hexagon_##TAG
	#define END(TAG) .size TAG,.-TAG

	.text
	.global __hexagon_adddf3
	.global __hexagon_subdf3
	.type __hexagon_adddf3, @function
	.type __hexagon_subdf3, @function

	Q6_ALIAS(adddf3)
	FAST_ALIAS(adddf3)
	FAST2_ALIAS(adddf3)
	Q6_ALIAS(subdf3)
	FAST_ALIAS(subdf3)
	FAST2_ALIAS(subdf3)

	.p2align 5
	__hexagon_adddf3:
	{
	EXPA = extractu(AH,#EXPBITS,#HI_MANTBITS)
	EXPB = extractu(BH,#EXPBITS,#HI_MANTBITS)
	ATMP = combine(##0x20000000,#0)
	}
	{
	NORMAL = dfclass(A,#2)
	NORMAL = dfclass(B,#2)
	BTMP = ATMP
	BIGB = cmp.gtu(EXPB,EXPA) // Is B substantially greater than A?
	}
	{
	if (!NORMAL) jump .Ladd_abnormal // If abnormal, go to special code
	if (BIGB) A = B // if B >> A, swap A and B
	if (BIGB) B = A // If B >> A, swap A and B
	if (BIGB) EXPB_A = combine(EXPA,EXPB) // swap exponents
	}
	{
	ATMP = insert(A,#MANTBITS,#EXPBITS-2) // Q1.62
	BTMP = insert(B,#MANTBITS,#EXPBITS-2) // Q1.62
	EXPDIFF = sub(EXPA,EXPB)
	ZTMP = combine(#62,#1)
	}
	#undef BIGB
	#undef NORMAL
	#define B_POS p3
	#define A_POS p2
	#define NO_STICKIES p1
	.Ladd_continue:
	{
	EXPDIFF = min(EXPDIFF,ZTMPH) // If exponent difference >= ~60,
	// will collapse to sticky bit
	ATMP2 = neg(ATMP)
	A_POS = cmp.gt(AH,#-1)
	EXTRACTOFF = #0
	}
	{
	if (!A_POS) ATMP = ATMP2
	ATMP2 = extractu(BTMP,EXTRACTAMT)
	BTMP = ASR(BTMP,EXPDIFF)
	#undef EXTRACTAMT
	#undef EXPDIFF
	#undef EXTRACTOFF
	#define ZERO r15:14
	ZERO = #0
	}
	{
	NO_STICKIES = cmp.eq(ATMP2,ZERO)
	if (!NO_STICKIES.new) BTMPL = or(BTMPL,ZTMPL)
	EXPB = add(EXPA,#-BIAS-60)
	B_POS = cmp.gt(BH,#-1)
	}
	{
	ATMP = add(ATMP,BTMP) // ADD!!!
	ATMP2 = sub(ATMP,BTMP) // Negate and ADD --> SUB!!!
	ZTMP = combine(#54,##2045)
	}
	{
	p0 = cmp.gtu(EXPA,ZTMPH) // must be pretty high in case of large cancellation
	p0 = !cmp.gtu(EXPA,ZTMPL)
	if (!p0.new) jump:nt .Ladd_ovf_unf
	if (!B_POS) ATMP = ATMP2 // if B neg, pick difference
	}
	{
	A = convert_d2df(ATMP) // Convert to Double Precision, taking care of flags, etc. So nice!
	p0 = cmp.eq(ATMPH,#0)
	p0 = cmp.eq(ATMPL,#0)
	if (p0.new) jump:nt .Ladd_zero // or maybe conversion handles zero case correctly?
	}
	{
	AH += asl(EXPB,#HI_MANTBITS)
	jumpr r31
	}
	.falign
	__hexagon_subdf3:
	{
	BH = togglebit(BH,#31)
	jump __qdsp_adddf3
	}


	.falign
	.Ladd_zero:
	// True zero, full cancellation
	// +0 unless round towards negative infinity
	{
	TMP = USR
	A = #0
	BH = #1
	}
	{
	TMP = extractu(TMP,#2,#22)
	BH = asl(BH,#31)
	}
	{
	p0 = cmp.eq(TMP,#2)
	if (p0.new) AH = xor(AH,BH)
	jumpr r31
	}
	.falign
	.Ladd_ovf_unf:
	// Overflow or Denormal is possible
	// Good news: Underflow flag is not possible!

	// ATMP has 2's complement value
	//
	// EXPA has A's exponent, EXPB has EXPA-BIAS-60
	//
	// Convert, extract exponent, add adjustment.
	// If > 2046, overflow
	// If <= 0, denormal
	//
	// Note that we've not done our zero check yet, so do that too

	{
	A = convert_d2df(ATMP)
	p0 = cmp.eq(ATMPH,#0)
	p0 = cmp.eq(ATMPL,#0)
	if (p0.new) jump:nt .Ladd_zero
	}
	{
	TMP = extractu(AH,#EXPBITS,#HI_MANTBITS)
	AH += asl(EXPB,#HI_MANTBITS)
	}
	{
	EXPB = add(EXPB,TMP)
	B = combine(##0x00100000,#0)
	}
	{
	p0 = cmp.gt(EXPB,##BIAS+BIAS-2)
	if (p0.new) jump:nt .Ladd_ovf
	}
	{
	p0 = cmp.gt(EXPB,#0)
	if (p0.new) jumpr:t r31
	TMP = sub(#1,EXPB)
	}
	{
	B = insert(A,#MANTBITS,#0)
	A = ATMP
	}
	{
	B = lsr(B,TMP)
	}
	{
	A = insert(B,#63,#0)
	jumpr r31
	}
	.falign
	.Ladd_ovf:
	// We get either max finite value or infinity. Either way, overflow+inexact
	{
	A = ATMP // 2's complement value
	TMP = USR
	ATMP = combine(##0x7fefffff,#-1) // positive max finite
	}
	{
	EXPB = extractu(TMP,#2,#SR_ROUND_OFF) // rounding bits
	TMP = or(TMP,#0x28) // inexact + overflow
	BTMP = combine(##0x7ff00000,#0) // positive infinity
	}
	{
	USR = TMP
	EXPB ^= lsr(AH,#31) // Does sign match rounding?
	TMP = EXPB // unmodified rounding mode
	}
	{
	p0 = !cmp.eq(TMP,#1) // If not round-to-zero and
	p0 = !cmp.eq(EXPB,#2) // Not rounding the other way,
	if (p0.new) ATMP = BTMP // we should get infinity
	}
	{
	A = insert(ATMP,#63,#0) // insert inf/maxfinite, leave sign
	}
	{
	p0 = dfcmp.eq(A,A)
	jumpr r31
	}

	.Ladd_abnormal:
	{
	ATMP = extractu(A,#63,#0) // strip off sign
	BTMP = extractu(B,#63,#0) // strip off sign
	}
	{
	p3 = cmp.gtu(ATMP,BTMP)
	if (!p3.new) A = B // sort values
	if (!p3.new) B = A // sort values
	}
	{
	// Any NaN --> NaN, possibly raise invalid if sNaN
	p0 = dfclass(A,#0x0f) // A not NaN?
	if (!p0.new) jump:nt .Linvalid_nan_add
	if (!p3) ATMP = BTMP
	if (!p3) BTMP = ATMP
	}
	{
	// Infinity + non-infinity number is infinity
	// Infinity + infinity --> inf or nan
	p1 = dfclass(A,#0x08) // A is infinity
	if (p1.new) jump:nt .Linf_add
	}
	{
	p2 = dfclass(B,#0x01) // B is zero
	if (p2.new) jump:nt .LB_zero // so return A or special 0+0
	ATMP = #0
	}
	// We are left with adding one or more subnormals
	{
	p0 = dfclass(A,#4)
	if (p0.new) jump:nt .Ladd_two_subnormal
	ATMP = combine(##0x20000000,#0)
	}
	{
	EXPA = extractu(AH,#EXPBITS,#HI_MANTBITS)
	EXPB = #1
	// BTMP already ABS(B)
	BTMP = asl(BTMP,#EXPBITS-2)
	}
	#undef ZERO
	#define EXTRACTOFF r14
	#define EXPDIFF r15
	{
	ATMP = insert(A,#MANTBITS,#EXPBITS-2)
	EXPDIFF = sub(EXPA,EXPB)
	ZTMP = combine(#62,#1)
	jump .Ladd_continue
	}

	.Ladd_two_subnormal:
	{
	ATMP = extractu(A,#63,#0)
	BTMP = extractu(B,#63,#0)
	}
	{
	ATMP = neg(ATMP)
	BTMP = neg(BTMP)
	p0 = cmp.gt(AH,#-1)
	p1 = cmp.gt(BH,#-1)
	}
	{
	if (p0) ATMP = A
	if (p1) BTMP = B
	}
	{
	ATMP = add(ATMP,BTMP)
	}
	{
	BTMP = neg(ATMP)
	p0 = cmp.gt(ATMPH,#-1)
	B = #0
	}
	{
	if (!p0) A = BTMP
	if (p0) A = ATMP
	BH = ##0x80000000
	}
	{
	if (!p0) AH = or(AH,BH)
	p0 = dfcmp.eq(A,B)
	if (p0.new) jump:nt .Lzero_plus_zero
	}
	{
	jumpr r31
	}

	.Linvalid_nan_add:
	{
	TMP = convert_df2sf(A) // will generate invalid if sNaN
	p0 = dfclass(B,#0x0f) // if B is not NaN
	if (p0.new) B = A // make it whatever A is
	}
	{
	BL = convert_df2sf(B) // will generate invalid if sNaN
	A = #-1
	jumpr r31
	}
	.falign
	.LB_zero:
	{
	p0 = dfcmp.eq(ATMP,A) // is A also zero?
	if (!p0.new) jumpr:t r31 // If not, just return A
	}
	// 0 + 0 is special
	// if equal integral values, they have the same sign, which is fine for all rounding
	// modes.
	// If unequal in sign, we get +0 for all rounding modes except round down
	.Lzero_plus_zero:
	{
	p0 = cmp.eq(A,B)
	if (p0.new) jumpr:t r31
	}
	{
	TMP = USR
	}
	{
	TMP = extractu(TMP,#2,#SR_ROUND_OFF)
	A = #0
	}
	{
	p0 = cmp.eq(TMP,#2)
	if (p0.new) AH = ##0x80000000
	jumpr r31
	}
	.Linf_add:
	// adding infinities is only OK if they are equal
	{
	p0 = !cmp.eq(AH,BH) // Do they have different signs
	p0 = dfclass(B,#8) // And is B also infinite?
	if (!p0.new) jumpr:t r31 // If not, just a normal inf
	}
	{
	BL = ##0x7f800001 // sNAN
	}
	{
	A = convert_sf2df(BL) // trigger invalid, set NaN
	jumpr r31
	}
	END(__hexagon_adddf3)