Initial revision

mach/m68020/libem/LIST

@@ -0,0 +1,24 @@
+libem_s.a
+aar.s
+lar.s
+sar.s
+csa.s
+csb.s
+shp.s
+set.s
+inn.s
+fat.s
+trp.s
+mon.s
+nop.s
+dia.s
+printf.s
+cii.s
+cuu.s
+cmi.s
+cms.s
+cmu.s
+cvf.s
+exg.s
+los.s
+sts.s

mach/m68020/libem/Makefile

@@ -0,0 +1,28 @@
+# $Header$
+MACH=m68020
+all:            libem_o.a end.o
+
+install: 	all
+		../../install libem_o.a tail_em
+		../../install end.o end_em
+
+cmp:		all
+		-../../compare libem_o.a tail_em
+		-../../compare end.o end_em
+
+end.o:		end.s
+		$(MACH) -I../../../h -c end.s
+
+libem_o.a:	libem_s.a
+		ASAR=aal ; export ASAR ;\
+		march . libem_o.a
+
+clean:
+		rm -f *.o libem_o.a
+
+opr :
+		make pr | opr
+
+pr:
+		@arch pv libem_s.a | pr -h `pwd`/libem_s.a
+		@pr `pwd`/end.s

mach/m68020/libem/aar.s

@@ -0,0 +1,32 @@
+.define	.aar
+.sect .text
+.sect .rom
+.sect .data
+.sect .bss
+.sect .text
+
+.aar:	! (on entry d0 contains the integer size in the descriptor)
+
+	cmp.l	#4, d0
+	beq	9f
+	move.l	#EILLINS, -(sp)
+	jmp	(.fatal)
+9:
+	! register usage:
+	! a0: descriptor address
+	! a1: return address
+	! d0: index
+
+	! The address is calculated by taking the relative index
+	! (index - lower bound), multiplying that with the element
+	! size and adding the result to the array base address.
+
+	move.l	(sp)+, a1	! return address
+	move.l	(sp)+, a0	! descriptor address
+	move.l	(sp)+, d0	! index
+	sub.l	(a0), d0	! relative index
+	muls.l	(8,a0), d0
+	move.l	(sp)+, a0	! array base address
+	add.l	d0, a0		! address of array element
+	jmp	(a1)		! return
+.align 2

mach/m68020/libem/cii.s

@@ -0,0 +1,27 @@
+.define	.cii
+.sect .text
+.sect .rom
+.sect .data
+.sect .bss
+
+.sect .text
+.cii:
+	move.l	(sp)+, a0	! return address
+	move.l	(sp)+, d0	! destination size
+	sub.l	(sp)+, d0	! destination - source size
+	bgt	1f
+	sub.l	d0, sp		! pop extra bytes
+	jmp	(a0)
+1:
+	clr.l	d1
+	tst.l	(sp)
+	bne	4f
+	not.l	d1		! d1 contains sign of source
+4:
+	asr.l	#2, d0
+	sub.l	#1, d0
+2:
+	move.l	d1, -(sp)
+	dbf	d0, 2b
+	jmp	(a0)
+.align 2

mach/m68020/libem/cmi.s

@@ -0,0 +1,28 @@
+.define	.cmi
+.sect .text
+.sect .rom
+.sect .data
+.sect .bss
+
+.sect .text
+	! on entry d0: # bytes in 1 block
+	! on exit d0: result
+.cmi:
+	move.l	(sp)+, d2	! return address
+	move.l	sp, a0		! address of top block
+	lea	(sp,d0.l), a1	! address of lower block
+	move.l	d0, d1
+	asr.l	#2, d0
+1:
+	cmp.l	(a0)+, (a1)+
+	bne	2f
+	sub.l	#1, d0
+	bne	1b
+2:
+	bge	3f
+	neg.l	d0		! less
+3:
+	lea	(sp,d1.l*2), sp	! new sp; two blocks popped
+	move.l	d2,a0
+	jmp	(a0)		! return
+.align 2

mach/m68020/libem/cms.s

