head     56.1;
access   ;
symbols  ;
locks    ; strict;
comment  @# @;


56.1
date     91.11.05.09.34.31;  author jwh;  state Exp;
branches ;
next     55.1;

55.1
date     91.08.25.10.12.56;  author jwh;  state Exp;
branches ;
next     54.2;

54.2
date     91.08.21.14.40.42;  author jwh;  state Exp;
branches ;
next     54.1;

54.1
date     91.03.18.15.20.02;  author jwh;  state Exp;
branches ;
next     53.1;

53.1
date     91.03.11.19.21.27;  author jwh;  state Exp;
branches ;
next     52.1;

52.1
date     91.02.19.09.05.20;  author jwh;  state Exp;
branches ;
next     51.2;

51.2
date     91.02.10.16.49.30;  author jwh;  state Exp;
branches ;
next     51.1;

51.1
date     91.01.30.16.04.33;  author jwh;  state Exp;
branches ;
next     1.1;

1.1
date     91.01.16.15.37.35;  author jwh;  state Exp;
branches ;
next     ;


desc
@first version.
@


56.1
log
@Automatic bump of revision number for PWS version 3.25
@
text
@@


55.1
log
@Automatic bump of revision number for PWS version 3.25A
@
text
@@


54.2
log
@
pws2rcs automatic delta on Wed Aug 21 13:42:03 MDT 1991
@
text
@@


54.1
log
@Automatic bump of revision number for PWS version 3.24
@
text
@a0 685
*
*       util.sa 3.1 12/10/90
*
*       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.


*       section 8

	include fpsp_h

	refr    mem_read

	def     g_dfmtou
	def     g_opcls
	def     g_rndpr
	def     get_fline
	def     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        dc.l    $7fff0000,$00000000,$00000000,$00000000
*                                       ;largest +ext
EXT_PLRG        dc.l    $7ffe0000,$ffffffff,$ffffffff,$00000000
*                                       ;largest magnitude +sgl in ext
SGL_PLRG        dc.l    $407e0000,$ffffff00,$00000000,$00000000
*                                       ;largest magnitude +dbl in ext
DBL_PLRG        dc.l    $43fe0000,$ffffffff,$fffff800,$00000000
*                                       ;largest -ext

tblovfl    equ    *
	dc.l    EXT_RN
	dc.l    EXT_RZ
	dc.l    EXT_RM
	dc.l    EXT_RP
	dc.l    SGL_RN
	dc.l    SGL_RZ
	dc.l    SGL_RM
	dc.l    SGL_RP
	dc.l    DBL_RN
	dc.l    DBL_RZ
	dc.l    DBL_RM
	dc.l    DBL_RP
	dc.l    error
	dc.l    error
	dc.l    error
	dc.l    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)
*
	def     ovf_r_k
ovf_r_k    equ    *
	lea     ETEMP(a6),a0    ;a0 points to source operand
	bclr    #sign_bit,ETEMP_EX(a6)
	sne     ETEMP_SGN(a6)   ;convert to internal IEEE format

	bfextu  FPCONTROL_MODE(a6){0:2},d0 ;set round precision
	bra.b   ovf_res
*
*       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 FPCONTROL unless
* the instruction is fsgldiv or fsglmul, then the rounding precision
* must be set to extended.
*
	def     ovf_r_x2
ovf_r_x2    equ    *
	btst    #E3,E_BYTE(a6)          ;check for nu exception
	beq.b   ovf_FPCONTROL
ovf_e3_exc    equ    *
	move.w  CMDREG3B(a6),d0
	andi.w  #$7f,d0
	cmpi.w  #$30,d0
	beq.b   ovf_fsgl
	cmpi.w  #$33,d0
	bne.b   ovf_FPCONTROL
*
* Inst is either fsgldiv or fsglmul.  Force extended precision.
*
ovf_fsgl    equ    *
	clr.l   d0
	bra.b   ovf_res
*
* Inst is not either fsgldiv or fsglmul.  The precision is in the FPCONTROL.
*
ovf_FPCONTROL    equ    *
	bfextu  FPCONTROL_MODE(a6){0:2},d0 ;set round precision
	bra.b   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.
*
	def     ovf_r_x3
ovf_r_x3    equ    *
	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
*
	def     ovf_res
