Merge Btrfs into fs/btrfs
[linux-2.6] / arch / m68k / fpsp040 / res_func.S
1 |
2 |       res_func.sa 3.9 7/29/91
3 |
4 | Normalizes denormalized numbers if necessary and updates the
5 | stack frame.  The function is then restored back into the
6 | machine and the 040 completes the operation.  This routine
7 | is only used by the unsupported data type/format handler.
8 | (Exception vector 55).
9 |
10 | For packed move out (fmove.p fpm,<ea>) the operation is
11 | completed here; data is packed and moved to user memory.
12 | The stack is restored to the 040 only in the case of a
13 | reportable exception in the conversion.
14 |
15 |
16 |               Copyright (C) Motorola, Inc. 1990
17 |                       All Rights Reserved
18 |
19 |       For details on the license for this file, please see the
20 |       file, README, in this same directory.
21
22 RES_FUNC:    |idnt    2,1 | Motorola 040 Floating Point Software Package
23
24         |section        8
25
26 #include "fpsp.h"
27
28 sp_bnds:        .short  0x3f81,0x407e
29                 .short  0x3f6a,0x0000
30 dp_bnds:        .short  0x3c01,0x43fe
31                 .short  0x3bcd,0x0000
32
33         |xref   mem_write
34         |xref   bindec
35         |xref   get_fline
36         |xref   round
37         |xref   denorm
38         |xref   dest_ext
39         |xref   dest_dbl
40         |xref   dest_sgl
41         |xref   unf_sub
42         |xref   nrm_set
43         |xref   dnrm_lp
44         |xref   ovf_res
45         |xref   reg_dest
46         |xref   t_ovfl
47         |xref   t_unfl
48
49         .global res_func
50         .global p_move
51
52 res_func:
53         clrb    DNRM_FLG(%a6)
54         clrb    RES_FLG(%a6)
55         clrb    CU_ONLY(%a6)
56         tstb    DY_MO_FLG(%a6)
57         beqs    monadic
58 dyadic:
59         btstb   #7,DTAG(%a6)    |if dop = norm=000, zero=001,
60 |                               ;inf=010 or nan=011
61         beqs    monadic         |then branch
62 |                               ;else denorm
63 | HANDLE DESTINATION DENORM HERE
64 |                               ;set dtag to norm
65 |                               ;write the tag & fpte15 to the fstack
66         leal    FPTEMP(%a6),%a0
67
68         bclrb   #sign_bit,LOCAL_EX(%a0)
69         sne     LOCAL_SGN(%a0)
70
71         bsr     nrm_set         |normalize number (exp will go negative)
72         bclrb   #sign_bit,LOCAL_EX(%a0) |get rid of false sign
73         bfclr   LOCAL_SGN(%a0){#0:#8}   |change back to IEEE ext format
74         beqs    dpos
75         bsetb   #sign_bit,LOCAL_EX(%a0)
76 dpos:
77         bfclr   DTAG(%a6){#0:#4}        |set tag to normalized, FPTE15 = 0
78         bsetb   #4,DTAG(%a6)    |set FPTE15
79         orb     #0x0f,DNRM_FLG(%a6)
80 monadic:
81         leal    ETEMP(%a6),%a0
82         btstb   #direction_bit,CMDREG1B(%a6)    |check direction
83         bne     opclass3                        |it is a mv out
84 |
85 | At this point, only opclass 0 and 2 possible
86 |
87         btstb   #7,STAG(%a6)    |if sop = norm=000, zero=001,
88 |                               ;inf=010 or nan=011
89         bne     mon_dnrm        |else denorm
90         tstb    DY_MO_FLG(%a6)  |all cases of dyadic instructions would
91         bne     normal          |require normalization of denorm
92
93 | At this point:
94 |       monadic instructions:   fabs  = $18  fneg   = $1a  ftst   = $3a
95 |                               fmove = $00  fsmove = $40  fdmove = $44
96 |                               fsqrt = $05* fssqrt = $41  fdsqrt = $45
97 |                               (*fsqrt reencoded to $05)
98 |
99         movew   CMDREG1B(%a6),%d0       |get command register
100         andil   #0x7f,%d0                       |strip to only command word
101 |
102 | At this point, fabs, fneg, fsmove, fdmove, ftst, fsqrt, fssqrt, and
103 | fdsqrt are possible.
104 | For cases fabs, fneg, fsmove, and fdmove goto spos (do not normalize)
105 | For cases fsqrt, fssqrt, and fdsqrt goto nrm_src (do normalize)
106 |
107         btstl   #0,%d0
108         bne     normal                  |weed out fsqrt instructions
109 |
110 | cu_norm handles fmove in instructions with normalized inputs.
111 | The routine round is used to correctly round the input for the
112 | destination precision and mode.
113 |
114 cu_norm:
115         st      CU_ONLY(%a6)            |set cu-only inst flag
116         movew   CMDREG1B(%a6),%d0
117         andib   #0x3b,%d0               |isolate bits to select inst
118         tstb    %d0
119         beql    cu_nmove        |if zero, it is an fmove
120         cmpib   #0x18,%d0
121         beql    cu_nabs         |if $18, it is fabs
122         cmpib   #0x1a,%d0
123         beql    cu_nneg         |if $1a, it is fneg
124 |
125 | Inst is ftst.  Check the source operand and set the cc's accordingly.
126 | No write is done, so simply rts.
127 |
128 cu_ntst:
129         movew   LOCAL_EX(%a0),%d0
130         bclrl   #15,%d0
131         sne     LOCAL_SGN(%a0)
132         beqs    cu_ntpo
133         orl     #neg_mask,USER_FPSR(%a6) |set N
134 cu_ntpo:
135         cmpiw   #0x7fff,%d0     |test for inf/nan
136         bnes    cu_ntcz
137         tstl    LOCAL_HI(%a0)
138         bnes    cu_ntn
139         tstl    LOCAL_LO(%a0)
140         bnes    cu_ntn
141         orl     #inf_mask,USER_FPSR(%a6)
142         rts
143 cu_ntn:
144         orl     #nan_mask,USER_FPSR(%a6)
145         movel   ETEMP_EX(%a6),FPTEMP_EX(%a6)    |set up fptemp sign for
146 |                                               ;snan handler
147
148         rts
149 cu_ntcz:
150         tstl    LOCAL_HI(%a0)
151         bnel    cu_ntsx
152         tstl    LOCAL_LO(%a0)
153         bnel    cu_ntsx
154         orl     #z_mask,USER_FPSR(%a6)
155 cu_ntsx:
156         rts
157 |
158 | Inst is fabs.  Execute the absolute value function on the input.
159 | Branch to the fmove code.  If the operand is NaN, do nothing.
160 |
161 cu_nabs:
162         moveb   STAG(%a6),%d0
163         btstl   #5,%d0                  |test for NaN or zero
164         bne     wr_etemp                |if either, simply write it
165         bclrb   #7,LOCAL_EX(%a0)                |do abs
166         bras    cu_nmove                |fmove code will finish
167 |
168 | Inst is fneg.  Execute the negate value function on the input.
169 | Fall though to the fmove code.  If the operand is NaN, do nothing.
170 |
171 cu_nneg:
172         moveb   STAG(%a6),%d0
173         btstl   #5,%d0                  |test for NaN or zero
174         bne     wr_etemp                |if either, simply write it
175         bchgb   #7,LOCAL_EX(%a0)                |do neg
176 |
177 | Inst is fmove.  This code also handles all result writes.
178 | If bit 2 is set, round is forced to double.  If it is clear,
179 | and bit 6 is set, round is forced to single.  If both are clear,
180 | the round precision is found in the fpcr.  If the rounding precision
181 | is double or single, round the result before the write.
182 |
183 cu_nmove:
184         moveb   STAG(%a6),%d0
185         andib   #0xe0,%d0                       |isolate stag bits
186         bne     wr_etemp                |if not norm, simply write it
187         btstb   #2,CMDREG1B+1(%a6)      |check for rd
188         bne     cu_nmrd
189         btstb   #6,CMDREG1B+1(%a6)      |check for rs
190         bne     cu_nmrs
191 |
192 | The move or operation is not with forced precision.  Test for
193 | nan or inf as the input; if so, simply write it to FPn.  Use the
194 | FPCR_MODE byte to get rounding on norms and zeros.
195 |
196 cu_nmnr:
197         bfextu  FPCR_MODE(%a6){#0:#2},%d0
198         tstb    %d0                     |check for extended
199         beq     cu_wrexn                |if so, just write result
200         cmpib   #1,%d0                  |check for single
201         beq     cu_nmrs                 |fall through to double
202 |
203 | The move is fdmove or round precision is double.
204 |
205 cu_nmrd:
206         movel   #2,%d0                  |set up the size for denorm
207         movew   LOCAL_EX(%a0),%d1               |compare exponent to double threshold
208         andw    #0x7fff,%d1
209         cmpw    #0x3c01,%d1
210         bls     cu_nunfl
211         bfextu  FPCR_MODE(%a6){#2:#2},%d1       |get rmode
212         orl     #0x00020000,%d1         |or in rprec (double)
213         clrl    %d0                     |clear g,r,s for round
214         bclrb   #sign_bit,LOCAL_EX(%a0) |convert to internal format
215         sne     LOCAL_SGN(%a0)
216         bsrl    round
217         bfclr   LOCAL_SGN(%a0){#0:#8}
218         beqs    cu_nmrdc
219         bsetb   #sign_bit,LOCAL_EX(%a0)
220 cu_nmrdc:
221         movew   LOCAL_EX(%a0),%d1               |check for overflow
222         andw    #0x7fff,%d1
223         cmpw    #0x43ff,%d1
224         bge     cu_novfl                |take care of overflow case
225         bra     cu_wrexn
226 |
227 | The move is fsmove or round precision is single.
228 |
229 cu_nmrs:
230         movel   #1,%d0
231         movew   LOCAL_EX(%a0),%d1
232         andw    #0x7fff,%d1
233         cmpw    #0x3f81,%d1
234         bls     cu_nunfl
235         bfextu  FPCR_MODE(%a6){#2:#2},%d1
236         orl     #0x00010000,%d1
237         clrl    %d0
238         bclrb   #sign_bit,LOCAL_EX(%a0)
239         sne     LOCAL_SGN(%a0)
240         bsrl    round
241         bfclr   LOCAL_SGN(%a0){#0:#8}
242         beqs    cu_nmrsc
243         bsetb   #sign_bit,LOCAL_EX(%a0)
244 cu_nmrsc:
245         movew   LOCAL_EX(%a0),%d1
246         andw    #0x7FFF,%d1
247         cmpw    #0x407f,%d1
248         blt     cu_wrexn
249 |
250 | The operand is above precision boundaries.  Use t_ovfl to
251 | generate the correct value.
252 |
253 cu_novfl:
254         bsr     t_ovfl
255         bra     cu_wrexn
256 |
257 | The operand is below precision boundaries.  Use denorm to
258 | generate the correct value.
259 |
260 cu_nunfl:
261         bclrb   #sign_bit,LOCAL_EX(%a0)
262         sne     LOCAL_SGN(%a0)
263         bsr     denorm
264         bfclr   LOCAL_SGN(%a0){#0:#8}   |change back to IEEE ext format
265         beqs    cu_nucont
266         bsetb   #sign_bit,LOCAL_EX(%a0)
267 cu_nucont:
268         bfextu  FPCR_MODE(%a6){#2:#2},%d1
269         btstb   #2,CMDREG1B+1(%a6)      |check for rd
270         bne     inst_d
271         btstb   #6,CMDREG1B+1(%a6)      |check for rs
272         bne     inst_s
273         swap    %d1
274         moveb   FPCR_MODE(%a6),%d1
275         lsrb    #6,%d1
276         swap    %d1
277         bra     inst_sd
278 inst_d:
279         orl     #0x00020000,%d1
280         bra     inst_sd
281 inst_s:
282         orl     #0x00010000,%d1
283 inst_sd:
284         bclrb   #sign_bit,LOCAL_EX(%a0)
285         sne     LOCAL_SGN(%a0)
286         bsrl    round
287         bfclr   LOCAL_SGN(%a0){#0:#8}
288         beqs    cu_nuflp
289         bsetb   #sign_bit,LOCAL_EX(%a0)
290 cu_nuflp:
291         btstb   #inex2_bit,FPSR_EXCEPT(%a6)
292         beqs    cu_nuninx
293         orl     #aunfl_mask,USER_FPSR(%a6) |if the round was inex, set AUNFL
294 cu_nuninx:
295         tstl    LOCAL_HI(%a0)           |test for zero
296         bnes    cu_nunzro
297         tstl    LOCAL_LO(%a0)
298         bnes    cu_nunzro
299 |
300 | The mantissa is zero from the denorm loop.  Check sign and rmode
301 | to see if rounding should have occurred which would leave the lsb.
302 |
303         movel   USER_FPCR(%a6),%d0
304         andil   #0x30,%d0               |isolate rmode
305         cmpil   #0x20,%d0
306         blts    cu_nzro
307         bnes    cu_nrp
308 cu_nrm:
309         tstw    LOCAL_EX(%a0)   |if positive, set lsb
310         bges    cu_nzro
311         btstb   #7,FPCR_MODE(%a6) |check for double
312         beqs    cu_nincs
313         bras    cu_nincd
314 cu_nrp:
315         tstw    LOCAL_EX(%a0)   |if positive, set lsb
316         blts    cu_nzro
317         btstb   #7,FPCR_MODE(%a6) |check for double
318         beqs    cu_nincs
319 cu_nincd:
320         orl     #0x800,LOCAL_LO(%a0) |inc for double
321         bra     cu_nunzro
322 cu_nincs:
323         orl     #0x100,LOCAL_HI(%a0) |inc for single
324         bra     cu_nunzro
325 cu_nzro:
326         orl     #z_mask,USER_FPSR(%a6)
327         moveb   STAG(%a6),%d0
328         andib   #0xe0,%d0
329         cmpib   #0x40,%d0               |check if input was tagged zero
330         beqs    cu_numv
331 cu_nunzro:
332         orl     #unfl_mask,USER_FPSR(%a6) |set unfl
333 cu_numv:
334         movel   (%a0),ETEMP(%a6)
335         movel   4(%a0),ETEMP_HI(%a6)
336         movel   8(%a0),ETEMP_LO(%a6)
337 |
338 | Write the result to memory, setting the fpsr cc bits.  NaN and Inf
339 | bypass cu_wrexn.
340 |
341 cu_wrexn:
342         tstw    LOCAL_EX(%a0)           |test for zero
343         beqs    cu_wrzero
344         cmpw    #0x8000,LOCAL_EX(%a0)   |test for zero
345         bnes    cu_wreon
346 cu_wrzero:
347         orl     #z_mask,USER_FPSR(%a6)  |set Z bit
348 cu_wreon:
349         tstw    LOCAL_EX(%a0)
350         bpl     wr_etemp
351         orl     #neg_mask,USER_FPSR(%a6)
352         bra     wr_etemp
353
354 |
355 | HANDLE SOURCE DENORM HERE
356 |
357 |                               ;clear denorm stag to norm
358 |                               ;write the new tag & ete15 to the fstack
359 mon_dnrm:
360 |
361 | At this point, check for the cases in which normalizing the
362 | denorm produces incorrect results.
363 |
364         tstb    DY_MO_FLG(%a6)  |all cases of dyadic instructions would
365         bnes    nrm_src         |require normalization of denorm
366
367 | At this point:
368 |       monadic instructions:   fabs  = $18  fneg   = $1a  ftst   = $3a
369 |                               fmove = $00  fsmove = $40  fdmove = $44
370 |                               fsqrt = $05* fssqrt = $41  fdsqrt = $45
371 |                               (*fsqrt reencoded to $05)
372 |
373         movew   CMDREG1B(%a6),%d0       |get command register
374         andil   #0x7f,%d0                       |strip to only command word
375 |
376 | At this point, fabs, fneg, fsmove, fdmove, ftst, fsqrt, fssqrt, and
377 | fdsqrt are possible.
378 | For cases fabs, fneg, fsmove, and fdmove goto spos (do not normalize)
379 | For cases fsqrt, fssqrt, and fdsqrt goto nrm_src (do normalize)
380 |
381         btstl   #0,%d0
382         bnes    nrm_src         |weed out fsqrt instructions
383         st      CU_ONLY(%a6)    |set cu-only inst flag
384         bra     cu_dnrm         |fmove, fabs, fneg, ftst
385 |                               ;cases go to cu_dnrm
386 nrm_src:
387         bclrb   #sign_bit,LOCAL_EX(%a0)
388         sne     LOCAL_SGN(%a0)
389         bsr     nrm_set         |normalize number (exponent will go
390 |                               ; negative)
391         bclrb   #sign_bit,LOCAL_EX(%a0) |get rid of false sign
392
393         bfclr   LOCAL_SGN(%a0){#0:#8}   |change back to IEEE ext format
394         beqs    spos
395         bsetb   #sign_bit,LOCAL_EX(%a0)
396 spos:
397         bfclr   STAG(%a6){#0:#4}        |set tag to normalized, FPTE15 = 0
398         bsetb   #4,STAG(%a6)    |set ETE15
399         orb     #0xf0,DNRM_FLG(%a6)
400 normal:
401         tstb    DNRM_FLG(%a6)   |check if any of the ops were denorms
402         bne     ck_wrap         |if so, check if it is a potential
403 |                               ;wrap-around case
404 fix_stk:
405         moveb   #0xfe,CU_SAVEPC(%a6)
406         bclrb   #E1,E_BYTE(%a6)
407
408         clrw    NMNEXC(%a6)
409
410         st      RES_FLG(%a6)    |indicate that a restore is needed
411         rts
412
413 |
414 | cu_dnrm handles all cu-only instructions (fmove, fabs, fneg, and
415 | ftst) completely in software without an frestore to the 040.
416 |
417 cu_dnrm:
418         st      CU_ONLY(%a6)
419         movew   CMDREG1B(%a6),%d0
420         andib   #0x3b,%d0               |isolate bits to select inst
421         tstb    %d0
422         beql    cu_dmove        |if zero, it is an fmove
423         cmpib   #0x18,%d0
424         beql    cu_dabs         |if $18, it is fabs
425         cmpib   #0x1a,%d0
426         beql    cu_dneg         |if $1a, it is fneg
427 |
428 | Inst is ftst.  Check the source operand and set the cc's accordingly.
429 | No write is done, so simply rts.
430 |
431 cu_dtst:
432         movew   LOCAL_EX(%a0),%d0
433         bclrl   #15,%d0
434         sne     LOCAL_SGN(%a0)
435         beqs    cu_dtpo
436         orl     #neg_mask,USER_FPSR(%a6) |set N
437 cu_dtpo:
438         cmpiw   #0x7fff,%d0     |test for inf/nan
439         bnes    cu_dtcz
440         tstl    LOCAL_HI(%a0)
441         bnes    cu_dtn
442         tstl    LOCAL_LO(%a0)
443         bnes    cu_dtn
444         orl     #inf_mask,USER_FPSR(%a6)
445         rts
446 cu_dtn:
447         orl     #nan_mask,USER_FPSR(%a6)
448         movel   ETEMP_EX(%a6),FPTEMP_EX(%a6)    |set up fptemp sign for
449 |                                               ;snan handler
450         rts
451 cu_dtcz:
452         tstl    LOCAL_HI(%a0)
453         bnel    cu_dtsx
454         tstl    LOCAL_LO(%a0)
455         bnel    cu_dtsx
456         orl     #z_mask,USER_FPSR(%a6)
457 cu_dtsx:
458         rts
459 |
460 | Inst is fabs.  Execute the absolute value function on the input.
461 | Branch to the fmove code.
462 |
463 cu_dabs:
464         bclrb   #7,LOCAL_EX(%a0)                |do abs
465         bras    cu_dmove                |fmove code will finish
466 |
467 | Inst is fneg.  Execute the negate value function on the input.
468 | Fall though to the fmove code.
469 |
470 cu_dneg:
471         bchgb   #7,LOCAL_EX(%a0)                |do neg
472 |
473 | Inst is fmove.  This code also handles all result writes.
474 | If bit 2 is set, round is forced to double.  If it is clear,
475 | and bit 6 is set, round is forced to single.  If both are clear,
476 | the round precision is found in the fpcr.  If the rounding precision
477 | is double or single, the result is zero, and the mode is checked
478 | to determine if the lsb of the result should be set.
479 |
480 cu_dmove:
481         btstb   #2,CMDREG1B+1(%a6)      |check for rd
482         bne     cu_dmrd
483         btstb   #6,CMDREG1B+1(%a6)      |check for rs
484         bne     cu_dmrs
485 |
486 | The move or operation is not with forced precision.  Use the
487 | FPCR_MODE byte to get rounding.
488 |
489 cu_dmnr:
490         bfextu  FPCR_MODE(%a6){#0:#2},%d0
491         tstb    %d0                     |check for extended
492         beq     cu_wrexd                |if so, just write result
493         cmpib   #1,%d0                  |check for single
494         beq     cu_dmrs                 |fall through to double
495 |
496 | The move is fdmove or round precision is double.  Result is zero.
497 | Check rmode for rp or rm and set lsb accordingly.
498 |
499 cu_dmrd:
500         bfextu  FPCR_MODE(%a6){#2:#2},%d1       |get rmode
501         tstw    LOCAL_EX(%a0)           |check sign
502         blts    cu_dmdn
503         cmpib   #3,%d1                  |check for rp
504         bne     cu_dpd                  |load double pos zero
505         bra     cu_dpdr                 |load double pos zero w/lsb
506 cu_dmdn:
507         cmpib   #2,%d1                  |check for rm
508         bne     cu_dnd                  |load double neg zero
509         bra     cu_dndr                 |load double neg zero w/lsb
510 |
511 | The move is fsmove or round precision is single.  Result is zero.
512 | Check for rp or rm and set lsb accordingly.
513 |
514 cu_dmrs:
515         bfextu  FPCR_MODE(%a6){#2:#2},%d1       |get rmode
516         tstw    LOCAL_EX(%a0)           |check sign
517         blts    cu_dmsn
518         cmpib   #3,%d1                  |check for rp
519         bne     cu_spd                  |load single pos zero
520         bra     cu_spdr                 |load single pos zero w/lsb
521 cu_dmsn:
522         cmpib   #2,%d1                  |check for rm
523         bne     cu_snd                  |load single neg zero
524         bra     cu_sndr                 |load single neg zero w/lsb
525 |
526 | The precision is extended, so the result in etemp is correct.
527 | Simply set unfl (not inex2 or aunfl) and write the result to
528 | the correct fp register.
529 cu_wrexd:
530         orl     #unfl_mask,USER_FPSR(%a6)
531         tstw    LOCAL_EX(%a0)
532         beq     wr_etemp
533         orl     #neg_mask,USER_FPSR(%a6)
534         bra     wr_etemp
535 |
536 | These routines write +/- zero in double format.  The routines
537 | cu_dpdr and cu_dndr set the double lsb.
538 |
539 cu_dpd:
540         movel   #0x3c010000,LOCAL_EX(%a0)       |force pos double zero
541         clrl    LOCAL_HI(%a0)
542         clrl    LOCAL_LO(%a0)
543         orl     #z_mask,USER_FPSR(%a6)
544         orl     #unfinx_mask,USER_FPSR(%a6)
545         bra     wr_etemp
546 cu_dpdr:
547         movel   #0x3c010000,LOCAL_EX(%a0)       |force pos double zero
548         clrl    LOCAL_HI(%a0)
549         movel   #0x800,LOCAL_LO(%a0)    |with lsb set
550         orl     #unfinx_mask,USER_FPSR(%a6)
551         bra     wr_etemp
552 cu_dnd:
553         movel   #0xbc010000,LOCAL_EX(%a0)       |force pos double zero
554         clrl    LOCAL_HI(%a0)
555         clrl    LOCAL_LO(%a0)
556         orl     #z_mask,USER_FPSR(%a6)
557         orl     #neg_mask,USER_FPSR(%a6)
558         orl     #unfinx_mask,USER_FPSR(%a6)
559         bra     wr_etemp
560 cu_dndr:
561         movel   #0xbc010000,LOCAL_EX(%a0)       |force pos double zero
562         clrl    LOCAL_HI(%a0)
563         movel   #0x800,LOCAL_LO(%a0)    |with lsb set
564         orl     #neg_mask,USER_FPSR(%a6)
565         orl     #unfinx_mask,USER_FPSR(%a6)
566         bra     wr_etemp
567 |
568 | These routines write +/- zero in single format.  The routines
569 | cu_dpdr and cu_dndr set the single lsb.
570 |
571 cu_spd:
572         movel   #0x3f810000,LOCAL_EX(%a0)       |force pos single zero
573         clrl    LOCAL_HI(%a0)
574         clrl    LOCAL_LO(%a0)
575         orl     #z_mask,USER_FPSR(%a6)
576         orl     #unfinx_mask,USER_FPSR(%a6)
577         bra     wr_etemp
578 cu_spdr:
579         movel   #0x3f810000,LOCAL_EX(%a0)       |force pos single zero
580         movel   #0x100,LOCAL_HI(%a0)    |with lsb set
581         clrl    LOCAL_LO(%a0)
582         orl     #unfinx_mask,USER_FPSR(%a6)
583         bra     wr_etemp
584 cu_snd:
585         movel   #0xbf810000,LOCAL_EX(%a0)       |force pos single zero
586         clrl    LOCAL_HI(%a0)
587         clrl    LOCAL_LO(%a0)
588         orl     #z_mask,USER_FPSR(%a6)
589         orl     #neg_mask,USER_FPSR(%a6)
590         orl     #unfinx_mask,USER_FPSR(%a6)
591         bra     wr_etemp
592 cu_sndr:
593         movel   #0xbf810000,LOCAL_EX(%a0)       |force pos single zero
594         movel   #0x100,LOCAL_HI(%a0)    |with lsb set
595         clrl    LOCAL_LO(%a0)
596         orl     #neg_mask,USER_FPSR(%a6)
597         orl     #unfinx_mask,USER_FPSR(%a6)
598         bra     wr_etemp
599
600 |
601 | This code checks for 16-bit overflow conditions on dyadic
602 | operations which are not restorable into the floating-point
603 | unit and must be completed in software.  Basically, this
604 | condition exists with a very large norm and a denorm.  One
605 | of the operands must be denormalized to enter this code.
606 |
607 | Flags used:
608 |       DY_MO_FLG contains 0 for monadic op, $ff for dyadic
609 |       DNRM_FLG contains $00 for neither op denormalized
610 |                         $0f for the destination op denormalized
611 |                         $f0 for the source op denormalized
612 |                         $ff for both ops denormalized
613 |
614 | The wrap-around condition occurs for add, sub, div, and cmp
615 | when
616 |
617 |       abs(dest_exp - src_exp) >= $8000
618 |
619 | and for mul when
620 |
621 |       (dest_exp + src_exp) < $0
622 |
623 | we must process the operation here if this case is true.
624 |
625 | The rts following the frcfpn routine is the exit from res_func
626 | for this condition.  The restore flag (RES_FLG) is left clear.
627 | No frestore is done unless an exception is to be reported.
628 |
629 | For fadd:
630 |       if(sign_of(dest) != sign_of(src))
631 |               replace exponent of src with $3fff (keep sign)
632 |               use fpu to perform dest+new_src (user's rmode and X)
633 |               clr sticky
634 |       else
635 |               set sticky
636 |       call round with user's precision and mode
637 |       move result to fpn and wbtemp
638 |
639 | For fsub:
640 |       if(sign_of(dest) == sign_of(src))
641 |               replace exponent of src with $3fff (keep sign)
642 |               use fpu to perform dest+new_src (user's rmode and X)
643 |               clr sticky
644 |       else
645 |               set sticky
646 |       call round with user's precision and mode
647 |       move result to fpn and wbtemp
648 |
649 | For fdiv/fsgldiv:
650 |       if(both operands are denorm)
651 |               restore_to_fpu;
652 |       if(dest is norm)
653 |               force_ovf;
654 |       else(dest is denorm)
655 |               force_unf:
656 |
657 | For fcmp:
658 |       if(dest is norm)
659 |               N = sign_of(dest);
660 |       else(dest is denorm)
661 |               N = sign_of(src);
662 |
663 | For fmul:
664 |       if(both operands are denorm)
665 |               force_unf;
666 |       if((dest_exp + src_exp) < 0)
667 |               force_unf:
668 |       else
669 |               restore_to_fpu;
670 |
671 | local equates:
672         .set    addcode,0x22
673         .set    subcode,0x28
674         .set    mulcode,0x23
675         .set    divcode,0x20
676         .set    cmpcode,0x38
677 ck_wrap:
678         | tstb  DY_MO_FLG(%a6)  ;check for fsqrt
679         beq     fix_stk         |if zero, it is fsqrt
680         movew   CMDREG1B(%a6),%d0
681         andiw   #0x3b,%d0               |strip to command bits
682         cmpiw   #addcode,%d0
683         beq     wrap_add
684         cmpiw   #subcode,%d0
685         beq     wrap_sub
686         cmpiw   #mulcode,%d0
687         beq     wrap_mul
688         cmpiw   #cmpcode,%d0
689         beq     wrap_cmp
690 |
691 | Inst is fdiv.
692 |
693 wrap_div:
694         cmpb    #0xff,DNRM_FLG(%a6) |if both ops denorm,
695         beq     fix_stk          |restore to fpu
696 |
697 | One of the ops is denormalized.  Test for wrap condition
698 | and force the result.
699 |
700         cmpb    #0x0f,DNRM_FLG(%a6) |check for dest denorm
701         bnes    div_srcd
702 div_destd:
703         bsrl    ckinf_ns
704         bne     fix_stk
705         bfextu  ETEMP_EX(%a6){#1:#15},%d0       |get src exp (always pos)
706         bfexts  FPTEMP_EX(%a6){#1:#15},%d1      |get dest exp (always neg)
707         subl    %d1,%d0                 |subtract dest from src
708         cmpl    #0x7fff,%d0
709         blt     fix_stk                 |if less, not wrap case
710         clrb    WBTEMP_SGN(%a6)
711         movew   ETEMP_EX(%a6),%d0               |find the sign of the result
712         movew   FPTEMP_EX(%a6),%d1
713         eorw    %d1,%d0
714         andiw   #0x8000,%d0
715         beq     force_unf
716         st      WBTEMP_SGN(%a6)
717         bra     force_unf
718
719 ckinf_ns:
720         moveb   STAG(%a6),%d0           |check source tag for inf or nan
721         bra     ck_in_com
722 ckinf_nd:
723         moveb   DTAG(%a6),%d0           |check destination tag for inf or nan
724 ck_in_com:
725         andib   #0x60,%d0                       |isolate tag bits
726         cmpb    #0x40,%d0                       |is it inf?
727         beq     nan_or_inf              |not wrap case
728         cmpb    #0x60,%d0                       |is it nan?
729         beq     nan_or_inf              |yes, not wrap case?
730         cmpb    #0x20,%d0                       |is it a zero?
731         beq     nan_or_inf              |yes
732         clrl    %d0
733         rts                             |then ; it is either a zero of norm,
734 |                                       ;check wrap case
735 nan_or_inf:
736         moveql  #-1,%d0
737         rts
738
739
740
741 div_srcd:
742         bsrl    ckinf_nd
743         bne     fix_stk
744         bfextu  FPTEMP_EX(%a6){#1:#15},%d0      |get dest exp (always pos)
745         bfexts  ETEMP_EX(%a6){#1:#15},%d1       |get src exp (always neg)
746         subl    %d1,%d0                 |subtract src from dest
747         cmpl    #0x8000,%d0
748         blt     fix_stk                 |if less, not wrap case
749         clrb    WBTEMP_SGN(%a6)
750         movew   ETEMP_EX(%a6),%d0               |find the sign of the result
751         movew   FPTEMP_EX(%a6),%d1
752         eorw    %d1,%d0
753         andiw   #0x8000,%d0
754         beqs    force_ovf
755         st      WBTEMP_SGN(%a6)
756 |
757 | This code handles the case of the instruction resulting in
758 | an overflow condition.
759 |
760 force_ovf:
761         bclrb   #E1,E_BYTE(%a6)
762         orl     #ovfl_inx_mask,USER_FPSR(%a6)
763         clrw    NMNEXC(%a6)
764         leal    WBTEMP(%a6),%a0         |point a0 to memory location
765         movew   CMDREG1B(%a6),%d0
766         btstl   #6,%d0                  |test for forced precision
767         beqs    frcovf_fpcr
768         btstl   #2,%d0                  |check for double
769         bnes    frcovf_dbl
770         movel   #0x1,%d0                        |inst is forced single
771         bras    frcovf_rnd
772 frcovf_dbl:
773         movel   #0x2,%d0                        |inst is forced double
774         bras    frcovf_rnd
775 frcovf_fpcr:
776         bfextu  FPCR_MODE(%a6){#0:#2},%d0       |inst not forced - use fpcr prec
777 frcovf_rnd:
778
779 | The 881/882 does not set inex2 for the following case, so the
780 | line is commented out to be compatible with 881/882
781 |       tst.b   %d0
782 |       beq.b   frcovf_x
783 |       or.l    #inex2_mask,USER_FPSR(%a6) ;if prec is s or d, set inex2
784
785 |frcovf_x:
786         bsrl    ovf_res                 |get correct result based on
787 |                                       ;round precision/mode.  This
788 |                                       ;sets FPSR_CC correctly
789 |                                       ;returns in external format
790         bfclr   WBTEMP_SGN(%a6){#0:#8}
791         beq     frcfpn
792         bsetb   #sign_bit,WBTEMP_EX(%a6)
793         bra     frcfpn
794 |
795 | Inst is fadd.
796 |
797 wrap_add:
798         cmpb    #0xff,DNRM_FLG(%a6) |if both ops denorm,
799         beq     fix_stk          |restore to fpu
800 |
801 | One of the ops is denormalized.  Test for wrap condition
802 | and complete the instruction.
803 |
804         cmpb    #0x0f,DNRM_FLG(%a6) |check for dest denorm
805         bnes    add_srcd
806 add_destd:
807         bsrl    ckinf_ns
808         bne     fix_stk
809         bfextu  ETEMP_EX(%a6){#1:#15},%d0       |get src exp (always pos)
810         bfexts  FPTEMP_EX(%a6){#1:#15},%d1      |get dest exp (always neg)
811         subl    %d1,%d0                 |subtract dest from src
812         cmpl    #0x8000,%d0
813         blt     fix_stk                 |if less, not wrap case
814         bra     add_wrap
815 add_srcd:
816         bsrl    ckinf_nd
817         bne     fix_stk
818         bfextu  FPTEMP_EX(%a6){#1:#15},%d0      |get dest exp (always pos)
819         bfexts  ETEMP_EX(%a6){#1:#15},%d1       |get src exp (always neg)
820         subl    %d1,%d0                 |subtract src from dest
821         cmpl    #0x8000,%d0
822         blt     fix_stk                 |if less, not wrap case
823 |
824 | Check the signs of the operands.  If they are unlike, the fpu
825 | can be used to add the norm and 1.0 with the sign of the
826 | denorm and it will correctly generate the result in extended
827 | precision.  We can then call round with no sticky and the result
828 | will be correct for the user's rounding mode and precision.  If
829 | the signs are the same, we call round with the sticky bit set
830 | and the result will be correct for the user's rounding mode and
831 | precision.
832 |
833 add_wrap:
834         movew   ETEMP_EX(%a6),%d0
835         movew   FPTEMP_EX(%a6),%d1
836         eorw    %d1,%d0
837         andiw   #0x8000,%d0
838         beq     add_same
839 |
840 | The signs are unlike.
841 |
842         cmpb    #0x0f,DNRM_FLG(%a6) |is dest the denorm?
843         bnes    add_u_srcd
844         movew   FPTEMP_EX(%a6),%d0
845         andiw   #0x8000,%d0
846         orw     #0x3fff,%d0     |force the exponent to +/- 1
847         movew   %d0,FPTEMP_EX(%a6) |in the denorm
848         movel   USER_FPCR(%a6),%d0
849         andil   #0x30,%d0
850         fmovel  %d0,%fpcr               |set up users rmode and X
851         fmovex  ETEMP(%a6),%fp0
852         faddx   FPTEMP(%a6),%fp0
853         leal    WBTEMP(%a6),%a0 |point a0 to wbtemp in frame
854         fmovel  %fpsr,%d1
855         orl     %d1,USER_FPSR(%a6) |capture cc's and inex from fadd
856         fmovex  %fp0,WBTEMP(%a6)        |write result to memory
857         lsrl    #4,%d0          |put rmode in lower 2 bits
858         movel   USER_FPCR(%a6),%d1
859         andil   #0xc0,%d1
860         lsrl    #6,%d1          |put precision in upper word
861         swap    %d1
862         orl     %d0,%d1         |set up for round call
863         clrl    %d0             |force sticky to zero
864         bclrb   #sign_bit,WBTEMP_EX(%a6)
865         sne     WBTEMP_SGN(%a6)
866         bsrl    round           |round result to users rmode & prec
867         bfclr   WBTEMP_SGN(%a6){#0:#8}  |convert back to IEEE ext format
868         beq     frcfpnr
869         bsetb   #sign_bit,WBTEMP_EX(%a6)
870         bra     frcfpnr
871 add_u_srcd:
872         movew   ETEMP_EX(%a6),%d0
873         andiw   #0x8000,%d0
874         orw     #0x3fff,%d0     |force the exponent to +/- 1
875         movew   %d0,ETEMP_EX(%a6) |in the denorm
876         movel   USER_FPCR(%a6),%d0
877         andil   #0x30,%d0
878         fmovel  %d0,%fpcr               |set up users rmode and X
879         fmovex  ETEMP(%a6),%fp0
880         faddx   FPTEMP(%a6),%fp0
881         fmovel  %fpsr,%d1
882         orl     %d1,USER_FPSR(%a6) |capture cc's and inex from fadd
883         leal    WBTEMP(%a6),%a0 |point a0 to wbtemp in frame
884         fmovex  %fp0,WBTEMP(%a6)        |write result to memory
885         lsrl    #4,%d0          |put rmode in lower 2 bits
886         movel   USER_FPCR(%a6),%d1
887         andil   #0xc0,%d1
888         lsrl    #6,%d1          |put precision in upper word
889         swap    %d1
890         orl     %d0,%d1         |set up for round call
891         clrl    %d0             |force sticky to zero
892         bclrb   #sign_bit,WBTEMP_EX(%a6)
893         sne     WBTEMP_SGN(%a6) |use internal format for round
894         bsrl    round           |round result to users rmode & prec
895         bfclr   WBTEMP_SGN(%a6){#0:#8}  |convert back to IEEE ext format
896         beq     frcfpnr
897         bsetb   #sign_bit,WBTEMP_EX(%a6)
898         bra     frcfpnr
899 |
900 | Signs are alike:
901 |
902 add_same:
903         cmpb    #0x0f,DNRM_FLG(%a6) |is dest the denorm?
904         bnes    add_s_srcd
905 add_s_destd:
906         leal    ETEMP(%a6),%a0
907         movel   USER_FPCR(%a6),%d0
908         andil   #0x30,%d0
909         lsrl    #4,%d0          |put rmode in lower 2 bits
910         movel   USER_FPCR(%a6),%d1
911         andil   #0xc0,%d1
912         lsrl    #6,%d1          |put precision in upper word
913         swap    %d1
914         orl     %d0,%d1         |set up for round call
915         movel   #0x20000000,%d0 |set sticky for round
916         bclrb   #sign_bit,ETEMP_EX(%a6)
917         sne     ETEMP_SGN(%a6)
918         bsrl    round           |round result to users rmode & prec
919         bfclr   ETEMP_SGN(%a6){#0:#8}   |convert back to IEEE ext format
920         beqs    add_s_dclr
921         bsetb   #sign_bit,ETEMP_EX(%a6)
922 add_s_dclr:
923         leal    WBTEMP(%a6),%a0
924         movel   ETEMP(%a6),(%a0)        |write result to wbtemp
925         movel   ETEMP_HI(%a6),4(%a0)
926         movel   ETEMP_LO(%a6),8(%a0)
927         tstw    ETEMP_EX(%a6)
928         bgt     add_ckovf
929         orl     #neg_mask,USER_FPSR(%a6)
930         bra     add_ckovf
931 add_s_srcd:
932         leal    FPTEMP(%a6),%a0
933         movel   USER_FPCR(%a6),%d0
934         andil   #0x30,%d0
935         lsrl    #4,%d0          |put rmode in lower 2 bits
936         movel   USER_FPCR(%a6),%d1
937         andil   #0xc0,%d1
938         lsrl    #6,%d1          |put precision in upper word
939         swap    %d1
940         orl     %d0,%d1         |set up for round call
941         movel   #0x20000000,%d0 |set sticky for round
942         bclrb   #sign_bit,FPTEMP_EX(%a6)
943         sne     FPTEMP_SGN(%a6)
944         bsrl    round           |round result to users rmode & prec
945         bfclr   FPTEMP_SGN(%a6){#0:#8}  |convert back to IEEE ext format
946         beqs    add_s_sclr
947         bsetb   #sign_bit,FPTEMP_EX(%a6)
948 add_s_sclr:
949         leal    WBTEMP(%a6),%a0
950         movel   FPTEMP(%a6),(%a0)       |write result to wbtemp
951         movel   FPTEMP_HI(%a6),4(%a0)
952         movel   FPTEMP_LO(%a6),8(%a0)
953         tstw    FPTEMP_EX(%a6)
954         bgt     add_ckovf
955         orl     #neg_mask,USER_FPSR(%a6)
956 add_ckovf:
957         movew   WBTEMP_EX(%a6),%d0
958         andiw   #0x7fff,%d0
959         cmpiw   #0x7fff,%d0
960         bne     frcfpnr
961 |
962 | The result has overflowed to $7fff exponent.  Set I, ovfl,
963 | and aovfl, and clr the mantissa (incorrectly set by the
964 | round routine.)
965 |
966         orl     #inf_mask+ovfl_inx_mask,USER_FPSR(%a6)
967         clrl    4(%a0)
968         bra     frcfpnr
969 |
970 | Inst is fsub.
971 |
972 wrap_sub:
973         cmpb    #0xff,DNRM_FLG(%a6) |if both ops denorm,
974         beq     fix_stk          |restore to fpu
975 |
976 | One of the ops is denormalized.  Test for wrap condition
977 | and complete the instruction.
978 |
979         cmpb    #0x0f,DNRM_FLG(%a6) |check for dest denorm
980         bnes    sub_srcd
981 sub_destd:
982         bsrl    ckinf_ns
983         bne     fix_stk
984         bfextu  ETEMP_EX(%a6){#1:#15},%d0       |get src exp (always pos)
985         bfexts  FPTEMP_EX(%a6){#1:#15},%d1      |get dest exp (always neg)
986         subl    %d1,%d0                 |subtract src from dest
987         cmpl    #0x8000,%d0
988         blt     fix_stk                 |if less, not wrap case
989         bra     sub_wrap
990 sub_srcd:
991         bsrl    ckinf_nd
992         bne     fix_stk
993         bfextu  FPTEMP_EX(%a6){#1:#15},%d0      |get dest exp (always pos)
994         bfexts  ETEMP_EX(%a6){#1:#15},%d1       |get src exp (always neg)
995         subl    %d1,%d0                 |subtract dest from src
996         cmpl    #0x8000,%d0
997         blt     fix_stk                 |if less, not wrap case
998 |
999 | Check the signs of the operands.  If they are alike, the fpu
1000 | can be used to subtract from the norm 1.0 with the sign of the
1001 | denorm and it will correctly generate the result in extended
1002 | precision.  We can then call round with no sticky and the result
1003 | will be correct for the user's rounding mode and precision.  If
1004 | the signs are unlike, we call round with the sticky bit set
1005 | and the result will be correct for the user's rounding mode and
1006 | precision.
1007 |
1008 sub_wrap:
1009         movew   ETEMP_EX(%a6),%d0
1010         movew   FPTEMP_EX(%a6),%d1
1011         eorw    %d1,%d0
1012         andiw   #0x8000,%d0
1013         bne     sub_diff
1014 |
1015 | The signs are alike.
1016 |
1017         cmpb    #0x0f,DNRM_FLG(%a6) |is dest the denorm?
1018         bnes    sub_u_srcd
1019         movew   FPTEMP_EX(%a6),%d0
1020         andiw   #0x8000,%d0
1021         orw     #0x3fff,%d0     |force the exponent to +/- 1
1022         movew   %d0,FPTEMP_EX(%a6) |in the denorm
1023         movel   USER_FPCR(%a6),%d0
1024         andil   #0x30,%d0
1025         fmovel  %d0,%fpcr               |set up users rmode and X
1026         fmovex  FPTEMP(%a6),%fp0
1027         fsubx   ETEMP(%a6),%fp0
1028         fmovel  %fpsr,%d1
1029         orl     %d1,USER_FPSR(%a6) |capture cc's and inex from fadd
1030         leal    WBTEMP(%a6),%a0 |point a0 to wbtemp in frame
1031         fmovex  %fp0,WBTEMP(%a6)        |write result to memory
1032         lsrl    #4,%d0          |put rmode in lower 2 bits
1033         movel   USER_FPCR(%a6),%d1
1034         andil   #0xc0,%d1
1035         lsrl    #6,%d1          |put precision in upper word
1036         swap    %d1
1037         orl     %d0,%d1         |set up for round call
1038         clrl    %d0             |force sticky to zero
1039         bclrb   #sign_bit,WBTEMP_EX(%a6)
1040         sne     WBTEMP_SGN(%a6)
1041         bsrl    round           |round result to users rmode & prec
1042         bfclr   WBTEMP_SGN(%a6){#0:#8}  |convert back to IEEE ext format
1043         beq     frcfpnr
1044         bsetb   #sign_bit,WBTEMP_EX(%a6)
1045         bra     frcfpnr
1046 sub_u_srcd:
1047         movew   ETEMP_EX(%a6),%d0
1048         andiw   #0x8000,%d0
1049         orw     #0x3fff,%d0     |force the exponent to +/- 1
1050         movew   %d0,ETEMP_EX(%a6) |in the denorm
1051         movel   USER_FPCR(%a6),%d0
1052         andil   #0x30,%d0
1053         fmovel  %d0,%fpcr               |set up users rmode and X
1054         fmovex  FPTEMP(%a6),%fp0
1055         fsubx   ETEMP(%a6),%fp0
1056         fmovel  %fpsr,%d1
1057         orl     %d1,USER_FPSR(%a6) |capture cc's and inex from fadd
1058         leal    WBTEMP(%a6),%a0 |point a0 to wbtemp in frame
1059         fmovex  %fp0,WBTEMP(%a6)        |write result to memory
1060         lsrl    #4,%d0          |put rmode in lower 2 bits
1061         movel   USER_FPCR(%a6),%d1
1062         andil   #0xc0,%d1
1063         lsrl    #6,%d1          |put precision in upper word
1064         swap    %d1
1065         orl     %d0,%d1         |set up for round call
1066         clrl    %d0             |force sticky to zero
1067         bclrb   #sign_bit,WBTEMP_EX(%a6)
1068         sne     WBTEMP_SGN(%a6)
1069         bsrl    round           |round result to users rmode & prec
1070         bfclr   WBTEMP_SGN(%a6){#0:#8}  |convert back to IEEE ext format
1071         beq     frcfpnr
1072         bsetb   #sign_bit,WBTEMP_EX(%a6)
1073         bra     frcfpnr
1074 |
1075 | Signs are unlike:
1076 |
1077 sub_diff:
1078         cmpb    #0x0f,DNRM_FLG(%a6) |is dest the denorm?
1079         bnes    sub_s_srcd
1080 sub_s_destd:
1081         leal    ETEMP(%a6),%a0
1082         movel   USER_FPCR(%a6),%d0
1083         andil   #0x30,%d0
1084         lsrl    #4,%d0          |put rmode in lower 2 bits
1085         movel   USER_FPCR(%a6),%d1
1086         andil   #0xc0,%d1
1087         lsrl    #6,%d1          |put precision in upper word
1088         swap    %d1
1089         orl     %d0,%d1         |set up for round call
1090         movel   #0x20000000,%d0 |set sticky for round
1091 |
1092 | Since the dest is the denorm, the sign is the opposite of the
1093 | norm sign.
1094 |
1095         eoriw   #0x8000,ETEMP_EX(%a6)   |flip sign on result
1096         tstw    ETEMP_EX(%a6)
1097         bgts    sub_s_dwr
1098         orl     #neg_mask,USER_FPSR(%a6)
1099 sub_s_dwr:
1100         bclrb   #sign_bit,ETEMP_EX(%a6)
1101         sne     ETEMP_SGN(%a6)
1102         bsrl    round           |round result to users rmode & prec
1103         bfclr   ETEMP_SGN(%a6){#0:#8}   |convert back to IEEE ext format
1104         beqs    sub_s_dclr
1105         bsetb   #sign_bit,ETEMP_EX(%a6)
1106 sub_s_dclr:
1107         leal    WBTEMP(%a6),%a0
1108         movel   ETEMP(%a6),(%a0)        |write result to wbtemp
1109         movel   ETEMP_HI(%a6),4(%a0)
1110         movel   ETEMP_LO(%a6),8(%a0)
1111         bra     sub_ckovf
1112 sub_s_srcd:
1113         leal    FPTEMP(%a6),%a0
1114         movel   USER_FPCR(%a6),%d0
1115         andil   #0x30,%d0
1116         lsrl    #4,%d0          |put rmode in lower 2 bits
1117         movel   USER_FPCR(%a6),%d1
1118         andil   #0xc0,%d1
1119         lsrl    #6,%d1          |put precision in upper word
1120         swap    %d1
1121         orl     %d0,%d1         |set up for round call
1122         movel   #0x20000000,%d0 |set sticky for round
1123         bclrb   #sign_bit,FPTEMP_EX(%a6)
1124         sne     FPTEMP_SGN(%a6)
1125         bsrl    round           |round result to users rmode & prec
1126         bfclr   FPTEMP_SGN(%a6){#0:#8}  |convert back to IEEE ext format
1127         beqs    sub_s_sclr
1128         bsetb   #sign_bit,FPTEMP_EX(%a6)
1129 sub_s_sclr:
1130         leal    WBTEMP(%a6),%a0
1131         movel   FPTEMP(%a6),(%a0)       |write result to wbtemp
1132         movel   FPTEMP_HI(%a6),4(%a0)
1133         movel   FPTEMP_LO(%a6),8(%a0)
1134         tstw    FPTEMP_EX(%a6)
1135         bgt     sub_ckovf
1136         orl     #neg_mask,USER_FPSR(%a6)
1137 sub_ckovf:
1138         movew   WBTEMP_EX(%a6),%d0
1139         andiw   #0x7fff,%d0
1140         cmpiw   #0x7fff,%d0
1141         bne     frcfpnr
1142 |
1143 | The result has overflowed to $7fff exponent.  Set I, ovfl,
1144 | and aovfl, and clr the mantissa (incorrectly set by the
1145 | round routine.)
1146 |
1147         orl     #inf_mask+ovfl_inx_mask,USER_FPSR(%a6)
1148         clrl    4(%a0)
1149         bra     frcfpnr
1150 |
1151 | Inst is fcmp.
1152 |
1153 wrap_cmp:
1154         cmpb    #0xff,DNRM_FLG(%a6) |if both ops denorm,
1155         beq     fix_stk          |restore to fpu
1156 |
1157 | One of the ops is denormalized.  Test for wrap condition
1158 | and complete the instruction.
1159 |
1160         cmpb    #0x0f,DNRM_FLG(%a6) |check for dest denorm
1161         bnes    cmp_srcd
1162 cmp_destd:
1163         bsrl    ckinf_ns
1164         bne     fix_stk
1165         bfextu  ETEMP_EX(%a6){#1:#15},%d0       |get src exp (always pos)
1166         bfexts  FPTEMP_EX(%a6){#1:#15},%d1      |get dest exp (always neg)
1167         subl    %d1,%d0                 |subtract dest from src
1168         cmpl    #0x8000,%d0
1169         blt     fix_stk                 |if less, not wrap case
1170         tstw    ETEMP_EX(%a6)           |set N to ~sign_of(src)
1171         bge     cmp_setn
1172         rts
1173 cmp_srcd:
1174         bsrl    ckinf_nd
1175         bne     fix_stk
1176         bfextu  FPTEMP_EX(%a6){#1:#15},%d0      |get dest exp (always pos)
1177         bfexts  ETEMP_EX(%a6){#1:#15},%d1       |get src exp (always neg)
1178         subl    %d1,%d0                 |subtract src from dest
1179         cmpl    #0x8000,%d0
1180         blt     fix_stk                 |if less, not wrap case
1181         tstw    FPTEMP_EX(%a6)          |set N to sign_of(dest)
1182         blt     cmp_setn
1183         rts
1184 cmp_setn:
1185         orl     #neg_mask,USER_FPSR(%a6)
1186         rts
1187
1188 |
1189 | Inst is fmul.
1190 |
1191 wrap_mul:
1192         cmpb    #0xff,DNRM_FLG(%a6) |if both ops denorm,
1193         beq     force_unf       |force an underflow (really!)
1194 |
1195 | One of the ops is denormalized.  Test for wrap condition
1196 | and complete the instruction.
1197 |
1198         cmpb    #0x0f,DNRM_FLG(%a6) |check for dest denorm
1199         bnes    mul_srcd
1200 mul_destd:
1201         bsrl    ckinf_ns
1202         bne     fix_stk
1203         bfextu  ETEMP_EX(%a6){#1:#15},%d0       |get src exp (always pos)
1204         bfexts  FPTEMP_EX(%a6){#1:#15},%d1      |get dest exp (always neg)
1205         addl    %d1,%d0                 |subtract dest from src
1206         bgt     fix_stk
1207         bra     force_unf
1208 mul_srcd:
1209         bsrl    ckinf_nd
1210         bne     fix_stk
1211         bfextu  FPTEMP_EX(%a6){#1:#15},%d0      |get dest exp (always pos)
1212         bfexts  ETEMP_EX(%a6){#1:#15},%d1       |get src exp (always neg)
1213         addl    %d1,%d0                 |subtract src from dest
1214         bgt     fix_stk
1215
1216 |
1217 | This code handles the case of the instruction resulting in
1218 | an underflow condition.
1219 |
1220 force_unf:
1221         bclrb   #E1,E_BYTE(%a6)
1222         orl     #unfinx_mask,USER_FPSR(%a6)
1223         clrw    NMNEXC(%a6)
1224         clrb    WBTEMP_SGN(%a6)
1225         movew   ETEMP_EX(%a6),%d0               |find the sign of the result
1226         movew   FPTEMP_EX(%a6),%d1
1227         eorw    %d1,%d0
1228         andiw   #0x8000,%d0
1229         beqs    frcunfcont
1230         st      WBTEMP_SGN(%a6)
1231 frcunfcont:
1232         lea     WBTEMP(%a6),%a0         |point a0 to memory location
1233         movew   CMDREG1B(%a6),%d0
1234         btstl   #6,%d0                  |test for forced precision
1235         beqs    frcunf_fpcr
1236         btstl   #2,%d0                  |check for double
1237         bnes    frcunf_dbl
1238         movel   #0x1,%d0                        |inst is forced single
1239         bras    frcunf_rnd
1240 frcunf_dbl:
1241         movel   #0x2,%d0                        |inst is forced double
1242         bras    frcunf_rnd
1243 frcunf_fpcr:
1244         bfextu  FPCR_MODE(%a6){#0:#2},%d0       |inst not forced - use fpcr prec
1245 frcunf_rnd:
1246         bsrl    unf_sub                 |get correct result based on
1247 |                                       ;round precision/mode.  This
1248 |                                       ;sets FPSR_CC correctly
1249         bfclr   WBTEMP_SGN(%a6){#0:#8}  |convert back to IEEE ext format
1250         beqs    frcfpn
1251         bsetb   #sign_bit,WBTEMP_EX(%a6)
1252         bra     frcfpn
1253
1254 |
1255 | Write the result to the user's fpn.  All results must be HUGE to be
1256 | written; otherwise the results would have overflowed or underflowed.
1257 | If the rounding precision is single or double, the ovf_res routine
1258 | is needed to correctly supply the max value.
1259 |
1260 frcfpnr:
1261         movew   CMDREG1B(%a6),%d0
1262         btstl   #6,%d0                  |test for forced precision
1263         beqs    frcfpn_fpcr
1264         btstl   #2,%d0                  |check for double
1265         bnes    frcfpn_dbl
1266         movel   #0x1,%d0                        |inst is forced single
1267         bras    frcfpn_rnd
1268 frcfpn_dbl:
1269         movel   #0x2,%d0                        |inst is forced double
1270         bras    frcfpn_rnd
1271 frcfpn_fpcr:
1272         bfextu  FPCR_MODE(%a6){#0:#2},%d0       |inst not forced - use fpcr prec
1273         tstb    %d0
1274         beqs    frcfpn                  |if extended, write what you got
1275 frcfpn_rnd:
1276         bclrb   #sign_bit,WBTEMP_EX(%a6)
1277         sne     WBTEMP_SGN(%a6)
1278         bsrl    ovf_res                 |get correct result based on
1279 |                                       ;round precision/mode.  This
1280 |                                       ;sets FPSR_CC correctly
1281         bfclr   WBTEMP_SGN(%a6){#0:#8}  |convert back to IEEE ext format
1282         beqs    frcfpn_clr
1283         bsetb   #sign_bit,WBTEMP_EX(%a6)
1284 frcfpn_clr:
1285         orl     #ovfinx_mask,USER_FPSR(%a6)
1286 |
1287 | Perform the write.
1288 |
1289 frcfpn:
1290         bfextu  CMDREG1B(%a6){#6:#3},%d0        |extract fp destination register
1291         cmpib   #3,%d0
1292         bles    frc0123                 |check if dest is fp0-fp3
1293         movel   #7,%d1
1294         subl    %d0,%d1
1295         clrl    %d0
1296         bsetl   %d1,%d0
1297         fmovemx WBTEMP(%a6),%d0
1298         rts
1299 frc0123:
1300         cmpib   #0,%d0
1301         beqs    frc0_dst
1302         cmpib   #1,%d0
1303         beqs    frc1_dst
1304         cmpib   #2,%d0
1305         beqs    frc2_dst
1306 frc3_dst:
1307         movel   WBTEMP_EX(%a6),USER_FP3(%a6)
1308         movel   WBTEMP_HI(%a6),USER_FP3+4(%a6)
1309         movel   WBTEMP_LO(%a6),USER_FP3+8(%a6)
1310         rts
1311 frc2_dst:
1312         movel   WBTEMP_EX(%a6),USER_FP2(%a6)
1313         movel   WBTEMP_HI(%a6),USER_FP2+4(%a6)
1314         movel   WBTEMP_LO(%a6),USER_FP2+8(%a6)
1315         rts
1316 frc1_dst:
1317         movel   WBTEMP_EX(%a6),USER_FP1(%a6)
1318         movel   WBTEMP_HI(%a6),USER_FP1+4(%a6)
1319         movel   WBTEMP_LO(%a6),USER_FP1+8(%a6)
1320         rts
1321 frc0_dst:
1322         movel   WBTEMP_EX(%a6),USER_FP0(%a6)
1323         movel   WBTEMP_HI(%a6),USER_FP0+4(%a6)
1324         movel   WBTEMP_LO(%a6),USER_FP0+8(%a6)
1325         rts
1326
1327 |
1328 | Write etemp to fpn.
1329 | A check is made on enabled and signalled snan exceptions,
1330 | and the destination is not overwritten if this condition exists.
1331 | This code is designed to make fmoveins of unsupported data types
1332 | faster.
1333 |
1334 wr_etemp:
1335         btstb   #snan_bit,FPSR_EXCEPT(%a6)      |if snan is set, and
1336         beqs    fmoveinc                |enabled, force restore
1337         btstb   #snan_bit,FPCR_ENABLE(%a6) |and don't overwrite
1338         beqs    fmoveinc                |the dest
1339         movel   ETEMP_EX(%a6),FPTEMP_EX(%a6)    |set up fptemp sign for
1340 |                                               ;snan handler
1341         tstb    ETEMP(%a6)              |check for negative
1342         blts    snan_neg
1343         rts
1344 snan_neg:
1345         orl     #neg_bit,USER_FPSR(%a6) |snan is negative; set N
1346         rts
1347 fmoveinc:
1348         clrw    NMNEXC(%a6)
1349         bclrb   #E1,E_BYTE(%a6)
1350         moveb   STAG(%a6),%d0           |check if stag is inf
1351         andib   #0xe0,%d0
1352         cmpib   #0x40,%d0
1353         bnes    fminc_cnan
1354         orl     #inf_mask,USER_FPSR(%a6) |if inf, nothing yet has set I
1355         tstw    LOCAL_EX(%a0)           |check sign
1356         bges    fminc_con
1357         orl     #neg_mask,USER_FPSR(%a6)
1358         bra     fminc_con
1359 fminc_cnan:
1360         cmpib   #0x60,%d0                       |check if stag is NaN
1361         bnes    fminc_czero
1362         orl     #nan_mask,USER_FPSR(%a6) |if nan, nothing yet has set NaN
1363         movel   ETEMP_EX(%a6),FPTEMP_EX(%a6)    |set up fptemp sign for
1364 |                                               ;snan handler
1365         tstw    LOCAL_EX(%a0)           |check sign
1366         bges    fminc_con
1367         orl     #neg_mask,USER_FPSR(%a6)
1368         bra     fminc_con
1369 fminc_czero:
1370         cmpib   #0x20,%d0                       |check if zero
1371         bnes    fminc_con
1372         orl     #z_mask,USER_FPSR(%a6)  |if zero, set Z
1373         tstw    LOCAL_EX(%a0)           |check sign
1374         bges    fminc_con
1375         orl     #neg_mask,USER_FPSR(%a6)
1376 fminc_con:
1377         bfextu  CMDREG1B(%a6){#6:#3},%d0        |extract fp destination register
1378         cmpib   #3,%d0
1379         bles    fp0123                  |check if dest is fp0-fp3
1380         movel   #7,%d1
1381         subl    %d0,%d1
1382         clrl    %d0
1383         bsetl   %d1,%d0
1384         fmovemx ETEMP(%a6),%d0
1385         rts
1386
1387 fp0123:
1388         cmpib   #0,%d0
1389         beqs    fp0_dst
1390         cmpib   #1,%d0
1391         beqs    fp1_dst
1392         cmpib   #2,%d0
1393         beqs    fp2_dst
1394 fp3_dst:
1395         movel   ETEMP_EX(%a6),USER_FP3(%a6)
1396         movel   ETEMP_HI(%a6),USER_FP3+4(%a6)
1397         movel   ETEMP_LO(%a6),USER_FP3+8(%a6)
1398         rts
1399 fp2_dst:
1400         movel   ETEMP_EX(%a6),USER_FP2(%a6)
1401         movel   ETEMP_HI(%a6),USER_FP2+4(%a6)
1402         movel   ETEMP_LO(%a6),USER_FP2+8(%a6)
1403         rts
1404 fp1_dst:
1405         movel   ETEMP_EX(%a6),USER_FP1(%a6)
1406         movel   ETEMP_HI(%a6),USER_FP1+4(%a6)
1407         movel   ETEMP_LO(%a6),USER_FP1+8(%a6)
1408         rts
1409 fp0_dst:
1410         movel   ETEMP_EX(%a6),USER_FP0(%a6)
1411         movel   ETEMP_HI(%a6),USER_FP0+4(%a6)
1412         movel   ETEMP_LO(%a6),USER_FP0+8(%a6)
1413         rts
1414
1415 opclass3:
1416         st      CU_ONLY(%a6)
1417         movew   CMDREG1B(%a6),%d0       |check if packed moveout
1418         andiw   #0x0c00,%d0     |isolate last 2 bits of size field
1419         cmpiw   #0x0c00,%d0     |if size is 011 or 111, it is packed
1420         beq     pack_out        |else it is norm or denorm
1421         bra     mv_out
1422
1423
1424 |
1425 |       MOVE OUT
1426 |
1427
1428 mv_tbl:
1429         .long   li
1430         .long   sgp
1431         .long   xp
1432         .long   mvout_end       |should never be taken
1433         .long   wi
1434         .long   dp
1435         .long   bi
1436         .long   mvout_end       |should never be taken
1437 mv_out:
1438         bfextu  CMDREG1B(%a6){#3:#3},%d1        |put source specifier in d1
1439         leal    mv_tbl,%a0
1440         movel   %a0@(%d1:l:4),%a0
1441         jmp     (%a0)
1442
1443 |
1444 | This exit is for move-out to memory.  The aunfl bit is
1445 | set if the result is inex and unfl is signalled.
1446 |
1447 mvout_end:
1448         btstb   #inex2_bit,FPSR_EXCEPT(%a6)
1449         beqs    no_aufl
1450         btstb   #unfl_bit,FPSR_EXCEPT(%a6)
1451         beqs    no_aufl
1452         bsetb   #aunfl_bit,FPSR_AEXCEPT(%a6)
1453 no_aufl:
1454         clrw    NMNEXC(%a6)
1455         bclrb   #E1,E_BYTE(%a6)
1456         fmovel  #0,%FPSR                        |clear any cc bits from res_func
1457 |
1458 | Return ETEMP to extended format from internal extended format so
1459 | that gen_except will have a correctly signed value for ovfl/unfl
1460 | handlers.
1461 |
1462         bfclr   ETEMP_SGN(%a6){#0:#8}
1463         beqs    mvout_con
1464         bsetb   #sign_bit,ETEMP_EX(%a6)
1465 mvout_con:
1466         rts
1467 |
1468 | This exit is for move-out to int register.  The aunfl bit is
1469 | not set in any case for this move.
1470 |
1471 mvouti_end:
1472         clrw    NMNEXC(%a6)
1473         bclrb   #E1,E_BYTE(%a6)
1474         fmovel  #0,%FPSR                        |clear any cc bits from res_func
1475 |
1476 | Return ETEMP to extended format from internal extended format so
1477 | that gen_except will have a correctly signed value for ovfl/unfl
1478 | handlers.
1479 |
1480         bfclr   ETEMP_SGN(%a6){#0:#8}
1481         beqs    mvouti_con
1482         bsetb   #sign_bit,ETEMP_EX(%a6)
1483 mvouti_con:
1484         rts
1485 |
1486 | li is used to handle a long integer source specifier
1487 |
1488
1489 li:
1490         moveql  #4,%d0          |set byte count
1491
1492         btstb   #7,STAG(%a6)    |check for extended denorm
1493         bne     int_dnrm        |if so, branch
1494
1495         fmovemx ETEMP(%a6),%fp0-%fp0
1496         fcmpd   #0x41dfffffffc00000,%fp0
1497 | 41dfffffffc00000 in dbl prec = 401d0000fffffffe00000000 in ext prec
1498         fbge    lo_plrg
1499         fcmpd   #0xc1e0000000000000,%fp0
1500 | c1e0000000000000 in dbl prec = c01e00008000000000000000 in ext prec
1501         fble    lo_nlrg
1502 |
1503 | at this point, the answer is between the largest pos and neg values
1504 |
1505         movel   USER_FPCR(%a6),%d1      |use user's rounding mode
1506         andil   #0x30,%d1
1507         fmovel  %d1,%fpcr
1508         fmovel  %fp0,L_SCR1(%a6)        |let the 040 perform conversion
1509         fmovel %fpsr,%d1
1510         orl     %d1,USER_FPSR(%a6)      |capture inex2/ainex if set
1511         bra     int_wrt
1512
1513
1514 lo_plrg:
1515         movel   #0x7fffffff,L_SCR1(%a6) |answer is largest positive int
1516         fbeq    int_wrt                 |exact answer
1517         fcmpd   #0x41dfffffffe00000,%fp0
1518 | 41dfffffffe00000 in dbl prec = 401d0000ffffffff00000000 in ext prec
1519         fbge    int_operr               |set operr
1520         bra     int_inx                 |set inexact
1521
1522 lo_nlrg:
1523         movel   #0x80000000,L_SCR1(%a6)
1524         fbeq    int_wrt                 |exact answer
1525         fcmpd   #0xc1e0000000100000,%fp0
1526 | c1e0000000100000 in dbl prec = c01e00008000000080000000 in ext prec
1527         fblt    int_operr               |set operr
1528         bra     int_inx                 |set inexact
1529
1530 |
1531 | wi is used to handle a word integer source specifier
1532 |
1533
1534 wi:
1535         moveql  #2,%d0          |set byte count
1536
1537         btstb   #7,STAG(%a6)    |check for extended denorm
1538         bne     int_dnrm        |branch if so
1539
1540         fmovemx ETEMP(%a6),%fp0-%fp0
1541         fcmps   #0x46fffe00,%fp0
1542 | 46fffe00 in sgl prec = 400d0000fffe000000000000 in ext prec
1543         fbge    wo_plrg
1544         fcmps   #0xc7000000,%fp0
1545 | c7000000 in sgl prec = c00e00008000000000000000 in ext prec
1546         fble    wo_nlrg
1547
1548 |
1549 | at this point, the answer is between the largest pos and neg values
1550 |
1551         movel   USER_FPCR(%a6),%d1      |use user's rounding mode
1552         andil   #0x30,%d1
1553         fmovel  %d1,%fpcr
1554         fmovew  %fp0,L_SCR1(%a6)        |let the 040 perform conversion
1555         fmovel %fpsr,%d1
1556         orl     %d1,USER_FPSR(%a6)      |capture inex2/ainex if set
1557         bra     int_wrt
1558
1559 wo_plrg:
1560         movew   #0x7fff,L_SCR1(%a6)     |answer is largest positive int
1561         fbeq    int_wrt                 |exact answer
1562         fcmps   #0x46ffff00,%fp0
1563 | 46ffff00 in sgl prec = 400d0000ffff000000000000 in ext prec
1564         fbge    int_operr               |set operr
1565         bra     int_inx                 |set inexact
1566
1567 wo_nlrg:
1568         movew   #0x8000,L_SCR1(%a6)
1569         fbeq    int_wrt                 |exact answer
1570         fcmps   #0xc7000080,%fp0
1571 | c7000080 in sgl prec = c00e00008000800000000000 in ext prec
1572         fblt    int_operr               |set operr
1573         bra     int_inx                 |set inexact
1574
1575 |
1576 | bi is used to handle a byte integer source specifier
1577 |
1578
1579 bi:
1580         moveql  #1,%d0          |set byte count
1581
1582         btstb   #7,STAG(%a6)    |check for extended denorm
1583         bne     int_dnrm        |branch if so
1584
1585         fmovemx ETEMP(%a6),%fp0-%fp0
1586         fcmps   #0x42fe0000,%fp0
1587 | 42fe0000 in sgl prec = 40050000fe00000000000000 in ext prec
1588         fbge    by_plrg
1589         fcmps   #0xc3000000,%fp0
1590 | c3000000 in sgl prec = c00600008000000000000000 in ext prec
1591         fble    by_nlrg
1592
1593 |
1594 | at this point, the answer is between the largest pos and neg values
1595 |
1596         movel   USER_FPCR(%a6),%d1      |use user's rounding mode
1597         andil   #0x30,%d1
1598         fmovel  %d1,%fpcr
1599         fmoveb  %fp0,L_SCR1(%a6)        |let the 040 perform conversion
1600         fmovel %fpsr,%d1
1601         orl     %d1,USER_FPSR(%a6)      |capture inex2/ainex if set
1602         bra     int_wrt
1603
1604 by_plrg:
1605         moveb   #0x7f,L_SCR1(%a6)               |answer is largest positive int
1606         fbeq    int_wrt                 |exact answer
1607         fcmps   #0x42ff0000,%fp0
1608 | 42ff0000 in sgl prec = 40050000ff00000000000000 in ext prec
1609         fbge    int_operr               |set operr
1610         bra     int_inx                 |set inexact
1611
1612 by_nlrg:
1613         moveb   #0x80,L_SCR1(%a6)
1614         fbeq    int_wrt                 |exact answer
1615         fcmps   #0xc3008000,%fp0
1616 | c3008000 in sgl prec = c00600008080000000000000 in ext prec
1617         fblt    int_operr               |set operr
1618         bra     int_inx                 |set inexact
1619
1620 |
1621 | Common integer routines
1622 |
1623 | int_drnrm---account for possible nonzero result for round up with positive
1624 | operand and round down for negative answer.  In the first case (result = 1)
1625 | byte-width (store in d0) of result must be honored.  In the second case,
1626 | -1 in L_SCR1(a6) will cover all contingencies (FMOVE.B/W/L out).
1627
1628 int_dnrm:
1629         movel   #0,L_SCR1(%a6)  | initialize result to 0
1630         bfextu  FPCR_MODE(%a6){#2:#2},%d1       | d1 is the rounding mode
1631         cmpb    #2,%d1
1632         bmis    int_inx         | if RN or RZ, done
1633         bnes    int_rp          | if RP, continue below
1634         tstw    ETEMP(%a6)      | RM: store -1 in L_SCR1 if src is negative
1635         bpls    int_inx         | otherwise result is 0
1636         movel   #-1,L_SCR1(%a6)
1637         bras    int_inx
1638 int_rp:
1639         tstw    ETEMP(%a6)      | RP: store +1 of proper width in L_SCR1 if
1640 |                               ; source is greater than 0
1641         bmis    int_inx         | otherwise, result is 0
1642         lea     L_SCR1(%a6),%a1 | a1 is address of L_SCR1
1643         addal   %d0,%a1         | offset by destination width -1
1644         subal   #1,%a1
1645         bsetb   #0,(%a1)                | set low bit at a1 address
1646 int_inx:
1647         oril    #inx2a_mask,USER_FPSR(%a6)
1648         bras    int_wrt
1649 int_operr:
1650         fmovemx %fp0-%fp0,FPTEMP(%a6)   |FPTEMP must contain the extended
1651 |                               ;precision source that needs to be
1652 |                               ;converted to integer this is required
1653 |                               ;if the operr exception is enabled.
1654 |                               ;set operr/aiop (no inex2 on int ovfl)
1655
1656         oril    #opaop_mask,USER_FPSR(%a6)
1657 |                               ;fall through to perform int_wrt
1658 int_wrt:
1659         movel   EXC_EA(%a6),%a1 |load destination address
1660         tstl    %a1             |check to see if it is a dest register
1661         beqs    wrt_dn          |write data register
1662         lea     L_SCR1(%a6),%a0 |point to supervisor source address
1663         bsrl    mem_write
1664         bra     mvouti_end
1665
1666 wrt_dn:
1667         movel   %d0,-(%sp)      |d0 currently contains the size to write
1668         bsrl    get_fline       |get_fline returns Dn in d0
1669         andiw   #0x7,%d0                |isolate register
1670         movel   (%sp)+,%d1      |get size
1671         cmpil   #4,%d1          |most frequent case
1672         beqs    sz_long
1673         cmpil   #2,%d1
1674         bnes    sz_con
1675         orl     #8,%d0          |add 'word' size to register#
1676         bras    sz_con
1677 sz_long:
1678         orl     #0x10,%d0               |add 'long' size to register#
1679 sz_con:
1680         movel   %d0,%d1         |reg_dest expects size:reg in d1
1681         bsrl    reg_dest        |load proper data register
1682         bra     mvouti_end
1683 xp:
1684         lea     ETEMP(%a6),%a0
1685         bclrb   #sign_bit,LOCAL_EX(%a0)
1686         sne     LOCAL_SGN(%a0)
1687         btstb   #7,STAG(%a6)    |check for extended denorm
1688         bne     xdnrm
1689         clrl    %d0
1690         bras    do_fp           |do normal case
1691 sgp:
1692         lea     ETEMP(%a6),%a0
1693         bclrb   #sign_bit,LOCAL_EX(%a0)
1694         sne     LOCAL_SGN(%a0)
1695         btstb   #7,STAG(%a6)    |check for extended denorm
1696         bne     sp_catas        |branch if so
1697         movew   LOCAL_EX(%a0),%d0
1698         lea     sp_bnds,%a1
1699         cmpw    (%a1),%d0
1700         blt     sp_under
1701         cmpw    2(%a1),%d0
1702         bgt     sp_over
1703         movel   #1,%d0          |set destination format to single
1704         bras    do_fp           |do normal case
1705 dp:
1706         lea     ETEMP(%a6),%a0
1707         bclrb   #sign_bit,LOCAL_EX(%a0)
1708         sne     LOCAL_SGN(%a0)
1709
1710         btstb   #7,STAG(%a6)    |check for extended denorm
1711         bne     dp_catas        |branch if so
1712
1713         movew   LOCAL_EX(%a0),%d0
1714         lea     dp_bnds,%a1
1715
1716         cmpw    (%a1),%d0
1717         blt     dp_under
1718         cmpw    2(%a1),%d0
1719         bgt     dp_over
1720
1721         movel   #2,%d0          |set destination format to double
1722 |                               ;fall through to do_fp
1723 |
1724 do_fp:
1725         bfextu  FPCR_MODE(%a6){#2:#2},%d1       |rnd mode in d1
1726         swap    %d0                     |rnd prec in upper word
1727         addl    %d0,%d1                 |d1 has PREC/MODE info
1728
1729         clrl    %d0                     |clear g,r,s
1730
1731         bsrl    round                   |round
1732
1733         movel   %a0,%a1
1734         movel   EXC_EA(%a6),%a0
1735
1736         bfextu  CMDREG1B(%a6){#3:#3},%d1        |extract destination format
1737 |                                       ;at this point only the dest
1738 |                                       ;formats sgl, dbl, ext are
1739 |                                       ;possible
1740         cmpb    #2,%d1
1741         bgts    ddbl                    |double=5, extended=2, single=1
1742         bnes    dsgl
1743 |                                       ;fall through to dext
1744 dext:
1745         bsrl    dest_ext
1746         bra     mvout_end
1747 dsgl:
1748         bsrl    dest_sgl
1749         bra     mvout_end
1750 ddbl:
1751         bsrl    dest_dbl
1752         bra     mvout_end
1753
1754 |
1755 | Handle possible denorm or catastrophic underflow cases here
1756 |
1757 xdnrm:
1758         bsr     set_xop         |initialize WBTEMP
1759         bsetb   #wbtemp15_bit,WB_BYTE(%a6) |set wbtemp15
1760
1761         movel   %a0,%a1
1762         movel   EXC_EA(%a6),%a0 |a0 has the destination pointer
1763         bsrl    dest_ext        |store to memory
1764         bsetb   #unfl_bit,FPSR_EXCEPT(%a6)
1765         bra     mvout_end
1766
1767 sp_under:
1768         bsetb   #etemp15_bit,STAG(%a6)
1769
1770         cmpw    4(%a1),%d0
1771         blts    sp_catas        |catastrophic underflow case
1772
1773         movel   #1,%d0          |load in round precision
1774         movel   #sgl_thresh,%d1 |load in single denorm threshold
1775         bsrl    dpspdnrm        |expects d1 to have the proper
1776 |                               ;denorm threshold
1777         bsrl    dest_sgl        |stores value to destination
1778         bsetb   #unfl_bit,FPSR_EXCEPT(%a6)
1779         bra     mvout_end       |exit
1780
1781 dp_under:
1782         bsetb   #etemp15_bit,STAG(%a6)
1783
1784         cmpw    4(%a1),%d0
1785         blts    dp_catas        |catastrophic underflow case
1786
1787         movel   #dbl_thresh,%d1 |load in double precision threshold
1788         movel   #2,%d0
1789         bsrl    dpspdnrm        |expects d1 to have proper
1790 |                               ;denorm threshold
1791 |                               ;expects d0 to have round precision
1792         bsrl    dest_dbl        |store value to destination
1793         bsetb   #unfl_bit,FPSR_EXCEPT(%a6)
1794         bra     mvout_end       |exit
1795
1796 |
1797 | Handle catastrophic underflow cases here
1798 |
1799 sp_catas:
1800 | Temp fix for z bit set in unf_sub
1801         movel   USER_FPSR(%a6),-(%a7)
1802
1803         movel   #1,%d0          |set round precision to sgl
1804
1805         bsrl    unf_sub         |a0 points to result
1806
1807         movel   (%a7)+,USER_FPSR(%a6)
1808
1809         movel   #1,%d0
1810         subw    %d0,LOCAL_EX(%a0) |account for difference between
1811 |                               ;denorm/norm bias
1812
1813         movel   %a0,%a1         |a1 has the operand input
1814         movel   EXC_EA(%a6),%a0 |a0 has the destination pointer
1815
1816         bsrl    dest_sgl        |store the result
1817         oril    #unfinx_mask,USER_FPSR(%a6)
1818         bra     mvout_end
1819
1820 dp_catas:
1821 | Temp fix for z bit set in unf_sub
1822         movel   USER_FPSR(%a6),-(%a7)
1823
1824         movel   #2,%d0          |set round precision to dbl
1825         bsrl    unf_sub         |a0 points to result
1826
1827         movel   (%a7)+,USER_FPSR(%a6)
1828
1829         movel   #1,%d0
1830         subw    %d0,LOCAL_EX(%a0) |account for difference between
1831 |                               ;denorm/norm bias
1832
1833         movel   %a0,%a1         |a1 has the operand input
1834         movel   EXC_EA(%a6),%a0 |a0 has the destination pointer
1835
1836         bsrl    dest_dbl        |store the result
1837         oril    #unfinx_mask,USER_FPSR(%a6)
1838         bra     mvout_end
1839
1840 |
1841 | Handle catastrophic overflow cases here
1842 |
1843 sp_over:
1844 | Temp fix for z bit set in unf_sub
1845         movel   USER_FPSR(%a6),-(%a7)
1846
1847         movel   #1,%d0
1848         leal    FP_SCR1(%a6),%a0        |use FP_SCR1 for creating result
1849         movel   ETEMP_EX(%a6),(%a0)
1850         movel   ETEMP_HI(%a6),4(%a0)
1851         movel   ETEMP_LO(%a6),8(%a0)
1852         bsrl    ovf_res
1853
1854         movel   (%a7)+,USER_FPSR(%a6)
1855
1856         movel   %a0,%a1
1857         movel   EXC_EA(%a6),%a0
1858         bsrl    dest_sgl
1859         orl     #ovfinx_mask,USER_FPSR(%a6)
1860         bra     mvout_end
1861
1862 dp_over:
1863 | Temp fix for z bit set in ovf_res
1864         movel   USER_FPSR(%a6),-(%a7)
1865
1866         movel   #2,%d0
1867         leal    FP_SCR1(%a6),%a0        |use FP_SCR1 for creating result
1868         movel   ETEMP_EX(%a6),(%a0)
1869         movel   ETEMP_HI(%a6),4(%a0)
1870         movel   ETEMP_LO(%a6),8(%a0)
1871         bsrl    ovf_res
1872
1873         movel   (%a7)+,USER_FPSR(%a6)
1874
1875         movel   %a0,%a1
1876         movel   EXC_EA(%a6),%a0
1877         bsrl    dest_dbl
1878         orl     #ovfinx_mask,USER_FPSR(%a6)
1879         bra     mvout_end
1880
1881 |
1882 |       DPSPDNRM
1883 |
1884 | This subroutine takes an extended normalized number and denormalizes
1885 | it to the given round precision. This subroutine also decrements
1886 | the input operand's exponent by 1 to account for the fact that
1887 | dest_sgl or dest_dbl expects a normalized number's bias.
1888 |
1889 | Input: a0  points to a normalized number in internal extended format
1890 |        d0  is the round precision (=1 for sgl; =2 for dbl)
1891 |        d1  is the single precision or double precision
1892 |            denorm threshold
1893 |
1894 | Output: (In the format for dest_sgl or dest_dbl)
1895 |        a0   points to the destination
1896 |        a1   points to the operand
1897 |
1898 | Exceptions: Reports inexact 2 exception by setting USER_FPSR bits
1899 |
1900 dpspdnrm:
1901         movel   %d0,-(%a7)      |save round precision
1902         clrl    %d0             |clear initial g,r,s
1903         bsrl    dnrm_lp         |careful with d0, it's needed by round
1904
1905         bfextu  FPCR_MODE(%a6){#2:#2},%d1 |get rounding mode
1906         swap    %d1
1907         movew   2(%a7),%d1      |set rounding precision
1908         swap    %d1             |at this point d1 has PREC/MODE info
1909         bsrl    round           |round result, sets the inex bit in
1910 |                               ;USER_FPSR if needed
1911
1912         movew   #1,%d0
1913         subw    %d0,LOCAL_EX(%a0) |account for difference in denorm
1914 |                               ;vs norm bias
1915
1916         movel   %a0,%a1         |a1 has the operand input
1917         movel   EXC_EA(%a6),%a0 |a0 has the destination pointer
1918         addw    #4,%a7          |pop stack
1919         rts
1920 |
1921 | SET_XOP initialized WBTEMP with the value pointed to by a0
1922 | input: a0 points to input operand in the internal extended format
1923 |
1924 set_xop:
1925         movel   LOCAL_EX(%a0),WBTEMP_EX(%a6)
1926         movel   LOCAL_HI(%a0),WBTEMP_HI(%a6)
1927         movel   LOCAL_LO(%a0),WBTEMP_LO(%a6)
1928         bfclr   WBTEMP_SGN(%a6){#0:#8}
1929         beqs    sxop
1930         bsetb   #sign_bit,WBTEMP_EX(%a6)
1931 sxop:
1932         bfclr   STAG(%a6){#5:#4}        |clear wbtm66,wbtm1,wbtm0,sbit
1933         rts
1934 |
1935 |       P_MOVE
1936 |
1937 p_movet:
1938         .long   p_move
1939         .long   p_movez
1940         .long   p_movei
1941         .long   p_moven
1942         .long   p_move
1943 p_regd:
1944         .long   p_dyd0
1945         .long   p_dyd1
1946         .long   p_dyd2
1947         .long   p_dyd3
1948         .long   p_dyd4
1949         .long   p_dyd5
1950         .long   p_dyd6
1951         .long   p_dyd7
1952
1953 pack_out:
1954         leal    p_movet,%a0     |load jmp table address
1955         movew   STAG(%a6),%d0   |get source tag
1956         bfextu  %d0{#16:#3},%d0 |isolate source bits
1957         movel   (%a0,%d0.w*4),%a0       |load a0 with routine label for tag
1958         jmp     (%a0)           |go to the routine
1959
1960 p_write:
1961         movel   #0x0c,%d0       |get byte count
1962         movel   EXC_EA(%a6),%a1 |get the destination address
1963         bsr     mem_write       |write the user's destination
1964         moveb   #0,CU_SAVEPC(%a6) |set the cu save pc to all 0's
1965
1966 |
1967 | Also note that the dtag must be set to norm here - this is because
1968 | the 040 uses the dtag to execute the correct microcode.
1969 |
1970         bfclr    DTAG(%a6){#0:#3}  |set dtag to norm
1971
1972         rts
1973
1974 | Notes on handling of special case (zero, inf, and nan) inputs:
1975 |       1. Operr is not signalled if the k-factor is greater than 18.
1976 |       2. Per the manual, status bits are not set.
1977 |
1978
1979 p_move:
1980         movew   CMDREG1B(%a6),%d0
1981         btstl   #kfact_bit,%d0  |test for dynamic k-factor
1982         beqs    statick         |if clear, k-factor is static
1983 dynamick:
1984         bfextu  %d0{#25:#3},%d0 |isolate register for dynamic k-factor
1985         lea     p_regd,%a0
1986         movel   %a0@(%d0:l:4),%a0
1987         jmp     (%a0)
1988 statick:
1989         andiw   #0x007f,%d0     |get k-factor
1990         bfexts  %d0{#25:#7},%d0 |sign extend d0 for bindec
1991         leal    ETEMP(%a6),%a0  |a0 will point to the packed decimal
1992         bsrl    bindec          |perform the convert; data at a6
1993         leal    FP_SCR1(%a6),%a0        |load a0 with result address
1994         bral    p_write
1995 p_movez:
1996         leal    ETEMP(%a6),%a0  |a0 will point to the packed decimal
1997         clrw    2(%a0)          |clear lower word of exp
1998         clrl    4(%a0)          |load second lword of ZERO
1999         clrl    8(%a0)          |load third lword of ZERO
2000         bra     p_write         |go write results
2001 p_movei:
2002         fmovel  #0,%FPSR                |clear aiop
2003         leal    ETEMP(%a6),%a0  |a0 will point to the packed decimal
2004         clrw    2(%a0)          |clear lower word of exp
2005         bra     p_write         |go write the result
2006 p_moven:
2007         leal    ETEMP(%a6),%a0  |a0 will point to the packed decimal
2008         clrw    2(%a0)          |clear lower word of exp
2009         bra     p_write         |go write the result
2010
2011 |
2012 | Routines to read the dynamic k-factor from Dn.
2013 |
2014 p_dyd0:
2015         movel   USER_D0(%a6),%d0
2016         bras    statick
2017 p_dyd1:
2018         movel   USER_D1(%a6),%d0
2019         bras    statick
2020 p_dyd2:
2021         movel   %d2,%d0
2022         bras    statick
2023 p_dyd3:
2024         movel   %d3,%d0
2025         bras    statick
2026 p_dyd4:
2027         movel   %d4,%d0
2028         bras    statick
2029 p_dyd5:
2030         movel   %d5,%d0
2031         bras    statick
2032 p_dyd6:
2033         movel   %d6,%d0
2034         bra     statick
2035 p_dyd7:
2036         movel   %d7,%d0
2037         bra     statick
2038
2039         |end