@@ -0,0 +1,25 @@
+.define	.cms
+.sect .text
+.sect .rom
+.sect .data
+.sect .bss
+
+.sect .text
+	! d0 contains set size
+	! on exit d0 is zero for equal, non-zero for not equal
+.cms:
+	move.l	(sp)+, d2	! return address
+	move.l	sp, a0		! address of top block
+	lea	(sp,d0.l), a1	! address of lower block
+	move.l	d0, d1
+	asr.l	#2, d0
+1:
+	cmp.l	(a0)+, (a1)+
+	bne	2f
+	sub.l	#1, d0
+	bne	1b
+2:
+	lea	(sp,d1.l*2), sp	! new sp; two blocks popped
+	move.l	d2,a0
+	jmp	(a0)
+.align 2

mach/m68020/libem/cmu.s

@@ -0,0 +1,28 @@
+.define	.cmu
+.sect .text
+.sect .rom
+.sect .data
+.sect .bss
+
+.sect .text
+	! on entry d0: # bytes in 1 block
+	! on exit d0: result
+.cmu:
+	move.l	(sp)+, d2	! return address
+	move.l	sp, a0		! address of top block
+	lea	(sp,d0.l), a1	! address of lower block
+	move.l	d0, d1
+	asr.l	#2, d0
+1:
+	cmp.l	(a0)+, (a1)+
+	bne	2f
+	sub.l	#1, d0
+	bne	1b		! note: on equal carry is set
+2:
+	bcc	3f
+	neg.l	d0		! less
+3:
+	lea	(sp,d1.l*2), sp	! new sp; two blocks popped
+	move.l	d2, a0
+	jmp	(a0)
+.align 2

mach/m68020/libem/compmodule

@@ -0,0 +1,4 @@
+if ${MACH?} -c $1 1>&2
+then echo `basename $1 $2`.o
+else exit 1
+fi

mach/m68020/libem/csa.s

@@ -0,0 +1,25 @@
+.define	.csa
+.sect .text
+.sect .rom
+.sect .data
+.sect .bss
+
+.sect .text
+
+.csa:
+	move.l	(sp)+, a0	! jump table address
+	move.l	(a0)+, a1	! default address
+	move.l	(sp)+, d0	! index
+	sub.l	(a0)+, d0	! index - lower bound
+	blt	1f
+	cmp.l	(a0)+, d0	! rel. index, upper - lower bound
+	bgt	1f
+	move.l	(a0,d0.l*4), a1	! jump address
+1:
+	move.l	a1, d0
+	beq	2f
+	jmp	(a1)		! jump to specified address
+2:
+	move.l	#ECASE, -(sp)
+	jmp	(.fatal)
+.align 2

mach/m68020/libem/csb.s

@@ -0,0 +1,28 @@
+.define	.csb
+.sect .text
+.sect .rom
+.sect .data
+.sect .bss
+
+.sect .text
+
+.csb:
+	move.l	(sp)+, a0	! case descriptor
+	move.l	(sp)+, d0	! index
+	move.l	(a0)+, a1	! default jump address
+	move.l	(a0)+, d1	! # entries
+	beq	3f
+	sub.l	#1, d1
+1:
+	cmp.l	(a0,d1.w*8), d0
+	dbeq	d1, 1b
+	bne	3f
+	move.l	(4,a0,d1.w*8), a1 ! jump address
+3:
+	move.l	a1, d0
+	beq	4f
+	jmp	(a1)
+4:
+	move.l	#ECASE, -(sp)
+	jmp	(.fatal)
+.align 2

mach/m68020/libem/cuu.s

@@ -0,0 +1,25 @@
+.define	.ciu, .cui, .cuu
+.sect .text
+.sect .rom
+.sect .data
+.sect .bss
+
+.sect .text
+	! only converts between sizes of multiples of four
+.ciu:
+.cui:
+.cuu:
+	move.l	(sp)+, a0	! return address
+	move.l	(sp)+, d0	! destination size
+	sub.l	(sp)+, d0
+	bgt	1f
+	sub.l	d0, sp
+	jmp	(a0)
+1:
+	asr.l	#2, d0
+	sub.l	#1, d0
+2:
+	clr.l	-(sp)
+	dbf	d0, 2b
+	jmp	(a0)
+.align 2

mach/m68020/libem/cvf.s