ovf_res    equ    *
	lsl.l   #2,d0           ;move round precision to d0{3:2}
	bfextu  FPCONTROL_MODE(a6){2:2},d1 ;set round mode
	or.l    d1,d0           ;index is fmt:mode in d0{3:0}
	lea     tblovfl,a1      ;load a1 with table address
	move.l  (a1,d0*4),a1    ;use d0 as index to the table
	jmp     (a1)            ;go to the correct routine
*
*case DEST_FMT = EXT
*
EXT_RN    equ    *
	lea     EXT_PINF,a1     ;answer is +/- infinity
	bset    #inf_bit,FPSTATUS_CC(a6)
	bra     set_sign        ;now go set the sign
EXT_RZ    equ    *
	lea     EXT_PLRG,a1     ;answer is +/- large number
	bra     set_sign        ;now go set the sign
EXT_RM    equ    *
	tst.b   LOCAL_SGN(a0)   ;if negative overflow
	beq.b   e_rm_pos
e_rm_neg    equ    *
	lea     EXT_PINF,a1     ;answer is negative infinity
	ori.l  #neginf_mask,USER_FPSTATUS(a6)
	bra     end_ovfr
e_rm_pos    equ    *
	lea     EXT_PLRG,a1     ;answer is large positive number
	bra     end_ovfr
EXT_RP    equ    *
	tst.b   LOCAL_SGN(a0)   ;if negative overflow
	beq.b   e_rp_pos
e_rp_neg    equ    *
	lea     EXT_PLRG,a1     ;answer is large negative number
	bset    #neg_bit,FPSTATUS_CC(a6)
	bra     end_ovfr
e_rp_pos    equ    *
	lea     EXT_PINF,a1     ;answer is positive infinity
	bset    #inf_bit,FPSTATUS_CC(a6)
	bra     end_ovfr
*
*case DEST_FMT = DBL
*
DBL_RN    equ    *
	lea     EXT_PINF,a1     ;answer is +/- infinity
	bset    #inf_bit,FPSTATUS_CC(a6)
	bra     set_sign
DBL_RZ    equ    *
	lea     DBL_PLRG,a1     ;answer is +/- large number
	bra     set_sign        ;now go set the sign
DBL_RM    equ    *
	tst.b   LOCAL_SGN(a0)   ;if negative overflow
	beq.b   d_rm_pos
d_rm_neg    equ    *
	lea     EXT_PINF,a1     ;answer is negative infinity
	ori.l  #neginf_mask,USER_FPSTATUS(a6)
	bra     end_ovfr        ;inf is same for all precisions (ext,dbl,sgl)
d_rm_pos    equ    *
	lea     DBL_PLRG,a1     ;answer is large positive number
	bra     end_ovfr
DBL_RP    equ    *
	tst.b   LOCAL_SGN(a0)   ;if negative overflow
	beq.b   d_rp_pos
d_rp_neg    equ    *
	lea     DBL_PLRG,a1     ;answer is large negative number
	bset    #neg_bit,FPSTATUS_CC(a6)
	bra     end_ovfr
d_rp_pos    equ    *
	lea     EXT_PINF,a1     ;answer is positive infinity
	bset    #inf_bit,FPSTATUS_CC(a6)
	bra     end_ovfr
*
*case DEST_FMT = SGL
*
SGL_RN    equ    *
	lea     EXT_PINF,a1     ;answer is +/-  infinity
	bset    #inf_bit,FPSTATUS_CC(a6)
	bra.b   set_sign
SGL_RZ    equ    *
	lea     SGL_PLRG,a1     ;anwer is +/- large number
	bra.b   set_sign
SGL_RM    equ    *
	tst.b   LOCAL_SGN(a0)   ;if negative overflow
	beq.b   s_rm_pos
s_rm_neg    equ    *
	lea     EXT_PINF,a1     ;answer is negative infinity
	ori.l  #neginf_mask,USER_FPSTATUS(a6)
	bra.b   end_ovfr
s_rm_pos    equ    *
	lea     SGL_PLRG,a1     ;answer is large positive number
	bra.b   end_ovfr
SGL_RP    equ    *
	tst.b   LOCAL_SGN(a0)   ;if negative overflow
	beq.b   s_rp_pos
s_rp_neg    equ    *
	lea     SGL_PLRG,a1     ;answer is large negative number
	bset    #neg_bit,FPSTATUS_CC(a6)
	bra.b   end_ovfr
s_rp_pos    equ    *
	lea     EXT_PINF,a1     ;answer is postive infinity
	bset    #inf_bit,FPSTATUS_CC(a6)
	bra.b   end_ovfr

