ack/mach/m68020/libem/rmi8.s

.define .rmi8
.sect .text
.sect .rom
.sect .data
.sect .bss

yh=8
yl=12
xh=16
xl=20
	! .rmi8 yields d0:d1 = remainder from x / y

.sect .text
.rmi8:
	move.l	d3, -(sp)	! preserve caller's d3
	clr.l	d2		! d2 = 0, non-negative result
	move.l	(xh, sp), d0	! d0 for .divrem8
	bge	1f
	move.l	#1, d2		! d2 = 1, negative result
	neg.l	(xl, sp)
	negx.l	d0		! x = absolute value
1:	move.l	(yh, sp), d1	! d1 for .divrem8
	bge	1f
	neg.l	(yl, sp)
	negx.l	d1		! y = absolute value
1:	move.l	d2, -(sp)
	jsr	(.divrem8)
	move.l	(sp)+, d0
	beq	1f		! branch unless result < 0
	neg.l	d3
	negx.l	d2		! negate quotient d3:d2
1:	move.l	d3, d1
	move.l	d2, d0
	move.l	(sp)+, d3
	rtd	#16
Add 8-byte long long for linux68k. Add rules for 8-byte integers to m68020 ncg. Add 8-byte long long to ACK C on linux68k. Enable long-long tests for linux68k. The tests pass in our emulator using musahi; I don't have a real 68k processor and haven't tried other emulators. Still missing are conversions between 8-byte integers and any size of floats. The long-long tests don't cover these conversions, and our emulator can't do floating-point. Our build always enables TBL68020 and uses word size 4. Without TBL68020, 8-byte multiply and divide are missing. With word size 2, some conversions between 2-byte and 8-byte integers are missing. Fix .cii in libem, which didn't work when converting from 1-byte or 2-byte integers. Now .cii and .cuu work, but also add some rules to skip .cii and .cuu when converting 8-byte integers. The new rule for loc 4 loc 8 cii `with test_set4` exposes a bug: the table may believe that the condition codes test a 4-byte register when they only test a word or byte, and this incorrect test may describe an unsigned word or byte as negative. Another rule `with exact test_set1+test_set2` works around the bug by ignoring the negative flag, because a zero-extended word or byte is never negative. The old rules for comparison and logic do work with 8-byte integers and bitsets, but add some specific 8-byte rules to skip libem calls or loops. There were no rules for 8-byte arithmetic, shift, or rotate; so add some. There is a register shortage, because the table requires preserving d3 to d7, leaving only 3 data registers (d0, d1, d2) for 8-byte operations. Because of the shortage, the code may move data to an address register, or read a memory location more than once. The multiplication and division code are translations of the i386 code. They pass the tests, but might not give the best performance on a real 68k processor. 2019-09-24 17:32:17 +00:00			`.define .rmi8`
			`.sect .text`
			`.sect .rom`
			`.sect .data`
			`.sect .bss`

			`yh=8`
			`yl=12`
			`xh=16`
			`xl=20`
			`! .rmi8 yields d0:d1 = remainder from x / y`

			`.sect .text`
			`.rmi8:`
			`move.l d3, -(sp) ! preserve caller's d3`
			`clr.l d2 ! d2 = 0, non-negative result`
			`move.l (xh, sp), d0 ! d0 for .divrem8`
			`bge 1f`
			`move.l #1, d2 ! d2 = 1, negative result`
			`neg.l (xl, sp)`
			`negx.l d0 ! x = absolute value`
			`1: move.l (yh, sp), d1 ! d1 for .divrem8`
			`bge 1f`
			`neg.l (yl, sp)`
			`negx.l d1 ! y = absolute value`
			`1: move.l d2, -(sp)`
			`jsr (.divrem8)`
			`move.l (sp)+, d0`
			`beq 1f ! branch unless result < 0`
			`neg.l d3`
			`negx.l d2 ! negate quotient d3:d2`
			`1: move.l d3, d1`
			`move.l d2, d0`
			`move.l (sp)+, d3`
			`rtd #16`