@@ -0,0 +1,20 @@
+.define	.cfi, .cif,.cfu,.cuf,.cff
+.sect .text
+.sect .rom
+.sect .data
+.sect .bss
+
+	.sect .text
+
+	! this is a dummy float conversion routine
+.cfi:
+.cif:
+.cfu:
+.cuf:
+.cff:
+	move.l	(sp)+, a0	! return address
+	move.l	(sp)+, d0	! destination size
+	sub.l	(sp)+, d0	! diff. in sizes
+	sub.l	d0, sp
+	jmp	(a0)
+.align 2

mach/m68020/libem/dia.s

@@ -0,0 +1,48 @@
+.define	.diagnos
+.sect .text
+.sect .rom
+.sect .data
+.sect .bss
+
+space	= 040
+del	= 0177
+
+.sect .data
+.range:	.data1 space, del-1
+.align	2
+
+.sect .text
+.diagnos:
+	movem.l	d0/d1/d2/a0, -(sp)
+	move.l	(.lino), -(sp)
+	move.l	(.filn), d2
+	beq	1f
+	move.l	d2, a0
+	move.l	#40, d0
+3:
+	move.b	(a0)+, d1
+	beq	2f
+	cmp2.b	(.range), d1
+	bcs	1f
+	dbf	d0, 3b
+2:
+	move.l	d2, -(sp)
+	pea	(fmt)
+	jsr	(_printf)
+	lea	(8, sp), sp
+	move.l	(28, sp), (sp)
+	jsr	(_printf)
+	lea	(4, sp), sp
+	movem.l	(sp)+, d0/d1/d2/a0
+	move.l	(sp), (4, sp)
+	lea	(4, sp), sp
+	rts
+
+1:
+	move.l	#unknwn, d2
+	bra	2b
+
+.sect .data
+fmt:		.asciz "%s, line %d: "
+unknwn:		.asciz "unknown file"
+.align 2

mach/m68020/libem/end.s

@@ -0,0 +1,20 @@
+.define	endtext,enddata,endbss,_etext,_edata,_end
+.sect .text
+	.align 4
+.sect .rom
+	.align 4
+.sect .data
+	.align 4
+.sect .bss
+	.align 4
+.sect .end ! only for declaration of _end and endbss.
+
+	.sect .text
+endtext:
+_etext:
+	.sect .data
+enddata:
+_edata:
+	.sect .end
+_end:
+endbss:

mach/m68020/libem/exg.s

@@ -0,0 +1,20 @@
+.define	.exg
+.sect .text
+.sect .rom
+.sect .data
+.sect .bss
+
+.sect .text
+	! d0 : exchange size in bytes
+.exg:
+	lea	(4,sp,d0), a0	! address of bottom block
+	lea	(4,sp), a1	! address of top block
+	asr.l	#2, d0
+	sub.l	#1, d0
+1:
+	move.l	(a1), d1
+	move.l	(a0), (a1)+
+	move.l	d1, (a0)+
+	dbf	d0, 1b
+	rts
+.align 2

mach/m68020/libem/fat.s

@@ -0,0 +1,11 @@
+.define	.fatal
+.sect .text
+.sect .rom
+.sect .data
+.sect .bss
+
+	.sect .text
+.fatal:
+	jsr	(.trp)
+	jmp	(EXIT)
+.align 2

mach/m68020/libem/inn.s

@@ -0,0 +1,32 @@
+.define	.inn
+.sect .text
+.sect .rom
+.sect .data
+.sect .bss
+.sect .text
+
+.inn:	! d0 bitnumber
+	! d1 setsize in bytes
+	! on exit: 0 or 1 in d0
+
+	move.l	d2, -(sp)
+	move.l	d0, d2
+	asr.l	#3, d2		! offset from sp in bytes
+	eor.l	#3, d2		! longs are stored in high-to-low order
+	cmp.l	d1, d2
+	bge	1f		! bitnumber too large
+	btst	d0, (8,sp,d2.l)
+	beq	2f
+	move.l	#1, d0
+	bra	3f
+1:
+	move.l	#ESET, -(sp)
+	jsr	(.trp)
+2:
+	clr.l	d0
+3:
+	move.l	(sp)+, d2
+	move.l	(sp)+, a0	! return address
+	add.l	d1, sp		! pop bitset
+	jmp	(a0)		! return
+.align 2

