365 lines
6.7 KiB
Plaintext
365 lines
6.7 KiB
Plaintext
!----------------------------------------------------------------------------
|
|
! SIGNED INTEGER ARITHMETIC
|
|
!------------------------------------------------------------------------------
|
|
|
|
adi_l: adroff ; move.w (a1),d0 ; bra 1f
|
|
adi_z: mov (sp)+,d0
|
|
1: sub.w wrd,d0 ; beq adi_1W
|
|
sub.w wrd,d0 ; beq adi_2W
|
|
bra e_oddz
|
|
adi_1W:
|
|
#if test
|
|
comp und,(sp) ; beq 6f
|
|
comp und,word(sp); bne 7f
|
|
6: bsr e_iund
|
|
#endif
|
|
7: mov (sp)+,d0 ; ad d0,(sp)
|
|
#if test
|
|
bvs 9f
|
|
#endif
|
|
jmp (a4)
|
|
adi_2W:
|
|
#ifdef lword
|
|
bsr no8bar ; add.l #8,sp
|
|
jmp (a4)
|
|
#else
|
|
move.l (sp)+,d0 ; add.l d0,(sp)
|
|
#endif
|
|
#if test
|
|
bvs 9f
|
|
#endif
|
|
jmp (a4)
|
|
|
|
!--------------------------------------------------------------------------
|
|
|
|
sbi_z: mov (sp)+,d0 ; bra 1f
|
|
sbi_l: adroff ; move.w (a1),d0
|
|
1: sub.w wrd,d0 ; beq sbi_1W
|
|
sub.w wrd,d0 ; beq sbi_2W
|
|
bra e_oddz
|
|
sbi_1W:
|
|
#if test
|
|
comp und,(sp) ; beq 6f
|
|
comp und,word(sp) ; bne 7f
|
|
6: bsr e_iund
|
|
#endif
|
|
7: mov (sp)+,d0 ; subt d0,(sp)
|
|
#if test
|
|
bvs 9f
|
|
#endif
|
|
jmp (a4)
|
|
sbi_2W:
|
|
#ifdef lword
|
|
add.l #8,sp ; bsr no8bar
|
|
jmp (a4)
|
|
#else
|
|
move.l (sp)+,d0 ; sub.l d0,(sp)
|
|
#endif
|
|
#if test
|
|
bvs 9f
|
|
#endif
|
|
jmp (a4)
|
|
9: bsr e_iovfl ; jmp (a4)
|
|
|
|
!----------------------------------------------------------------------------
|
|
|
|
mli_z: mov (sp)+,d0 ; bra 0f
|
|
mli_l: adroff ; move.w (a1),d0
|
|
0: sub.w wrd,d0 ; beq mli_1W
|
|
sub.w wrd,d0 ; beq mli_2W
|
|
bra e_oddz
|
|
mli_1W: mov (sp)+,d0
|
|
#if test
|
|
comp und,d0 ; beq 1f
|
|
comp und,(sp) ; bne 2f
|
|
1: bsr e_iund
|
|
#endif
|
|
2:
|
|
#ifdef lword
|
|
move.l (sp)+,d1 ; bra 4f
|
|
#else
|
|
muls (sp),d0 ; move.w d0,(sp)
|
|
#if test
|
|
bpl 3f ; not.l d0
|
|
3: swap d0 ; tst.w d0 ; bne 9b
|
|
#endif
|
|
jmp (a4)
|
|
#endif
|
|
mli_2W:
|
|
#ifdef lword
|
|
bsr no8bar ; add.l #4,sp
|
|
move.l (sp)+,d0 ; add.l #4,sp
|
|
move.l (sp)+,d1
|
|
#else
|
|
move.l (sp)+,d0 ; move.l (sp)+,d1
|
|
#endif
|
|
4: move.l #0,d5 ; tst.l d0 ; bpl 5f
|
|
neg.l d0 ; not.w d5
|
|
5: tst.l d1 ; bpl 6f
|
|
neg.l d1 ; not.w d5
|
|
6: bsr mlu4
|
|
#if test
|
|
tst.l d4 ; bne 7f
|
|
tst.l d0 ; bpl 8f
|
|
7: bsr e_iovfl
|
|
#endif
|
|
8: tst.w d5 ; beq 0f
|
|
neg.l d0
|
|
0: move.l d0,-(sp)
|
|
!next 4 lines only in case 8 byte arithmetic
|
|
!#ifdef lword
|
|
! bmi 1f ; clr.l -(sp) ; bra 2f
|
|
!1: move.l #-1,-(sp)
|
|
!#endif
|
|
2: jmp (a4)
|
|
|
|
!subroutine for unsigned 4byte multiplication . Expects multiplier in d0 and
|
|
! multiplicant in d1 . Returns 4 byte result in d0 . If d4=0 overflow did
|
|
! not occur on the multiplication , else it did .
|
|
|
|
.define mlu4
|
|
.text
|
|
|
|
mlu4: move.l d1,d3 ; move.l d0,d2
|
|
swap d2 ; swap d3
|
|
#if test
|
|
move.l d3,d4 ; mulu d2,d4
|
|
#endif
|
|
mulu d0,d3 ; swap d3
|
|
mulu d1,d2 ; swap d2
|
|
#if test
|
|
or.w d3,d4 ; or.w d2,d4
|
|
#endif
|
|
clr.w d3 ; clr.w d2
|
|
mulu d1,d0 ; add.l d3,d0
|
|
#if test
|
|
bvc 1f ; bset #0,d4
|
|
#endif
|
|
1: add.l d2,d0
|
|
#if test
|
|
bvc 2f ; bset #0,d4
|
|
#endif
|
|
2: rts
|
|
|
|
!---------------------------------------------------------------------------
|
|
|
|
dvi_z: mov (sp)+,d0 ; bra 0f
|
|
dvi_l: adroff ; move.w (a1),d0
|
|
0: sub.w wrd,d0 ; beq dvi_1W
|
|
sub.w wrd,d0 ; beq dvi_2W
|
|
bra e_oddz
|
|
dvi_1W:
|
|
#ifdef lword
|
|
bsr dvi4 ; move.l d1,-(sp)
|
|
#else
|
|
bsr dvi2 ; move.w d1,-(sp)
|
|
#endif
|
|
jmp (a4)
|
|
dvi_2W:
|
|
#ifdef lword
|
|
bsr no8bar ; tst.l (sp)+
|
|
move.l (sp)+,(sp) ; bsr dvi4
|
|
move.l d1,-(sp) ; clr.l -(sp)
|
|
#else
|
|
bsr dvi4 ; move.l d1,-(sp)
|
|
#endif
|
|
jmp (a4)
|
|
|
|
rmi_z: mov (sp)+,d0 ; bra 1f
|
|
rmi_l: adroff ; move.w (a1),d0
|
|
1: sub.l wrd,d0 ; beq rmi_1W
|
|
sub.l wrd,d0 ; beq rmi_2W
|
|
bra e_oddz
|
|
rmi_1W:
|
|
#ifdef lword
|
|
bsr dvi4 ; move.l d3,-(sp)
|
|
#else
|
|
bsr dvi2 ; swap d1
|
|
move.w d1,-(sp)
|
|
#endif
|
|
jmp (a4)
|
|
rmi_2W:
|
|
#ifdef lword
|
|
bsr no8bar ; tst.l (sp)+
|
|
move.l (sp)+,(sp) ; bsr dvi4
|
|
move.l d3,-(sp) ; clr.l -(sp)
|
|
#else
|
|
bsr dvi4 ; move.l d3,-(sp)
|
|
#endif
|
|
jmp (a4)
|
|
|
|
! 2byte division . In d1: quotient=low word ; remainder=high word
|
|
#ifndef lword
|
|
dvi2: move.l (sp)+,d2
|
|
move.w (sp)+,d0 !divisor
|
|
move.w (sp)+,d1 ; ext.l d1 !dividend
|
|
#if test
|
|
cmp.w und,d1 ; bne 1f
|
|
bsr e_iund
|
|
1: cmp.w und,d0 ; bne 2f
|
|
bsr e_iund
|
|
2: tst.w d0 ; bne 3f
|
|
bsr e_idivz ; move.l und,d1 ; bra 4f
|
|
3:
|
|
#endif
|
|
divs d0,d1
|
|
4: move.l d2,-(sp) ; rts
|
|
#endif
|
|
|
|
! long signed division . quotient in d1 , remainder in d3
|
|
dvi4: move.l (sp)+,d5
|
|
move.l (sp)+,d0 !divisor
|
|
move.l (sp)+,d1 !dividend
|
|
#ifdef lword
|
|
cmp.l und,d0 ; beq 0f
|
|
cmp.l und,d1 ; bne 1f
|
|
0: bsr e_iund
|
|
1:
|
|
#endif
|
|
move.l #0,d4 !sign in d4
|
|
tst.l d0 ; bpl 1f
|
|
neg.l d0 ; not.w d4
|
|
1: tst.l d1 ; bpl 2f
|
|
neg.l d1
|
|
not.w d4 ; swap d4
|
|
not.w d4 ; swap d4
|
|
2: bsr dvu4
|
|
tst.w d4 ; beq 3f
|
|
neg.l d1 !quotient
|
|
3: tst.l d4 ; bpl 4f
|
|
neg.l d3 !remainder
|
|
4: move.l d5,-(sp) ; rts
|
|
|
|
!Expects d0 divisor , d1 dividend. Gives d1 quotient ,d3 remainder
|
|
|
|
.define dvu4
|
|
.text
|
|
dvu4:
|
|
#if test
|
|
tst.l d0 ; bne 1f
|
|
bsr e_idivz
|
|
1:
|
|
#endif
|
|
move.l #0,d3 ; move.l #32,d2
|
|
3: lsl.l #1,d1 ; roxl.l #1,d3
|
|
cmp.l d0,d3 ; blt 4f
|
|
sub.l d0,d3 ; add.l #1,d1
|
|
4: sub.w #1,d2 ; bgt 3b
|
|
rts
|
|
|
|
!----------------------------------------------------------------------------
|
|
|
|
ngi_z: mov (sp)+,d0 ; bra 0f
|
|
ngi_l: adroff ; move.w (a1),d0
|
|
0: sub.l wrd,d0 ; bne 2f
|
|
#if test
|
|
comp und,(sp) ; bne 1f
|
|
bsr e_iund
|
|
1:
|
|
#endif
|
|
nega (sp) ; jmp (a4)
|
|
2: cmp.l wrd,d0 ; beq 3f
|
|
bra e_oddz
|
|
3:
|
|
#ifdef lword
|
|
bsr no8bar ; not.l (sp)
|
|
neg.l 4(sp)
|
|
#else
|
|
neg.l (sp)
|
|
#endif
|
|
#if test
|
|
bvc 4f ; bsr e_iovfl
|
|
4:
|
|
#endif
|
|
jmp (a4)
|
|
|
|
!--------------------------------------------------------------------------
|
|
|
|
sli_z: mov (sp)+,d0 ; bra 0f
|
|
sli_l: adroff ; move.w (a1),d0
|
|
0: sub.w wrd,d0 ; beq sli_1W
|
|
sub.w wrd,d0 ; beq sli2
|
|
bra e_oddz
|
|
sli_1W: mov (sp)+,d0 !d0 contains the shift count
|
|
bmi 5f
|
|
9: mov (sp)+,d1 !integer to shift
|
|
#if test
|
|
comp und,d0 ; bne 1f
|
|
bsr e_iund
|
|
1:
|
|
#endif
|
|
asle d0,d1 ! ASLE
|
|
#if test
|
|
bvc 2f ; bsr e_iovfl
|
|
2:
|
|
#endif
|
|
mov d1,-(sp) ; jmp (a4)
|
|
sli2:
|
|
#ifdef lword
|
|
bsr no8bar ; move.l (sp)+,d1
|
|
move.l (sp)+,d2 ; move.l (sp)+,d0
|
|
3: asl.l #1,d0 ; roxl.l #1,d2
|
|
sub.l #1,d1 ; bgt 3b
|
|
move.l d0,-(sp) ; move.l d2,-(sp)
|
|
#else
|
|
move.w (sp)+,d0
|
|
bmi 6f
|
|
8: move.l (sp),d1
|
|
asl.l d0,d1
|
|
#if test
|
|
bvc 4f ; bsr e_iovfl
|
|
4:
|
|
#endif
|
|
move.l d1,(sp)
|
|
#endif
|
|
jmp (a4)
|
|
5: nega d0 ; bra 8f
|
|
#ifndef lword
|
|
6: neg.w d0 ; bra 9f
|
|
#endif
|
|
|
|
!------------------------------------------------------------------------------
|
|
7: nega d0 ; bra 9b
|
|
#ifndef lword
|
|
6: neg.w d0 ; bra 8b
|
|
#endif
|
|
|
|
sri_z: mov (sp)+,d0 ; bra 0f
|
|
sri_l: adroff ; move.w (a1),d0
|
|
0: sub.w wrd,d0 ; bne sri2
|
|
mov (sp)+,d0
|
|
bmi 7b
|
|
8: mov (sp)+,d1
|
|
#if test
|
|
comp und,d0 ; bne 1f
|
|
bsr e_iund
|
|
1:
|
|
#endif
|
|
asri d0,d1
|
|
#if test
|
|
bvc 2f ; bsr e_iovfl
|
|
2:
|
|
#endif
|
|
mov d1,-(sp) ; jmp (a4)
|
|
sri2: sub.w wrd,d0 ; beq 3f
|
|
bra e_oddz
|
|
3:
|
|
#ifdef lword
|
|
bsr no8bar ; move.l (sp)+,d1
|
|
move.l (sp)+,d2 ; move.l (sp),d0
|
|
sub.l #1,d1
|
|
4: asr.l #1,d2 ; roxr.l #1,d0 ; dbra d1,4b
|
|
move.l d0,(sp) ; move.l d2,-(sp)
|
|
#else
|
|
move.w (sp)+,d0
|
|
bmi 6b
|
|
9: move.l (sp),d1
|
|
asr.l d0,d1
|
|
#if test
|
|
bvc 5f ; bsr e_iovfl
|
|
5:
|
|
#endif
|
|
move.l d1,(sp)
|
|
#endif
|
|
jmp (a4)
|