set_sign    equ    *
	tst.b   LOCAL_SGN(a0)   ;if negative overflow
	beq.b   end_ovfr
neg_sign    equ    *
	bset    #neg_bit,FPSTATUS_CC(a6)

end_ovfr    equ    *
	move.w  LOCAL_EX(a1),LOCAL_EX(a0) ;do not overwrite sign
	move.l  LOCAL_HI(a1),LOCAL_HI(a0)
	move.l  LOCAL_LO(a1),LOCAL_LO(a0)
	rts


*
*       ERROR
*
error    equ    *
	rts
*
*       get_fline --- get f-line opcode of interrupted instruction
*
*       Returns opcode in the low word of d0.
*
get_fline    equ    *
	move.l  USER_FPIADDR(a6),a0       ;opcode address
	move.l  #0,-(a7)        ;reserve a word on the stack
	lea     2(a7),a1        ;point to low word of temporary
	move.l  #2,d0           ;count
	bsr     mem_read
	move.l  (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 FPCONTROL{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 FPCONTROL{7:6}
*            case 00 then RND_PREC = EXT
*            case 01 then RND_PREC = SGL
*            case 10 then RND_PREC = DBL
* end
*
g_rndpr    equ    *
	bsr.b   g_opcls         ;get opclass in d0{2:0}
	cmp.w   #$0003,d0       ;check for opclass 011
	bne.b   op_0x0

*
* For move out instructions (opclass 011) the destination format
* is the same as the rounding precision.  Pass results from g_dfmtou.
*
	bsr.b   g_dfmtou
	rts
op_0x0    equ    *
	btst    #E3,E_BYTE(a6)
	beq.b   rnd_e1

	move.l  CMDREG3B(a6),d0 ;rounding precision in d0{10:9}
	bfextu  d0{9:2},d0      ;move the rounding prec bits to d0{1:0}
	btst    #30,d0          ;check either of the ext codes
	beq.b   rnd_e1          ;if cmd3b has size=ext, check FPCONTROL bits
*
* 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
*
	cmpi.l  #2,d0
	blt.b   rnd_ext
	beq.b   rnd_sgl
rnd_dbl    equ    *
	move.l  #2,d0
	rts
rnd_ext    equ    *
	clr.l   d0
	rts
rnd_sgl    equ    *
	move.l  #1,d0
	rts
*
* Get rounding precision set in FPCONTROL{7:6}.
*
rnd_e1    equ    *
	move.l  USER_FPCONTROL(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    equ    *
	btst    #E3,E_BYTE(a6)
	beq.b   opc_1b          ;if set, go to cmdreg1b
opc_3b    equ    *
	clr.l   d0              ;if E3, only opclass 0x0 is possible
	rts
opc_1b    equ    *
	move.l  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    equ    *
	btst    #E3,E_BYTE(a6)
	beq.b   op011
	clr.l   d0              ;if E1, size is always ext
	rts
op011    equ    *
	move.l  CMDREG1B(a6),d0
	bfextu  d0{3:3},d0      ;dest fmt from cmdreg1b{12:10}
	cmp.b   #1,d0           ;check for single
	bne.b   not_sgl
	move.l  #1,d0
	rts
not_sgl    equ    *
	cmp.b   #5,d0           ;check for double
	bne.b   not_dbl
	move.l  #2,d0
	rts
not_dbl    equ    *
	clr.l   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        dc.l    $00000000,$00000000,$00000000,$00000000
*                                       ;+zero
SGL_PZRO        dc.l    $3f810000,$00000000,$00000000,$00000000
*                                       ;+zero
DBL_PZRO        dc.l    $3c010000,$00000000,$00000000,$00000000
*                                       ;smallest +ext denorm
EXT_PSML        dc.l    $00000000,$00000000,$00000001,$00000000
*                                       ;smallest +sgl denorm
SGL_PSML        dc.l    $3f810000,$00000100,$00000000,$00000000
*                                       ;smallest +dbl denorm
DBL_PSML        dc.l    $3c010000,$00000000,$00000800,$00000000
*
*       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    equ    *
	dc.l    uEXT_RN
	dc.l    uEXT_RZ
	dc.l    uEXT_RM
	dc.l    uEXT_RP
	dc.l    uSGL_RN
	dc.l    uSGL_RZ
	dc.l    uSGL_RM
	dc.l    uSGL_RP
	dc.l    uDBL_RN
	dc.l    uDBL_RZ
	dc.l    uDBL_RM
	dc.l    uDBL_RP
	dc.l    uDBL_RN
	dc.l    uDBL_RZ
	dc.l    uDBL_RM
	dc.l    uDBL_RP

	def     unf_sub
unf_sub    equ    *
	lsl.l   #2,d0           ;move round precision to d0{3:2}
	bfextu  FPCONTROL_MODE(a6){2:2},d1 ;set round mode
	or.l    d1,d0           ;index is fmt:mode in d0{3:0}
	lea     tblunf,a1       ;load a1 with table address
	move.l  (a1,d0*4),a1    ;use d0 as index to the table
	jmp     (a1)            ;go to the correct routine
*
*case DEST_FMT = EXT
*
uEXT_RN    equ    *
	lea     EXT_PZRO,a1     ;answer is +/- zero
	bset    #z_bit,FPSTATUS_CC(a6)
	bra     uset_sign       ;now go set the sign
uEXT_RZ    equ    *
	lea     EXT_PZRO,a1     ;answer is +/- zero
	bset    #z_bit,FPSTATUS_CC(a6)
	bra     uset_sign       ;now go set the sign
uEXT_RM    equ    *
	tst.b   LOCAL_SGN(a0)   ;if negative underflow
	beq.b   ue_rm_pos
ue_rm_neg    equ    *
	lea     EXT_PSML,a1     ;answer is negative smallest denorm
	bset    #neg_bit,FPSTATUS_CC(a6)
	bra     end_unfr
ue_rm_pos    equ    *
	lea     EXT_PZRO,a1     ;answer is positive zero
	bset    #z_bit,FPSTATUS_CC(a6)
	bra     end_unfr
uEXT_RP    equ    *
	tst.b   LOCAL_SGN(a0)   ;if negative underflow
	beq.b   ue_rp_pos
ue_rp_neg    equ    *
	lea     EXT_PZRO,a1     ;answer is negative zero
	ori.l   #negz_mask,USER_FPSTATUS(a6)
	bra     end_unfr
ue_rp_pos    equ    *
	lea     EXT_PSML,a1     ;answer is positive smallest denorm
	bra     end_unfr
*
*case DEST_FMT = DBL
*
uDBL_RN    equ    *
	lea     DBL_PZRO,a1     ;answer is +/- zero
	bset    #z_bit,FPSTATUS_CC(a6)
	bra     uset_sign
uDBL_RZ    equ    *
	lea     DBL_PZRO,a1     ;answer is +/- zero
	bset    #z_bit,FPSTATUS_CC(a6)
	bra     uset_sign       ;now go set the sign
uDBL_RM    equ    *
	tst.b   LOCAL_SGN(a0)   ;if negative overflow
	beq.b   ud_rm_pos
ud_rm_neg    equ    *
	lea     DBL_PSML,a1     ;answer is smallest denormalized negative
	bset    #neg_bit,FPSTATUS_CC(a6)
	bra     end_unfr
ud_rm_pos    equ    *
	lea     DBL_PZRO,a1     ;answer is positive zero
	bset    #z_bit,FPSTATUS_CC(a6)
	bra     end_unfr
uDBL_RP    equ    *
	tst.b   LOCAL_SGN(a0)   ;if negative overflow
	beq.b   ud_rp_pos
ud_rp_neg    equ    *
	lea     DBL_PZRO,a1     ;answer is negative zero
	ori.l   #negz_mask,USER_FPSTATUS(a6)
	bra     end_unfr
ud_rp_pos    equ    *
	lea     DBL_PSML,a1     ;answer is smallest denormalized negative
	bra     end_unfr
*
*case DEST_FMT = SGL
*
uSGL_RN    equ    *
	lea     SGL_PZRO,a1     ;answer is +/- zero
	bset    #z_bit,FPSTATUS_CC(a6)
	bra.b   uset_sign
uSGL_RZ    equ    *
	lea     SGL_PZRO,a1     ;answer is +/- zero
	bset    #z_bit,FPSTATUS_CC(a6)
	bra.b   uset_sign
uSGL_RM    equ    *
	tst.b   LOCAL_SGN(a0)   ;if negative overflow
	beq.b   us_rm_pos
us_rm_neg    equ    *
	lea     SGL_PSML,a1     ;answer is smallest denormalized negative
	bset    #neg_bit,FPSTATUS_CC(a6)
	bra.b   end_unfr
us_rm_pos    equ    *
	lea     SGL_PZRO,a1     ;answer is positive zero
	bset    #z_bit,FPSTATUS_CC(a6)
	bra.b   end_unfr
uSGL_RP    equ    *
	tst.b   LOCAL_SGN(a0)   ;if negative overflow
	beq.b   us_rp_pos
us_rp_neg    equ    *
	lea     SGL_PZRO,a1     ;answer is negative zero
	ori.l   #negz_mask,USER_FPSTATUS(a6)
	bra.b   end_unfr
us_rp_pos    equ    *
	lea     SGL_PSML,a1     ;answer is smallest denormalized positive
	bra.b   end_unfr

uset_sign    equ    *
	tst.b   LOCAL_SGN(a0)   ;if negative overflow
	beq.b   end_unfr
uneg_sign    equ    *
	bset    #neg_bit,FPSTATUS_CC(a6)

end_unfr    equ    *
	move.w  LOCAL_EX(a1),LOCAL_EX(a0) ;be careful not to overwrite sign
	move.l  LOCAL_HI(a1),LOCAL_HI(a0)
	move.l  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    equ    *
	dc.l    byte_d0
	dc.l    byte_d1
	dc.l    byte_d2
	dc.l    byte_d3
	dc.l    byte_d4
	dc.l    byte_d5
	dc.l    byte_d6
	dc.l    byte_d7
	dc.l    word_d0
	dc.l    word_d1
	dc.l    word_d2
	dc.l    word_d3
	dc.l    word_d4
	dc.l    word_d5
	dc.l    word_d6
	dc.l    word_d7
	dc.l    long_d0
	dc.l    long_d1
	dc.l    long_d2
	dc.l    long_d3
	dc.l    long_d4
	dc.l    long_d5
	dc.l    long_d6
	dc.l    long_d7

reg_dest    equ    *
	lea     pregdst,a0
	move.l  (a0,d1*4),a0
	jmp     (a0)

byte_d0    equ    *
	move.b  L_SCR1(a6),USER_D0+3(a6)
	rts
byte_d1    equ    *
	move.b  L_SCR1(a6),USER_D1+3(a6)
	rts
byte_d2    equ    *
	move.b  L_SCR1(a6),d2
	rts
byte_d3    equ    *
	move.b  L_SCR1(a6),d3
	rts
byte_d4    equ    *
	move.b  L_SCR1(a6),d4
	rts
byte_d5    equ    *
	move.b  L_SCR1(a6),d5
	rts
byte_d6    equ    *
	move.b  L_SCR1(a6),d6
	rts
byte_d7    equ    *
	move.b  L_SCR1(a6),d7
	rts
word_d0    equ    *
	move.w  L_SCR1(a6),USER_D0+2(a6)
	rts
word_d1    equ    *
	move.w  L_SCR1(a6),USER_D1+2(a6)
	rts
word_d2    equ    *
	move.w  L_SCR1(a6),d2
	rts
word_d3    equ    *
	move.w  L_SCR1(a6),d3
	rts
word_d4    equ    *
	move.w  L_SCR1(a6),d4
	rts
word_d5    equ    *
	move.w  L_SCR1(a6),d5
	rts
word_d6    equ    *
	move.w  L_SCR1(a6),d6
	rts
word_d7    equ    *
	move.w  L_SCR1(a6),d7
	rts
long_d0    equ    *
	move.l  L_SCR1(a6),USER_D0(a6)
	rts
long_d1    equ    *
	move.l  L_SCR1(a6),USER_D1(a6)
	rts
long_d2    equ    *
	move.l  L_SCR1(a6),d2
	rts
long_d3    equ    *
	move.l  L_SCR1(a6),d3
	rts
long_d4    equ    *
	move.l  L_SCR1(a6),d4
	rts
long_d5    equ    *
	move.l  L_SCR1(a6),d5
	rts
long_d6    equ    *
	move.l  L_SCR1(a6),d6
	rts
long_d7    equ    *
	move.l  L_SCR1(a6),d7
	rts
	end
@


53.1
log
@Automatic bump of revision number for PWS version 3.24B
@
text
@@


52.1
log
@Automatic bump of revision number for PWS version 3.24A
@
text
@@


51.2
log
@*** empty log message ***
@
text
@@


51.1
log
@Automatic bump of revision number for PWS version 3.24d
@
text
@d26 1
a26 1
	include fpsp.h
@


1.1
log
@Initial revision
@
text
@@
