use libkern components; from graichen

1 files changed, 0 insertions, 294 deletions

diff --git a/sys/arch/pmax/pmax/locore.S b/sys/arch/pmax/pmax/locore.S
index 4d628d1d626..f6b110c9151 100644
--- a/sys/arch/pmax/pmax/locore.S
+++ b/sys/arch/pmax/pmax/locore.S
@@ -244,292 +244,6 @@ baderr:
 END(badaddr)
 
 /*
- * netorder = htonl(hostorder)
- * hostorder = ntohl(netorder)
- */
-LEAF(htonl)				# a0 = 0x11223344, return 0x44332211
-ALEAF(ntohl)
-	srl	v1, a0, 24		# v1 = 0x00000011
-	sll	v0, a0, 24		# v0 = 0x44000000
-	or	v0, v0, v1
-	and	v1, a0, 0xff00
-	sll	v1, v1, 8		# v1 = 0x00330000
-	or	v0, v0, v1
-	srl	v1, a0, 8
-	and	v1, v1, 0xff00		# v1 = 0x00002200
-	j	ra
-	or	v0, v0, v1
-END(htonl)
-
-/*
- * netorder = htons(hostorder)
- * hostorder = ntohs(netorder)
- */
-LEAF(htons)
-ALEAF(ntohs)
-	srl	v0, a0, 8
-	and	v0, v0, 0xff
-	sll	v1, a0, 8
-	and	v1, v1, 0xff00
-	j	ra
-	or	v0, v0, v1
-END(htons)
-
-/*
- * bit = ffs(value)
- */
-LEAF(ffs)
-	beq	a0, zero, 2f
-	move	v0, zero
-1:
-	and	v1, a0, 1		# bit set?
-	addu	v0, v0, 1
-	beq	v1, zero, 1b		# no, continue
-	srl	a0, a0, 1
-2:
-	j	ra
-	nop
-END(ffs)
-
-/*
- * strlen(str)
- */
-LEAF(strlen)
-	addu	v1, a0, 1
-1:
-	lb	v0, 0(a0)		# get byte from string
-	addu	a0, a0, 1		# increment pointer
-	bne	v0, zero, 1b		# continue if not end
-	nop
-	j	ra
-	subu	v0, a0, v1		# compute length - 1 for '\0' char
-END(strlen)
-
-/*
- * NOTE: this version assumes unsigned chars in order to be "8 bit clean".
- */
-LEAF(strcmp)
-1:
-	lbu	t0, 0(a0)		# get two bytes and compare them
-	lbu	t1, 0(a1)
-	beq	t0, zero, LessOrEq	# end of first string?
-	nop
-	bne	t0, t1, NotEq
-	nop
-	lbu	t0, 1(a0)		# unroll loop
-	lbu	t1, 1(a1)
-	beq	t0, zero, LessOrEq	# end of first string?
-	addu	a0, a0, 2
-	beq	t0, t1, 1b
-	addu	a1, a1, 2
-NotEq:
-	j	ra
-	subu	v0, t0, t1
-LessOrEq:
-	j	ra
-	subu	v0, zero, t1
-END(strcmp)
-
-/*
- * bzero(s1, n)
- */
-LEAF(bzero)
-ALEAF(blkclr)
-	blt	a1, 12, smallclr	# small amount to clear?
-	subu	a3, zero, a0		# compute # bytes to word align address
-	and	a3, a3, 3
-	beq	a3, zero, 1f		# skip if word aligned
-	subu	a1, a1, a3		# subtract from remaining count
-	swr	zero, 0(a0)		# clear 1, 2, or 3 bytes to align
-	addu	a0, a0, a3
-1:
-	and	v0, a1, 3		# compute number of words left
-	subu	a3, a1, v0
-	move	a1, v0
-	addu	a3, a3, a0		# compute ending address
-2:
-	addu	a0, a0, 4		# clear words
-	bne	a0, a3, 2b		#  unrolling loop does not help
-	sw	zero, -4(a0)		#  since we are limited by memory speed
-smallclr:
-	ble	a1, zero, 2f
-	addu	a3, a1, a0		# compute ending address
-1:
-	addu	a0, a0, 1		# clear bytes
-	bne	a0, a3, 1b
-	sb	zero, -1(a0)
-2:
-	j	ra
-	nop
-END(bzero)
-
-/*
- * bcmp(s1, s2, n)
- */
-LEAF(bcmp)
-	blt	a2, 16, smallcmp	# is it worth any trouble?
-	xor	v0, a0, a1		# compare low two bits of addresses
-	and	v0, v0, 3
-	subu	a3, zero, a1		# compute # bytes to word align address
-	bne	v0, zero, unalignedcmp	# not possible to align addresses
-	and	a3, a3, 3
-
-	beq	a3, zero, 1f
-	subu	a2, a2, a3		# subtract from remaining count
-	move	v0, v1			# init v0,v1 so unmodified bytes match
-	lwr	v0, 0(a0)		# read 1, 2, or 3 bytes
-	lwr	v1, 0(a1)
-	addu	a1, a1, a3
-	bne	v0, v1, nomatch
-	addu	a0, a0, a3
-1:
-	and	a3, a2, ~3		# compute number of whole words left
-	subu	a2, a2, a3		#   which has to be >= (16-3) & ~3
-	addu	a3, a3, a0		# compute ending address
-2:
-	lw	v0, 0(a0)		# compare words
-	lw	v1, 0(a1)
-	addu	a0, a0, 4
-	bne	v0, v1, nomatch
-	addu	a1, a1, 4
-	bne	a0, a3, 2b
-	nop
-	b	smallcmp		# finish remainder
-	nop
-unalignedcmp:
-	beq	a3, zero, 2f
-	subu	a2, a2, a3		# subtract from remaining count
-	addu	a3, a3, a0		# compute ending address
-1:
-	lbu	v0, 0(a0)		# compare bytes until a1 word aligned
-	lbu	v1, 0(a1)
-	addu	a0, a0, 1
-	bne	v0, v1, nomatch
-	addu	a1, a1, 1
-	bne	a0, a3, 1b
-	nop
-2:
-	and	a3, a2, ~3		# compute number of whole words left
-	subu	a2, a2, a3		#   which has to be >= (16-3) & ~3
-	addu	a3, a3, a0		# compute ending address
-3:
-	lwr	v0, 0(a0)		# compare words a0 unaligned, a1 aligned
-	lwl	v0, 3(a0)
-	lw	v1, 0(a1)
-	addu	a0, a0, 4
-	bne	v0, v1, nomatch
-	addu	a1, a1, 4
-	bne	a0, a3, 3b
-	nop
-smallcmp:
-	ble	a2, zero, match
-	addu	a3, a2, a0		# compute ending address
-1:
-	lbu	v0, 0(a0)
-	lbu	v1, 0(a1)
-	addu	a0, a0, 1
-	bne	v0, v1, nomatch
-	addu	a1, a1, 1
-	bne	a0, a3, 1b
-	nop
-match:
-	j	ra
-	move	v0, zero
-nomatch:
-	j	ra
-	li	v0, 1
-END(bcmp)
-
-/*
- * memcpy(to, from, len)
- * {ov}bcopy(from, to, len)
- */
-LEAF(memcpy)
-	move	v0, a0			# swap from and to
-	move	a0, a1
-	move	a1, v0
-ALEAF(bcopy)
-ALEAF(ovbcopy)
-	addu	t0, a0, a2		# t0 = end of s1 region
-	sltu	t1, a1, t0
-	sltu	t2, a0, a1
-	and	t1, t1, t2		# t1 = true if from < to < (from+len)
-	beq	t1, zero, forward	# non overlapping, do forward copy
-	slt	t2, a2, 12		# check for small copy
-
-	ble	a2, zero, 2f
-	addu	t1, a1, a2		# t1 = end of to region
-1:
-	lb	v1, -1(t0)		# copy bytes backwards,
-	subu	t0, t0, 1		#   doesnt happen often so do slow way
-	subu	t1, t1, 1
-	bne	t0, a0, 1b
-	sb	v1, 0(t1)
-2:
-	j	ra
-	nop
-forward:
-	bne	t2, zero, smallcpy	# do a small bcopy
-	xor	v1, a0, a1		# compare low two bits of addresses
-	and	v1, v1, 3
-	subu	a3, zero, a1		# compute # bytes to word align address
-	beq	v1, zero, aligned	# addresses can be word aligned
-	and	a3, a3, 3
-
-	beq	a3, zero, 1f
-	subu	a2, a2, a3		# subtract from remaining count
-	lwr	v1, 0(a0)		# get next 4 bytes (unaligned)
-	lwl	v1, 3(a0)
-	addu	a0, a0, a3
-	swr	v1, 0(a1)		# store 1, 2, or 3 bytes to align a1
-	addu	a1, a1, a3
-1:
-	and	v1, a2, 3		# compute number of words left
-	subu	a3, a2, v1
-	move	a2, v1
-	addu	a3, a3, a0		# compute ending address
-2:
-	lwr	v1, 0(a0)		# copy words a0 unaligned, a1 aligned
-	lwl	v1, 3(a0)
-	addu	a0, a0, 4
-	addu	a1, a1, 4
-	bne	a0, a3, 2b
-	sw	v1, -4(a1)
-	b	smallcpy
-	nop
-aligned:
-	beq	a3, zero, 1f
-	subu	a2, a2, a3		# subtract from remaining count
-	lwr	v1, 0(a0)		# copy 1, 2, or 3 bytes to align
-	addu	a0, a0, a3
-	swr	v1, 0(a1)
-	addu	a1, a1, a3
-1:
-	and	v1, a2, 3		# compute number of whole words left
-	subu	a3, a2, v1
-	move	a2, v1
-	addu	a3, a3, a0		# compute ending address
-2:
-	lw	v1, 0(a0)		# copy words
-	addu	a0, a0, 4
-	addu	a1, a1, 4
-	bne	a0, a3, 2b
-	sw	v1, -4(a1)
-smallcpy:
-	ble	a2, zero, 2f
-	addu	a3, a2, a0		# compute ending address
-1:
-	lbu	v1, 0(a0)		# copy bytes
-	addu	a0, a0, 1
-	addu	a1, a1, 1
-	bne	a0, a3, 1b
-	sb	v1, -1(a1)
-2:
-	j	ra
-	nop
-END(memcpy)
-
-/*
  * fillw(pat, addr, count)
  */
 LEAF(fillw)
@@ -1172,14 +886,6 @@ LEAF(_remque)
 END(_remque)
 
 /*
- * GCC2 seems to want to call __main in main() for some reason.
- */
-LEAF(__main)
-	j	ra
-	nop
-END(__main)
-
-/*
  *----------------------------------------------------------------------------
  *
  * mips_r2000_UTLBmiss --