m68k: Implement ndelay() based on the existing udelay() logic
[linux-3.10.git] / arch / m68k / fpsp040 / round.S
1 |
2 |       round.sa 3.4 7/29/91
3 |
4 |       handle rounding and normalization tasks
5 |
6 |
7 |
8 |               Copyright (C) Motorola, Inc. 1990
9 |                       All Rights Reserved
10 |
11 |       For details on the license for this file, please see the
12 |       file, README, in this same directory.
13
14 |ROUND  idnt    2,1 | Motorola 040 Floating Point Software Package
15
16         |section        8
17
18 #include "fpsp.h"
19
20 |
21 |       round --- round result according to precision/mode
22 |
23 |       a0 points to the input operand in the internal extended format
24 |       d1(high word) contains rounding precision:
25 |               ext = $0000xxxx
26 |               sgl = $0001xxxx
27 |               dbl = $0002xxxx
28 |       d1(low word) contains rounding mode:
29 |               RN  = $xxxx0000
30 |               RZ  = $xxxx0001
31 |               RM  = $xxxx0010
32 |               RP  = $xxxx0011
33 |       d0{31:29} contains the g,r,s bits (extended)
34 |
35 |       On return the value pointed to by a0 is correctly rounded,
36 |       a0 is preserved and the g-r-s bits in d0 are cleared.
37 |       The result is not typed - the tag field is invalid.  The
38 |       result is still in the internal extended format.
39 |
40 |       The INEX bit of USER_FPSR will be set if the rounded result was
41 |       inexact (i.e. if any of the g-r-s bits were set).
42 |
43
44         .global round
45 round:
46 | If g=r=s=0 then result is exact and round is done, else set
47 | the inex flag in status reg and continue.
48 |
49         bsrs    ext_grs                 |this subroutine looks at the
50 |                                       :rounding precision and sets
51 |                                       ;the appropriate g-r-s bits.
52         tstl    %d0                     |if grs are zero, go force
53         bne     rnd_cont                |lower bits to zero for size
54
55         swap    %d1                     |set up d1.w for round prec.
56         bra     truncate
57
58 rnd_cont:
59 |
60 | Use rounding mode as an index into a jump table for these modes.
61 |
62         orl     #inx2a_mask,USER_FPSR(%a6) |set inex2/ainex
63         lea     mode_tab,%a1
64         movel   (%a1,%d1.w*4),%a1
65         jmp     (%a1)
66 |
67 | Jump table indexed by rounding mode in d1.w.  All following assumes
68 | grs != 0.
69 |
70 mode_tab:
71         .long   rnd_near
72         .long   rnd_zero
73         .long   rnd_mnus
74         .long   rnd_plus
75 |
76 |       ROUND PLUS INFINITY
77 |
78 |       If sign of fp number = 0 (positive), then add 1 to l.
79 |
80 rnd_plus:
81         swap    %d1                     |set up d1 for round prec.
82         tstb    LOCAL_SGN(%a0)          |check for sign
83         bmi     truncate                |if positive then truncate
84         movel   #0xffffffff,%d0         |force g,r,s to be all f's
85         lea     add_to_l,%a1
86         movel   (%a1,%d1.w*4),%a1
87         jmp     (%a1)
88 |
89 |       ROUND MINUS INFINITY
90 |
91 |       If sign of fp number = 1 (negative), then add 1 to l.
92 |
93 rnd_mnus:
94         swap    %d1                     |set up d1 for round prec.
95         tstb    LOCAL_SGN(%a0)          |check for sign
96         bpl     truncate                |if negative then truncate
97         movel   #0xffffffff,%d0         |force g,r,s to be all f's
98         lea     add_to_l,%a1
99         movel   (%a1,%d1.w*4),%a1
100         jmp     (%a1)
101 |
102 |       ROUND ZERO
103 |
104 |       Always truncate.
105 rnd_zero:
106         swap    %d1                     |set up d1 for round prec.
107         bra     truncate
108 |
109 |
110 |       ROUND NEAREST
111 |
112 |       If (g=1), then add 1 to l and if (r=s=0), then clear l
113 |       Note that this will round to even in case of a tie.
114 |
115 rnd_near:
116         swap    %d1                     |set up d1 for round prec.
117         asll    #1,%d0                  |shift g-bit to c-bit
118         bcc     truncate                |if (g=1) then
119         lea     add_to_l,%a1
120         movel   (%a1,%d1.w*4),%a1
121         jmp     (%a1)
122
123 |
124 |       ext_grs --- extract guard, round and sticky bits
125 |
126 | Input:        d1 =            PREC:ROUND
127 | Output:       d0{31:29}=      guard, round, sticky
128 |
129 | The ext_grs extract the guard/round/sticky bits according to the
130 | selected rounding precision. It is called by the round subroutine
131 | only.  All registers except d0 are kept intact. d0 becomes an
132 | updated guard,round,sticky in d0{31:29}
133 |
134 | Notes: the ext_grs uses the round PREC, and therefore has to swap d1
135 |        prior to usage, and needs to restore d1 to original.
136 |
137 ext_grs:
138         swap    %d1                     |have d1.w point to round precision
139         cmpiw   #0,%d1
140         bnes    sgl_or_dbl
141         bras    end_ext_grs
142
143 sgl_or_dbl:
144         moveml  %d2/%d3,-(%a7)          |make some temp registers
145         cmpiw   #1,%d1
146         bnes    grs_dbl
147 grs_sgl:
148         bfextu  LOCAL_HI(%a0){#24:#2},%d3       |sgl prec. g-r are 2 bits right
149         movel   #30,%d2                 |of the sgl prec. limits
150         lsll    %d2,%d3                 |shift g-r bits to MSB of d3
151         movel   LOCAL_HI(%a0),%d2               |get word 2 for s-bit test
152         andil   #0x0000003f,%d2         |s bit is the or of all other
153         bnes    st_stky                 |bits to the right of g-r
154         tstl    LOCAL_LO(%a0)           |test lower mantissa
155         bnes    st_stky                 |if any are set, set sticky
156         tstl    %d0                     |test original g,r,s
157         bnes    st_stky                 |if any are set, set sticky
158         bras    end_sd                  |if words 3 and 4 are clr, exit
159 grs_dbl:
160         bfextu  LOCAL_LO(%a0){#21:#2},%d3       |dbl-prec. g-r are 2 bits right
161         movel   #30,%d2                 |of the dbl prec. limits
162         lsll    %d2,%d3                 |shift g-r bits to the MSB of d3
163         movel   LOCAL_LO(%a0),%d2               |get lower mantissa  for s-bit test
164         andil   #0x000001ff,%d2         |s bit is the or-ing of all
165         bnes    st_stky                 |other bits to the right of g-r
166         tstl    %d0                     |test word original g,r,s
167         bnes    st_stky                 |if any are set, set sticky
168         bras    end_sd                  |if clear, exit
169 st_stky:
170         bset    #rnd_stky_bit,%d3
171 end_sd:
172         movel   %d3,%d0                 |return grs to d0
173         moveml  (%a7)+,%d2/%d3          |restore scratch registers
174 end_ext_grs:
175         swap    %d1                     |restore d1 to original
176         rts
177
178 |*******************  Local Equates
179         .set    ad_1_sgl,0x00000100     |  constant to add 1 to l-bit in sgl prec
180         .set    ad_1_dbl,0x00000800     |  constant to add 1 to l-bit in dbl prec
181
182
183 |Jump table for adding 1 to the l-bit indexed by rnd prec
184
185 add_to_l:
186         .long   add_ext
187         .long   add_sgl
188         .long   add_dbl
189         .long   add_dbl
190 |
191 |       ADD SINGLE
192 |
193 add_sgl:
194         addl    #ad_1_sgl,LOCAL_HI(%a0)
195         bccs    scc_clr                 |no mantissa overflow
196         roxrw  LOCAL_HI(%a0)            |shift v-bit back in
197         roxrw  LOCAL_HI+2(%a0)          |shift v-bit back in
198         addw    #0x1,LOCAL_EX(%a0)      |and incr exponent
199 scc_clr:
200         tstl    %d0                     |test for rs = 0
201         bnes    sgl_done
202         andiw  #0xfe00,LOCAL_HI+2(%a0)  |clear the l-bit
203 sgl_done:
204         andil   #0xffffff00,LOCAL_HI(%a0) |truncate bits beyond sgl limit
205         clrl    LOCAL_LO(%a0)           |clear d2
206         rts
207
208 |
209 |       ADD EXTENDED
210 |
211 add_ext:
212         addql  #1,LOCAL_LO(%a0)         |add 1 to l-bit
213         bccs    xcc_clr                 |test for carry out
214         addql  #1,LOCAL_HI(%a0)         |propagate carry
215         bccs    xcc_clr
216         roxrw  LOCAL_HI(%a0)            |mant is 0 so restore v-bit
217         roxrw  LOCAL_HI+2(%a0)          |mant is 0 so restore v-bit
218         roxrw   LOCAL_LO(%a0)
219         roxrw   LOCAL_LO+2(%a0)
220         addw    #0x1,LOCAL_EX(%a0)      |and inc exp
221 xcc_clr:
222         tstl    %d0                     |test rs = 0
223         bnes    add_ext_done
224         andib   #0xfe,LOCAL_LO+3(%a0)   |clear the l bit
225 add_ext_done:
226         rts
227 |
228 |       ADD DOUBLE
229 |
230 add_dbl:
231         addl    #ad_1_dbl,LOCAL_LO(%a0)
232         bccs    dcc_clr
233         addql   #1,LOCAL_HI(%a0)                |propagate carry
234         bccs    dcc_clr
235         roxrw   LOCAL_HI(%a0)           |mant is 0 so restore v-bit
236         roxrw   LOCAL_HI+2(%a0)         |mant is 0 so restore v-bit
237         roxrw   LOCAL_LO(%a0)
238         roxrw   LOCAL_LO+2(%a0)
239         addw    #0x1,LOCAL_EX(%a0)      |incr exponent
240 dcc_clr:
241         tstl    %d0                     |test for rs = 0
242         bnes    dbl_done
243         andiw   #0xf000,LOCAL_LO+2(%a0) |clear the l-bit
244
245 dbl_done:
246         andil   #0xfffff800,LOCAL_LO(%a0) |truncate bits beyond dbl limit
247         rts
248
249 error:
250         rts
251 |
252 | Truncate all other bits
253 |
254 trunct:
255         .long   end_rnd
256         .long   sgl_done
257         .long   dbl_done
258         .long   dbl_done
259
260 truncate:
261         lea     trunct,%a1
262         movel   (%a1,%d1.w*4),%a1
263         jmp     (%a1)
264
265 end_rnd:
266         rts
267
268 |
269 |       NORMALIZE
270 |
271 | These routines (nrm_zero & nrm_set) normalize the unnorm.  This
272 | is done by shifting the mantissa left while decrementing the
273 | exponent.
274 |
275 | NRM_SET shifts and decrements until there is a 1 set in the integer
276 | bit of the mantissa (msb in d1).
277 |
278 | NRM_ZERO shifts and decrements until there is a 1 set in the integer
279 | bit of the mantissa (msb in d1) unless this would mean the exponent
280 | would go less than 0.  In that case the number becomes a denorm - the
281 | exponent (d0) is set to 0 and the mantissa (d1 & d2) is not
282 | normalized.
283 |
284 | Note that both routines have been optimized (for the worst case) and
285 | therefore do not have the easy to follow decrement/shift loop.
286 |
287 |       NRM_ZERO
288 |
289 |       Distance to first 1 bit in mantissa = X
290 |       Distance to 0 from exponent = Y
291 |       If X < Y
292 |       Then
293 |         nrm_set
294 |       Else
295 |         shift mantissa by Y
296 |         set exponent = 0
297 |
298 |input:
299 |       FP_SCR1 = exponent, ms mantissa part, ls mantissa part
300 |output:
301 |       L_SCR1{4} = fpte15 or ete15 bit
302 |
303         .global nrm_zero
304 nrm_zero:
305         movew   LOCAL_EX(%a0),%d0
306         cmpw   #64,%d0          |see if exp > 64
307         bmis    d0_less
308         bsr     nrm_set         |exp > 64 so exp won't exceed 0
309         rts
310 d0_less:
311         moveml  %d2/%d3/%d5/%d6,-(%a7)
312         movel   LOCAL_HI(%a0),%d1
313         movel   LOCAL_LO(%a0),%d2
314
315         bfffo   %d1{#0:#32},%d3 |get the distance to the first 1
316 |                               ;in ms mant
317         beqs    ms_clr          |branch if no bits were set
318         cmpw    %d3,%d0         |of X>Y
319         bmis    greater         |then exp will go past 0 (neg) if
320 |                               ;it is just shifted
321         bsr     nrm_set         |else exp won't go past 0
322         moveml  (%a7)+,%d2/%d3/%d5/%d6
323         rts
324 greater:
325         movel   %d2,%d6         |save ls mant in d6
326         lsll    %d0,%d2         |shift ls mant by count
327         lsll    %d0,%d1         |shift ms mant by count
328         movel   #32,%d5
329         subl    %d0,%d5         |make op a denorm by shifting bits
330         lsrl    %d5,%d6         |by the number in the exp, then
331 |                               ;set exp = 0.
332         orl     %d6,%d1         |shift the ls mant bits into the ms mant
333         movel   #0,%d0          |same as if decremented exp to 0
334 |                               ;while shifting
335         movew   %d0,LOCAL_EX(%a0)
336         movel   %d1,LOCAL_HI(%a0)
337         movel   %d2,LOCAL_LO(%a0)
338         moveml  (%a7)+,%d2/%d3/%d5/%d6
339         rts
340 ms_clr:
341         bfffo   %d2{#0:#32},%d3 |check if any bits set in ls mant
342         beqs    all_clr         |branch if none set
343         addw    #32,%d3
344         cmpw    %d3,%d0         |if X>Y
345         bmis    greater         |then branch
346         bsr     nrm_set         |else exp won't go past 0
347         moveml  (%a7)+,%d2/%d3/%d5/%d6
348         rts
349 all_clr:
350         movew   #0,LOCAL_EX(%a0)        |no mantissa bits set. Set exp = 0.
351         moveml  (%a7)+,%d2/%d3/%d5/%d6
352         rts
353 |
354 |       NRM_SET
355 |
356         .global nrm_set
357 nrm_set:
358         movel   %d7,-(%a7)
359         bfffo   LOCAL_HI(%a0){#0:#32},%d7 |find first 1 in ms mant to d7)
360         beqs    lower           |branch if ms mant is all 0's
361
362         movel   %d6,-(%a7)
363
364         subw    %d7,LOCAL_EX(%a0)       |sub exponent by count
365         movel   LOCAL_HI(%a0),%d0       |d0 has ms mant
366         movel   LOCAL_LO(%a0),%d1 |d1 has ls mant
367
368         lsll    %d7,%d0         |shift first 1 to j bit position
369         movel   %d1,%d6         |copy ls mant into d6
370         lsll    %d7,%d6         |shift ls mant by count
371         movel   %d6,LOCAL_LO(%a0)       |store ls mant into memory
372         moveql  #32,%d6
373         subl    %d7,%d6         |continue shift
374         lsrl    %d6,%d1         |shift off all bits but those that will
375 |                               ;be shifted into ms mant
376         orl     %d1,%d0         |shift the ls mant bits into the ms mant
377         movel   %d0,LOCAL_HI(%a0)       |store ms mant into memory
378         moveml  (%a7)+,%d7/%d6  |restore registers
379         rts
380
381 |
382 | We get here if ms mant was = 0, and we assume ls mant has bits
383 | set (otherwise this would have been tagged a zero not a denorm).
384 |
385 lower:
386         movew   LOCAL_EX(%a0),%d0       |d0 has exponent
387         movel   LOCAL_LO(%a0),%d1       |d1 has ls mant
388         subw    #32,%d0         |account for ms mant being all zeros
389         bfffo   %d1{#0:#32},%d7 |find first 1 in ls mant to d7)
390         subw    %d7,%d0         |subtract shift count from exp
391         lsll    %d7,%d1         |shift first 1 to integer bit in ms mant
392         movew   %d0,LOCAL_EX(%a0)       |store ms mant
393         movel   %d1,LOCAL_HI(%a0)       |store exp
394         clrl    LOCAL_LO(%a0)   |clear ls mant
395         movel   (%a7)+,%d7
396         rts
397 |
398 |       denorm --- denormalize an intermediate result
399 |
400 |       Used by underflow.
401 |
402 | Input:
403 |       a0       points to the operand to be denormalized
404 |                (in the internal extended format)
405 |
406 |       d0:      rounding precision
407 | Output:
408 |       a0       points to the denormalized result
409 |                (in the internal extended format)
410 |
411 |       d0      is guard,round,sticky
412 |
413 | d0 comes into this routine with the rounding precision. It
414 | is then loaded with the denormalized exponent threshold for the
415 | rounding precision.
416 |
417
418         .global denorm
419 denorm:
420         btstb   #6,LOCAL_EX(%a0)        |check for exponents between $7fff-$4000
421         beqs    no_sgn_ext
422         bsetb   #7,LOCAL_EX(%a0)        |sign extend if it is so
423 no_sgn_ext:
424
425         cmpib   #0,%d0          |if 0 then extended precision
426         bnes    not_ext         |else branch
427
428         clrl    %d1             |load d1 with ext threshold
429         clrl    %d0             |clear the sticky flag
430         bsr     dnrm_lp         |denormalize the number
431         tstb    %d1             |check for inex
432         beq     no_inex         |if clr, no inex
433         bras    dnrm_inex       |if set, set inex
434
435 not_ext:
436         cmpil   #1,%d0          |if 1 then single precision
437         beqs    load_sgl        |else must be 2, double prec
438
439 load_dbl:
440         movew   #dbl_thresh,%d1 |put copy of threshold in d1
441         movel   %d1,%d0         |copy d1 into d0
442         subw    LOCAL_EX(%a0),%d0       |diff = threshold - exp
443         cmpw    #67,%d0         |if diff > 67 (mant + grs bits)
444         bpls    chk_stky        |then branch (all bits would be
445 |                               ; shifted off in denorm routine)
446         clrl    %d0             |else clear the sticky flag
447         bsr     dnrm_lp         |denormalize the number
448         tstb    %d1             |check flag
449         beqs    no_inex         |if clr, no inex
450         bras    dnrm_inex       |if set, set inex
451
452 load_sgl:
453         movew   #sgl_thresh,%d1 |put copy of threshold in d1
454         movel   %d1,%d0         |copy d1 into d0
455         subw    LOCAL_EX(%a0),%d0       |diff = threshold - exp
456         cmpw    #67,%d0         |if diff > 67 (mant + grs bits)
457         bpls    chk_stky        |then branch (all bits would be
458 |                               ; shifted off in denorm routine)
459         clrl    %d0             |else clear the sticky flag
460         bsr     dnrm_lp         |denormalize the number
461         tstb    %d1             |check flag
462         beqs    no_inex         |if clr, no inex
463         bras    dnrm_inex       |if set, set inex
464
465 chk_stky:
466         tstl    LOCAL_HI(%a0)   |check for any bits set
467         bnes    set_stky
468         tstl    LOCAL_LO(%a0)   |check for any bits set
469         bnes    set_stky
470         bras    clr_mant
471 set_stky:
472         orl     #inx2a_mask,USER_FPSR(%a6) |set inex2/ainex
473         movel   #0x20000000,%d0 |set sticky bit in return value
474 clr_mant:
475         movew   %d1,LOCAL_EX(%a0)               |load exp with threshold
476         movel   #0,LOCAL_HI(%a0)        |set d1 = 0 (ms mantissa)
477         movel   #0,LOCAL_LO(%a0)                |set d2 = 0 (ms mantissa)
478         rts
479 dnrm_inex:
480         orl     #inx2a_mask,USER_FPSR(%a6) |set inex2/ainex
481 no_inex:
482         rts
483
484 |
485 |       dnrm_lp --- normalize exponent/mantissa to specified threshold
486 |
487 | Input:
488 |       a0              points to the operand to be denormalized
489 |       d0{31:29}       initial guard,round,sticky
490 |       d1{15:0}        denormalization threshold
491 | Output:
492 |       a0              points to the denormalized operand
493 |       d0{31:29}       final guard,round,sticky
494 |       d1.b            inexact flag:  all ones means inexact result
495 |
496 | The LOCAL_LO and LOCAL_GRS parts of the value are copied to FP_SCR2
497 | so that bfext can be used to extract the new low part of the mantissa.
498 | Dnrm_lp can be called with a0 pointing to ETEMP or WBTEMP and there
499 | is no LOCAL_GRS scratch word following it on the fsave frame.
500 |
501         .global dnrm_lp
502 dnrm_lp:
503         movel   %d2,-(%sp)              |save d2 for temp use
504         btstb   #E3,E_BYTE(%a6)         |test for type E3 exception
505         beqs    not_E3                  |not type E3 exception
506         bfextu  WBTEMP_GRS(%a6){#6:#3},%d2      |extract guard,round, sticky  bit
507         movel   #29,%d0
508         lsll    %d0,%d2                 |shift g,r,s to their positions
509         movel   %d2,%d0
510 not_E3:
511         movel   (%sp)+,%d2              |restore d2
512         movel   LOCAL_LO(%a0),FP_SCR2+LOCAL_LO(%a6)
513         movel   %d0,FP_SCR2+LOCAL_GRS(%a6)
514         movel   %d1,%d0                 |copy the denorm threshold
515         subw    LOCAL_EX(%a0),%d1               |d1 = threshold - uns exponent
516         bles    no_lp                   |d1 <= 0
517         cmpw    #32,%d1
518         blts    case_1                  |0 = d1 < 32
519         cmpw    #64,%d1
520         blts    case_2                  |32 <= d1 < 64
521         bra     case_3                  |d1 >= 64
522 |
523 | No normalization necessary
524 |
525 no_lp:
526         clrb    %d1                     |set no inex2 reported
527         movel   FP_SCR2+LOCAL_GRS(%a6),%d0      |restore original g,r,s
528         rts
529 |
530 | case (0<d1<32)
531 |
532 case_1:
533         movel   %d2,-(%sp)
534         movew   %d0,LOCAL_EX(%a0)               |exponent = denorm threshold
535         movel   #32,%d0
536         subw    %d1,%d0                 |d0 = 32 - d1
537         bfextu  LOCAL_EX(%a0){%d0:#32},%d2
538         bfextu  %d2{%d1:%d0},%d2                |d2 = new LOCAL_HI
539         bfextu  LOCAL_HI(%a0){%d0:#32},%d1      |d1 = new LOCAL_LO
540         bfextu  FP_SCR2+LOCAL_LO(%a6){%d0:#32},%d0      |d0 = new G,R,S
541         movel   %d2,LOCAL_HI(%a0)               |store new LOCAL_HI
542         movel   %d1,LOCAL_LO(%a0)               |store new LOCAL_LO
543         clrb    %d1
544         bftst   %d0{#2:#30}
545         beqs    c1nstky
546         bsetl   #rnd_stky_bit,%d0
547         st      %d1
548 c1nstky:
549         movel   FP_SCR2+LOCAL_GRS(%a6),%d2      |restore original g,r,s
550         andil   #0xe0000000,%d2         |clear all but G,R,S
551         tstl    %d2                     |test if original G,R,S are clear
552         beqs    grs_clear
553         orl     #0x20000000,%d0         |set sticky bit in d0
554 grs_clear:
555         andil   #0xe0000000,%d0         |clear all but G,R,S
556         movel   (%sp)+,%d2
557         rts
558 |
559 | case (32<=d1<64)
560 |
561 case_2:
562         movel   %d2,-(%sp)
563         movew   %d0,LOCAL_EX(%a0)               |unsigned exponent = threshold
564         subw    #32,%d1                 |d1 now between 0 and 32
565         movel   #32,%d0
566         subw    %d1,%d0                 |d0 = 32 - d1
567         bfextu  LOCAL_EX(%a0){%d0:#32},%d2
568         bfextu  %d2{%d1:%d0},%d2                |d2 = new LOCAL_LO
569         bfextu  LOCAL_HI(%a0){%d0:#32},%d1      |d1 = new G,R,S
570         bftst   %d1{#2:#30}
571         bnes    c2_sstky                |bra if sticky bit to be set
572         bftst   FP_SCR2+LOCAL_LO(%a6){%d0:#32}
573         bnes    c2_sstky                |bra if sticky bit to be set
574         movel   %d1,%d0
575         clrb    %d1
576         bras    end_c2
577 c2_sstky:
578         movel   %d1,%d0
579         bsetl   #rnd_stky_bit,%d0
580         st      %d1
581 end_c2:
582         clrl    LOCAL_HI(%a0)           |store LOCAL_HI = 0
583         movel   %d2,LOCAL_LO(%a0)               |store LOCAL_LO
584         movel   FP_SCR2+LOCAL_GRS(%a6),%d2      |restore original g,r,s
585         andil   #0xe0000000,%d2         |clear all but G,R,S
586         tstl    %d2                     |test if original G,R,S are clear
587         beqs    clear_grs
588         orl     #0x20000000,%d0         |set sticky bit in d0
589 clear_grs:
590         andil   #0xe0000000,%d0         |get rid of all but G,R,S
591         movel   (%sp)+,%d2
592         rts
593 |
594 | d1 >= 64 Force the exponent to be the denorm threshold with the
595 | correct sign.
596 |
597 case_3:
598         movew   %d0,LOCAL_EX(%a0)
599         tstw    LOCAL_SGN(%a0)
600         bges    c3con
601 c3neg:
602         orl     #0x80000000,LOCAL_EX(%a0)
603 c3con:
604         cmpw    #64,%d1
605         beqs    sixty_four
606         cmpw    #65,%d1
607         beqs    sixty_five
608 |
609 | Shift value is out of range.  Set d1 for inex2 flag and
610 | return a zero with the given threshold.
611 |
612         clrl    LOCAL_HI(%a0)
613         clrl    LOCAL_LO(%a0)
614         movel   #0x20000000,%d0
615         st      %d1
616         rts
617
618 sixty_four:
619         movel   LOCAL_HI(%a0),%d0
620         bfextu  %d0{#2:#30},%d1
621         andil   #0xc0000000,%d0
622         bras    c3com
623
624 sixty_five:
625         movel   LOCAL_HI(%a0),%d0
626         bfextu  %d0{#1:#31},%d1
627         andil   #0x80000000,%d0
628         lsrl    #1,%d0                  |shift high bit into R bit
629
630 c3com:
631         tstl    %d1
632         bnes    c3ssticky
633         tstl    LOCAL_LO(%a0)
634         bnes    c3ssticky
635         tstb    FP_SCR2+LOCAL_GRS(%a6)
636         bnes    c3ssticky
637         clrb    %d1
638         bras    c3end
639
640 c3ssticky:
641         bsetl   #rnd_stky_bit,%d0
642         st      %d1
643 c3end:
644         clrl    LOCAL_HI(%a0)
645         clrl    LOCAL_LO(%a0)
646         rts
647
648         |end