Subversion Repositories openrisc_me

//

//      $Id: util.S,v 1.2 2001-09-27 12:01:22 chris Exp $

//

//      util.sa 3.7 7/29/91

//

//      This file contains routines used by other programs.

//

//      ovf_res: used by overflow to force the correct

//               result. ovf_r_k, ovf_r_x2, ovf_r_x3 are

//               derivatives of this routine.

//      get_fline: get user's opcode word

//      g_dfmtou: returns the destination format.

//      g_opcls: returns the opclass of the float instruction.

//      g_rndpr: returns the rounding precision.

//      reg_dest: write byte, word, or long data to Dn

//

//

//              Copyright (C) Motorola, Inc. 1990

//                      All Rights Reserved

//

//      THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF MOTOROLA

//      The copyright notice above does not evidence any

//      actual or intended publication of such source code.

//UTIL  idnt    2,1 | Motorola 040 Floating Point Software Package

        |section        8

#include "fpsp.defs"

        |xref   mem_read

        .global g_dfmtou

        .global g_opcls

        .global g_rndpr

        .global get_fline

        .global reg_dest

//

// Final result table for ovf_res. Note that the negative counterparts

// are unnecessary as ovf_res always returns the sign separately from

// the exponent.

//                                      ;+inf

EXT_PINF:       .long   0x7fff0000,0x00000000,0x00000000,0x00000000

//                                      ;largest +ext

EXT_PLRG:       .long   0x7ffe0000,0xffffffff,0xffffffff,0x00000000

//                                      ;largest magnitude +sgl in ext

SGL_PLRG:       .long   0x407e0000,0xffffff00,0x00000000,0x00000000

//                                      ;largest magnitude +dbl in ext

DBL_PLRG:       .long   0x43fe0000,0xffffffff,0xfffff800,0x00000000

//                                      ;largest -ext

tblovfl:

        .long   EXT_RN

        .long   EXT_RZ

        .long   EXT_RM

        .long   EXT_RP

        .long   SGL_RN

        .long   SGL_RZ

        .long   SGL_RM

        .long   SGL_RP

        .long   DBL_RN

        .long   DBL_RZ

        .long   DBL_RM

        .long   DBL_RP

        .long   error

        .long   error

        .long   error

        .long   error

//

//      ovf_r_k --- overflow result calculation

//

// This entry point is used by kernel_ex.

//

// This forces the destination precision to be extended

//

// Input:       operand in ETEMP

// Output:      a result is in ETEMP (internal extended format)

//

        .global ovf_r_k

ovf_r_k:

        lea     ETEMP(%a6),%a0  //a0 points to source operand

        bclrb   #sign_bit,ETEMP_EX(%a6)

        sne     ETEMP_SGN(%a6)  //convert to internal IEEE format

//

//      ovf_r_x2 --- overflow result calculation

//

// This entry point used by x_ovfl.  (opclass 0 and 2)

//

// Input                a0  points to an operand in the internal extended format

// Output       a0  points to the result in the internal extended format

//

// This sets the round precision according to the user's FPCR unless the

// instruction is fsgldiv or fsglmul or fsadd, fdadd, fsub, fdsub, fsmul,

// fdmul, fsdiv, fddiv, fssqrt, fsmove, fdmove, fsabs, fdabs, fsneg, fdneg.

// If the instruction is fsgldiv of fsglmul, the rounding precision must be

// extended.  If the instruction is not fsgldiv or fsglmul but a force-

// precision instruction, the rounding precision is then set to the force

// precision.

        .global ovf_r_x2

ovf_r_x2:

        btstb   #E3,E_BYTE(%a6)         //check for nu exception

        beql    ovf_e1_exc              //it is cu exception

ovf_e3_exc:

        movew   CMDREG3B(%a6),%d0               //get the command word

        andiw   #0x00000060,%d0         //clear all bits except 6 and 5

        cmpil   #0x00000040,%d0

        beql    ovff_sgl                //force precision is single

        cmpil   #0x00000060,%d0

        beql    ovff_dbl                //force precision is double

        movew   CMDREG3B(%a6),%d0               //get the command word again

        andil   #0x7f,%d0                       //clear all except operation

        cmpil   #0x33,%d0

        beql    ovf_fsgl                //fsglmul or fsgldiv

        cmpil   #0x30,%d0

        beql    ovf_fsgl

        bra     ovf_fpcr                //instruction is none of the above