mach/m68020/libem/lar.s

@@ -0,0 +1,52 @@
+.define	.lar
+.sect .text
+.sect .rom
+.sect .data
+.sect .bss
+.sect .text
+	! (on entry d0 contains the integer size in the descriptor)
+.lar:
+	cmp.l	#4, d0
+	beq	9f
+	move.l	#EILLINS, -(sp)
+	jmp	(.fatal)
+9:
+	! register usage:
+	! a0: descriptor address
+	! a1: base address
+	! d0: index
+	! d1: # bytes / element
+	! d2: save return address
+
+	! For address calculation; see comment in 'aar.s'.
+
+	move.l	(sp)+, d2	! return address
+	move.l	(sp)+, a0	! descriptor address
+	move.l	(sp)+, d0	! index
+	move.l	(sp)+, a1	! array base address
+	sub.l	(a0), d0	! relative index
+	move.l	(8,a0), d1	! # bytes / element
+	cmp.l	#1, d1
+	bne	2f
+	clr.l	-(sp)
+	move.b	(a1,d0.l), (3,sp) ! one byte element
+	bra	5f
+2:
+	cmp.l	#2, d1
+	bne	4f
+	clr.l	-(sp)
+	move.w	(a1,d0.l*2), (2,sp) ! two byte element
+	bra	5f
+4:	
+	muls.l	d1, d0
+	add.l	d0, a1		! address of 4n byte element
+	add.l	d1, a1		! because of predecrement
+	asr.l	#2, d1
+	sub.l	#1, d1
+1:
+	move.l	-(a1), -(sp)
+	dbf	d1, 1b
+5:
+	move.l	d2,a0
+	jmp	(a0)
+.align 2

mach/m68020/libem/los.s

@@ -0,0 +1,35 @@
+.define .los
+.sect .text
+.sect .rom
+.sect .data
+.sect .bss
+
+	! d0 : # bytes
+	! a0 : source address
+	! a1 : return address
+.sect .text
+.los:
+	move.l	(sp)+, a1
+	move.l	(sp)+, d0
+	move.l	(sp)+, a0
+	cmp.l	#1, d0
+	bne	1f
+	clr.l	-(sp)
+	move.b	(a0), (3,sp)	!1 byte
+	bra	3f
+1:
+	cmp.l 	#2, d0
+	bne	2f
+	clr.l	-(sp)
+	move.w	(a0), (2,sp)	!2 bytes
+	bra	3f
+2:
+	add.l	d0, a0		!>=4 bytes
+	asr.l 	#2, d0
+	sub.l	#1, d0
+
+4:	move.l	-(a0), -(sp)	
+	dbf	d0, 4b
+3:
+	jmp	(a1)
+.align 2

mach/m68020/libem/mon.s

@@ -0,0 +1,17 @@
+.define .mon
+.sect .text
+.sect .rom
+.sect .data
+.sect .bss
+
+.sect .text
+.mon:
+	move.l	(sp)+,a0
+	pea	(fmt)
+	jsr	(.diagnos)
+	add.l	#8, sp
+	jmp	(EXIT)
+
+.sect .data
+fmt:	.asciz "system call %d not implemented\n"
+.align 2

mach/m68020/libem/nop.s

@@ -0,0 +1,20 @@
+.define .nop
+.sect .text
+.sect .rom
+.sect .data
+.sect .bss
+
+.sect .text
+.nop:
+	move.l	(.limhp),-(sp)
+	move.l	(.reghp),-(sp)
+	pea	(12, sp)
+	move.l	(.lino),-(sp)
+	pea	(fmt)
+	jsr	(.diagnos)
+	lea	(20, sp), sp
+	rts
+
+.sect .data
+fmt:	.asciz "test %d, sp 0x%x, .reghp 0x%x, .limhp 0x%x.\n"
+.align 2

mach/m68020/libem/printf.s

