[PATCH] Add wording to m68k .S files to help clarify license info
[linux-3.10.git] / arch / m68k / fpsp040 / util.S
1 |
2 |       util.sa 3.7 7/29/91
3 |
4 |       This file contains routines used by other programs.
5 |
6 |       ovf_res: used by overflow to force the correct
7 |                result. ovf_r_k, ovf_r_x2, ovf_r_x3 are
8 |                derivatives of this routine.
9 |       get_fline: get user's opcode word
10 |       g_dfmtou: returns the destination format.
11 |       g_opcls: returns the opclass of the float instruction.
12 |       g_rndpr: returns the rounding precision.
13 |       reg_dest: write byte, word, or long data to Dn
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 |UTIL   idnt    2,1 | Motorola 040 Floating Point Software Package
23
24         |section        8
25
26 #include "fpsp.h"
27
28         |xref   mem_read
29
30         .global g_dfmtou
31         .global g_opcls
32         .global g_rndpr
33         .global get_fline
34         .global reg_dest
35
36 |
37 | Final result table for ovf_res. Note that the negative counterparts
38 | are unnecessary as ovf_res always returns the sign separately from
39 | the exponent.
40 |                                       ;+inf
41 EXT_PINF:       .long   0x7fff0000,0x00000000,0x00000000,0x00000000
42 |                                       ;largest +ext
43 EXT_PLRG:       .long   0x7ffe0000,0xffffffff,0xffffffff,0x00000000
44 |                                       ;largest magnitude +sgl in ext
45 SGL_PLRG:       .long   0x407e0000,0xffffff00,0x00000000,0x00000000
46 |                                       ;largest magnitude +dbl in ext
47 DBL_PLRG:       .long   0x43fe0000,0xffffffff,0xfffff800,0x00000000
48 |                                       ;largest -ext
49
50 tblovfl:
51         .long   EXT_RN
52         .long   EXT_RZ
53         .long   EXT_RM
54         .long   EXT_RP
55         .long   SGL_RN
56         .long   SGL_RZ
57         .long   SGL_RM
58         .long   SGL_RP
59         .long   DBL_RN
60         .long   DBL_RZ
61         .long   DBL_RM
62         .long   DBL_RP
63         .long   error
64         .long   error
65         .long   error
66         .long   error
67
68
69 |
70 |       ovf_r_k --- overflow result calculation
71 |
72 | This entry point is used by kernel_ex.
73 |
74 | This forces the destination precision to be extended
75 |
76 | Input:        operand in ETEMP
77 | Output:       a result is in ETEMP (internal extended format)
78 |
79         .global ovf_r_k
80 ovf_r_k:
81         lea     ETEMP(%a6),%a0  |a0 points to source operand
82         bclrb   #sign_bit,ETEMP_EX(%a6)
83         sne     ETEMP_SGN(%a6)  |convert to internal IEEE format
84
85 |
86 |       ovf_r_x2 --- overflow result calculation
87 |
88 | This entry point used by x_ovfl.  (opclass 0 and 2)
89 |
90 | Input         a0  points to an operand in the internal extended format
91 | Output        a0  points to the result in the internal extended format
92 |
93 | This sets the round precision according to the user's FPCR unless the
94 | instruction is fsgldiv or fsglmul or fsadd, fdadd, fsub, fdsub, fsmul,
95 | fdmul, fsdiv, fddiv, fssqrt, fsmove, fdmove, fsabs, fdabs, fsneg, fdneg.
96 | If the instruction is fsgldiv of fsglmul, the rounding precision must be
97 | extended.  If the instruction is not fsgldiv or fsglmul but a force-
98 | precision instruction, the rounding precision is then set to the force
99 | precision.
100
101         .global ovf_r_x2
102 ovf_r_x2:
103         btstb   #E3,E_BYTE(%a6)         |check for nu exception
104         beql    ovf_e1_exc              |it is cu exception
105 ovf_e3_exc:
106         movew   CMDREG3B(%a6),%d0               |get the command word
107         andiw   #0x00000060,%d0         |clear all bits except 6 and 5
108         cmpil   #0x00000040,%d0
109         beql    ovff_sgl                |force precision is single
110         cmpil   #0x00000060,%d0
111         beql    ovff_dbl                |force precision is double
112         movew   CMDREG3B(%a6),%d0               |get the command word again
113         andil   #0x7f,%d0                       |clear all except operation
114         cmpil   #0x33,%d0
115         beql    ovf_fsgl                |fsglmul or fsgldiv
116         cmpil   #0x30,%d0
117         beql    ovf_fsgl
118         bra     ovf_fpcr                |instruction is none of the above
119 |                                       ;use FPCR
120 ovf_e1_exc:
121         movew   CMDREG1B(%a6),%d0               |get command word
122         andil   #0x00000044,%d0         |clear all bits except 6 and 2
123         cmpil   #0x00000040,%d0
124         beql    ovff_sgl                |the instruction is force single
125         cmpil   #0x00000044,%d0
126         beql    ovff_dbl                |the instruction is force double
127         movew   CMDREG1B(%a6),%d0               |again get the command word
128         andil   #0x0000007f,%d0         |clear all except the op code
129         cmpil   #0x00000027,%d0
130         beql    ovf_fsgl                |fsglmul
131         cmpil   #0x00000024,%d0
132         beql    ovf_fsgl                |fsgldiv
133         bra     ovf_fpcr                |none of the above, use FPCR
134 |
135 |
136 | Inst is either fsgldiv or fsglmul.  Force extended precision.
137 |
138 ovf_fsgl:
139         clrl    %d0
140         bra     ovf_res
141
142 ovff_sgl:
143         movel   #0x00000001,%d0         |set single
144         bra     ovf_res
145 ovff_dbl:
146         movel   #0x00000002,%d0         |set double
147         bra     ovf_res
148 |
149 | The precision is in the fpcr.
150 |
151 ovf_fpcr:
152         bfextu  FPCR_MODE(%a6){#0:#2},%d0 |set round precision
153         bra     ovf_res
154
155 |
156 |
157 |       ovf_r_x3 --- overflow result calculation
158 |
159 | This entry point used by x_ovfl. (opclass 3 only)
160 |
161 | Input         a0  points to an operand in the internal extended format
162 | Output        a0  points to the result in the internal extended format
163 |
164 | This sets the round precision according to the destination size.
165 |
166         .global ovf_r_x3
167 ovf_r_x3:
168         bsr     g_dfmtou        |get dest fmt in d0{1:0}
169 |                               ;for fmovout, the destination format
170 |                               ;is the rounding precision
171
172 |
173 |       ovf_res --- overflow result calculation
174 |
175 | Input:
176 |       a0      points to operand in internal extended format
177 | Output:
178 |       a0      points to result in internal extended format
179 |
180         .global ovf_res
181 ovf_res:
182         lsll    #2,%d0          |move round precision to d0{3:2}
183         bfextu  FPCR_MODE(%a6){#2:#2},%d1 |set round mode
184         orl     %d1,%d0         |index is fmt:mode in d0{3:0}
185         leal    tblovfl,%a1     |load a1 with table address
186         movel   %a1@(%d0:l:4),%a1       |use d0 as index to the table
187         jmp     (%a1)           |go to the correct routine
188 |
189 |case DEST_FMT = EXT
190 |
191 EXT_RN:
192         leal    EXT_PINF,%a1    |answer is +/- infinity
193         bsetb   #inf_bit,FPSR_CC(%a6)
194         bra     set_sign        |now go set the sign
195 EXT_RZ:
196         leal    EXT_PLRG,%a1    |answer is +/- large number
197         bra     set_sign        |now go set the sign
198 EXT_RM:
199         tstb    LOCAL_SGN(%a0)  |if negative overflow
200         beqs    e_rm_pos
201 e_rm_neg:
202         leal    EXT_PINF,%a1    |answer is negative infinity
203         orl     #neginf_mask,USER_FPSR(%a6)
204         bra     end_ovfr
205 e_rm_pos:
206         leal    EXT_PLRG,%a1    |answer is large positive number
207         bra     end_ovfr
208 EXT_RP:
209         tstb    LOCAL_SGN(%a0)  |if negative overflow
210         beqs    e_rp_pos
211 e_rp_neg:
212         leal    EXT_PLRG,%a1    |answer is large negative number
213         bsetb   #neg_bit,FPSR_CC(%a6)
214         bra     end_ovfr
215 e_rp_pos:
216         leal    EXT_PINF,%a1    |answer is positive infinity
217         bsetb   #inf_bit,FPSR_CC(%a6)
218         bra     end_ovfr
219 |
220 |case DEST_FMT = DBL
221 |
222 DBL_RN:
223         leal    EXT_PINF,%a1    |answer is +/- infinity
224         bsetb   #inf_bit,FPSR_CC(%a6)
225         bra     set_sign
226 DBL_RZ:
227         leal    DBL_PLRG,%a1    |answer is +/- large number
228         bra     set_sign        |now go set the sign
229 DBL_RM:
230         tstb    LOCAL_SGN(%a0)  |if negative overflow
231         beqs    d_rm_pos
232 d_rm_neg:
233         leal    EXT_PINF,%a1    |answer is negative infinity
234         orl     #neginf_mask,USER_FPSR(%a6)
235         bra     end_ovfr        |inf is same for all precisions (ext,dbl,sgl)
236 d_rm_pos:
237         leal    DBL_PLRG,%a1    |answer is large positive number
238         bra     end_ovfr
239 DBL_RP:
240         tstb    LOCAL_SGN(%a0)  |if negative overflow
241         beqs    d_rp_pos
242 d_rp_neg:
243         leal    DBL_PLRG,%a1    |answer is large negative number
244         bsetb   #neg_bit,FPSR_CC(%a6)
245         bra     end_ovfr
246 d_rp_pos:
247         leal    EXT_PINF,%a1    |answer is positive infinity
248         bsetb   #inf_bit,FPSR_CC(%a6)
249         bra     end_ovfr
250 |
251 |case DEST_FMT = SGL
252 |
253 SGL_RN:
254         leal    EXT_PINF,%a1    |answer is +/-  infinity
255         bsetb   #inf_bit,FPSR_CC(%a6)
256         bras    set_sign
257 SGL_RZ:
258         leal    SGL_PLRG,%a1    |answer is +/- large number
259         bras    set_sign
260 SGL_RM:
261         tstb    LOCAL_SGN(%a0)  |if negative overflow
262         beqs    s_rm_pos
263 s_rm_neg:
264         leal    EXT_PINF,%a1    |answer is negative infinity
265         orl     #neginf_mask,USER_FPSR(%a6)
266         bras    end_ovfr
267 s_rm_pos:
268         leal    SGL_PLRG,%a1    |answer is large positive number
269         bras    end_ovfr
270 SGL_RP:
271         tstb    LOCAL_SGN(%a0)  |if negative overflow
272         beqs    s_rp_pos
273 s_rp_neg:
274         leal    SGL_PLRG,%a1    |answer is large negative number
275         bsetb   #neg_bit,FPSR_CC(%a6)
276         bras    end_ovfr
277 s_rp_pos:
278         leal    EXT_PINF,%a1    |answer is positive infinity
279         bsetb   #inf_bit,FPSR_CC(%a6)
280         bras    end_ovfr
281
282 set_sign:
283         tstb    LOCAL_SGN(%a0)  |if negative overflow
284         beqs    end_ovfr
285 neg_sign:
286         bsetb   #neg_bit,FPSR_CC(%a6)
287
288 end_ovfr:
289         movew   LOCAL_EX(%a1),LOCAL_EX(%a0) |do not overwrite sign
290         movel   LOCAL_HI(%a1),LOCAL_HI(%a0)
291         movel   LOCAL_LO(%a1),LOCAL_LO(%a0)
292         rts
293
294
295 |
296 |       ERROR
297 |
298 error:
299         rts
300 |
301 |       get_fline --- get f-line opcode of interrupted instruction
302 |
303 |       Returns opcode in the low word of d0.
304 |
305 get_fline:
306         movel   USER_FPIAR(%a6),%a0     |opcode address
307         movel   #0,-(%a7)       |reserve a word on the stack
308         leal    2(%a7),%a1      |point to low word of temporary
309         movel   #2,%d0          |count
310         bsrl    mem_read
311         movel   (%a7)+,%d0
312         rts
313 |
314 |       g_rndpr --- put rounding precision in d0{1:0}
315 |
316 |       valid return codes are:
317 |               00 - extended
318 |               01 - single
319 |               10 - double
320 |
321 | begin
322 | get rounding precision (cmdreg3b{6:5})
323 | begin
324 |  case opclass = 011 (move out)
325 |       get destination format - this is the also the rounding precision
326 |
327 |  case opclass = 0x0
328 |       if E3
329 |           *case RndPr(from cmdreg3b{6:5} = 11  then RND_PREC = DBL
330 |           *case RndPr(from cmdreg3b{6:5} = 10  then RND_PREC = SGL
331 |            case RndPr(from cmdreg3b{6:5} = 00 | 01
332 |               use precision from FPCR{7:6}
333 |                       case 00 then RND_PREC = EXT
334 |                       case 01 then RND_PREC = SGL
335 |                       case 10 then RND_PREC = DBL
336 |       else E1
337 |            use precision in FPCR{7:6}
338 |            case 00 then RND_PREC = EXT
339 |            case 01 then RND_PREC = SGL
340 |            case 10 then RND_PREC = DBL
341 | end
342 |
343 g_rndpr:
344         bsr     g_opcls         |get opclass in d0{2:0}
345         cmpw    #0x0003,%d0     |check for opclass 011
346         bnes    op_0x0
347
348 |
349 | For move out instructions (opclass 011) the destination format
350 | is the same as the rounding precision.  Pass results from g_dfmtou.
351 |
352         bsr     g_dfmtou
353         rts
354 op_0x0:
355         btstb   #E3,E_BYTE(%a6)
356         beql    unf_e1_exc      |branch to e1 underflow
357 unf_e3_exc:
358         movel   CMDREG3B(%a6),%d0       |rounding precision in d0{10:9}
359         bfextu  %d0{#9:#2},%d0  |move the rounding prec bits to d0{1:0}
360         cmpil   #0x2,%d0
361         beql    unff_sgl        |force precision is single
362         cmpil   #0x3,%d0                |force precision is double
363         beql    unff_dbl
364         movew   CMDREG3B(%a6),%d0       |get the command word again
365         andil   #0x7f,%d0               |clear all except operation
366         cmpil   #0x33,%d0
367         beql    unf_fsgl        |fsglmul or fsgldiv
368         cmpil   #0x30,%d0
369         beql    unf_fsgl        |fsgldiv or fsglmul
370         bra     unf_fpcr
371 unf_e1_exc:
372         movel   CMDREG1B(%a6),%d0       |get 32 bits off the stack, 1st 16 bits
373 |                               ;are the command word
374         andil   #0x00440000,%d0 |clear all bits except bits 6 and 2
375         cmpil   #0x00400000,%d0
376         beql    unff_sgl        |force single
377         cmpil   #0x00440000,%d0 |force double
378         beql    unff_dbl
379         movel   CMDREG1B(%a6),%d0       |get the command word again
380         andil   #0x007f0000,%d0 |clear all bits except the operation
381         cmpil   #0x00270000,%d0
382         beql    unf_fsgl        |fsglmul
383         cmpil   #0x00240000,%d0
384         beql    unf_fsgl        |fsgldiv
385         bra     unf_fpcr
386
387 |
388 | Convert to return format.  The values from cmdreg3b and the return
389 | values are:
390 |       cmdreg3b        return       precision
391 |       --------        ------       ---------
392 |         00,01           0             ext
393 |          10             1             sgl
394 |          11             2             dbl
395 | Force single
396 |
397 unff_sgl:
398         movel   #1,%d0          |return 1
399         rts
400 |
401 | Force double
402 |
403 unff_dbl:
404         movel   #2,%d0          |return 2
405         rts
406 |
407 | Force extended
408 |
409 unf_fsgl:
410         movel   #0,%d0
411         rts
412 |
413 | Get rounding precision set in FPCR{7:6}.
414 |
415 unf_fpcr:
416         movel   USER_FPCR(%a6),%d0 |rounding precision bits in d0{7:6}
417         bfextu  %d0{#24:#2},%d0 |move the rounding prec bits to d0{1:0}
418         rts
419 |
420 |       g_opcls --- put opclass in d0{2:0}
421 |
422 g_opcls:
423         btstb   #E3,E_BYTE(%a6)
424         beqs    opc_1b          |if set, go to cmdreg1b
425 opc_3b:
426         clrl    %d0             |if E3, only opclass 0x0 is possible
427         rts
428 opc_1b:
429         movel   CMDREG1B(%a6),%d0
430         bfextu  %d0{#0:#3},%d0  |shift opclass bits d0{31:29} to d0{2:0}
431         rts
432 |
433 |       g_dfmtou --- put destination format in d0{1:0}
434 |
435 |       If E1, the format is from cmdreg1b{12:10}
436 |       If E3, the format is extended.
437 |
438 |       Dest. Fmt.
439 |               extended  010 -> 00
440 |               single    001 -> 01
441 |               double    101 -> 10
442 |
443 g_dfmtou:
444         btstb   #E3,E_BYTE(%a6)
445         beqs    op011
446         clrl    %d0             |if E1, size is always ext
447         rts
448 op011:
449         movel   CMDREG1B(%a6),%d0
450         bfextu  %d0{#3:#3},%d0  |dest fmt from cmdreg1b{12:10}
451         cmpb    #1,%d0          |check for single
452         bnes    not_sgl
453         movel   #1,%d0
454         rts
455 not_sgl:
456         cmpb    #5,%d0          |check for double
457         bnes    not_dbl
458         movel   #2,%d0
459         rts
460 not_dbl:
461         clrl    %d0             |must be extended
462         rts
463
464 |
465 |
466 | Final result table for unf_sub. Note that the negative counterparts
467 | are unnecessary as unf_sub always returns the sign separately from
468 | the exponent.
469 |                                       ;+zero
470 EXT_PZRO:       .long   0x00000000,0x00000000,0x00000000,0x00000000
471 |                                       ;+zero
472 SGL_PZRO:       .long   0x3f810000,0x00000000,0x00000000,0x00000000
473 |                                       ;+zero
474 DBL_PZRO:       .long   0x3c010000,0x00000000,0x00000000,0x00000000
475 |                                       ;smallest +ext denorm
476 EXT_PSML:       .long   0x00000000,0x00000000,0x00000001,0x00000000
477 |                                       ;smallest +sgl denorm
478 SGL_PSML:       .long   0x3f810000,0x00000100,0x00000000,0x00000000
479 |                                       ;smallest +dbl denorm
480 DBL_PSML:       .long   0x3c010000,0x00000000,0x00000800,0x00000000
481 |
482 |       UNF_SUB --- underflow result calculation
483 |
484 | Input:
485 |       d0      contains round precision
486 |       a0      points to input operand in the internal extended format
487 |
488 | Output:
489 |       a0      points to correct internal extended precision result.
490 |
491
492 tblunf:
493         .long   uEXT_RN
494         .long   uEXT_RZ
495         .long   uEXT_RM
496         .long   uEXT_RP
497         .long   uSGL_RN
498         .long   uSGL_RZ
499         .long   uSGL_RM
500         .long   uSGL_RP
501         .long   uDBL_RN
502         .long   uDBL_RZ
503         .long   uDBL_RM
504         .long   uDBL_RP
505         .long   uDBL_RN
506         .long   uDBL_RZ
507         .long   uDBL_RM
508         .long   uDBL_RP
509
510         .global unf_sub
511 unf_sub:
512         lsll    #2,%d0          |move round precision to d0{3:2}
513         bfextu  FPCR_MODE(%a6){#2:#2},%d1 |set round mode
514         orl     %d1,%d0         |index is fmt:mode in d0{3:0}
515         leal    tblunf,%a1      |load a1 with table address
516         movel   %a1@(%d0:l:4),%a1       |use d0 as index to the table
517         jmp     (%a1)           |go to the correct routine
518 |
519 |case DEST_FMT = EXT
520 |
521 uEXT_RN:
522         leal    EXT_PZRO,%a1    |answer is +/- zero
523         bsetb   #z_bit,FPSR_CC(%a6)
524         bra     uset_sign       |now go set the sign
525 uEXT_RZ:
526         leal    EXT_PZRO,%a1    |answer is +/- zero
527         bsetb   #z_bit,FPSR_CC(%a6)
528         bra     uset_sign       |now go set the sign
529 uEXT_RM:
530         tstb    LOCAL_SGN(%a0)  |if negative underflow
531         beqs    ue_rm_pos
532 ue_rm_neg:
533         leal    EXT_PSML,%a1    |answer is negative smallest denorm
534         bsetb   #neg_bit,FPSR_CC(%a6)
535         bra     end_unfr
536 ue_rm_pos:
537         leal    EXT_PZRO,%a1    |answer is positive zero
538         bsetb   #z_bit,FPSR_CC(%a6)
539         bra     end_unfr
540 uEXT_RP:
541         tstb    LOCAL_SGN(%a0)  |if negative underflow
542         beqs    ue_rp_pos
543 ue_rp_neg:
544         leal    EXT_PZRO,%a1    |answer is negative zero
545         oril    #negz_mask,USER_FPSR(%a6)
546         bra     end_unfr
547 ue_rp_pos:
548         leal    EXT_PSML,%a1    |answer is positive smallest denorm
549         bra     end_unfr
550 |
551 |case DEST_FMT = DBL
552 |
553 uDBL_RN:
554         leal    DBL_PZRO,%a1    |answer is +/- zero
555         bsetb   #z_bit,FPSR_CC(%a6)
556         bra     uset_sign
557 uDBL_RZ:
558         leal    DBL_PZRO,%a1    |answer is +/- zero
559         bsetb   #z_bit,FPSR_CC(%a6)
560         bra     uset_sign       |now go set the sign
561 uDBL_RM:
562         tstb    LOCAL_SGN(%a0)  |if negative overflow
563         beqs    ud_rm_pos
564 ud_rm_neg:
565         leal    DBL_PSML,%a1    |answer is smallest denormalized negative
566         bsetb   #neg_bit,FPSR_CC(%a6)
567         bra     end_unfr
568 ud_rm_pos:
569         leal    DBL_PZRO,%a1    |answer is positive zero
570         bsetb   #z_bit,FPSR_CC(%a6)
571         bra     end_unfr
572 uDBL_RP:
573         tstb    LOCAL_SGN(%a0)  |if negative overflow
574         beqs    ud_rp_pos
575 ud_rp_neg:
576         leal    DBL_PZRO,%a1    |answer is negative zero
577         oril    #negz_mask,USER_FPSR(%a6)
578         bra     end_unfr
579 ud_rp_pos:
580         leal    DBL_PSML,%a1    |answer is smallest denormalized negative
581         bra     end_unfr
582 |
583 |case DEST_FMT = SGL
584 |
585 uSGL_RN:
586         leal    SGL_PZRO,%a1    |answer is +/- zero
587         bsetb   #z_bit,FPSR_CC(%a6)
588         bras    uset_sign
589 uSGL_RZ:
590         leal    SGL_PZRO,%a1    |answer is +/- zero
591         bsetb   #z_bit,FPSR_CC(%a6)
592         bras    uset_sign
593 uSGL_RM:
594         tstb    LOCAL_SGN(%a0)  |if negative overflow
595         beqs    us_rm_pos
596 us_rm_neg:
597         leal    SGL_PSML,%a1    |answer is smallest denormalized negative
598         bsetb   #neg_bit,FPSR_CC(%a6)
599         bras    end_unfr
600 us_rm_pos:
601         leal    SGL_PZRO,%a1    |answer is positive zero
602         bsetb   #z_bit,FPSR_CC(%a6)
603         bras    end_unfr
604 uSGL_RP:
605         tstb    LOCAL_SGN(%a0)  |if negative overflow
606         beqs    us_rp_pos
607 us_rp_neg:
608         leal    SGL_PZRO,%a1    |answer is negative zero
609         oril    #negz_mask,USER_FPSR(%a6)
610         bras    end_unfr
611 us_rp_pos:
612         leal    SGL_PSML,%a1    |answer is smallest denormalized positive
613         bras    end_unfr
614
615 uset_sign:
616         tstb    LOCAL_SGN(%a0)  |if negative overflow
617         beqs    end_unfr
618 uneg_sign:
619         bsetb   #neg_bit,FPSR_CC(%a6)
620
621 end_unfr:
622         movew   LOCAL_EX(%a1),LOCAL_EX(%a0) |be careful not to overwrite sign
623         movel   LOCAL_HI(%a1),LOCAL_HI(%a0)
624         movel   LOCAL_LO(%a1),LOCAL_LO(%a0)
625         rts
626 |
627 |       reg_dest --- write byte, word, or long data to Dn
628 |
629 |
630 | Input:
631 |       L_SCR1: Data
632 |       d1:     data size and dest register number formatted as:
633 |
634 |       32              5    4     3     2     1     0
635 |       -----------------------------------------------
636 |       |        0        |    Size   |  Dest Reg #   |
637 |       -----------------------------------------------
638 |
639 |       Size is:
640 |               0 - Byte
641 |               1 - Word
642 |               2 - Long/Single
643 |
644 pregdst:
645         .long   byte_d0
646         .long   byte_d1
647         .long   byte_d2
648         .long   byte_d3
649         .long   byte_d4
650         .long   byte_d5
651         .long   byte_d6
652         .long   byte_d7
653         .long   word_d0
654         .long   word_d1
655         .long   word_d2
656         .long   word_d3
657         .long   word_d4
658         .long   word_d5
659         .long   word_d6
660         .long   word_d7
661         .long   long_d0
662         .long   long_d1
663         .long   long_d2
664         .long   long_d3
665         .long   long_d4
666         .long   long_d5
667         .long   long_d6
668         .long   long_d7
669
670 reg_dest:
671         leal    pregdst,%a0
672         movel   %a0@(%d1:l:4),%a0
673         jmp     (%a0)
674
675 byte_d0:
676         moveb   L_SCR1(%a6),USER_D0+3(%a6)
677         rts
678 byte_d1:
679         moveb   L_SCR1(%a6),USER_D1+3(%a6)
680         rts
681 byte_d2:
682         moveb   L_SCR1(%a6),%d2
683         rts
684 byte_d3:
685         moveb   L_SCR1(%a6),%d3
686         rts
687 byte_d4:
688         moveb   L_SCR1(%a6),%d4
689         rts
690 byte_d5:
691         moveb   L_SCR1(%a6),%d5
692         rts
693 byte_d6:
694         moveb   L_SCR1(%a6),%d6
695         rts
696 byte_d7:
697         moveb   L_SCR1(%a6),%d7
698         rts
699 word_d0:
700         movew   L_SCR1(%a6),USER_D0+2(%a6)
701         rts
702 word_d1:
703         movew   L_SCR1(%a6),USER_D1+2(%a6)
704         rts
705 word_d2:
706         movew   L_SCR1(%a6),%d2
707         rts
708 word_d3:
709         movew   L_SCR1(%a6),%d3
710         rts
711 word_d4:
712         movew   L_SCR1(%a6),%d4
713         rts
714 word_d5:
715         movew   L_SCR1(%a6),%d5
716         rts
717 word_d6:
718         movew   L_SCR1(%a6),%d6
719         rts
720 word_d7:
721         movew   L_SCR1(%a6),%d7
722         rts
723 long_d0:
724         movel   L_SCR1(%a6),USER_D0(%a6)
725         rts
726 long_d1:
727         movel   L_SCR1(%a6),USER_D1(%a6)
728         rts
729 long_d2:
730         movel   L_SCR1(%a6),%d2
731         rts
732 long_d3:
733         movel   L_SCR1(%a6),%d3
734         rts
735 long_d4:
736         movel   L_SCR1(%a6),%d4
737         rts
738 long_d5:
739         movel   L_SCR1(%a6),%d5
740         rts
741 long_d6:
742         movel   L_SCR1(%a6),%d6
743         rts
744 long_d7:
745         movel   L_SCR1(%a6),%d7
746         rts
747         |end