//                                      ;use FPCR

ovf_e1_exc:

        movew   CMDREG1B(%a6),%d0               //get command word

        andil   #0x00000044,%d0         //clear all bits except 6 and 2

        cmpil   #0x00000040,%d0

        beql    ovff_sgl                //the instruction is force single

        cmpil   #0x00000044,%d0

        beql    ovff_dbl                //the instruction is force double

        movew   CMDREG1B(%a6),%d0               //again get the command word

        andil   #0x0000007f,%d0         //clear all except the op code

        cmpil   #0x00000027,%d0

        beql    ovf_fsgl                //fsglmul

        cmpil   #0x00000024,%d0

        beql    ovf_fsgl                //fsgldiv

        bra     ovf_fpcr                //none of the above, use FPCR

//

//

// Inst is either fsgldiv or fsglmul.  Force extended precision.

//

ovf_fsgl:

        clrl    %d0

        bra     ovf_res

ovff_sgl:

        movel   #0x00000001,%d0         //set single

        bra     ovf_res

ovff_dbl:

        movel   #0x00000002,%d0         //set double

        bra     ovf_res

//

// The precision is in the fpcr.

//

ovf_fpcr:

        bfextu  FPCR_MODE(%a6){#0:#2},%d0 //set round precision

        bra     ovf_res

//

//

//      ovf_r_x3 --- overflow result calculation

//

// This entry point used by x_ovfl. (opclass 3 only)

//

// Input                a0  points to an operand in the internal extended format

// Output       a0  points to the result in the internal extended format

//

// This sets the round precision according to the destination size.

//

        .global ovf_r_x3

ovf_r_x3:

        bsr     g_dfmtou        //get dest fmt in d0{1:0}

//                              ;for fmovout, the destination format

//                              ;is the rounding precision

//

//      ovf_res --- overflow result calculation

//

// Input:

//      a0      points to operand in internal extended format

// Output:

//      a0      points to result in internal extended format

//

        .global ovf_res

ovf_res:

        lsll    #2,%d0          //move round precision to d0{3:2}

        bfextu  FPCR_MODE(%a6){#2:#2},%d1 //set round mode

        orl     %d1,%d0         //index is fmt:mode in d0{3:0}

        leal    tblovfl,%a1     //load a1 with table address

        movel   %a1@(%d0:l:4),%a1       //use d0 as index to the table

        jmp     (%a1)           //go to the correct routine

//

//case DEST_FMT = EXT

//

EXT_RN:

        leal    EXT_PINF,%a1    //answer is +/- infinity

        bsetb   #inf_bit,FPSR_CC(%a6)

        bra     set_sign        //now go set the sign

EXT_RZ:

        leal    EXT_PLRG,%a1    //answer is +/- large number

        bra     set_sign        //now go set the sign

EXT_RM:

        tstb    LOCAL_SGN(%a0)  //if negative overflow

        beqs    e_rm_pos

e_rm_neg:

        leal    EXT_PINF,%a1    //answer is negative infinity

        orl     #neginf_mask,USER_FPSR(%a6)

        bra     end_ovfr

e_rm_pos:

        leal    EXT_PLRG,%a1    //answer is large positive number

        bra     end_ovfr

EXT_RP:

        tstb    LOCAL_SGN(%a0)  //if negative overflow

        beqs    e_rp_pos

e_rp_neg:

        leal    EXT_PLRG,%a1    //answer is large negative number

        bsetb   #neg_bit,FPSR_CC(%a6)

        bra     end_ovfr

e_rp_pos:

        leal    EXT_PINF,%a1    //answer is positive infinity

        bsetb   #inf_bit,FPSR_CC(%a6)

        bra     end_ovfr

//

//case DEST_FMT = DBL

//

DBL_RN:

        leal    EXT_PINF,%a1    //answer is +/- infinity

        bsetb   #inf_bit,FPSR_CC(%a6)

        bra     set_sign

DBL_RZ:

        leal    DBL_PLRG,%a1    //answer is +/- large number

        bra     set_sign        //now go set the sign

DBL_RM:

        tstb    LOCAL_SGN(%a0)  //if negative overflow

        beqs    d_rm_pos

d_rm_neg:

        leal    EXT_PINF,%a1    //answer is negative infinity

        orl     #neginf_mask,USER_FPSR(%a6)

        bra     end_ovfr        //inf is same for all precisions (ext,dbl,sgl)

d_rm_pos:

        leal    DBL_PLRG,%a1    //answer is large positive number

        bra     end_ovfr

DBL_RP:

        tstb    LOCAL_SGN(%a0)  //if negative overflow

        beqs    d_rp_pos

d_rp_neg:

        leal    DBL_PLRG,%a1    //answer is large negative number

        bsetb   #neg_bit,FPSR_CC(%a6)

        bra     end_ovfr

d_rp_pos:

        leal    EXT_PINF,%a1    //answer is positive infinity

        bsetb   #inf_bit,FPSR_CC(%a6)

        bra     end_ovfr

//

//case DEST_FMT = SGL

//

SGL_RN:

        leal    EXT_PINF,%a1    //answer is +/-  infinity

        bsetb   #inf_bit,FPSR_CC(%a6)

        bras    set_sign

SGL_RZ:

        leal    SGL_PLRG,%a1    //answer is +/- large number

        bras    set_sign

SGL_RM:

        tstb    LOCAL_SGN(%a0)  //if negative overflow

        beqs    s_rm_pos

s_rm_neg:

        leal    EXT_PINF,%a1    //answer is negative infinity

        orl     #neginf_mask,USER_FPSR(%a6)

        bras    end_ovfr

s_rm_pos:

        leal    SGL_PLRG,%a1    //answer is large positive number

        bras    end_ovfr

SGL_RP:

        tstb    LOCAL_SGN(%a0)  //if negative overflow

        beqs    s_rp_pos

s_rp_neg:

        leal    SGL_PLRG,%a1    //answer is large negative number

        bsetb   #neg_bit,FPSR_CC(%a6)

        bras    end_ovfr

s_rp_pos:

        leal    EXT_PINF,%a1    //answer is positive infinity

        bsetb   #inf_bit,FPSR_CC(%a6)

        bras    end_ovfr

set_sign:

        tstb    LOCAL_SGN(%a0)  //if negative overflow

        beqs    end_ovfr

neg_sign:

        bsetb   #neg_bit,FPSR_CC(%a6)

end_ovfr:

        movew   LOCAL_EX(%a1),LOCAL_EX(%a0) //do not overwrite sign

        movel   LOCAL_HI(%a1),LOCAL_HI(%a0)

        movel   LOCAL_LO(%a1),LOCAL_LO(%a0)

        rts

//

//      ERROR

//

error:

        rts

//

//      get_fline --- get f-line opcode of interrupted instruction

//

//      Returns opcode in the low word of d0.

//

get_fline:

        movel   USER_FPIAR(%a6),%a0     //opcode address

        movel   #0,-(%a7)       //reserve a word on the stack

        leal    2(%a7),%a1      //point to low word of temporary

        movel   #2,%d0          //count

        bsrl    mem_read

        movel   (%a7)+,%d0

        rts

//

//      g_rndpr --- put rounding precision in d0{1:0}

//

//      valid return codes are:

//              00 - extended

//              01 - single

//              10 - double

//

// begin

// get rounding precision (cmdreg3b{6:5})

// begin

//  case        opclass = 011 (move out)

//      get destination format - this is the also the rounding precision

//

//  case        opclass = 0x0

//      if E3

//          *case RndPr(from cmdreg3b{6:5} = 11  then RND_PREC = DBL

//          *case RndPr(from cmdreg3b{6:5} = 10  then RND_PREC = SGL

//           case RndPr(from cmdreg3b{6:5} = 00 | 01

//              use precision from FPCR{7:6}

//                      case 00 then RND_PREC = EXT

//                      case 01 then RND_PREC = SGL

//                      case 10 then RND_PREC = DBL

//      else E1

//           use precision in FPCR{7:6}

//           case 00 then RND_PREC = EXT

//           case 01 then RND_PREC = SGL

//           case 10 then RND_PREC = DBL

// end

//

g_rndpr:

        bsr     g_opcls         //get opclass in d0{2:0}

        cmpw    #0x0003,%d0     //check for opclass 011

        bnes    op_0x0

//

// For move out instructions (opclass 011) the destination format

// is the same as the rounding precision.  Pass results from g_dfmtou.

//

        bsr     g_dfmtou

        rts

op_0x0:

        btstb   #E3,E_BYTE(%a6)

        beql    unf_e1_exc      //branch to e1 underflow

unf_e3_exc:

        movel   CMDREG3B(%a6),%d0       //rounding precision in d0{10:9}

        bfextu  %d0{#9:#2},%d0  //move the rounding prec bits to d0{1:0}

        cmpil   #0x2,%d0

        beql    unff_sgl        //force precision is single

        cmpil   #0x3,%d0                //force precision is double

        beql    unff_dbl

        movew   CMDREG3B(%a6),%d0       //get the command word again

        andil   #0x7f,%d0               //clear all except operation

        cmpil   #0x33,%d0

        beql    unf_fsgl        //fsglmul or fsgldiv

        cmpil   #0x30,%d0

        beql    unf_fsgl        //fsgldiv or fsglmul

        bra     unf_fpcr

unf_e1_exc:

        movel   CMDREG1B(%a6),%d0       //get 32 bits off the stack, 1st 16 bits

//                              ;are the command word

        andil   #0x00440000,%d0 //clear all bits except bits 6 and 2

        cmpil   #0x00400000,%d0

        beql    unff_sgl        //force single

        cmpil   #0x00440000,%d0 //force double

        beql    unff_dbl

        movel   CMDREG1B(%a6),%d0       //get the command word again

        andil   #0x007f0000,%d0 //clear all bits except the operation

        cmpil   #0x00270000,%d0

        beql    unf_fsgl        //fsglmul

        cmpil   #0x00240000,%d0

        beql    unf_fsgl        //fsgldiv

        bra     unf_fpcr

//

// Convert to return format.  The values from cmdreg3b and the return

// values are:

//      cmdreg3b        return       precision

//      --------        ------       ---------

//        00,01           0             ext

//         10             1             sgl

//         11             2             dbl

// Force single

//

unff_sgl:

        movel   #1,%d0          //return 1

        rts

//

// Force double

//

unff_dbl:

        movel   #2,%d0          //return 2

        rts

//

// Force extended

//

unf_fsgl:

        movel   #0,%d0

        rts

//

// Get rounding precision set in FPCR{7:6}.

//

unf_fpcr:

        movel   USER_FPCR(%a6),%d0 //rounding precision bits in d0{7:6}

        bfextu  %d0{#24:#2},%d0 //move the rounding prec bits to d0{1:0}

        rts

//

//      g_opcls --- put opclass in d0{2:0}

//

g_opcls:

        btstb   #E3,E_BYTE(%a6)

        beqs    opc_1b          //if set, go to cmdreg1b

opc_3b:

        clrl    %d0             //if E3, only opclass 0x0 is possible

        rts

opc_1b:

        movel   CMDREG1B(%a6),%d0

        bfextu  %d0{#0:#3},%d0  //shift opclass bits d0{31:29} to d0{2:0}

        rts

//

//      g_dfmtou --- put destination format in d0{1:0}

//

//      If E1, the format is from cmdreg1b{12:10}

//      If E3, the format is extended.

//

//      Dest. Fmt.

//              extended  010 -> 00

//              single    001 -> 01

//              double    101 -> 10

//

g_dfmtou:

        btstb   #E3,E_BYTE(%a6)

        beqs    op011

        clrl    %d0             //if E1, size is always ext

        rts

op011:

        movel   CMDREG1B(%a6),%d0

        bfextu  %d0{#3:#3},%d0  //dest fmt from cmdreg1b{12:10}

        cmpb    #1,%d0          //check for single

        bnes    not_sgl

        movel   #1,%d0

        rts

not_sgl:

        cmpb    #5,%d0          //check for double

        bnes    not_dbl

        movel   #2,%d0

        rts

not_dbl:

        clrl    %d0             //must be extended

        rts

//

//

// Final result table for unf_sub. Note that the negative counterparts

// are unnecessary as unf_sub always returns the sign separately from

// the exponent.

//                                      ;+zero

EXT_PZRO:       .long   0x00000000,0x00000000,0x00000000,0x00000000

//                                      ;+zero

SGL_PZRO:       .long   0x3f810000,0x00000000,0x00000000,0x00000000

//                                      ;+zero

DBL_PZRO:       .long   0x3c010000,0x00000000,0x00000000,0x00000000

//                                      ;smallest +ext denorm

EXT_PSML:       .long   0x00000000,0x00000000,0x00000001,0x00000000

//                                      ;smallest +sgl denorm

SGL_PSML:       .long   0x3f810000,0x00000100,0x00000000,0x00000000

//                                      ;smallest +dbl denorm

DBL_PSML:       .long   0x3c010000,0x00000000,0x00000800,0x00000000

//

//      UNF_SUB --- underflow result calculation

//

// Input:

//      d0      contains round precision

//      a0      points to input operand in the internal extended format

//

// Output:

//      a0      points to correct internal extended precision result.

//

tblunf:

        .long   uEXT_RN

        .long   uEXT_RZ

        .long   uEXT_RM

        .long   uEXT_RP

        .long   uSGL_RN

        .long   uSGL_RZ

        .long   uSGL_RM

        .long   uSGL_RP

        .long   uDBL_RN

        .long   uDBL_RZ

        .long   uDBL_RM

        .long   uDBL_RP

        .long   uDBL_RN

        .long   uDBL_RZ

        .long   uDBL_RM

        .long   uDBL_RP

        .global unf_sub

unf_sub:

        lsll    #2,%d0          //move round precision to d0{3:2}

        bfextu  FPCR_MODE(%a6){#2:#2},%d1 //set round mode

        orl     %d1,%d0         //index is fmt:mode in d0{3:0}

        leal    tblunf,%a1      //load a1 with table address

        movel   %a1@(%d0:l:4),%a1       //use d0 as index to the table

        jmp     (%a1)           //go to the correct routine

//

//case DEST_FMT = EXT

//

uEXT_RN:

        leal    EXT_PZRO,%a1    //answer is +/- zero

        bsetb   #z_bit,FPSR_CC(%a6)

        bra     uset_sign       //now go set the sign

uEXT_RZ:

        leal    EXT_PZRO,%a1    //answer is +/- zero

        bsetb   #z_bit,FPSR_CC(%a6)

        bra     uset_sign       //now go set the sign

uEXT_RM:

        tstb    LOCAL_SGN(%a0)  //if negative underflow

        beqs    ue_rm_pos

ue_rm_neg:

        leal    EXT_PSML,%a1    //answer is negative smallest denorm

        bsetb   #neg_bit,FPSR_CC(%a6)

        bra     end_unfr

ue_rm_pos:

        leal    EXT_PZRO,%a1    //answer is positive zero

        bsetb   #z_bit,FPSR_CC(%a6)

        bra     end_unfr

uEXT_RP:

        tstb    LOCAL_SGN(%a0)  //if negative underflow

        beqs    ue_rp_pos

ue_rp_neg:

        leal    EXT_PZRO,%a1    //answer is negative zero

        oril    #negz_mask,USER_FPSR(%a6)

        bra     end_unfr

ue_rp_pos:

        leal    EXT_PSML,%a1    //answer is positive smallest denorm

        bra     end_unfr

//

//case DEST_FMT = DBL

//

uDBL_RN:

        leal    DBL_PZRO,%a1    //answer is +/- zero

        bsetb   #z_bit,FPSR_CC(%a6)

        bra     uset_sign

uDBL_RZ:

        leal    DBL_PZRO,%a1    //answer is +/- zero

        bsetb   #z_bit,FPSR_CC(%a6)

        bra     uset_sign       //now go set the sign

uDBL_RM:

        tstb    LOCAL_SGN(%a0)  //if negative overflow

        beqs    ud_rm_pos

ud_rm_neg:

        leal    DBL_PSML,%a1    //answer is smallest denormalized negative

        bsetb   #neg_bit,FPSR_CC(%a6)

        bra     end_unfr

ud_rm_pos:

        leal    DBL_PZRO,%a1    //answer is positive zero

        bsetb   #z_bit,FPSR_CC(%a6)

        bra     end_unfr

uDBL_RP:

        tstb    LOCAL_SGN(%a0)  //if negative overflow

        beqs    ud_rp_pos

ud_rp_neg:

        leal    DBL_PZRO,%a1    //answer is negative zero

        oril    #negz_mask,USER_FPSR(%a6)

        bra     end_unfr

ud_rp_pos:

        leal    DBL_PSML,%a1    //answer is smallest denormalized negative

        bra     end_unfr

//

//case DEST_FMT = SGL

//

uSGL_RN:

        leal    SGL_PZRO,%a1    //answer is +/- zero

        bsetb   #z_bit,FPSR_CC(%a6)

        bras    uset_sign

uSGL_RZ:

        leal    SGL_PZRO,%a1    //answer is +/- zero

        bsetb   #z_bit,FPSR_CC(%a6)

        bras    uset_sign

uSGL_RM:

        tstb    LOCAL_SGN(%a0)  //if negative overflow

        beqs    us_rm_pos

us_rm_neg:

        leal    SGL_PSML,%a1    //answer is smallest denormalized negative

        bsetb   #neg_bit,FPSR_CC(%a6)

        bras    end_unfr

us_rm_pos:

        leal    SGL_PZRO,%a1    //answer is positive zero

        bsetb   #z_bit,FPSR_CC(%a6)

        bras    end_unfr

uSGL_RP:

        tstb    LOCAL_SGN(%a0)  //if negative overflow

        beqs    us_rp_pos

us_rp_neg:

        leal    SGL_PZRO,%a1    //answer is negative zero

        oril    #negz_mask,USER_FPSR(%a6)

        bras    end_unfr

us_rp_pos:

        leal    SGL_PSML,%a1    //answer is smallest denormalized positive

        bras    end_unfr

uset_sign:

        tstb    LOCAL_SGN(%a0)  //if negative overflow

        beqs    end_unfr

uneg_sign:

        bsetb   #neg_bit,FPSR_CC(%a6)

end_unfr:

        movew   LOCAL_EX(%a1),LOCAL_EX(%a0) //be careful not to overwrite sign

        movel   LOCAL_HI(%a1),LOCAL_HI(%a0)

        movel   LOCAL_LO(%a1),LOCAL_LO(%a0)

        rts

//

//      reg_dest --- write byte, word, or long data to Dn

//

//

// Input:

//      L_SCR1: Data

//      d1:     data size and dest register number formatted as:

//

//      32              5    4     3     2     1     0

//       -----------------------------------------------

//       |        0        |    Size   |  Dest Reg #   |

//       -----------------------------------------------

//

//      Size is:

//              0 - Byte

//              1 - Word

//              2 - Long/Single

//

pregdst:

        .long   byte_d0

        .long   byte_d1

        .long   byte_d2

        .long   byte_d3

        .long   byte_d4

        .long   byte_d5

        .long   byte_d6

        .long   byte_d7

        .long   word_d0

        .long   word_d1

        .long   word_d2

        .long   word_d3

        .long   word_d4

        .long   word_d5

        .long   word_d6

        .long   word_d7

        .long   long_d0

        .long   long_d1

        .long   long_d2

        .long   long_d3

        .long   long_d4

        .long   long_d5

        .long   long_d6

        .long   long_d7

reg_dest:

        leal    pregdst,%a0

        movel   %a0@(%d1:l:4),%a0

        jmp     (%a0)

byte_d0:

        moveb   L_SCR1(%a6),USER_D0+3(%a6)

        rts

byte_d1:

        moveb   L_SCR1(%a6),USER_D1+3(%a6)

        rts

byte_d2:

        moveb   L_SCR1(%a6),%d2

        rts

byte_d3:

        moveb   L_SCR1(%a6),%d3

        rts

byte_d4:

        moveb   L_SCR1(%a6),%d4

        rts

byte_d5:

        moveb   L_SCR1(%a6),%d5

        rts

byte_d6:

        moveb   L_SCR1(%a6),%d6

        rts

byte_d7:

        moveb   L_SCR1(%a6),%d7

        rts

word_d0:

        movew   L_SCR1(%a6),USER_D0+2(%a6)

        rts

word_d1:

        movew   L_SCR1(%a6),USER_D1+2(%a6)

        rts

word_d2:

        movew   L_SCR1(%a6),%d2

        rts

word_d3:

        movew   L_SCR1(%a6),%d3

        rts

word_d4:

        movew   L_SCR1(%a6),%d4

        rts

word_d5:

        movew   L_SCR1(%a6),%d5

        rts

word_d6:

        movew   L_SCR1(%a6),%d6

        rts

word_d7:

        movew   L_SCR1(%a6),%d7

        rts

long_d0:

        movel   L_SCR1(%a6),USER_D0(%a6)

        rts

long_d1:

        movel   L_SCR1(%a6),USER_D1(%a6)

        rts

long_d2:

        movel   L_SCR1(%a6),%d2

        rts

long_d3:

        movel   L_SCR1(%a6),%d3

        rts

long_d4:

        movel   L_SCR1(%a6),%d4

        rts

long_d5:

        movel   L_SCR1(%a6),%d5

        rts

long_d6:

        movel   L_SCR1(%a6),%d6

        rts

long_d7:

        movel   L_SCR1(%a6),%d7

        rts

        |end