@@ -0,0 +1,83 @@
+.define _printf, _putchar, _getal, _char
+.sect .text
+.sect .rom
+.sect .data
+.sect .bss
+.sect .bss
+_getal:
+	.space	12
+_char:
+	.space	1
+	.align  2
+.sect .data
+hexs:
+	.ascii	"0123456789abcdef"
+	.align	2
+.sect .text
+_printf:
+	movem.l	d0/d1/d2/a0/a1/a2/a3/a4/a5/a6, -(sp)
+	lea	(44, sp), a6	! a6 <- address of arguments
+	move.l	(a6)+, a5	! a5 <- address of format
+next:	move.b	(a5)+, d0
+	beq	out
+	cmp.b	#'%', d0
+	beq	procnt
+put:	move.l	d0, -(sp)
+	jsr	(_putchar)	! long argument on stack
+	tst.l	(sp)+
+	bra	next
+
+procnt:	move.b	(a5)+, d0
+	cmp.b	#'d', d0	! NOTE: %d means unsigned.
+	beq	digit
+	cmp.b	#'x', d0
+	beq	hex
+	cmp.b	#'s', d0
+	beq	string
+	cmp.b	#'%', d0	! second % has to be printed.
+	beq	put
+	tst.b	-(a5)		! normal char should be printed
+	bra	next
+
+string:	move.l	(a6)+, a2	! a2 <- address of string
+sloop:	move.b	(a2)+, d0
+	beq	next
+	move.l	d0, -(sp)
+	jsr	(_putchar)	! long argument on stack
+	tst.l	(sp)+
+	bra	sloop
+
+digit:	move.l	(a6)+, d1	! d1 <- integer
+	move.l	#_getal+12, a2	! a2 <- ptr to last part of buf
+	clr.b	-(a2)		! stringterminator
+1:	divul.l	#10, d2:d1	! d1 <- qotient; d2 <- remainder
+	add.l	#'0', d2
+	move.b	d2, -(a2)
+	tst.l	d1		! if quotient = 0 then ready
+	bne	1b
+	bra	sloop		! print digitstring.
+
+hex:	move.l	(a6)+, d1	! d1 <- integer
+	move.l	#_getal+12, a2	! a2 <- ptr to last part of buf
+	clr.b	-(a2)		! stringterminator
+	move.l	#7, d2		! loop control
+1:	move.l	d1, d0
+	and.l	#15, d0
+	move.b	(hexs,d0.w), -(a2) ! hex digit
+	asr.l	#4, d1
+	dbf	d2, 1b
+	bra	sloop
+
+out:
+	movem.l	(sp)+, d0/d1/d2/a0/a1/a2/a3/a4/a5/a6
+	rts
+
+
+_putchar:
+	move.l	#1, -(sp)
+	pea	(11,sp)
+	move.l	#1, -(sp)
+	jsr	(_write)
+	lea	(12, sp), sp
+	rts
+.align 2

mach/m68020/libem/sar.s

@@ -0,0 +1,54 @@
+.define	.sar
+.sect .text
+.sect .rom
+.sect .data
+.sect .bss
+
+.sect .text
+	! (on entry d0 contains the integer size in the descriptor)
+.sar:
+	cmp.l	#4, d0
+	beq	9f
+	move.l	#EILLINS, -(sp)
+	jmp	(.fatal)
+9:
+	! register usage:
+	! a0: descriptor address
+	! a1: base address
+	! d0: index
+	! d1: # bytes / element
+	! d2: return address
+
+	! For address calculation; see comment in 'aar.s'.
+	! If the element size is a fraction of EM_WSIZE (4)
+	! the calculation is done by adding.
+
+	move.l	(sp)+, d2	! return address
+	move.l	(sp)+, a0
+	move.l	(sp)+, d0
+	move.l	(sp)+, a1
+	sub.l	(a0), d0
+	move.l	(8,a0), d1	! # bytes / element
+	cmp.l	#1, d1
+	bne 	2f
+	move.l	(sp)+, d1
+	move.b	d1, (a1,d0.l)	! store one byte element
+	bra	5f
+2:
+	cmp.l	#2, d1
+	bne 	4f
+	move.l	(sp)+, d1
+	move.w	d1, (a1,d0.l*2)	! store two byte element
+	bra	5f
+4:				! here: 4n byte element
+	muls.l	d1, d0
+	add.l	d0, a1		! address of 4n byte element
+	asr.l	#2, d1
+	sub.l	#1, d1
+1:
+	move.l	(sp)+, (a1)+
+	dbf	d1, 1b
+5:
+	move.l	d2,a0
+	jmp	(a0)
+.align 2

