arch/m68k/fpsp040/round.S - kernel/msm-4.19 - Gitiles

 |
 |	round.sa 3.4 7/29/91
 |
 |	handle rounding and normalization tasks
 |
 |
 |
 |		Copyright (C) Motorola, Inc. 1990
 |			All Rights Reserved
 |
 |	THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF MOTOROLA
 |	The copyright notice above does not evidence any
 |	actual or intended publication of such source code.

 |ROUND	idnt    2,1 | Motorola 040 Floating Point Software Package

 	|section	8

 #include "fpsp.h"

 |
 |	round --- round result according to precision/mode
 |
 |	a0 points to the input operand in the internal extended format
 |	d1(high word) contains rounding precision:
 |		ext = $0000xxxx
 |		sgl = $0001xxxx
 |		dbl = $0002xxxx
 |	d1(low word) contains rounding mode:
 |		RN  = $xxxx0000
 |		RZ  = $xxxx0001
 |		RM  = $xxxx0010
 |		RP  = $xxxx0011
 |	d0{31:29} contains the g,r,s bits (extended)
 |
 |	On return the value pointed to by a0 is correctly rounded,
 |	a0 is preserved and the g-r-s bits in d0 are cleared.
 |	The result is not typed - the tag field is invalid.  The
 |	result is still in the internal extended format.
 |
 |	The INEX bit of USER_FPSR will be set if the rounded result was
 |	inexact (i.e. if any of the g-r-s bits were set).
 |

 	.global	round
 round:
 | If g=r=s=0 then result is exact and round is done, else set
 | the inex flag in status reg and continue.
 |
 	bsrs	ext_grs			|this subroutine looks at the
 |					:rounding precision and sets
 |					;the appropriate g-r-s bits.
 	tstl	%d0			|if grs are zero, go force
 	bne	rnd_cont		|lower bits to zero for size

 	swap	%d1			|set up d1.w for round prec.
 	bra	truncate

 rnd_cont:
 |
 | Use rounding mode as an index into a jump table for these modes.
 |
 	orl	#inx2a_mask,USER_FPSR(%a6) |set inex2/ainex
 	lea	mode_tab,%a1
 	movel	(%a1,%d1.w*4),%a1
 	jmp	(%a1)
 |
 | Jump table indexed by rounding mode in d1.w.  All following assumes
 | grs != 0.
 |
 mode_tab:
 	.long	rnd_near
 	.long	rnd_zero
 	.long	rnd_mnus
 	.long	rnd_plus
 |
 |	ROUND PLUS INFINITY
 |
 |	If sign of fp number = 0 (positive), then add 1 to l.
 |
 rnd_plus:
 	swap	%d1			|set up d1 for round prec.
 	tstb	LOCAL_SGN(%a0)		|check for sign
 	bmi	truncate		|if positive then truncate
 	movel	#0xffffffff,%d0		|force g,r,s to be all f's
 	lea	add_to_l,%a1
 	movel	(%a1,%d1.w*4),%a1
 	jmp	(%a1)
 |
 |	ROUND MINUS INFINITY
 |
 |	If sign of fp number = 1 (negative), then add 1 to l.
 |
 rnd_mnus:
 	swap	%d1			|set up d1 for round prec.
 	tstb	LOCAL_SGN(%a0)		|check for sign
 	bpl	truncate		|if negative then truncate
 	movel	#0xffffffff,%d0		|force g,r,s to be all f's
 	lea	add_to_l,%a1
 	movel	(%a1,%d1.w*4),%a1
 	jmp	(%a1)
 |
 |	ROUND ZERO
 |
 |	Always truncate.
 rnd_zero:
 	swap	%d1			|set up d1 for round prec.
 	bra	truncate
 |
 |
 |	ROUND NEAREST
 |
 |	If (g=1), then add 1 to l and if (r=s=0), then clear l
 |	Note that this will round to even in case of a tie.
 |
 rnd_near:
 	swap	%d1			|set up d1 for round prec.
 	asll	#1,%d0			|shift g-bit to c-bit
 	bcc	truncate		|if (g=1) then
 	lea	add_to_l,%a1
 	movel	(%a1,%d1.w*4),%a1
 	jmp	(%a1)

 |
 |	ext_grs --- extract guard, round and sticky bits
 |
 | Input:	d1 =		PREC:ROUND
 | Output:	d0{31:29}=	guard, round, sticky
 |
 | The ext_grs extract the guard/round/sticky bits according to the
 | selected rounding precision. It is called by the round subroutine
 | only.  All registers except d0 are kept intact. d0 becomes an
 | updated guard,round,sticky in d0{31:29}
 |
 | Notes: the ext_grs uses the round PREC, and therefore has to swap d1
 |	 prior to usage, and needs to restore d1 to original.
 |
 ext_grs:
 	swap	%d1			|have d1.w point to round precision
 	cmpiw	#0,%d1
 	bnes	sgl_or_dbl
 	bras	end_ext_grs

 sgl_or_dbl:
 	moveml	%d2/%d3,-(%a7)		|make some temp registers
 	cmpiw	#1,%d1
 	bnes	grs_dbl
 grs_sgl:
 	bfextu	LOCAL_HI(%a0){#24:#2},%d3	|sgl prec. g-r are 2 bits right
 	movel	#30,%d2			|of the sgl prec. limits
 	lsll	%d2,%d3			|shift g-r bits to MSB of d3
 	movel	LOCAL_HI(%a0),%d2		|get word 2 for s-bit test
 	andil	#0x0000003f,%d2		|s bit is the or of all other
 	bnes	st_stky			|bits to the right of g-r
 	tstl	LOCAL_LO(%a0)		|test lower mantissa
 	bnes	st_stky			|if any are set, set sticky
 	tstl	%d0			|test original g,r,s
 	bnes	st_stky			|if any are set, set sticky
 	bras	end_sd			|if words 3 and 4 are clr, exit
 grs_dbl:
 	bfextu	LOCAL_LO(%a0){#21:#2},%d3	|dbl-prec. g-r are 2 bits right
 	movel	#30,%d2			|of the dbl prec. limits
 	lsll	%d2,%d3			|shift g-r bits to the MSB of d3
 	movel	LOCAL_LO(%a0),%d2		|get lower mantissa  for s-bit test
 	andil	#0x000001ff,%d2		|s bit is the or-ing of all
 	bnes	st_stky			|other bits to the right of g-r
 	tstl	%d0			|test word original g,r,s
 	bnes	st_stky			|if any are set, set sticky
 	bras	end_sd			|if clear, exit
 st_stky:
 	bset	#rnd_stky_bit,%d3
 end_sd:
 	movel	%d3,%d0			|return grs to d0
 	moveml	(%a7)+,%d2/%d3		|restore scratch registers
 end_ext_grs:
 	swap	%d1			|restore d1 to original
 	rts

 |*******************  Local Equates
 	.set	ad_1_sgl,0x00000100	|  constant to add 1 to l-bit in sgl prec
 	.set	ad_1_dbl,0x00000800	|  constant to add 1 to l-bit in dbl prec


 |Jump table for adding 1 to the l-bit indexed by rnd prec

 add_to_l:
 	.long	add_ext
 	.long	add_sgl
 	.long	add_dbl
 	.long	add_dbl
 |
 |	ADD SINGLE
 |
 add_sgl:
 	addl	#ad_1_sgl,LOCAL_HI(%a0)
 	bccs	scc_clr			|no mantissa overflow
 	roxrw  LOCAL_HI(%a0)		|shift v-bit back in
 	roxrw  LOCAL_HI+2(%a0)		|shift v-bit back in
 	addw	#0x1,LOCAL_EX(%a0)	|and incr exponent
 scc_clr:
 	tstl	%d0			|test for rs = 0
 	bnes	sgl_done
 	andiw  #0xfe00,LOCAL_HI+2(%a0)	|clear the l-bit
 sgl_done:
 	andil	#0xffffff00,LOCAL_HI(%a0) |truncate bits beyond sgl limit
 	clrl	LOCAL_LO(%a0)		|clear d2
 	rts

 |
 |	ADD EXTENDED
 |
 add_ext:
 	addql  #1,LOCAL_LO(%a0)		|add 1 to l-bit
 	bccs	xcc_clr			|test for carry out
 	addql  #1,LOCAL_HI(%a0)		|propagate carry
 	bccs	xcc_clr
 	roxrw  LOCAL_HI(%a0)		|mant is 0 so restore v-bit
 	roxrw  LOCAL_HI+2(%a0)		|mant is 0 so restore v-bit
 	roxrw	LOCAL_LO(%a0)
 	roxrw	LOCAL_LO+2(%a0)
 	addw	#0x1,LOCAL_EX(%a0)	|and inc exp
 xcc_clr:
 	tstl	%d0			|test rs = 0
 	bnes	add_ext_done
 	andib	#0xfe,LOCAL_LO+3(%a0)	|clear the l bit
 add_ext_done:
 	rts
 |
 |	ADD DOUBLE
 |
 add_dbl:
 	addl	#ad_1_dbl,LOCAL_LO(%a0)
 	bccs	dcc_clr
 	addql	#1,LOCAL_HI(%a0)		|propagate carry
 	bccs	dcc_clr
 	roxrw	LOCAL_HI(%a0)		|mant is 0 so restore v-bit
 	roxrw	LOCAL_HI+2(%a0)		|mant is 0 so restore v-bit
 	roxrw	LOCAL_LO(%a0)
 	roxrw	LOCAL_LO+2(%a0)
 	addw	#0x1,LOCAL_EX(%a0)	|incr exponent
 dcc_clr:
 	tstl	%d0			|test for rs = 0
 	bnes	dbl_done
 	andiw	#0xf000,LOCAL_LO+2(%a0)	|clear the l-bit

 dbl_done:
 	andil	#0xfffff800,LOCAL_LO(%a0) |truncate bits beyond dbl limit
 	rts

 error:
 	rts
 |
 | Truncate all other bits
 |
 trunct:
 	.long	end_rnd
 	.long	sgl_done
 	.long	dbl_done
 	.long	dbl_done

 truncate:
 	lea	trunct,%a1
 	movel	(%a1,%d1.w*4),%a1
 	jmp	(%a1)

 end_rnd:
 	rts

 |
 |	NORMALIZE
 |
 | These routines (nrm_zero & nrm_set) normalize the unnorm.  This
 | is done by shifting the mantissa left while decrementing the
 | exponent.
 |
 | NRM_SET shifts and decrements until there is a 1 set in the integer
 | bit of the mantissa (msb in d1).
 |
 | NRM_ZERO shifts and decrements until there is a 1 set in the integer
 | bit of the mantissa (msb in d1) unless this would mean the exponent
 | would go less than 0.  In that case the number becomes a denorm - the
 | exponent (d0) is set to 0 and the mantissa (d1 & d2) is not
 | normalized.
 |
 | Note that both routines have been optimized (for the worst case) and
 | therefore do not have the easy to follow decrement/shift loop.
 |
 |	NRM_ZERO
 |
 |	Distance to first 1 bit in mantissa = X
 |	Distance to 0 from exponent = Y
 |	If X < Y
 |	Then
 |	  nrm_set
 |	Else
 |	  shift mantissa by Y
 |	  set exponent = 0
 |
 |input:
 |	FP_SCR1 = exponent, ms mantissa part, ls mantissa part
 |output:
 |	L_SCR1{4} = fpte15 or ete15 bit
 |
 	.global	nrm_zero
 nrm_zero:
 	movew	LOCAL_EX(%a0),%d0
 	cmpw   #64,%d0          |see if exp > 64
 	bmis	d0_less
 	bsr	nrm_set		|exp > 64 so exp won't exceed 0
 	rts
 d0_less:
 	moveml	%d2/%d3/%d5/%d6,-(%a7)
 	movel	LOCAL_HI(%a0),%d1
 	movel	LOCAL_LO(%a0),%d2

 	bfffo	%d1{#0:#32},%d3	|get the distance to the first 1
 |				;in ms mant
 	beqs	ms_clr		|branch if no bits were set
 	cmpw	%d3,%d0		|of X>Y
 	bmis	greater		|then exp will go past 0 (neg) if
 |				;it is just shifted
 	bsr	nrm_set		|else exp won't go past 0
 	moveml	(%a7)+,%d2/%d3/%d5/%d6
 	rts
 greater:
 	movel	%d2,%d6		|save ls mant in d6
 	lsll	%d0,%d2		|shift ls mant by count
 	lsll	%d0,%d1		|shift ms mant by count
 	movel	#32,%d5
 	subl	%d0,%d5		|make op a denorm by shifting bits
 	lsrl	%d5,%d6		|by the number in the exp, then
 |				;set exp = 0.
 	orl	%d6,%d1		|shift the ls mant bits into the ms mant
 	movel	#0,%d0		|same as if decremented exp to 0
 |				;while shifting
 	movew	%d0,LOCAL_EX(%a0)
 	movel	%d1,LOCAL_HI(%a0)
 	movel	%d2,LOCAL_LO(%a0)
 	moveml	(%a7)+,%d2/%d3/%d5/%d6
 	rts
 ms_clr:
 	bfffo	%d2{#0:#32},%d3	|check if any bits set in ls mant
 	beqs	all_clr		|branch if none set
 	addw	#32,%d3
 	cmpw	%d3,%d0		|if X>Y
 	bmis	greater		|then branch
 	bsr	nrm_set		|else exp won't go past 0
 	moveml	(%a7)+,%d2/%d3/%d5/%d6
 	rts
 all_clr:
 	movew	#0,LOCAL_EX(%a0)	|no mantissa bits set. Set exp = 0.
 	moveml	(%a7)+,%d2/%d3/%d5/%d6
 	rts
 |
 |	NRM_SET
 |
 	.global	nrm_set
 nrm_set:
 	movel	%d7,-(%a7)
 	bfffo	LOCAL_HI(%a0){#0:#32},%d7 |find first 1 in ms mant to d7)
 	beqs	lower		|branch if ms mant is all 0's

 	movel	%d6,-(%a7)

 	subw	%d7,LOCAL_EX(%a0)	|sub exponent by count
 	movel	LOCAL_HI(%a0),%d0	|d0 has ms mant
 	movel	LOCAL_LO(%a0),%d1 |d1 has ls mant

 	lsll	%d7,%d0		|shift first 1 to j bit position
 	movel	%d1,%d6		|copy ls mant into d6
 	lsll	%d7,%d6		|shift ls mant by count
 	movel	%d6,LOCAL_LO(%a0)	|store ls mant into memory
 	moveql	#32,%d6
 	subl	%d7,%d6		|continue shift
 	lsrl	%d6,%d1		|shift off all bits but those that will
 |				;be shifted into ms mant
 	orl	%d1,%d0		|shift the ls mant bits into the ms mant
 	movel	%d0,LOCAL_HI(%a0)	|store ms mant into memory
 	moveml	(%a7)+,%d7/%d6	|restore registers
 	rts

 |
 | We get here if ms mant was = 0, and we assume ls mant has bits
 | set (otherwise this would have been tagged a zero not a denorm).
 |
 lower:
 	movew	LOCAL_EX(%a0),%d0	|d0 has exponent
 	movel	LOCAL_LO(%a0),%d1	|d1 has ls mant
 	subw	#32,%d0		|account for ms mant being all zeros
 	bfffo	%d1{#0:#32},%d7	|find first 1 in ls mant to d7)
 	subw	%d7,%d0		|subtract shift count from exp
 	lsll	%d7,%d1		|shift first 1 to integer bit in ms mant
 	movew	%d0,LOCAL_EX(%a0)	|store ms mant
 	movel	%d1,LOCAL_HI(%a0)	|store exp
 	clrl	LOCAL_LO(%a0)	|clear ls mant
 	movel	(%a7)+,%d7
 	rts
 |
 |	denorm --- denormalize an intermediate result
 |
 |	Used by underflow.
 |
 | Input:
 |	a0	 points to the operand to be denormalized
 |		 (in the internal extended format)
 |
 |	d0:	 rounding precision
 | Output:
 |	a0	 points to the denormalized result
 |		 (in the internal extended format)
 |
 |	d0	is guard,round,sticky
 |
 | d0 comes into this routine with the rounding precision. It
 | is then loaded with the denormalized exponent threshold for the
 | rounding precision.
 |

 	.global	denorm
 denorm:
 	btstb	#6,LOCAL_EX(%a0)	|check for exponents between $7fff-$4000
 	beqs	no_sgn_ext
 	bsetb	#7,LOCAL_EX(%a0)	|sign extend if it is so
 no_sgn_ext:

 	cmpib	#0,%d0		|if 0 then extended precision
 	bnes	not_ext		|else branch

 	clrl	%d1		|load d1 with ext threshold
 	clrl	%d0		|clear the sticky flag
 	bsr	dnrm_lp		|denormalize the number
 	tstb	%d1		|check for inex
 	beq	no_inex		|if clr, no inex
 	bras	dnrm_inex	|if set, set inex

 not_ext:
 	cmpil	#1,%d0		|if 1 then single precision
 	beqs	load_sgl	|else must be 2, double prec

 load_dbl:
 	movew	#dbl_thresh,%d1	|put copy of threshold in d1
 	movel	%d1,%d0		|copy d1 into d0
 	subw	LOCAL_EX(%a0),%d0	|diff = threshold - exp
 	cmpw	#67,%d0		|if diff > 67 (mant + grs bits)
 	bpls	chk_stky	|then branch (all bits would be
 |				; shifted off in denorm routine)
 	clrl	%d0		|else clear the sticky flag
 	bsr	dnrm_lp		|denormalize the number
 	tstb	%d1		|check flag
 	beqs	no_inex		|if clr, no inex
 	bras	dnrm_inex	|if set, set inex

 load_sgl:
 	movew	#sgl_thresh,%d1	|put copy of threshold in d1
 	movel	%d1,%d0		|copy d1 into d0
 	subw	LOCAL_EX(%a0),%d0	|diff = threshold - exp
 	cmpw	#67,%d0		|if diff > 67 (mant + grs bits)
 	bpls	chk_stky	|then branch (all bits would be
 |				; shifted off in denorm routine)
 	clrl	%d0		|else clear the sticky flag
 	bsr	dnrm_lp		|denormalize the number
 	tstb	%d1		|check flag
 	beqs	no_inex		|if clr, no inex
 	bras	dnrm_inex	|if set, set inex

 chk_stky:
 	tstl	LOCAL_HI(%a0)	|check for any bits set
 	bnes	set_stky
 	tstl	LOCAL_LO(%a0)	|check for any bits set
 	bnes	set_stky
 	bras	clr_mant
 set_stky:
 	orl	#inx2a_mask,USER_FPSR(%a6) |set inex2/ainex
 	movel	#0x20000000,%d0	|set sticky bit in return value
 clr_mant:
 	movew	%d1,LOCAL_EX(%a0)		|load exp with threshold
 	movel	#0,LOCAL_HI(%a0)	|set d1 = 0 (ms mantissa)
 	movel	#0,LOCAL_LO(%a0)		|set d2 = 0 (ms mantissa)
 	rts
 dnrm_inex:
 	orl	#inx2a_mask,USER_FPSR(%a6) |set inex2/ainex
 no_inex:
 	rts

 |
 |	dnrm_lp --- normalize exponent/mantissa to specified threshold
 |
 | Input:
 |	a0		points to the operand to be denormalized
 |	d0{31:29}	initial guard,round,sticky
 |	d1{15:0}	denormalization threshold
 | Output:
 |	a0		points to the denormalized operand
 |	d0{31:29}	final guard,round,sticky
 |	d1.b		inexact flag:  all ones means inexact result
 |
 | The LOCAL_LO and LOCAL_GRS parts of the value are copied to FP_SCR2
 | so that bfext can be used to extract the new low part of the mantissa.
 | Dnrm_lp can be called with a0 pointing to ETEMP or WBTEMP and there
 | is no LOCAL_GRS scratch word following it on the fsave frame.
 |
 	.global	dnrm_lp
 dnrm_lp:
 	movel	%d2,-(%sp)		|save d2 for temp use
 	btstb	#E3,E_BYTE(%a6)		|test for type E3 exception
 	beqs	not_E3			|not type E3 exception
 	bfextu	WBTEMP_GRS(%a6){#6:#3},%d2	|extract guard,round, sticky  bit
 	movel	#29,%d0
 	lsll	%d0,%d2			|shift g,r,s to their positions
 	movel	%d2,%d0
 not_E3:
 	movel	(%sp)+,%d2		|restore d2
 	movel	LOCAL_LO(%a0),FP_SCR2+LOCAL_LO(%a6)
 	movel	%d0,FP_SCR2+LOCAL_GRS(%a6)
 	movel	%d1,%d0			|copy the denorm threshold
 	subw	LOCAL_EX(%a0),%d1		|d1 = threshold - uns exponent
 	bles	no_lp			|d1 <= 0
 	cmpw	#32,%d1
 	blts	case_1			|0 = d1 < 32
 	cmpw	#64,%d1
 	blts	case_2			|32 <= d1 < 64
 	bra	case_3			|d1 >= 64
 |
 | No normalization necessary
 |
 no_lp:
 	clrb	%d1			|set no inex2 reported
 	movel	FP_SCR2+LOCAL_GRS(%a6),%d0	|restore original g,r,s
 	rts
 |
 | case (0<d1<32)
 |
 case_1:
 	movel	%d2,-(%sp)
 	movew	%d0,LOCAL_EX(%a0)		|exponent = denorm threshold
 	movel	#32,%d0
 	subw	%d1,%d0			|d0 = 32 - d1
 	bfextu	LOCAL_EX(%a0){%d0:#32},%d2
 	bfextu	%d2{%d1:%d0},%d2		|d2 = new LOCAL_HI
 	bfextu	LOCAL_HI(%a0){%d0:#32},%d1	|d1 = new LOCAL_LO
 	bfextu	FP_SCR2+LOCAL_LO(%a6){%d0:#32},%d0	|d0 = new G,R,S
 	movel	%d2,LOCAL_HI(%a0)		|store new LOCAL_HI
 	movel	%d1,LOCAL_LO(%a0)		|store new LOCAL_LO
 	clrb	%d1
 	bftst	%d0{#2:#30}
 	beqs	c1nstky
 	bsetl	#rnd_stky_bit,%d0
 	st	%d1
 c1nstky:
 	movel	FP_SCR2+LOCAL_GRS(%a6),%d2	|restore original g,r,s
 	andil	#0xe0000000,%d2		|clear all but G,R,S
 	tstl	%d2			|test if original G,R,S are clear
 	beqs	grs_clear
 	orl	#0x20000000,%d0		|set sticky bit in d0
 grs_clear:
 	andil	#0xe0000000,%d0		|clear all but G,R,S
 	movel	(%sp)+,%d2
 	rts
 |
 | case (32<=d1<64)
 |
 case_2:
 	movel	%d2,-(%sp)
 	movew	%d0,LOCAL_EX(%a0)		|unsigned exponent = threshold
 	subw	#32,%d1			|d1 now between 0 and 32
 	movel	#32,%d0
 	subw	%d1,%d0			|d0 = 32 - d1
 	bfextu	LOCAL_EX(%a0){%d0:#32},%d2
 	bfextu	%d2{%d1:%d0},%d2		|d2 = new LOCAL_LO
 	bfextu	LOCAL_HI(%a0){%d0:#32},%d1	|d1 = new G,R,S
 	bftst	%d1{#2:#30}
 	bnes	c2_sstky		|bra if sticky bit to be set
 	bftst	FP_SCR2+LOCAL_LO(%a6){%d0:#32}
 	bnes	c2_sstky		|bra if sticky bit to be set
 	movel	%d1,%d0
 	clrb	%d1
 	bras	end_c2
 c2_sstky:
 	movel	%d1,%d0
 	bsetl	#rnd_stky_bit,%d0
 	st	%d1
 end_c2:
 	clrl	LOCAL_HI(%a0)		|store LOCAL_HI = 0
 	movel	%d2,LOCAL_LO(%a0)		|store LOCAL_LO
 	movel	FP_SCR2+LOCAL_GRS(%a6),%d2	|restore original g,r,s
 	andil	#0xe0000000,%d2		|clear all but G,R,S
 	tstl	%d2			|test if original G,R,S are clear
 	beqs	clear_grs
 	orl	#0x20000000,%d0		|set sticky bit in d0
 clear_grs:
 	andil	#0xe0000000,%d0		|get rid of all but G,R,S
 	movel	(%sp)+,%d2
 	rts
 |
 | d1 >= 64 Force the exponent to be the denorm threshold with the
 | correct sign.
 |
 case_3:
 	movew	%d0,LOCAL_EX(%a0)
 	tstw	LOCAL_SGN(%a0)
 	bges	c3con
 c3neg:
 	orl	#0x80000000,LOCAL_EX(%a0)
 c3con:
 	cmpw	#64,%d1
 	beqs	sixty_four
 	cmpw	#65,%d1
 	beqs	sixty_five
 |
 | Shift value is out of range.  Set d1 for inex2 flag and
 | return a zero with the given threshold.
 |
 	clrl	LOCAL_HI(%a0)
 	clrl	LOCAL_LO(%a0)
 	movel	#0x20000000,%d0
 	st	%d1
 	rts

 sixty_four:
 	movel	LOCAL_HI(%a0),%d0
 	bfextu	%d0{#2:#30},%d1
 	andil	#0xc0000000,%d0
 	bras	c3com

 sixty_five:
 	movel	LOCAL_HI(%a0),%d0
 	bfextu	%d0{#1:#31},%d1
 	andil	#0x80000000,%d0
 	lsrl	#1,%d0			|shift high bit into R bit

 c3com:
 	tstl	%d1
 	bnes	c3ssticky
 	tstl	LOCAL_LO(%a0)
 	bnes	c3ssticky
 	tstb	FP_SCR2+LOCAL_GRS(%a6)
 	bnes	c3ssticky
 	clrb	%d1
 	bras	c3end

 c3ssticky:
 	bsetl	#rnd_stky_bit,%d0
 	st	%d1
 c3end:
 	clrl	LOCAL_HI(%a0)
 	clrl	LOCAL_LO(%a0)
 	rts

 	|end
	\|
	\| round.sa 3.4 7/29/91
	\|
	\| handle rounding and normalization tasks
	\|
	\|
	\|
	\| Copyright (C) Motorola, Inc. 1990
	\| All Rights Reserved
	\|
	\| THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF MOTOROLA
	\| The copyright notice above does not evidence any
	\| actual or intended publication of such source code.

	\|ROUND idnt 2,1 \| Motorola 040 Floating Point Software Package

	\|section 8

	#include "fpsp.h"

	\|
	\| round --- round result according to precision/mode
	\|
	\| a0 points to the input operand in the internal extended format
	\| d1(high word) contains rounding precision:
	\| ext = $0000xxxx
	\| sgl = $0001xxxx
	\| dbl = $0002xxxx
	\| d1(low word) contains rounding mode:
	\| RN = $xxxx0000
	\| RZ = $xxxx0001
	\| RM = $xxxx0010
	\| RP = $xxxx0011
	\| d0{31:29} contains the g,r,s bits (extended)
	\|
	\| On return the value pointed to by a0 is correctly rounded,
	\| a0 is preserved and the g-r-s bits in d0 are cleared.
	\| The result is not typed - the tag field is invalid. The
	\| result is still in the internal extended format.
	\|
	\| The INEX bit of USER_FPSR will be set if the rounded result was
	\| inexact (i.e. if any of the g-r-s bits were set).
	\|

	.global round
	round:
	\| If g=r=s=0 then result is exact and round is done, else set
	\| the inex flag in status reg and continue.
	\|
	bsrs ext_grs \|this subroutine looks at the
	\| :rounding precision and sets
	\| ;the appropriate g-r-s bits.
	tstl %d0 \|if grs are zero, go force
	bne rnd_cont \|lower bits to zero for size

	swap %d1 \|set up d1.w for round prec.
	bra truncate

	rnd_cont:
	\|
	\| Use rounding mode as an index into a jump table for these modes.
	\|
	orl #inx2a_mask,USER_FPSR(%a6) \|set inex2/ainex
	lea mode_tab,%a1
	movel (%a1,%d1.w*4),%a1
	jmp (%a1)
	\|
	\| Jump table indexed by rounding mode in d1.w. All following assumes
	\| grs != 0.
	\|
	mode_tab:
	.long rnd_near
	.long rnd_zero
	.long rnd_mnus
	.long rnd_plus
	\|
	\| ROUND PLUS INFINITY
	\|
	\| If sign of fp number = 0 (positive), then add 1 to l.
	\|
	rnd_plus:
	swap %d1 \|set up d1 for round prec.
	tstb LOCAL_SGN(%a0) \|check for sign
	bmi truncate \|if positive then truncate
	movel #0xffffffff,%d0 \|force g,r,s to be all f's
	lea add_to_l,%a1
	movel (%a1,%d1.w*4),%a1
	jmp (%a1)
	\|
	\| ROUND MINUS INFINITY
	\|
	\| If sign of fp number = 1 (negative), then add 1 to l.
	\|
	rnd_mnus:
	swap %d1 \|set up d1 for round prec.
	tstb LOCAL_SGN(%a0) \|check for sign
	bpl truncate \|if negative then truncate
	movel #0xffffffff,%d0 \|force g,r,s to be all f's
	lea add_to_l,%a1
	movel (%a1,%d1.w*4),%a1
	jmp (%a1)
	\|
	\| ROUND ZERO
	\|
	\| Always truncate.
	rnd_zero:
	swap %d1 \|set up d1 for round prec.
	bra truncate
	\|
	\|
	\| ROUND NEAREST
	\|
	\| If (g=1), then add 1 to l and if (r=s=0), then clear l
	\| Note that this will round to even in case of a tie.
	\|
	rnd_near:
	swap %d1 \|set up d1 for round prec.
	asll #1,%d0 \|shift g-bit to c-bit
	bcc truncate \|if (g=1) then
	lea add_to_l,%a1
	movel (%a1,%d1.w*4),%a1
	jmp (%a1)

	\|
	\| ext_grs --- extract guard, round and sticky bits
	\|
	\| Input: d1 = PREC:ROUND
	\| Output: d0{31:29}= guard, round, sticky
	\|
	\| The ext_grs extract the guard/round/sticky bits according to the
	\| selected rounding precision. It is called by the round subroutine
	\| only. All registers except d0 are kept intact. d0 becomes an
	\| updated guard,round,sticky in d0{31:29}
	\|
	\| Notes: the ext_grs uses the round PREC, and therefore has to swap d1
	\| prior to usage, and needs to restore d1 to original.
	\|
	ext_grs:
	swap %d1 \|have d1.w point to round precision
	cmpiw #0,%d1
	bnes sgl_or_dbl
	bras end_ext_grs

	sgl_or_dbl:
	moveml %d2/%d3,-(%a7) \|make some temp registers
	cmpiw #1,%d1
	bnes grs_dbl
	grs_sgl:
	bfextu LOCAL_HI(%a0){#24:#2},%d3 \|sgl prec. g-r are 2 bits right
	movel #30,%d2 \|of the sgl prec. limits
	lsll %d2,%d3 \|shift g-r bits to MSB of d3
	movel LOCAL_HI(%a0),%d2 \|get word 2 for s-bit test
	andil #0x0000003f,%d2 \|s bit is the or of all other
	bnes st_stky \|bits to the right of g-r
	tstl LOCAL_LO(%a0) \|test lower mantissa
	bnes st_stky \|if any are set, set sticky
	tstl %d0 \|test original g,r,s
	bnes st_stky \|if any are set, set sticky
	bras end_sd \|if words 3 and 4 are clr, exit
	grs_dbl:
	bfextu LOCAL_LO(%a0){#21:#2},%d3 \|dbl-prec. g-r are 2 bits right
	movel #30,%d2 \|of the dbl prec. limits
	lsll %d2,%d3 \|shift g-r bits to the MSB of d3
	movel LOCAL_LO(%a0),%d2 \|get lower mantissa for s-bit test
	andil #0x000001ff,%d2 \|s bit is the or-ing of all
	bnes st_stky \|other bits to the right of g-r
	tstl %d0 \|test word original g,r,s
	bnes st_stky \|if any are set, set sticky
	bras end_sd \|if clear, exit
	st_stky:
	bset #rnd_stky_bit,%d3
	end_sd:
	movel %d3,%d0 \|return grs to d0
	moveml (%a7)+,%d2/%d3 \|restore scratch registers
	end_ext_grs:
	swap %d1 \|restore d1 to original
	rts

	\|******************* Local Equates
	.set ad_1_sgl,0x00000100 \| constant to add 1 to l-bit in sgl prec
	.set ad_1_dbl,0x00000800 \| constant to add 1 to l-bit in dbl prec


	\|Jump table for adding 1 to the l-bit indexed by rnd prec

	add_to_l:
	.long add_ext
	.long add_sgl
	.long add_dbl
	.long add_dbl
	\|
	\| ADD SINGLE
	\|
	add_sgl:
	addl #ad_1_sgl,LOCAL_HI(%a0)
	bccs scc_clr \|no mantissa overflow
	roxrw LOCAL_HI(%a0) \|shift v-bit back in
	roxrw LOCAL_HI+2(%a0) \|shift v-bit back in
	addw #0x1,LOCAL_EX(%a0) \|and incr exponent
	scc_clr:
	tstl %d0 \|test for rs = 0
	bnes sgl_done
	andiw #0xfe00,LOCAL_HI+2(%a0) \|clear the l-bit
	sgl_done:
	andil #0xffffff00,LOCAL_HI(%a0) \|truncate bits beyond sgl limit
	clrl LOCAL_LO(%a0) \|clear d2
	rts

	\|
	\| ADD EXTENDED
	\|
	add_ext:
	addql #1,LOCAL_LO(%a0) \|add 1 to l-bit
	bccs xcc_clr \|test for carry out
	addql #1,LOCAL_HI(%a0) \|propagate carry
	bccs xcc_clr
	roxrw LOCAL_HI(%a0) \|mant is 0 so restore v-bit
	roxrw LOCAL_HI+2(%a0) \|mant is 0 so restore v-bit
	roxrw LOCAL_LO(%a0)
	roxrw LOCAL_LO+2(%a0)
	addw #0x1,LOCAL_EX(%a0) \|and inc exp
	xcc_clr:
	tstl %d0 \|test rs = 0
	bnes add_ext_done
	andib #0xfe,LOCAL_LO+3(%a0) \|clear the l bit
	add_ext_done:
	rts
	\|
	\| ADD DOUBLE
	\|
	add_dbl:
	addl #ad_1_dbl,LOCAL_LO(%a0)
	bccs dcc_clr
	addql #1,LOCAL_HI(%a0) \|propagate carry
	bccs dcc_clr
	roxrw LOCAL_HI(%a0) \|mant is 0 so restore v-bit
	roxrw LOCAL_HI+2(%a0) \|mant is 0 so restore v-bit
	roxrw LOCAL_LO(%a0)
	roxrw LOCAL_LO+2(%a0)
	addw #0x1,LOCAL_EX(%a0) \|incr exponent
	dcc_clr:
	tstl %d0 \|test for rs = 0
	bnes dbl_done
	andiw #0xf000,LOCAL_LO+2(%a0) \|clear the l-bit

	dbl_done:
	andil #0xfffff800,LOCAL_LO(%a0) \|truncate bits beyond dbl limit
	rts

	error:
	rts
	\|
	\| Truncate all other bits
	\|
	trunct:
	.long end_rnd
	.long sgl_done
	.long dbl_done
	.long dbl_done

	truncate:
	lea trunct,%a1
	movel (%a1,%d1.w*4),%a1
	jmp (%a1)

	end_rnd:
	rts

	\|
	\| NORMALIZE
	\|
	\| These routines (nrm_zero & nrm_set) normalize the unnorm. This
	\| is done by shifting the mantissa left while decrementing the
	\| exponent.
	\|
	\| NRM_SET shifts and decrements until there is a 1 set in the integer
	\| bit of the mantissa (msb in d1).
	\|
	\| NRM_ZERO shifts and decrements until there is a 1 set in the integer
	\| bit of the mantissa (msb in d1) unless this would mean the exponent
	\| would go less than 0. In that case the number becomes a denorm - the
	\| exponent (d0) is set to 0 and the mantissa (d1 & d2) is not
	\| normalized.
	\|
	\| Note that both routines have been optimized (for the worst case) and
	\| therefore do not have the easy to follow decrement/shift loop.
	\|
	\| NRM_ZERO
	\|
	\| Distance to first 1 bit in mantissa = X
	\| Distance to 0 from exponent = Y
	\| If X < Y
	\| Then
	\| nrm_set
	\| Else
	\| shift mantissa by Y
	\| set exponent = 0
	\|
	\|input:
	\| FP_SCR1 = exponent, ms mantissa part, ls mantissa part
	\|output:
	\| L_SCR1{4} = fpte15 or ete15 bit
	\|
	.global nrm_zero
	nrm_zero:
	movew LOCAL_EX(%a0),%d0
	cmpw #64,%d0 \|see if exp > 64
	bmis d0_less
	bsr nrm_set \|exp > 64 so exp won't exceed 0
	rts
	d0_less:
	moveml %d2/%d3/%d5/%d6,-(%a7)
	movel LOCAL_HI(%a0),%d1
	movel LOCAL_LO(%a0),%d2

	bfffo %d1{#0:#32},%d3 \|get the distance to the first 1
	\| ;in ms mant
	beqs ms_clr \|branch if no bits were set
	cmpw %d3,%d0 \|of X>Y
	bmis greater \|then exp will go past 0 (neg) if
	\| ;it is just shifted
	bsr nrm_set \|else exp won't go past 0
	moveml (%a7)+,%d2/%d3/%d5/%d6
	rts
	greater:
	movel %d2,%d6 \|save ls mant in d6
	lsll %d0,%d2 \|shift ls mant by count
	lsll %d0,%d1 \|shift ms mant by count
	movel #32,%d5
	subl %d0,%d5 \|make op a denorm by shifting bits
	lsrl %d5,%d6 \|by the number in the exp, then
	\| ;set exp = 0.
	orl %d6,%d1 \|shift the ls mant bits into the ms mant
	movel #0,%d0 \|same as if decremented exp to 0
	\| ;while shifting
	movew %d0,LOCAL_EX(%a0)
	movel %d1,LOCAL_HI(%a0)
	movel %d2,LOCAL_LO(%a0)
	moveml (%a7)+,%d2/%d3/%d5/%d6
	rts
	ms_clr:
	bfffo %d2{#0:#32},%d3 \|check if any bits set in ls mant
	beqs all_clr \|branch if none set
	addw #32,%d3
	cmpw %d3,%d0 \|if X>Y
	bmis greater \|then branch
	bsr nrm_set \|else exp won't go past 0
	moveml (%a7)+,%d2/%d3/%d5/%d6
	rts
	all_clr:
	movew #0,LOCAL_EX(%a0) \|no mantissa bits set. Set exp = 0.
	moveml (%a7)+,%d2/%d3/%d5/%d6
	rts
	\|
	\| NRM_SET
	\|
	.global nrm_set
	nrm_set:
	movel %d7,-(%a7)
	bfffo LOCAL_HI(%a0){#0:#32},%d7 \|find first 1 in ms mant to d7)
	beqs lower \|branch if ms mant is all 0's

	movel %d6,-(%a7)

	subw %d7,LOCAL_EX(%a0) \|sub exponent by count
	movel LOCAL_HI(%a0),%d0 \|d0 has ms mant
	movel LOCAL_LO(%a0),%d1 \|d1 has ls mant

	lsll %d7,%d0 \|shift first 1 to j bit position
	movel %d1,%d6 \|copy ls mant into d6
	lsll %d7,%d6 \|shift ls mant by count
	movel %d6,LOCAL_LO(%a0) \|store ls mant into memory
	moveql #32,%d6
	subl %d7,%d6 \|continue shift
	lsrl %d6,%d1 \|shift off all bits but those that will
	\| ;be shifted into ms mant
	orl %d1,%d0 \|shift the ls mant bits into the ms mant
	movel %d0,LOCAL_HI(%a0) \|store ms mant into memory
	moveml (%a7)+,%d7/%d6 \|restore registers
	rts

	\|
	\| We get here if ms mant was = 0, and we assume ls mant has bits
	\| set (otherwise this would have been tagged a zero not a denorm).
	\|
	lower:
	movew LOCAL_EX(%a0),%d0 \|d0 has exponent
	movel LOCAL_LO(%a0),%d1 \|d1 has ls mant
	subw #32,%d0 \|account for ms mant being all zeros
	bfffo %d1{#0:#32},%d7 \|find first 1 in ls mant to d7)
	subw %d7,%d0 \|subtract shift count from exp
	lsll %d7,%d1 \|shift first 1 to integer bit in ms mant
	movew %d0,LOCAL_EX(%a0) \|store ms mant
	movel %d1,LOCAL_HI(%a0) \|store exp
	clrl LOCAL_LO(%a0) \|clear ls mant
	movel (%a7)+,%d7
	rts
	\|
	\| denorm --- denormalize an intermediate result
	\|
	\| Used by underflow.
	\|
	\| Input:
	\| a0 points to the operand to be denormalized
	\| (in the internal extended format)
	\|
	\| d0: rounding precision
	\| Output:
	\| a0 points to the denormalized result
	\| (in the internal extended format)
	\|
	\| d0 is guard,round,sticky
	\|
	\| d0 comes into this routine with the rounding precision. It
	\| is then loaded with the denormalized exponent threshold for the
	\| rounding precision.
	\|

	.global denorm
	denorm:
	btstb #6,LOCAL_EX(%a0) \|check for exponents between $7fff-$4000
	beqs no_sgn_ext
	bsetb #7,LOCAL_EX(%a0) \|sign extend if it is so
	no_sgn_ext:

	cmpib #0,%d0 \|if 0 then extended precision
	bnes not_ext \|else branch

	clrl %d1 \|load d1 with ext threshold
	clrl %d0 \|clear the sticky flag
	bsr dnrm_lp \|denormalize the number
	tstb %d1 \|check for inex
	beq no_inex \|if clr, no inex
	bras dnrm_inex \|if set, set inex

	not_ext:
	cmpil #1,%d0 \|if 1 then single precision
	beqs load_sgl \|else must be 2, double prec

	load_dbl:
	movew #dbl_thresh,%d1 \|put copy of threshold in d1
	movel %d1,%d0 \|copy d1 into d0
	subw LOCAL_EX(%a0),%d0 \|diff = threshold - exp
	cmpw #67,%d0 \|if diff > 67 (mant + grs bits)
	bpls chk_stky \|then branch (all bits would be
	\| ; shifted off in denorm routine)
	clrl %d0 \|else clear the sticky flag
	bsr dnrm_lp \|denormalize the number
	tstb %d1 \|check flag
	beqs no_inex \|if clr, no inex
	bras dnrm_inex \|if set, set inex

	load_sgl:
	movew #sgl_thresh,%d1 \|put copy of threshold in d1
	movel %d1,%d0 \|copy d1 into d0
	subw LOCAL_EX(%a0),%d0 \|diff = threshold - exp
	cmpw #67,%d0 \|if diff > 67 (mant + grs bits)
	bpls chk_stky \|then branch (all bits would be
	\| ; shifted off in denorm routine)
	clrl %d0 \|else clear the sticky flag
	bsr dnrm_lp \|denormalize the number
	tstb %d1 \|check flag
	beqs no_inex \|if clr, no inex
	bras dnrm_inex \|if set, set inex

	chk_stky:
	tstl LOCAL_HI(%a0) \|check for any bits set
	bnes set_stky
	tstl LOCAL_LO(%a0) \|check for any bits set
	bnes set_stky
	bras clr_mant
	set_stky:
	orl #inx2a_mask,USER_FPSR(%a6) \|set inex2/ainex
	movel #0x20000000,%d0 \|set sticky bit in return value
	clr_mant:
	movew %d1,LOCAL_EX(%a0) \|load exp with threshold
	movel #0,LOCAL_HI(%a0) \|set d1 = 0 (ms mantissa)
	movel #0,LOCAL_LO(%a0) \|set d2 = 0 (ms mantissa)
	rts
	dnrm_inex:
	orl #inx2a_mask,USER_FPSR(%a6) \|set inex2/ainex
	no_inex:
	rts

	\|
	\| dnrm_lp --- normalize exponent/mantissa to specified threshold
	\|
	\| Input:
	\| a0 points to the operand to be denormalized
	\| d0{31:29} initial guard,round,sticky
	\| d1{15:0} denormalization threshold
	\| Output:
	\| a0 points to the denormalized operand
	\| d0{31:29} final guard,round,sticky
	\| d1.b inexact flag: all ones means inexact result
	\|
	\| The LOCAL_LO and LOCAL_GRS parts of the value are copied to FP_SCR2
	\| so that bfext can be used to extract the new low part of the mantissa.
	\| Dnrm_lp can be called with a0 pointing to ETEMP or WBTEMP and there
	\| is no LOCAL_GRS scratch word following it on the fsave frame.
	\|
	.global dnrm_lp
	dnrm_lp:
	movel %d2,-(%sp) \|save d2 for temp use
	btstb #E3,E_BYTE(%a6) \|test for type E3 exception
	beqs not_E3 \|not type E3 exception
	bfextu WBTEMP_GRS(%a6){#6:#3},%d2 \|extract guard,round, sticky bit
	movel #29,%d0
	lsll %d0,%d2 \|shift g,r,s to their positions
	movel %d2,%d0
	not_E3:
	movel (%sp)+,%d2 \|restore d2
	movel LOCAL_LO(%a0),FP_SCR2+LOCAL_LO(%a6)
	movel %d0,FP_SCR2+LOCAL_GRS(%a6)
	movel %d1,%d0 \|copy the denorm threshold
	subw LOCAL_EX(%a0),%d1 \|d1 = threshold - uns exponent
	bles no_lp \|d1 <= 0
	cmpw #32,%d1
	blts case_1 \|0 = d1 < 32
	cmpw #64,%d1
	blts case_2 \|32 <= d1 < 64
	bra case_3 \|d1 >= 64
	\|
	\| No normalization necessary
	\|
	no_lp:
	clrb %d1 \|set no inex2 reported
	movel FP_SCR2+LOCAL_GRS(%a6),%d0 \|restore original g,r,s
	rts
	\|
	\| case (0<d1<32)
	\|
	case_1:
	movel %d2,-(%sp)
	movew %d0,LOCAL_EX(%a0) \|exponent = denorm threshold
	movel #32,%d0
	subw %d1,%d0 \|d0 = 32 - d1
	bfextu LOCAL_EX(%a0){%d0:#32},%d2
	bfextu %d2{%d1:%d0},%d2 \|d2 = new LOCAL_HI
	bfextu LOCAL_HI(%a0){%d0:#32},%d1 \|d1 = new LOCAL_LO
	bfextu FP_SCR2+LOCAL_LO(%a6){%d0:#32},%d0 \|d0 = new G,R,S
	movel %d2,LOCAL_HI(%a0) \|store new LOCAL_HI
	movel %d1,LOCAL_LO(%a0) \|store new LOCAL_LO
	clrb %d1
	bftst %d0{#2:#30}
	beqs c1nstky
	bsetl #rnd_stky_bit,%d0
	st %d1
	c1nstky:
	movel FP_SCR2+LOCAL_GRS(%a6),%d2 \|restore original g,r,s
	andil #0xe0000000,%d2 \|clear all but G,R,S
	tstl %d2 \|test if original G,R,S are clear
	beqs grs_clear
	orl #0x20000000,%d0 \|set sticky bit in d0
	grs_clear:
	andil #0xe0000000,%d0 \|clear all but G,R,S
	movel (%sp)+,%d2
	rts
	\|
	\| case (32<=d1<64)
	\|
	case_2:
	movel %d2,-(%sp)
	movew %d0,LOCAL_EX(%a0) \|unsigned exponent = threshold
	subw #32,%d1 \|d1 now between 0 and 32
	movel #32,%d0
	subw %d1,%d0 \|d0 = 32 - d1
	bfextu LOCAL_EX(%a0){%d0:#32},%d2
	bfextu %d2{%d1:%d0},%d2 \|d2 = new LOCAL_LO
	bfextu LOCAL_HI(%a0){%d0:#32},%d1 \|d1 = new G,R,S
	bftst %d1{#2:#30}
	bnes c2_sstky \|bra if sticky bit to be set
	bftst FP_SCR2+LOCAL_LO(%a6){%d0:#32}
	bnes c2_sstky \|bra if sticky bit to be set
	movel %d1,%d0
	clrb %d1
	bras end_c2
	c2_sstky:
	movel %d1,%d0
	bsetl #rnd_stky_bit,%d0
	st %d1
	end_c2:
	clrl LOCAL_HI(%a0) \|store LOCAL_HI = 0
	movel %d2,LOCAL_LO(%a0) \|store LOCAL_LO
	movel FP_SCR2+LOCAL_GRS(%a6),%d2 \|restore original g,r,s
	andil #0xe0000000,%d2 \|clear all but G,R,S
	tstl %d2 \|test if original G,R,S are clear
	beqs clear_grs
	orl #0x20000000,%d0 \|set sticky bit in d0
	clear_grs:
	andil #0xe0000000,%d0 \|get rid of all but G,R,S
	movel (%sp)+,%d2
	rts
	\|
	\| d1 >= 64 Force the exponent to be the denorm threshold with the
	\| correct sign.
	\|
	case_3:
	movew %d0,LOCAL_EX(%a0)
	tstw LOCAL_SGN(%a0)
	bges c3con
	c3neg:
	orl #0x80000000,LOCAL_EX(%a0)
	c3con:
	cmpw #64,%d1
	beqs sixty_four
	cmpw #65,%d1
	beqs sixty_five
	\|
	\| Shift value is out of range. Set d1 for inex2 flag and
	\| return a zero with the given threshold.
	\|
	clrl LOCAL_HI(%a0)
	clrl LOCAL_LO(%a0)
	movel #0x20000000,%d0
	st %d1
	rts

	sixty_four:
	movel LOCAL_HI(%a0),%d0
	bfextu %d0{#2:#30},%d1
	andil #0xc0000000,%d0
	bras c3com

	sixty_five:
	movel LOCAL_HI(%a0),%d0
	bfextu %d0{#1:#31},%d1
	andil #0x80000000,%d0
	lsrl #1,%d0 \|shift high bit into R bit

	c3com:
	tstl %d1
	bnes c3ssticky
	tstl LOCAL_LO(%a0)
	bnes c3ssticky
	tstb FP_SCR2+LOCAL_GRS(%a6)
	bnes c3ssticky
	clrb %d1
	bras c3end

	c3ssticky:
	bsetl #rnd_stky_bit,%d0
	st %d1
	c3end:
	clrl LOCAL_HI(%a0)
	clrl LOCAL_LO(%a0)
	rts

	\|end