mach/m68020/libem/set.s

@@ -0,0 +1,33 @@
+.define	.set
+.sect .text
+.sect .rom
+.sect .data
+.sect .bss
+.sect	.text
+
+.set:	! d0 bitnumber
+	! d1 setsize in bytes
+
+	move.l	(sp)+, a0
+	move.l	d2, a1
+	move.l	d1, d2
+	asr.l	#2, d2
+	sub.l	#1, d2
+1:
+	clr.l	-(sp)
+	dbf	d2, 1b
+
+	move.l	d0, d2
+	asr.l	#3, d2		! offset from sp in bytes
+	eor.l	#3, d2		! longs are stored in high-to-low order
+	cmp.l	d1, d2
+	blt	2f
+	move.l	#ESET, -(sp)	! bitnumber too large
+	move.l	a1, d2
+	move.l	a0, -(sp)
+	jmp	(.trp)
+2:
+	bset	d0, (sp, d2.l)
+	move.l	a1, d2
+	jmp	(a0)	! return
+.align 2

mach/m68020/libem/shp.s

@@ -0,0 +1,26 @@
+.define	.strhp
+.sect .text
+.sect .rom
+.sect .data
+.sect .bss
+
+	.sect .text
+.strhp:
+	move.l	(sp)+, a0
+	move.l	(sp), d1	! new heap pointer
+	cmp.l	(.limhp), d1	! compare new heap pointer with limit
+	blt	1f
+	add.l	#0x400, d1
+	and.l	#~0x3ff, d1
+	move.l	d1, (.limhp)
+	move.l	d1, -(sp)
+	jsr	(_brk)		! allocate 1K bytes of extra storage
+	add.l	#4, sp
+	bcs	2f
+1:
+	move.l	(sp)+, (.reghp)	! store new value
+	jmp	(a0)		! return
+2:
+	move.l	#EHEAP, -(sp)
+	jmp	(.fatal)
+.align 2

mach/m68020/libem/sts.s

@@ -0,0 +1,34 @@
+.define .sts
+.sect .text
+.sect .rom
+.sect .data
+.sect .bss
+
+	! d0 : # bytes
+	! a0 : destination address
+	! a1 : return address
+.sect .text
+.sts:
+	move.l	(sp)+, a1
+	move.l	(sp)+, d0
+	move.l	(sp)+, a0
+	cmp.l	#1, d0
+	bne	1f
+	move.l	(sp)+, d0
+	move.b	d0, (a0)
+	bra	4f
+
+1:	cmp.l	#2, d0
+	bne	2f
+	move.l	(sp)+, d0
+	move.w	d0, (a0)
+	bra	4f
+2:
+	asr.l	#2, d0
+	sub.l	#1, d0
+3:
+	move.l	(sp)+, (a0)+
+	dbf	d0, 3b
+4:
+	jmp	(a1)		! return
+.align 2

mach/m68020/libem/trp.s

@@ -0,0 +1,40 @@
+.define	.trp
+.sect .text
+.sect .rom
+.sect .data
+.sect .bss
+
+	.sect .text
+.trp:
+	movem.l	d0/d1/a0, -(sp)
+	move.l	(16, sp), a0	! return address
+	move.l	(20, sp), d0	! error number
+	move.l	a0, (20, sp)
+	move.l	d0, (16, sp)
+	move.l	d0,-(sp)
+	cmp.l	#16, d0
+	bcc	1f
+	move.l	(.trpim), d1
+	btst	d0, d1
+	bne	3f
+1:
+	move.l	(.trppc), a0
+	move.l	a0, d0
+	beq	9f
+	clr.l	(.trppc)
+	jsr	(a0)
+3:
+	add.l	#4, sp
+	movem.l	(sp)+, d0/d1/a0
+	add.l	#4, sp
+	rts
+9:
+	pea	(fmt)
+	jsr	(.diagnos)
+	lea	(4, sp), sp
+	jsr	(__cleanup)
+	jmp	(EXIT)
+
+.sect .data
+fmt:	.asciz "trap %d called\n"
+.align 2