From 131dad5082834d5c21d81973d51e939dfb1a573c Mon Sep 17 00:00:00 2001
From: John Newlin <jnewlin@google.com>
Date: Mon, 20 Oct 2014 10:28:00 -0700
Subject: [PATCH 4/5] Add broadcom's memcpy patch.

---
 .../uclibc/0.9.33.2/uclibc-0063-brcm-memcpy.patch  | 2120 ++++++++++++++++++++
 1 file changed, 2120 insertions(+)
 create mode 100644 package/uclibc/0.9.33.2/uclibc-0063-brcm-memcpy.patch

diff --git a/package/uclibc/0.9.33.2/uclibc-0063-brcm-memcpy.patch b/package/uclibc/0.9.33.2/uclibc-0063-brcm-memcpy.patch
new file mode 100644
index 0000000..2112f81
--- /dev/null
+++ b/package/uclibc/0.9.33.2/uclibc-0063-brcm-memcpy.patch
@@ -0,0 +1,2120 @@
+commit e4756b4171ce4f6d4f58e0454335a09c3e7d6e6f
+Author: Kevin Cernekee <cernekee@gmail.com>
+Date:   Sat Apr 16 19:39:05 2011 -0700
+
+    uClibc: Add optimized memcpy() for BMIPS3300, BMIPS4380, BMIPS5000
+    
+    refs #SWLINUX-1853
+    
+    Signed-off-by: Kevin Cernekee <cernekee@gmail.com>
+
+diff --git a/libc/string/mips/_memcpy.S b/libc/string/mips/_memcpy.S
+new file mode 100644
+index 0000000..9674b9e
+--- /dev/null
++++ b/libc/string/mips/_memcpy.S
+@@ -0,0 +1,2050 @@
++/* Copyright (C) 2002, 2003 Free Software Foundation, Inc.
++   This file is part of the GNU C Library.
++   Contributed by Hartvig Ekner <hartvige@mips.com>, 2002.
++
++   Copyright (C) 2011 Broadcom Corporation
++
++   The GNU C Library is free software; you can redistribute it and/or
++   modify it under the terms of the GNU Lesser General Public
++   License as published by the Free Software Foundation; either
++   version 2.1 of the License, or (at your option) any later version.
++
++   The GNU C Library is distributed in the hope that it will be useful,
++   but WITHOUT ANY WARRANTY; without even the implied warranty of
++   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
++   Lesser General Public License for more details.
++
++   You should have received a copy of the GNU Lesser General Public
++   License along with the GNU C Library; if not, write to the Free
++   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
++   02111-1307 USA.  */
++
++#include <features.h>
++#include <endian.h>
++#include "sysdep.h"
++#include <sys/asm.h>
++#include <sys/regdef.h>
++
++#if !defined(__mips64)
++
++/* void *memcpy(void *s1, const void *s2, size_t n);  */
++
++#if __BYTE_ORDER == __BIG_ENDIAN
++#  define LWHI	lwl		/* high part is left in big-endian	*/
++#  define SWHI	swl		/* high part is left in big-endian	*/
++#  define LWLO	lwr		/* low part is right in big-endian	*/
++#  define SWLO	swr		/* low part is right in big-endian	*/
++#else
++#  define LWHI	lwr		/* high part is right in little-endian	*/
++#  define SWHI	swr		/* high part is right in little-endian	*/
++#  define LWLO	lwl		/* low part is left in little-endian	*/
++#  define SWLO	swl		/* low part is left in little-endian	*/
++#endif
++
++#ifdef __PIC__
++	.option	pic2
++#endif
++
++	.data
++	.align  2
++	.type	__memcpy_impl, @object
++	.size	__memcpy_impl, 4
++__memcpy_impl:
++	.word	0
++
++
++__str_bmips3300:
++	.string	"bmips3300"
++__str_bmips4380:
++	.string	"bmips4380"
++__str_bmips5000:
++	.string	"bmips5000"
++__cpulist:
++	.word	_3300_memcpy
++	.word	__str_bmips3300
++	.word	_4380_memcpy
++	.word	__str_bmips4380
++	.word	_5000_memcpy
++	.word	__str_bmips5000
++	.word	0
++
++
++	.text
++
++ENTRY (memcpy)
++	.set	noreorder
++#ifdef __PIC__
++	.cpload	t9
++#endif
++
++	lw	t0, __memcpy_impl
++	beqz	t0, detect_cpu		# based on cpu type
++	nop
++
++	jr	t0
++	nop
++
++_3300_memcpy:
++
++#undef L
++#define	L(x)	__BMIPS3300_memcpy_##x
++
++	slti	t0, a2, 8		# Less than 8?
++	bne	t0, zero, L(last8)
++	move	v0, a0			# Setup exit value before too late
++
++	xor	t0, a1, a0		# Find a0/a1 displacement
++	andi	t0, 0x3
++	bne	t0, zero, L(shift)	# Go handle the unaligned case
++	subu	t1, zero, a1
++	andi	t1, 0x3			# a0/a1 are aligned, but are we
++	beq	t1, zero, L(chk8w)	#  starting in the middle of a word?
++	subu	a2, t1
++	LWHI	t0, 0(a1)		# Yes we are... take care of that
++	addu	a1, t1
++	SWHI	t0, 0(a0)
++	addu	a0, t1
++
++L(chk8w):
++	andi	t0, a2, 0x1f		# 32 or more bytes left?
++	beq	t0, a2, L(chk1w)
++	subu	a3, a2, t0		# Yes
++
++	addu	a3, a0			# a3 = end address of loop
++	subu	a3, a3, 0x10
++	.align 4
++	move	a2, t0			# a2 = what will be left after loop
++
++	lw	t0,  0(a1)		# Loop taking 8 words at a time
++	sw	t0,  0(a0)
++L(lop8w):
++	lw	t1,  0x10(a1)
++	pref	30,  0x10(a0)
++	lw	t2,  0x4(a1)
++	lw	t3,  0x8(a1)
++	lw	t4, 0xc(a1)
++	sw	t1,  0x10(a0)
++	sw	t2,  0x4(a0)
++	sw	t3,  0x8(a0)
++	sw	t4, 0xc(a0)
++	add	a0, a0, 0x10
++	bne	a0, a3, L(lop8w)
++	add	a1, a1, 0x10
++	lw	t2,  0x4(a1)
++	lw	t3,  0x8(a1)
++	lw	t4, 0xc(a1)
++	sw	t2,  0x4(a0)
++	sw	t3,  0x8(a0)
++	sw	t4, 0xc(a0)
++	add	a1, a1, 0x10
++	add	a0, a0, 0x10
++
++L(chk1w):
++	andi	t0, a2, 0x3		# 4 or more bytes left?
++	beq	t0, a2, L(last8)
++	subu	a3, a2, t0		# Yes, handle them one word at a time
++	addu	a3, a1			# a3 again end address
++	move	a2, t0
++L(lop1w):
++	lw	t0, 0(a1)
++	addiu	a0, 4
++	addiu	a1, 4
++	bne	a1, a3, L(lop1w)
++	sw	t0, -4(a0)
++
++L(last8):
++	blez	a2, L(lst8e)		# Handle last 8 bytes, one at a time
++	addu	a3, a2, a1
++L(lst8l):
++	lb	t0, 0(a1)
++	addiu	a0, 1
++	addiu	a1, 1
++	bne	a1, a3, L(lst8l)
++	sb	t0, -1(a0)
++L(lst8e):
++	jr	ra			# Bye, bye
++	nop
++
++L(shift):
++	subu	a3, zero, a0		# Src and Dest unaligned
++	andi	a3, 0x3			#  (unoptimized case...)
++	beq	a3, zero, L(shft1)
++	subu	a2, a3			# a2 = bytes left
++	LWHI	t0, 0(a1)		# Take care of first odd part
++	LWLO	t0, 3(a1)
++	addu	a1, a3
++	SWHI	t0, 0(a0)
++	addu	a0, a3
++L(shft1):
++	andi	t0, a2, 0x3
++	subu	a3, a2, t0
++	addu	a3, a1
++L(shfth):
++	LWHI	t1, 0(a1)		# Limp through, word by word
++	LWLO	t1, 3(a1)
++	addiu	a0, 4
++	addiu	a1, 4
++	bne	a1, a3, L(shfth)
++	sw	t1, -4(a0)
++	b	L(last8)		# Handle anything which may be left
++	move	a2, t0
++
++_4380_memcpy:
++
++#undef L
++#define	L(x)	__BMIPS4380_memcpy_##x
++
++	slti	t0, a2, 8		# Less than 8 bytes?
++	bne	t0, zero, L(last8ByteCopy) #  Yes, proceed to process 8 bytes.
++	move	v0, a0			# setup exit value before too late
++
++	xor	t0, a1, a0		# find a0/a1 displacement
++	andi	t0, 0x3
++	beq	t0, zero, L(wordAlign)	# go handle the word-aligned case
++	subu	t1, zero, a1
++	b	L(unAlignSrcDest)
++	subu	a3, zero, a0
++
++	/*********************************************************************
++	 * SRC and DEST are Word-Aligned.
++	 *********************************************************************/
++L(wordAlign):
++	andi	t1, 0x3		# a0/a1 are aligned, but r we
++	beq	t1, zero, L(intCheck8w) #  starting in middle of a word?
++	subu	a2, t1
++
++	LWHI	t0, 0(a1)	# src is in the middle of a word...
++	addu	a1, t1
++	SWHI	t0, 0(a0)
++	addu	a0, t1
++
++L(intCheck8w): 			# SRC is at begin of word
++	andi	t0, a2, 0x1ff	# 512 or more bytes left ?
++	beq	t0, a2, L(check4w)	#   NO, less than 512, proceed to process 4w/16B
++	subu	a3, a2, t0	#   Yes, more than 512, maybe we can use FPU copy
++
++	addu	a3, a0		# a3 = end address of loop
++	subu	a3, a3, 0x100
++	.align 4
++	move	a2, t0		# a2 = what will be left after loop
++
++	lw	t6,  0(a1)	# Loop taking 32 words at a time
++
++	/*--------------------------------------------------------------------
++	 * Integer Copy Loop
++	 *--------------------------------------------------------------------*/
++L(intLoopBack):
++	pref	30,  0x40(a0)
++	lw	t5,  0x40(a1)
++
++	lw	t2,  0x4(a1)
++	lw	t3,  0x8(a1)
++	lw	t4,  0xc(a1)
++	sw	t6,  0x0(a0)
++	sw	t2,  0x4(a0)
++	sw	t3,  0x8(a0)
++	sw	t4,  0xc(a0)
++
++	lw	t1,  0x10(a1)
++	lw	t2,  0x14(a1)
++	lw	t3,  0x18(a1)
++	lw	t4,  0x1c(a1)
++	sw	t1,  0x10(a0)
++	sw	t2,  0x14(a0)
++	sw	t3,  0x18(a0)
++	sw	t4,  0x1c(a0)
++
++	lw	t1,  0x20(a1)
++	lw	t2,  0x24(a1)
++	lw	t3,  0x28(a1)
++	lw	t4,  0x2c(a1)
++	sw	t1,  0x20(a0)
++	sw	t2,  0x24(a0)
++	sw	t3,  0x28(a0)
++	sw	t4,  0x2c(a0)
++
++	lw	t1,  0x30(a1)
++	lw	t2,  0x34(a1)
++	lw	t3,  0x38(a1)
++	lw	t4,  0x3c(a1)
++	sw	t1,  0x30(a0)
++	sw	t2,  0x34(a0)
++	sw	t3,  0x38(a0)
++	sw	t4,  0x3c(a0)
++
++	pref	30,  0x80(a0)
++	lw	t6,  0x80(a1)
++
++	lw	t2,  0x44(a1)
++	lw	t3,  0x48(a1)
++	lw	t4,  0x4c(a1)
++	sw	t5,  0x40(a0)
++	sw	t2,  0x44(a0)
++	sw	t3,  0x48(a0)
++	sw	t4,  0x4c(a0)
++
++	lw	t1,  0x50(a1)
++	lw	t2,  0x54(a1)
++	lw	t3,  0x58(a1)
++	lw	t4,  0x5c(a1)
++	sw	t1,  0x50(a0)
++	sw	t2,  0x54(a0)
++	sw	t3,  0x58(a0)
++	sw	t4,  0x5c(a0)
++
++	lw	t1,  0x60(a1)
++	lw	t2,  0x64(a1)
++	lw	t3,  0x68(a1)
++	lw	t4,  0x6c(a1)
++	sw	t1,  0x60(a0)
++	sw	t2,  0x64(a0)
++	sw	t3,  0x68(a0)
++	sw	t4,  0x6c(a0)
++
++	lw	t1,  0x70(a1)
++	lw	t2,  0x74(a1)
++	lw	t3,  0x78(a1)
++	lw	t4,  0x7c(a1)
++	sw	t1,  0x70(a0)
++	sw	t2,  0x74(a0)
++	sw	t3,  0x78(a0)
++	sw	t4,  0x7c(a0)
++
++	pref	30,  0xc0(a0)
++	lw	t5,  0xc0(a1)
++
++	lw	t2,  0x84(a1)
++	lw	t3,  0x88(a1)
++	lw	t4,  0x8c(a1)
++	sw	t6,  0x80(a0)
++	sw	t2,  0x84(a0)
++	sw	t3,  0x88(a0)
++	sw	t4,  0x8c(a0)
++
++	lw	t1,  0x90(a1)
++	lw	t2,  0x94(a1)
++	lw	t3,  0x98(a1)
++	lw	t4,  0x9c(a1)
++	sw	t1,  0x90(a0)
++	sw	t2,  0x94(a0)
++	sw	t3,  0x98(a0)
++	sw	t4,  0x9c(a0)
++
++	lw	t1,  0xa0(a1)
++	lw	t2,  0xa4(a1)
++	lw	t3,  0xa8(a1)
++	lw	t4,  0xac(a1)
++	sw	t1,  0xa0(a0)
++	sw	t2,  0xa4(a0)
++	sw	t3,  0xa8(a0)
++	sw	t4,  0xac(a0)
++
++	lw	t1,  0xb0(a1)
++	lw	t2,  0xb4(a1)
++	lw	t3,  0xb8(a1)
++	lw	t4,  0xbc(a1)
++	sw	t1,  0xb0(a0)
++	sw	t2,  0xb4(a0)
++	sw	t3,  0xb8(a0)
++	sw	t4,  0xbc(a0)
++
++	pref	30,  0x100(a0)
++	lw	t6,  0x100(a1)
++
++	lw	t2,  0xc4(a1)
++	lw	t3,  0xc8(a1)
++	lw	t4,  0xcc(a1)
++	sw	t5,  0xc0(a0)
++	sw	t2,  0xc4(a0)
++	sw	t3,  0xc8(a0)
++	sw	t4,  0xcc(a0)
++
++	lw	t1,  0xd0(a1)
++	lw	t2,  0xd4(a1)
++	lw	t3,  0xd8(a1)
++	lw	t4,  0xdc(a1)
++	sw	t1,  0xd0(a0)
++	sw	t2,  0xd4(a0)
++	sw	t3,  0xd8(a0)
++	sw	t4,  0xdc(a0)
++
++	lw	t1,  0xe0(a1)
++	lw	t2,  0xe4(a1)
++	lw	t3,  0xe8(a1)
++	lw	t4,  0xec(a1)
++	sw	t1,  0xe0(a0)
++	sw	t2,  0xe4(a0)
++	sw	t3,  0xe8(a0)
++	sw	t4,  0xec(a0)
++
++	lw	t1,  0xf0(a1)
++	lw	t2,  0xf4(a1)
++	lw	t3,  0xf8(a1)
++	lw	t4,  0xfc(a1)
++	sw	t1,  0xf0(a0)
++	sw	t2,  0xf4(a0)
++	sw	t3,  0xf8(a0)
++	sw	t4,  0xfc(a0)
++
++	add	a0, a0, 0x100
++	bne	a0, a3, L(intLoopBack)
++	add	a1, a1, 0x100
++
++	lw	t2,  0x4(a1)
++	lw	t3,  0x8(a1)
++	lw	t4,  0xc(a1)
++	sw	t6,  0x0(a0)
++	sw	t2,  0x4(a0)
++	sw	t3,  0x8(a0)
++	sw	t4,  0xc(a0)
++
++	lw	t1,  0x10(a1)
++	lw	t2,  0x14(a1)
++	lw	t3,  0x18(a1)
++	lw	t4,  0x1c(a1)
++	sw	t1,  0x10(a0)
++	sw	t2,  0x14(a0)
++	sw	t3,  0x18(a0)
++	sw	t4,  0x1c(a0)
++
++	lw	t1,  0x20(a1)
++	lw	t2,  0x24(a1)
++	lw	t3,  0x28(a1)
++	lw	t4,  0x2c(a1)
++	sw	t1,  0x20(a0)
++	sw	t2,  0x24(a0)
++	sw	t3,  0x28(a0)
++	sw	t4,  0x2c(a0)
++
++	lw	t1,  0x30(a1)
++	lw	t2,  0x34(a1)
++	lw	t3,  0x38(a1)
++	lw	t4,  0x3c(a1)
++	sw	t1,  0x30(a0)
++	sw	t2,  0x34(a0)
++	sw	t3,  0x38(a0)
++	sw	t4,  0x3c(a0)
++
++	lw	t1,  0x40(a1)
++	lw	t2,  0x44(a1)
++	lw	t3,  0x48(a1)
++	lw	t4,  0x4c(a1)
++	sw	t1,  0x40(a0)
++	sw	t2,  0x44(a0)
++	sw	t3,  0x48(a0)
++	sw	t4,  0x4c(a0)
++
++	lw	t1,  0x50(a1)
++	lw	t2,  0x54(a1)
++	lw	t3,  0x58(a1)
++	lw	t4,  0x5c(a1)
++	sw	t1,  0x50(a0)
++	sw	t2,  0x54(a0)
++	sw	t3,  0x58(a0)
++	sw	t4,  0x5c(a0)
++
++	lw	t1,  0x60(a1)
++	lw	t2,  0x64(a1)
++	lw	t3,  0x68(a1)
++	lw	t4,  0x6c(a1)
++	sw	t1,  0x60(a0)
++	sw	t2,  0x64(a0)
++	sw	t3,  0x68(a0)
++	sw	t4,  0x6c(a0)
++
++	lw	t1,  0x70(a1)
++	lw	t2,  0x74(a1)
++	lw	t3,  0x78(a1)
++	lw	t4,  0x7c(a1)
++	sw	t1,  0x70(a0)
++	sw	t2,  0x74(a0)
++	sw	t3,  0x78(a0)
++	sw	t4,  0x7c(a0)
++
++	lw	t1,  0x80(a1)
++	lw	t2,  0x84(a1)
++	lw	t3,  0x88(a1)
++	lw	t4,  0x8c(a1)
++	sw	t1,  0x80(a0)
++	sw	t2,  0x84(a0)
++	sw	t3,  0x88(a0)
++	sw	t4,  0x8c(a0)
++
++	lw	t1,  0x90(a1)
++	lw	t2,  0x94(a1)
++	lw	t3,  0x98(a1)
++	lw	t4,  0x9c(a1)
++	sw	t1,  0x90(a0)
++	sw	t2,  0x94(a0)
++	sw	t3,  0x98(a0)
++	sw	t4,  0x9c(a0)
++
++	lw	t1,  0xa0(a1)
++	lw	t2,  0xa4(a1)
++	lw	t3,  0xa8(a1)
++	lw	t4,  0xac(a1)
++	sw	t1,  0xa0(a0)
++	sw	t2,  0xa4(a0)
++	sw	t3,  0xa8(a0)
++	sw	t4,  0xac(a0)
++
++	lw	t1,  0xb0(a1)
++	lw	t2,  0xb4(a1)
++	lw	t3,  0xb8(a1)
++	lw	t4,  0xbc(a1)
++	sw	t1,  0xb0(a0)
++	sw	t2,  0xb4(a0)
++	sw	t3,  0xb8(a0)
++	sw	t4,  0xbc(a0)
++
++	lw	t1,  0xc0(a1)
++	lw	t2,  0xc4(a1)
++	lw	t3,  0xc8(a1)
++	lw	t4,  0xcc(a1)
++	sw	t1,  0xc0(a0)
++	sw	t2,  0xc4(a0)
++	sw	t3,  0xc8(a0)
++	sw	t4,  0xcc(a0)
++
++	lw	t1,  0xd0(a1)
++	lw	t2,  0xd4(a1)
++	lw	t3,  0xd8(a1)
++	lw	t4,  0xdc(a1)
++	sw	t1,  0xd0(a0)
++	sw	t2,  0xd4(a0)
++	sw	t3,  0xd8(a0)
++	sw	t4,  0xdc(a0)
++
++	lw	t1,  0xe0(a1)
++	lw	t2,  0xe4(a1)
++	lw	t3,  0xe8(a1)
++	lw	t4,  0xec(a1)
++	sw	t1,  0xe0(a0)
++	sw	t2,  0xe4(a0)
++	sw	t3,  0xe8(a0)
++	sw	t4,  0xec(a0)
++
++	lw	t1,  0xf0(a1)
++	lw	t2,  0xf4(a1)
++	lw	t3,  0xf8(a1)
++	lw	t4,  0xfc(a1)
++	sw	t1,  0xf0(a0)
++	sw	t2,  0xf4(a0)
++	sw	t3,  0xf8(a0)
++	sw	t4,  0xfc(a0)
++
++	add	a1, a1, 0x100
++	add	a0, a0, 0x100
++
++	/*--------------------------------------------------------------------
++	 * copy if >16 and <512 bytes left-over
++	 *--------------------------------------------------------------------*/
++L(check4w): andi	t0, a2, 0xf		# 16 or more bytes left?
++	beq	t0, a2, L(check1w)		#   NO, less than 16, proceed to check1w (4bytes loop)
++	subu	a3, a2, t0			#   Yes, handle them in 16 bytes loop.
++
++	addu	a3, a1				# a3 = end address.
++	move	a2, t0
++
++L(loop4w):	lw	t0, 0(a1)		# loop for 16 bytes/4 words at a time.
++	lw	t1, 4(a1)
++	lw	t2, 8(a1)
++	lw	t3, 0xc(a1)
++	sw	t0, 0(a0)
++	sw	t1, 4(a0)
++	sw	t2, 8(a0)
++	addiu	a0, 16
++	addiu	a1, 16
++	bne	a1, a3, L(loop4w)
++	sw	t3, -4(a0)
++
++L(check1w): andi	t0, a2, 0x3		# 4 or more bytes left?
++	beq	t0, a2, L(last8ByteCopy)	#   NO, less than 4 bytes, proceed to process 3 bytes
++	subu	a3, a2, t0			#   Yes, handle them 1 word at a time
++	addu	a3, a1				# a3 = end address.
++	move	a2, t0
++
++L(loop1w):	lw	t0, 0(a1)		# loop 4 bytes/1 word at a time.
++	addiu	a0, 4
++	addiu	a1, 4
++	bne	a1, a3, L(loop1w)
++	sw	t0, -4(a0)
++
++L(last8ByteCopy):	blez	a2, L(last8BCExit)	# handle last 8 bytes, one byte at a time.
++	addu	a3, a2, a1
++
++L(last8BCLoopBack): lb	t0, 0(a1)	# last 8 bytes copy loop.
++	addiu	a0, 1
++	addiu	a1, 1
++	bne	a1, a3, L(last8BCLoopBack)
++	sb	t0, -1(a0)
++
++L(last8BCExit):
++	jr	$31			# return to caller.
++	nop
++
++
++
++	/*********************************************************************
++	 * SRC and DEST are NOT Aligned.
++	 *********************************************************************/
++L(unAlignSrcDest):				# SRC and DEST are NOT aligned.
++	andi	a3, 0x3			# Is DEST word aligned?
++	beq	a3, zero, L(uaCheck512)	#   YES, DEST is word-aligned, SW may be used.
++					#   NO, DEST is NOT word-aligned, has to adjust.
++
++	subu	a2, a3			# a2 = number of bytes left
++
++	LWHI	t0, 0(a1)		# DEST is NOT word aligned...
++	LWLO	t0, 3(a1)		#   adjust so DEST will be aligned.
++	addu	a1, a3
++	SWHI	t0, 0(a0)
++	addu	a0, a3
++L(uaCheck512):				# DEST is word-aligned.
++	andi	t0, a2, 0x1ff		# 512 or more bytes left ?
++	beq	t0, a2, L(uaCheck4w)	#   No, less than 512, cannot execute "pref"
++	subu	a3, a2, t0		#   Yes, more than 512, loop & "pref"
++
++	addu	a3, a0			# a3 = end address of loop
++	subu	a3, a3, 0x100
++	.align 4
++	move	a2, t0			# a2 = what will be left after loop
++	LWHI	t6,  0(a1)		# Loop taking 32 words at a time
++
++	/*--------------------------------------------------------------------
++	 * SRC and DEST are NOT Aligned, >512B, copy using LW/SW WITH pref
++	 *--------------------------------------------------------------------*/
++	add	t7, a0, 0x300		# prefetch dest 2 line size ahead.
++L(uaLoopBack):
++	pref	30,  0x40(a0)
++	LWHI	t5,  0x40(a1)
++
++	LWHI	t2,  0x4(a1)
++	LWHI	t3,  0x8(a1)
++	LWHI	t4,  0xc(a1)
++
++	LWLO	t6,  3(a1)
++	LWLO	t2,  0x7(a1)
++	LWLO	t3,  0xb(a1)
++	LWLO	t4,  0xf(a1)
++
++	sw	t6,  0x0(a0)
++	sw	t2,  0x4(a0)
++	sw	t3,  0x8(a0)
++	sw	t4,  0xc(a0)
++
++	# preload source
++	bge	t7, a3, L(uaSkip)
++	add	t7, t7, 0x100
++	lb	zero, 0x300(a1)
++L(uaSkip):
++	LWHI	t1,  0x10(a1)
++	LWHI	t2,  0x14(a1)
++	LWHI	t3,  0x18(a1)
++	LWHI	t4,  0x1c(a1)
++	LWLO	t1,  0x13(a1)
++	LWLO	t2,  0x17(a1)
++	LWLO	t3,  0x1b(a1)
++	LWLO	t4,  0x1f(a1)
++
++	sw	t1,  0x10(a0)
++	sw	t2,  0x14(a0)
++	sw	t3,  0x18(a0)
++	sw	t4,  0x1c(a0)
++
++	LWHI	t1,  0x20(a1)
++	LWHI	t2,  0x24(a1)
++	LWHI	t3,  0x28(a1)
++	LWHI	t4,  0x2c(a1)
++	LWLO	t1,  0x23(a1)
++	LWLO	t2,  0x27(a1)
++	LWLO	t3,  0x2b(a1)
++	LWLO	t4,  0x2f(a1)
++
++	sw	t1,  0x20(a0)
++	sw	t2,  0x24(a0)
++	sw	t3,  0x28(a0)
++	sw	t4,  0x2c(a0)
++
++	LWHI	t1,  0x30(a1)
++	LWHI	t2,  0x34(a1)
++	LWHI	t3,  0x38(a1)
++	LWHI	t4,  0x3c(a1)
++	LWLO	t1,  0x33(a1)
++	LWLO	t2,  0x37(a1)
++	LWLO	t3,  0x3b(a1)
++	LWLO	t4,  0x3f(a1)
++
++	sw	t1,  0x30(a0)
++	sw	t2,  0x34(a0)
++	sw	t3,  0x38(a0)
++	sw	t4,  0x3c(a0)
++
++	pref	30,  0x80(a0)
++	LWHI	t6,  0x80(a1)
++
++	LWHI	t2,  0x44(a1)
++	LWHI	t3,  0x48(a1)
++	LWHI	t4,  0x4c(a1)
++	LWLO	t5,  0x43(a1)
++	LWLO	t2,  0x47(a1)
++	LWLO	t3,  0x4b(a1)
++	LWLO	t4,  0x4f(a1)
++
++	sw	t5,  0x40(a0)
++	sw	t2,  0x44(a0)
++	sw	t3,  0x48(a0)
++	sw	t4,  0x4c(a0)
++
++	LWHI	t1,  0x50(a1)
++	LWHI	t2,  0x54(a1)
++	LWHI	t3,  0x58(a1)
++	LWHI	t4,  0x5c(a1)
++	LWLO	t1,  0x53(a1)
++	LWLO	t2,  0x57(a1)
++	LWLO	t3,  0x5b(a1)
++	LWLO	t4,  0x5f(a1)
++
++	sw	t1,  0x50(a0)
++	sw	t2,  0x54(a0)
++	sw	t3,  0x58(a0)
++	sw	t4,  0x5c(a0)
++
++	LWHI	t1,  0x60(a1)
++	LWHI	t2,  0x64(a1)
++	LWHI	t3,  0x68(a1)
++	LWHI	t4,  0x6c(a1)
++	LWLO	t1,  0x63(a1)
++	LWLO	t2,  0x67(a1)
++	LWLO	t3,  0x6b(a1)
++	LWLO	t4,  0x6f(a1)
++
++	sw	t1,  0x60(a0)
++	sw	t2,  0x64(a0)
++	sw	t3,  0x68(a0)
++	sw	t4,  0x6c(a0)
++
++	LWHI	t1,  0x70(a1)
++	LWHI	t2,  0x74(a1)
++	LWHI	t3,  0x78(a1)
++	LWHI	t4,  0x7c(a1)
++	LWLO	t1,  0x73(a1)
++	LWLO	t2,  0x77(a1)
++	LWLO	t3,  0x7b(a1)
++	LWLO	t4,  0x7f(a1)
++
++	sw	t1,  0x70(a0)
++	sw	t2,  0x74(a0)
++	sw	t3,  0x78(a0)
++	sw	t4,  0x7c(a0)
++
++	pref	30,  0xc0(a0)
++	LWHI	t5,  0xc0(a1)
++
++	LWHI	t2,  0x84(a1)
++	LWHI	t3,  0x88(a1)
++	LWHI	t4,  0x8c(a1)
++	LWLO	t6,  0x83(a1)
++	LWLO	t2,  0x87(a1)
++	LWLO	t3,  0x8b(a1)
++	LWLO	t4,  0x8f(a1)
++
++	sw	t6,  0x80(a0)
++	sw	t2,  0x84(a0)
++	sw	t3,  0x88(a0)
++	sw	t4,  0x8c(a0)
++
++	LWHI	t1,  0x90(a1)
++	LWHI	t2,  0x94(a1)
++	LWHI	t3,  0x98(a1)
++	LWHI	t4,  0x9c(a1)
++	LWLO	t1,  0x93(a1)
++	LWLO	t2,  0x97(a1)
++	LWLO	t3,  0x9b(a1)
++	LWLO	t4,  0x9f(a1)
++
++	sw	t1,  0x90(a0)
++	sw	t2,  0x94(a0)
++	sw	t3,  0x98(a0)
++	sw	t4,  0x9c(a0)
++
++	LWHI	t1,  0xa0(a1)
++	LWHI	t2,  0xa4(a1)
++	LWHI	t3,  0xa8(a1)
++	LWHI	t4,  0xac(a1)
++	LWLO	t1,  0xa3(a1)
++	LWLO	t2,  0xa7(a1)
++	LWLO	t3,  0xab(a1)
++	LWLO	t4,  0xaf(a1)
++
++	sw	t1,  0xa0(a0)
++	sw	t2,  0xa4(a0)
++	sw	t3,  0xa8(a0)
++	sw	t4,  0xac(a0)
++
++	LWHI	t1,  0xb0(a1)
++	LWHI	t2,  0xb4(a1)
++	LWHI	t3,  0xb8(a1)
++	LWHI	t4,  0xbc(a1)
++	LWLO	t1,  0xb3(a1)
++	LWLO	t2,  0xb7(a1)
++	LWLO	t3,  0xbb(a1)
++	LWLO	t4,  0xbf(a1)
++
++	sw	t1,  0xb0(a0)
++	sw	t2,  0xb4(a0)
++	sw	t3,  0xb8(a0)
++	sw	t4,  0xbc(a0)
++
++	pref	30,  0x100(a0)
++	LWHI	t6,  0x100(a1)
++
++	LWHI	t2,  0xc4(a1)
++	LWHI	t3,  0xc8(a1)
++	LWHI	t4,  0xcc(a1)
++	LWLO	t5,  0xc3(a1)
++	LWLO	t2,  0xc7(a1)
++	LWLO	t3,  0xcb(a1)
++	LWLO	t4,  0xcf(a1)
++
++	sw	t5,  0xc0(a0)
++	sw	t2,  0xc4(a0)
++	sw	t3,  0xc8(a0)
++	sw	t4,  0xcc(a0)
++
++	LWHI	t1,  0xd0(a1)
++	LWHI	t2,  0xd4(a1)
++	LWHI	t3,  0xd8(a1)
++	LWHI	t4,  0xdc(a1)
++	LWLO	t1,  0xd3(a1)
++	LWLO	t2,  0xd7(a1)
++	LWLO	t3,  0xdb(a1)
++	LWLO	t4,  0xdf(a1)
++
++	sw	t1,  0xd0(a0)
++	sw	t2,  0xd4(a0)
++	sw	t3,  0xd8(a0)
++	sw	t4,  0xdc(a0)
++
++	LWHI	t1,  0xe0(a1)
++	LWHI	t2,  0xe4(a1)
++	LWHI	t3,  0xe8(a1)
++	LWHI	t4,  0xec(a1)
++	LWLO	t1,  0xe3(a1)
++	LWLO	t2,  0xe7(a1)
++	LWLO	t3,  0xeb(a1)
++	LWLO	t4,  0xef(a1)
++
++	sw	t1,  0xe0(a0)
++	sw	t2,  0xe4(a0)
++	sw	t3,  0xe8(a0)
++	sw	t4,  0xec(a0)
++
++	LWHI	t1,  0xf0(a1)
++	LWHI	t2,  0xf4(a1)
++	LWHI	t3,  0xf8(a1)
++	LWHI	t4,  0xfc(a1)
++	LWLO	t1,  0xf3(a1)
++	LWLO	t2,  0xf7(a1)
++	LWLO	t3,  0xfb(a1)
++	LWLO	t4,  0xff(a1)
++
++	sw	t1,  0xf0(a0)
++	sw	t2,  0xf4(a0)
++	sw	t3,  0xf8(a0)
++	sw	t4,  0xfc(a0)
++
++	add	a0, a0, 0x100
++	bne		a0, a3, L(uaLoopBack)
++	add	a1, a1, 0x100
++
++	addu	a3, 0x100	# add 0x100 back
++
++	#
++	# copy loop 32 words at a time.
++	#
++L(uaRemain64LoopBack):
++	LWHI	t6,  0(a1)		# Loop taking 32 words at a time
++	LWHI	t2,  0x4(a1)
++	LWHI	t3,  0x8(a1)
++	LWHI	t4,  0xc(a1)
++	LWLO	t6,  3(a1)
++	LWLO	t2,  0x7(a1)
++	LWLO	t3,  0xb(a1)
++	LWLO	t4,  0xf(a1)
++
++	sw	t6,  0x0(a0)
++	sw	t2,  0x4(a0)
++	sw	t3,  0x8(a0)
++	sw	t4,  0xc(a0)
++
++	LWHI	t6,  0x10(a1)
++	LWHI	t2,  0x14(a1)
++	LWHI	t3,  0x18(a1)
++	LWHI	t4,  0x1c(a1)
++	LWLO	t6,  0x13(a1)
++	LWLO	t2,  0x17(a1)
++	LWLO	t3,  0x1b(a1)
++	LWLO	t4,  0x1f(a1)
++
++	sw	t6,  0x10(a0)
++	sw	t2,  0x14(a0)
++	sw	t3,  0x18(a0)
++	sw	t4,  0x1c(a0)
++
++	addiu	a0,  0x20
++	bne	a0,  a3, L(uaRemain64LoopBack)
++	addiu	a1,  0x20
++
++	addu	a3,  a2
++
++	/*--------------------------------------------------------------------
++	 * SRC and DEST are NOT Aligned, <512B, copy using LW/SW WITHOUT pref
++	 *--------------------------------------------------------------------*/
++L(uaCheck4w): andi	t0, a2, 0xf		# 16 or more bytes left?
++	beq	t0, a2, L(uaCheck1w)	#   NO, <16 bytes, proceed to process 1w
++	subu	a3, a2, t0		#   Yes, >16, copy 16 bytes at a time.
++
++	addu	a3, a1			# a3 = end address.
++	move	a2, t0
++
++L(ua4wLoopBack):				# loop 16 bytes/4 words at a time.
++	LWHI	t0, 0(a1)
++	LWHI	t1, 4(a1)
++	LWHI	t2, 8(a1)
++	LWHI	t3, 0xc(a1)
++	LWLO	t0, 3(a1)
++	LWLO	t1, 7(a1)
++	LWLO	t2, 0xb(a1)
++	LWLO	t3, 0xf(a1)
++	sw	t0, 0(a0)
++	sw	t1, 4(a0)
++	sw	t2, 8(a0)
++	addiu	a0, 16
++	addiu	a1, 16
++	bne	a1, a3, L(ua4wLoopBack)
++	sw	t3, -4(a0)
++
++L(uaCheck1w): andi	t0, a2, 0x3		# 4 or more bytes left?
++	beq	t0, a2, L(last8ByteCopy)	#   NO, <4 bytes, proceed to 8-bytes-copy
++	subu	a3, a2, t0
++
++	addu	a3, a0			#   YES, >4 bytes, can use LW/SW.
++
++L(uaRemain):
++	LWHI	t1, 0(a1)		# copy 1 word/4 bytes at a time.
++	LWLO	t1, 3(a1)
++	addiu	a0, 4
++	addiu	a1, 4
++	bne	a0, a3, L(uaRemain)
++	sw	t1, -4(a0)
++
++	b	L(last8ByteCopy)		# handle anything that may be left.
++	move	a2, t0
++
++#undef L
++#define	L(x)	__BMIPS5000_memcpy_##x
++
++_5000_memcpy:
++
++	slti	t0, a2, 8		# Less than 8 bytes?
++	bne	t0, zero, L(last8ByteCopy) #  Yes, proceed to process 8 bytes.
++	move	v0, a0			# setup exit value before too late
++
++	xor	t0, a1, a0		# find a0/a1 displacement
++	andi	t0, 0x7
++	beq	t0, zero, L(doubleWordAlign)  # go handle the double-aligned case
++	subu	t1, zero, a1
++
++	andi	t0, 0x3
++	beq	t0, zero, L(wordAlign)	# go handle the word-aligned case
++	nop
++	b	L(unAlignSrcDest)	# go handle the un-aligned case.
++	subu	a3, zero, a0
++
++	/*********************************************************************
++	 * SRC and DEST are Double Word Aligned.
++	 *********************************************************************/
++L(doubleWordAlign):
++	andi	t1, 0x7		# a0/a1 are aligned, but r we
++	beq	t1, zero, L(dwCheck8w) #  starting in middle of a word?
++	subu	a2, t1
++
++L(adjust):
++	andi	t2, t1, 0x3
++	LWHI	t0, 0(a1)	# src is in the middle of a word...
++	addu	a1, t1
++	SWHI	t0, 0(a0)
++	addu	a0, t1
++
++	andi	t1, 0x4		# if extra word, then adjust again.
++	beq	t1, zero, L(dwCheck8w)
++	nop
++	lw	t0, -4(a1)
++	sw	t0, -4(a0)
++
++L(dwCheck8w): 			# SRC is at begin of word
++	andi	t0, a2, 0x1ff	# 512 or more bytes left ?
++	beq	t0, a2, L(check4w)	#   NO, less than 512, proceed to process 4w/16B
++	subu	a3, a2, t0	#   Yes, more than 512, maybe we can use FPU copy
++
++	addu	a3, a0		# a3 = end address of loop
++	subu	a3, a3, 0x100
++	.align 4
++	move	a2, t0		# a2 = what will be left after loop
++
++	/*--------------------------------------------------------------------- *
++	 * Floating Point Copy 							*
++	 * memory copy for 64B D-Cache line size				*
++	 *--------------------------------------------------------------------- */
++
++	/* save f12, f14, f20, f24, f26 */
++	subu	sp, sp, 40
++	sdc1	$f12, 0(sp)
++	sdc1	$f14, 8(sp)
++	sdc1	$f20, 16(sp)
++	sdc1	$f24, 24(sp)
++	sdc1	$f26, 32(sp)
++
++	/* fpu copy start */
++	ldc1	$f4,  0x0(a1)
++	ldc1	$f20, 0x80(a1)
++	ldc1	$f6,  0x20(a1)
++	ldc1	$f8,  0x40(a1)
++	ldc1	$f10, 0x60(a1)
++	ldc1	$f18, 0xa0(a1)
++	ldc1	$f24, 0xc0(a1)
++	ldc1	$f26, 0xe0(a1)
++
++	pref	30, 0x20(a0)		# (prepare for store)
++	pref	30, 0x40(a0)
++	pref	30, 0x60(a0)
++
++L(fmCopyLoopBack):
++	/* first L2 line */
++	ldc1	$f12, 0x8(a1)
++	ldc1	$f14, 0x10(a1)
++	ldc1	$f16, 0x18(a1)
++	sdc1	$f4,  0x0(a0)
++	ldc1	$f4,  0x100(a1)
++	sdc1	$f12, 0x8(a0)
++	sdc1	$f14, 0x10(a0)
++	sdc1	$f16, 0x18(a0)
++
++	pref	30, 0x80(a0)
++
++	ldc1	$f12, 0x28(a1)
++	ldc1	$f14, 0x30(a1)
++	ldc1	$f16, 0x38(a1)
++	sdc1	$f6,  0x20(a0)
++	ldc1	$f6,  0x120(a1)
++	sdc1	$f12, 0x28(a0)
++	sdc1	$f14, 0x30(a0)
++	sdc1	$f16, 0x38(a0)
++
++	pref	30, 0xa0(a0)
++
++	ldc1	$f12, 0x48(a1)
++	ldc1	$f14, 0x50(a1)
++	ldc1	$f16, 0x58(a1)
++	sdc1	$f8,  0x40(a0)
++	ldc1	$f8,  0x140(a1)
++	sdc1	$f12, 0x48(a0)
++	sdc1	$f14, 0x50(a0)
++	sdc1	$f16, 0x58(a0)
++
++	pref	30, 0xc0(a0)
++
++	ldc1	$f12, 0x68(a1)
++	ldc1	$f14, 0x70(a1)
++	ldc1	$f16, 0x78(a1)
++	sdc1	$f10, 0x60(a0)
++	ldc1	$f10, 0x160(a1)
++	sdc1	$f12, 0x68(a0)
++	sdc1	$f14, 0x70(a0)
++	sdc1	$f16, 0x78(a0)
++
++	pref	30, 0xe0(a0)
++
++	/* 2nd L2 line */
++	ldc1	$f12, 0x88(a1)
++	ldc1	$f14, 0x90(a1)
++	ldc1	$f16, 0x98(a1)
++	sdc1	$f20, 0x80(a0)
++	ldc1	$f20, 0x180(a1)
++	sdc1	$f12, 0x88(a0)
++	sdc1	$f14, 0x90(a0)
++	sdc1	$f16, 0x98(a0)
++
++	pref	30, 0x100(a0)
++
++	ldc1	$f12, 0xa8(a1)
++	ldc1	$f14, 0xb0(a1)
++	ldc1	$f16, 0xb8(a1)
++	sdc1	$f18, 0xa0(a0)
++	ldc1	$f18, 0x1a0(a1)
++	sdc1	$f12, 0xa8(a0)
++	sdc1	$f14, 0xb0(a0)
++	sdc1	$f16, 0xb8(a0)
++
++	pref	30, 0x120(a0)
++
++	ldc1	$f12, 0xc8(a1)
++	ldc1	$f14, 0xd0(a1)
++	ldc1	$f16, 0xd8(a1)
++	sdc1	$f24, 0xc0(a0)
++	ldc1	$f24, 0x1c0(a1)
++	sdc1	$f12, 0xc8(a0)
++	sdc1	$f14, 0xd0(a0)
++	sdc1	$f16, 0xd8(a0)
++
++	pref	30, 0x140(a0)
++
++	ldc1	$f12, 0xe8(a1)
++	ldc1	$f14, 0xf0(a1)
++	ldc1	$f16, 0xf8(a1)
++	sdc1	$f26, 0xe0(a0)
++	ldc1	$f26, 0x1e0(a1)
++	sdc1	$f12, 0xe8(a0)
++	sdc1	$f14, 0xf0(a0)
++	sdc1	$f16, 0xf8(a0)
++
++	pref	30, 0x160(a0)
++
++	add	a0, a0, 0x100
++	bne	a0, a3, L(fmCopyLoopBack)
++	add	a1, a1, 0x100
++
++	/* last 256 bytes */
++	ldc1	$f4,  0x0(a1)
++	ldc1	$f20, 0x80(a1)
++	ldc1	$f6,  0x20(a1)
++	ldc1	$f8,  0x40(a1)
++	ldc1	$f10, 0x60(a1)
++	ldc1	$f18, 0xa0(a1)
++	ldc1	$f24, 0xc0(a1)
++	ldc1	$f26, 0xe0(a1)
++
++	ldc1	$f12, 0x8(a1)
++	ldc1	$f14, 0x10(a1)
++	ldc1	$f16, 0x18(a1)
++	sdc1	$f4,  0x0(a0)
++	sdc1	$f12, 0x8(a0)
++	sdc1	$f14, 0x10(a0)
++	sdc1	$f16, 0x18(a0)
++
++	ldc1	$f12, 0x28(a1)
++
++	ldc1	$f14, 0x30(a1)
++	ldc1	$f16, 0x38(a1)
++	sdc1	$f6,  0x20(a0)
++	sdc1	$f12, 0x28(a0)
++	sdc1	$f14, 0x30(a0)
++	sdc1	$f16, 0x38(a0)
++
++	ldc1	$f12, 0x48(a1)
++	ldc1	$f14, 0x50(a1)
++	ldc1	$f16, 0x58(a1)
++	sdc1	$f8,  0x40(a0)
++	sdc1	$f12, 0x48(a0)
++	sdc1	$f14, 0x50(a0)
++	sdc1	$f16, 0x58(a0)
++
++	ldc1	$f12, 0x68(a1)
++	ldc1	$f14, 0x70(a1)
++	ldc1	$f16, 0x78(a1)
++	sdc1	$f10, 0x60(a0)
++	sdc1	$f12, 0x68(a0)
++	sdc1	$f14, 0x70(a0)
++	sdc1	$f16, 0x78(a0)
++
++	/* last 128 bytes */
++	ldc1	$f12, 0x88(a1)
++	ldc1	$f14, 0x90(a1)
++	ldc1	$f16, 0x98(a1)
++	sdc1	$f20, 0x80(a0)
++	sdc1	$f12, 0x88(a0)
++	sdc1	$f14, 0x90(a0)
++	sdc1	$f16, 0x98(a0)
++
++	ldc1	$f12, 0xa8(a1)
++	ldc1	$f14, 0xb0(a1)
++	ldc1	$f16, 0xb8(a1)
++	sdc1	$f18, 0xa0(a0)
++	sdc1	$f12, 0xa8(a0)
++	sdc1	$f14, 0xb0(a0)
++	sdc1	$f16, 0xb8(a0)
++
++	ldc1	$f12, 0xc8(a1)
++	ldc1	$f14, 0xd0(a1)
++	ldc1	$f16, 0xd8(a1)
++	sdc1	$f24, 0xc0(a0)
++	sdc1	$f12, 0xc8(a0)
++	sdc1	$f14, 0xd0(a0)
++	sdc1	$f16, 0xd8(a0)
++
++	ldc1	$f12, 0xe8(a1)
++	ldc1	$f14, 0xf0(a1)
++	ldc1	$f16, 0xf8(a1)
++	sdc1	$f26, 0xe0(a0)
++	sdc1	$f12, 0xe8(a0)
++	sdc1	$f14, 0xf0(a0)
++	sdc1	$f16, 0xf8(a0)
++
++	add	a1, a1, 0x100
++	add	a0, a0, 0x100
++
++	/* restore f12, f14, f20, f24, f26 */
++	ldc1	$f12, 0(sp)
++	ldc1	$f14, 8(sp)
++	ldc1	$f20, 16(sp)
++	ldc1	$f24, 24(sp)
++	ldc1	$f26, 32(sp)
++	addu	sp, sp, 40
++
++	#
++	# Check if we could use LW/SW to copy.
++	#
++L(check4w): andi	t0, a2, 0xf		# 16 or more bytes left?
++	beq	t0, a2, L(check1w)	#   NO, less than 16, proceed to check1w (4bytes loop)
++	subu	a3, a2, t0		#   Yes, handle them in 16 bytes loop.
++
++	addu	a3, a1			# a3 = end address.
++	move	a2, t0
++
++L(loop4w): lw	t0, 0(a1)		# loop for 16 bytes/4 words at a time.
++	lw	t1, 4(a1)
++	lw	t2, 8(a1)
++	lw	t3, 0xc(a1)
++	sw	t0, 0(a0)
++	sw	t1, 4(a0)
++	sw	t2, 8(a0)
++	addiu	a0, 16
++	addiu	a1, 16
++	bne	a1, a3, L(loop4w)
++	sw	t3, -4(a0)
++
++L(check1w): andi	t0, a2, 0x3		# 4 or more bytes left?
++	beq	t0, a2, L(last8ByteCopy)	#   NO, less than 4 bytes, proceed to process 3 bytes
++	subu	a3, a2, t0			#   Yes, handle them 1 word at a time
++	addu	a3, a1				# a3 = end address.
++	move	a2, t0
++
++L(loop1w): lw	t0, 0(a1)		# loop 4 bytes/1 word at a time.
++	addiu	a0, 4
++	addiu	a1, 4
++	bne	a1, a3, L(loop1w)
++	sw	t0, -4(a0)
++
++L(last8ByteCopy): blez	a2, L(last8BCExit)  # handle last 8 bytes, one byte at a time.
++	addu	a3, a2, a1
++
++L(last8BCLoopBack): lb	t0, 0(a1)	# last 8 bytes copy loop.
++	addiu	a0, 1
++	addiu	a1, 1
++	bne	a1, a3, L(last8BCLoopBack)
++	sb	t0, -1(a0)
++
++L(last8BCExit):
++	jr	$31			# return to caller.
++	nop
++
++
++	/*********************************************************************
++	 * SRC and DEST are Word-Aligned.
++	 *********************************************************************/
++L(wordAlign):
++	andi	t1, 0x3		# a0/a1 are aligned, but r we
++	beq	t1, zero, L(intCheck8w) #  starting in middle of a word?
++	subu	a2, t1
++
++	LWHI	t0, 0(a1)	# src is in the middle of a word...
++	addu	a1, t1
++	SWHI	t0, 0(a0)
++	addu	a0, t1
++
++L(intCheck8w): 			# SRC is at begin of word
++	andi	t0, a2, 0x1ff	# 512 or more bytes left ?
++	beq	t0, a2, L(check4w)	#   NO, less than 512, proceed to process 4w/16B
++	subu	a3, a2, t0	#   Yes, more than 512, maybe we can use FPU copy
++
++				# a3 = copy size
++	subu	a3, a3, 0x100
++	.align 4
++	move	a2, t0		# a2 = what will be left after loop
++
++	/*--------------------------------------------------------------------- *
++	 * Integer Copy								*
++	 * mcopy: D-Cache line size = 32, unroll 8 D-Cache line, 		*
++	 *	  prefetch 2 L2 line, using integer registers 			*
++	 * memory copy for 64B D-Cache line size				*
++	 *--------------------------------------------------------------------- */
++	add	v1, a0, a3	#start address B(a0), end address B(v1)
++
++	/* save stable registers */
++	subu	sp, sp, 28
++	sw	$16, 0(sp)
++	sw	$17, 4(sp)
++	sw	$18, 8(sp)
++	sw	$19, 12(sp)
++	sw	$20, 16(sp)
++	sw	$21, 20(sp)
++	sw	$22, 24(sp)
++
++	lw	$8,  0x0(a1)	# The first 2 to trigger h/w prefetch
++	lw	$9,  0x20(a1)
++	lw	$12, 0x80(a1)	# trigger double prefetch
++	lw	$10,  0x40(a1)
++	lw	$11, 0x60(a1)
++	lw	$13, 0xa0(a1)
++	lw	$14, 0xc0(a1)
++	lw	$15, 0xe0(a1)
++
++	pref	30, 0x20(a0)	# (prepare for store)
++	pref	30, 0x40(a0)
++	pref	30, 0x60(a0)
++
++L(intCopyLoopBack):
++	/* first L2 line */
++	lw	$16,  0x4(a1)
++	lw	$17,  0x8(a1)
++	lw	$18,  0xc(a1)
++	lw	$19,  0x10(a1)
++	lw	$20,  0x14(a1)
++	lw	$21,  0x18(a1)
++	lw	$22,  0x1c(a1)
++
++	sw	$8, 0x0(a0)
++	lw	$8, 0x100(a1)
++
++	sw	$16,  0x4(a0)
++	sw	$17,  0x8(a0)
++	sw	$18,  0xc(a0)
++	sw	$19,  0x10(a0)
++	sw	$20,  0x14(a0)
++	sw	$21,  0x18(a0)
++	sw	$22,  0x1c(a0)
++
++	pref	30, 0x80(a0)
++
++	lw	$16,  0x24(a1)
++	lw	$17,  0x28(a1)
++	lw	$18,  0x2c(a1)
++	lw	$19,  0x30(a1)
++	lw	$20,  0x34(a1)
++	lw	$21,  0x38(a1)
++	lw	$22,  0x3c(a1)
++
++	sw	$9, 0x20(a0)
++	lw	$9, 0x120(a1)
++
++	sw	$16,  0x24(a0)
++	sw	$17,  0x28(a0)
++	sw	$18,  0x2c(a0)
++	sw	$19,  0x30(a0)
++	sw	$20,  0x34(a0)
++	sw	$21,  0x38(a0)
++	sw	$22,  0x3c(a0)
++
++	pref	30, 0xa1(a0)
++
++	lw	$16,  0x44(a1)
++	lw	$17,  0x48(a1)
++	lw	$18,  0x4c(a1)
++	lw	$19,  0x50(a1)
++	lw	$20,  0x54(a1)
++	lw	$21,  0x58(a1)
++	lw	$22,  0x5c(a1)
++
++	sw	$10,  0x40(a0)
++	lw	$10,  0x140(a1)
++
++	sw	$16,  0x44(a0)
++	sw	$17,  0x48(a0)
++	sw	$18,  0x4c(a0)
++	sw	$19,  0x50(a0)
++	sw	$20,  0x54(a0)
++	sw	$21,  0x58(a0)
++	sw	$22,  0x5c(a0)
++
++	pref	30, 0xc0(a0)
++
++	lw	$16,  0x64(a1)
++	lw	$17,  0x68(a1)
++	lw	$18,  0x6c(a1)
++	lw	$19,  0x70(a1)
++	lw	$20,  0x74(a1)
++	lw	$21,  0x78(a1)
++	lw	$22,  0x7c(a1)
++
++	sw	$11,  0x60(a0)
++	lw	$11,  0x160(a1)
++
++	sw	$16,  0x64(a0)
++	sw	$17,  0x68(a0)
++	sw	$18,  0x6c(a0)
++	sw	$19,  0x70(a0)
++	sw	$20,  0x74(a0)
++	sw	$21,  0x78(a0)
++	sw	$22,  0x7c(a0)
++
++	pref	30, 0xe0(a0)
++
++	/* 2nd L2 line */
++	lw	$16,  0x84(a1)
++	lw	$17,  0x88(a1)
++	lw	$18,  0x8c(a1)
++	lw	$19,  0x90(a1)
++	lw	$20,  0x94(a1)
++	lw	$21,  0x98(a1)
++	lw	$22,  0x9c(a1)
++
++	sw	$12,  0x80(a0)
++	lw	$12,  0x180(a1)
++
++	sw	$16,  0x84(a0)
++	sw	$17,  0x88(a0)
++	sw	$18,  0x8c(a0)
++	sw	$19,  0x90(a0)
++	sw	$20,  0x94(a0)
++	sw	$21,  0x98(a0)
++	sw	$22,  0x9c(a0)
++
++	pref	30, 0x100(a0)
++
++	lw	$16,  0xa4(a1)
++	lw	$17,  0xa8(a1)
++	lw	$18,  0xac(a1)
++	lw	$19,  0xb0(a1)
++	lw	$20,  0xb4(a1)
++	lw	$21,  0xb8(a1)
++	lw	$22,  0xbc(a1)
++
++	sw	$13,  0xa0(a0)
++	lw	$13,  0x1a0(a1)
++
++	sw	$16,  0xa4(a0)
++	sw	$17,  0xa8(a0)
++	sw	$18,  0xac(a0)
++	sw	$19,  0xb0(a0)
++	sw	$20,  0xb4(a0)
++	sw	$21,  0xb8(a0)
++	sw	$22,  0xbc(a0)
++
++	pref	30, 0x120(a0)
++
++	lw	$16,  0xc4(a1)
++	lw	$17,  0xc8(a1)
++	lw	$18,  0xcc(a1)
++	lw	$19,  0xd0(a1)
++	lw	$20,  0xd4(a1)
++	lw	$21,  0xd8(a1)
++	lw	$22,  0xdc(a1)
++
++	sw	$14,  0xc0(a0)
++	lw	$14,  0x1c0(a1)
++
++	sw	$16,  0xc4(a0)
++	sw	$17,  0xc8(a0)
++	sw	$18,  0xcc(a0)
++	sw	$19,  0xd0(a0)
++	sw	$20,  0xd4(a0)
++	sw	$21,  0xd8(a0)
++	sw	$22,  0xdc(a0)
++
++	pref	30, 0x140(a0)
++
++	lw	$16,  0xe4(a1)
++	lw	$17,  0xe8(a1)
++	lw	$18,  0xec(a1)
++	lw	$19,  0xf0(a1)
++	lw	$20,  0xf4(a1)
++	lw	$21,  0xf8(a1)
++	lw	$22,  0xfc(a1)
++
++	sw	$15,  0xe0(a0)
++	lw	$15,  0x1e0(a1)
++
++	sw	$16,  0xe4(a0)
++	sw	$17,  0xe8(a0)
++	sw	$18,  0xec(a0)
++	sw	$19,  0xf0(a0)
++	sw	$20,  0xf4(a0)
++	sw	$21,  0xf8(a0)
++	sw	$22,  0xfc(a0)
++
++	pref	30, 0x160(a0)
++
++	add	a0, a0, 0x100
++	bne	a0, v1, L(intCopyLoopBack)		/* loop back. */
++	add	a1, a1, 0x100
++
++	/* last 256 bytes */
++	lw	$16,  0x4(a1)
++	lw	$17,  0x8(a1)
++	lw	$18,  0xc(a1)
++	lw	$19,  0x10(a1)
++	lw	$20,  0x14(a1)
++	lw	$21,  0x18(a1)
++	lw	$22,  0x1c(a1)
++
++	sw	$8, 0x00(a0)
++
++	sw	$16,  0x04(a0)
++	sw	$17,  0x08(a0)
++	sw	$18,  0x0c(a0)
++	sw	$19,  0x10(a0)
++	sw	$20,  0x14(a0)
++	sw	$21,  0x18(a0)
++	sw	$22,  0x1c(a0)
++
++	lw	$16,  0x24(a1)
++	lw	$17,  0x28(a1)
++	lw	$18,  0x2c(a1)
++	lw	$19,  0x30(a1)
++	lw	$20,  0x34(a1)
++	lw	$21,  0x38(a1)
++	lw	$22,  0x3c(a1)
++
++	sw	$9, 0x20(a0)
++
++	sw	$16,  0x24(a0)
++	sw	$17,  0x28(a0)
++	sw	$18,  0x2c(a0)
++	sw	$19,  0x30(a0)
++	sw	$20,  0x34(a0)
++	sw	$21,  0x38(a0)
++	sw	$22,  0x3c(a0)
++
++	lw	$16,  0x44(a1)
++	lw	$17,  0x48(a1)
++	lw	$18,  0x4c(a1)
++	lw	$19,  0x50(a1)
++	lw	$20,  0x54(a1)
++	lw	$21,  0x58(a1)
++	lw	$22,  0x5c(a1)
++
++	sw	$10,  0x40(a0)
++
++	sw	$16,  0x44(a0)
++	sw	$17,  0x48(a0)
++	sw	$18,  0x4c(a0)
++	sw	$19,  0x50(a0)
++	sw	$20,  0x54(a0)
++	sw	$21,  0x58(a0)
++	sw	$22,  0x5c(a0)
++
++	lw	$16,  0x64(a1)
++	lw	$17,  0x68(a1)
++	lw	$18,  0x6c(a1)
++	lw	$19,  0x70(a1)
++	lw	$20,  0x74(a1)
++	lw	$21,  0x78(a1)
++	lw	$22,  0x7c(a1)
++
++	sw	$11,  0x60(a0)
++
++	sw	$16,  0x64(a0)
++	sw	$17,  0x68(a0)
++	sw	$18,  0x6c(a0)
++	sw	$19,  0x70(a0)
++	sw	$20,  0x74(a0)
++	sw	$21,  0x78(a0)
++	sw	$22,  0x7c(a0)
++
++	/* last 128 bytes */
++	lw	$16,  0x84(a1)
++	lw	$17,  0x88(a1)
++	lw	$18,  0x8c(a1)
++	lw	$19,  0x90(a1)
++	lw	$20,  0x94(a1)
++	lw	$21,  0x98(a1)
++	lw	$22,  0x9c(a1)
++
++	sw	$12,  0x80(a0)
++
++	sw	$16,  0x84(a0)
++	sw	$17,  0x88(a0)
++	sw	$18,  0x8c(a0)
++	sw	$19,  0x90(a0)
++	sw	$20,  0x94(a0)
++	sw	$21,  0x98(a0)
++	sw	$22,  0x9c(a0)
++
++	lw	$16,  0xa4(a1)
++	lw	$17,  0xa8(a1)
++	lw	$18,  0xac(a1)
++	lw	$19,  0xb0(a1)
++	lw	$20,  0xb4(a1)
++	lw	$21,  0xb8(a1)
++	lw	$22,  0xbc(a1)
++
++	sw	$13,  0xa0(a0)
++
++	sw	$16,  0xa4(a0)
++	sw	$17,  0xa8(a0)
++	sw	$18,  0xac(a0)
++	sw	$19,  0xb0(a0)
++	sw	$20,  0xb4(a0)
++	sw	$21,  0xb8(a0)
++	sw	$22,  0xbc(a0)
++
++	lw	$16,  0xc4(a1)
++	lw	$17,  0xc8(a1)
++	lw	$18,  0xcc(a1)
++	lw	$19,  0xd0(a1)
++	lw	$20,  0xd4(a1)
++	lw	$21,  0xd8(a1)
++	lw	$22,  0xdc(a1)
++
++	sw	$14,  0xc0(a0)
++
++	sw	$16,  0xc4(a0)
++	sw	$17,  0xc8(a0)
++	sw	$18,  0xcc(a0)
++	sw	$19,  0xd0(a0)
++	sw	$20,  0xd4(a0)
++	sw	$21,  0xd8(a0)
++	sw	$22,  0xdc(a0)
++
++	lw	$16,  0xe4(a1)
++	lw	$17,  0xe8(a1)
++	lw	$18,  0xec(a1)
++	lw	$19,  0xf0(a1)
++	lw	$20,  0xf4(a1)
++	lw	$21,  0xf8(a1)
++	lw	$22,  0xfc(a1)
++
++	sw	$15,  0xe0(a0)
++
++	sw	$16,  0xe4(a0)
++	sw	$17,  0xe8(a0)
++	sw	$18,  0xec(a0)
++	sw	$19,  0xf0(a0)
++	sw	$20,  0xf4(a0)
++	sw	$21,  0xf8(a0)
++	sw	$22,  0xfc(a0)
++
++	add	a0, a0, 0x100
++	add	a1, a1, 0x100
++
++	/* restore stable registers */
++	lw	$16, 0(sp)
++	lw	$17, 4(sp)
++	lw	$18, 8(sp)
++	lw	$19, 12(sp)
++	lw	$20, 16(sp)
++	lw	$21, 20(sp)
++	lw	$22, 24(sp)
++	addu	sp, sp, 28
++
++	b	L(check4w)
++	nop
++
++	/*--------------------------------------------------------------------
++	 * END Integer Copy Loop
++	 *--------------------------------------------------------------------*/
++
++	/*********************************************************************
++	 * SRC and DEST are NOT Aligned.
++	 *********************************************************************/
++L(unAlignSrcDest):			# SRC and DEST are NOT aligned.
++	andi	a3, 0x3			# Is DEST word aligned?
++	beq	a3, zero, L(uaCheck512)	#   YES, DEST is word-aligned, SW may be used.
++					#   NO, DEST is NOT word-aligned, has to adjust.
++
++	subu	a2, a3			# a2 = number of bytes left
++
++	LWHI	t0, 0(a1)		# DEST is NOT word aligned...
++	LWLO	t0, 3(a1)		#   adjust so DEST will be aligned.
++	addu	a1, a3
++	SWHI	t0, 0(a0)
++	addu	a0, a3
++L(uaCheck512):				# DEST is word-aligned.
++	andi	t0, a2, 0x1ff		# 512 or more bytes left ?
++	beq	t0, a2, L(uaCheck4w)	#   No, less than 512, cannot execute "pref"
++	subu	a3, a2, t0		#   Yes, more than 512, loop & "pref"
++
++	addu	a3, a0			# a3 = end address of loop
++	subu	a3, a3, 0x100
++	.align 4
++	move	a2, t0			# a2 = what will be left after loop
++	LWHI	t6,  0(a1)		# Loop taking 32 words at a time
++
++	/*--------------------------------------------------------------------
++	 * SRC and DEST are NOT Aligned, >512B, copy using LW/SW WITH pref
++	 *--------------------------------------------------------------------*/
++	add	t7, a0, 0x300		# prefetch dest 2 line size ahead.
++L(uaLoopBack):
++	pref	30,  0x40(a0)
++	LWHI	t5,  0x40(a1)
++
++	LWHI	t2,  0x4(a1)
++	LWHI	t3,  0x8(a1)
++	LWHI	t4,  0xc(a1)
++
++	LWLO	t6,  3(a1)
++	LWLO	t2,  0x7(a1)
++	LWLO	t3,  0xb(a1)
++	LWLO	t4,  0xf(a1)
++
++	sw	t6,  0x0(a0)
++	sw	t2,  0x4(a0)
++	sw	t3,  0x8(a0)
++	sw	t4,  0xc(a0)
++
++	# preload source
++	bge	t7, a3, L(uaSkip)
++	add	t7, t7, 0x100
++	lb	zero, 0x300(a1)
++L(uaSkip):
++	LWHI	t1,  0x10(a1)
++	LWHI	t2,  0x14(a1)
++	LWHI	t3,  0x18(a1)
++	LWHI	t4,  0x1c(a1)
++	LWLO	t1,  0x13(a1)
++	LWLO	t2,  0x17(a1)
++	LWLO	t3,  0x1b(a1)
++	LWLO	t4,  0x1f(a1)
++
++	sw	t1,  0x10(a0)
++	sw	t2,  0x14(a0)
++	sw	t3,  0x18(a0)
++	sw	t4,  0x1c(a0)
++
++	LWHI	t1,  0x20(a1)
++	LWHI	t2,  0x24(a1)
++	LWHI	t3,  0x28(a1)
++	LWHI	t4,  0x2c(a1)
++	LWLO	t1,  0x23(a1)
++	LWLO	t2,  0x27(a1)
++	LWLO	t3,  0x2b(a1)
++	LWLO	t4,  0x2f(a1)
++
++	sw	t1,  0x20(a0)
++	sw	t2,  0x24(a0)
++	sw	t3,  0x28(a0)
++	sw	t4,  0x2c(a0)
++
++	LWHI	t1,  0x30(a1)
++	LWHI	t2,  0x34(a1)
++	LWHI	t3,  0x38(a1)
++	LWHI	t4,  0x3c(a1)
++	LWLO	t1,  0x33(a1)
++	LWLO	t2,  0x37(a1)
++	LWLO	t3,  0x3b(a1)
++	LWLO	t4,  0x3f(a1)
++
++	sw	t1,  0x30(a0)
++	sw	t2,  0x34(a0)
++	sw	t3,  0x38(a0)
++	sw	t4,  0x3c(a0)
++
++	pref	30,  0x80(a0)
++	LWHI	t6,  0x80(a1)
++
++	LWHI	t2,  0x44(a1)
++	LWHI	t3,  0x48(a1)
++	LWHI	t4,  0x4c(a1)
++	LWLO	t5,  0x43(a1)
++	LWLO	t2,  0x47(a1)
++	LWLO	t3,  0x4b(a1)
++	LWLO	t4,  0x4f(a1)
++
++	sw	t5,  0x40(a0)
++	sw	t2,  0x44(a0)
++	sw	t3,  0x48(a0)
++	sw	t4,  0x4c(a0)
++
++	LWHI	t1,  0x50(a1)
++	LWHI	t2,  0x54(a1)
++	LWHI	t3,  0x58(a1)
++	LWHI	t4,  0x5c(a1)
++	LWLO	t1,  0x53(a1)
++	LWLO	t2,  0x57(a1)
++	LWLO	t3,  0x5b(a1)
++	LWLO	t4,  0x5f(a1)
++
++	sw	t1,  0x50(a0)
++	sw	t2,  0x54(a0)
++	sw	t3,  0x58(a0)
++	sw	t4,  0x5c(a0)
++
++	LWHI	t1,  0x60(a1)
++	LWHI	t2,  0x64(a1)
++	LWHI	t3,  0x68(a1)
++	LWHI	t4,  0x6c(a1)
++	LWLO	t1,  0x63(a1)
++	LWLO	t2,  0x67(a1)
++	LWLO	t3,  0x6b(a1)
++	LWLO	t4,  0x6f(a1)
++
++	sw	t1,  0x60(a0)
++	sw	t2,  0x64(a0)
++	sw	t3,  0x68(a0)
++	sw	t4,  0x6c(a0)
++
++	LWHI	t1,  0x70(a1)
++	LWHI	t2,  0x74(a1)
++	LWHI	t3,  0x78(a1)
++	LWHI	t4,  0x7c(a1)
++	LWLO	t1,  0x73(a1)
++	LWLO	t2,  0x77(a1)
++	LWLO	t3,  0x7b(a1)
++	LWLO	t4,  0x7f(a1)
++
++	sw	t1,  0x70(a0)
++	sw	t2,  0x74(a0)
++	sw	t3,  0x78(a0)
++	sw	t4,  0x7c(a0)
++
++	pref	30,  0xc0(a0)
++	LWHI	t5,  0xc0(a1)
++
++	LWHI	t2,  0x84(a1)
++	LWHI	t3,  0x88(a1)
++	LWHI	t4,  0x8c(a1)
++	LWLO	t6,  0x83(a1)
++	LWLO	t2,  0x87(a1)
++	LWLO	t3,  0x8b(a1)
++	LWLO	t4,  0x8f(a1)
++
++	sw	t6,  0x80(a0)
++	sw	t2,  0x84(a0)
++	sw	t3,  0x88(a0)
++	sw	t4,  0x8c(a0)
++
++	LWHI	t1,  0x90(a1)
++	LWHI	t2,  0x94(a1)
++	LWHI	t3,  0x98(a1)
++	LWHI	t4,  0x9c(a1)
++	LWLO	t1,  0x93(a1)
++	LWLO	t2,  0x97(a1)
++	LWLO	t3,  0x9b(a1)
++	LWLO	t4,  0x9f(a1)
++
++	sw	t1,  0x90(a0)
++	sw	t2,  0x94(a0)
++	sw	t3,  0x98(a0)
++	sw	t4,  0x9c(a0)
++
++	LWHI	t1,  0xa0(a1)
++	LWHI	t2,  0xa4(a1)
++	LWHI	t3,  0xa8(a1)
++	LWHI	t4,  0xac(a1)
++	LWLO	t1,  0xa3(a1)
++	LWLO	t2,  0xa7(a1)
++	LWLO	t3,  0xab(a1)
++	LWLO	t4,  0xaf(a1)
++
++	sw	t1,  0xa0(a0)
++	sw	t2,  0xa4(a0)
++	sw	t3,  0xa8(a0)
++	sw	t4,  0xac(a0)
++
++	LWHI	t1,  0xb0(a1)
++	LWHI	t2,  0xb4(a1)
++	LWHI	t3,  0xb8(a1)
++	LWHI	t4,  0xbc(a1)
++	LWLO	t1,  0xb3(a1)
++	LWLO	t2,  0xb7(a1)
++	LWLO	t3,  0xbb(a1)
++	LWLO	t4,  0xbf(a1)
++
++	sw	t1,  0xb0(a0)
++	sw	t2,  0xb4(a0)
++	sw	t3,  0xb8(a0)
++	sw	t4,  0xbc(a0)
++
++	pref	30,  0x100(a0)
++	LWHI	t6,  0x100(a1)
++
++	LWHI	t2,  0xc4(a1)
++	LWHI	t3,  0xc8(a1)
++	LWHI	t4,  0xcc(a1)
++	LWLO	t5,  0xc3(a1)
++	LWLO	t2,  0xc7(a1)
++	LWLO	t3,  0xcb(a1)
++	LWLO	t4,  0xcf(a1)
++
++	sw	t5,  0xc0(a0)
++	sw	t2,  0xc4(a0)
++	sw	t3,  0xc8(a0)
++	sw	t4,  0xcc(a0)
++
++	LWHI	t1,  0xd0(a1)
++	LWHI	t2,  0xd4(a1)
++	LWHI	t3,  0xd8(a1)
++	LWHI	t4,  0xdc(a1)
++	LWLO	t1,  0xd3(a1)
++	LWLO	t2,  0xd7(a1)
++	LWLO	t3,  0xdb(a1)
++	LWLO	t4,  0xdf(a1)
++
++	sw	t1,  0xd0(a0)
++	sw	t2,  0xd4(a0)
++	sw	t3,  0xd8(a0)
++	sw	t4,  0xdc(a0)
++
++	LWHI	t1,  0xe0(a1)
++	LWHI	t2,  0xe4(a1)
++	LWHI	t3,  0xe8(a1)
++	LWHI	t4,  0xec(a1)
++	LWLO	t1,  0xe3(a1)
++	LWLO	t2,  0xe7(a1)
++	LWLO	t3,  0xeb(a1)
++	LWLO	t4,  0xef(a1)
++
++	sw	t1,  0xe0(a0)
++	sw	t2,  0xe4(a0)
++	sw	t3,  0xe8(a0)
++	sw	t4,  0xec(a0)
++
++	LWHI	t1,  0xf0(a1)
++	LWHI	t2,  0xf4(a1)
++	LWHI	t3,  0xf8(a1)
++	LWHI	t4,  0xfc(a1)
++	LWLO	t1,  0xf3(a1)
++	LWLO	t2,  0xf7(a1)
++	LWLO	t3,  0xfb(a1)
++	LWLO	t4,  0xff(a1)
++
++	sw	t1,  0xf0(a0)
++	sw	t2,  0xf4(a0)
++	sw	t3,  0xf8(a0)
++	sw	t4,  0xfc(a0)
++
++	add	a0, a0, 0x100
++	bne		a0, a3, L(uaLoopBack)
++	add	a1, a1, 0x100
++
++	addu	a3, 0x100	# add 0x100 back
++
++	#
++	# copy loop 32 words at a time.
++	#
++L(uaRemain64LoopBack):
++	LWHI	t6,  0(a1)		# Loop taking 32 words at a time
++	LWHI	t2,  0x4(a1)
++	LWHI	t3,  0x8(a1)
++	LWHI	t4,  0xc(a1)
++	LWLO	t6,  3(a1)
++	LWLO	t2,  0x7(a1)
++	LWLO	t3,  0xb(a1)
++	LWLO	t4,  0xf(a1)
++
++	sw	t6,  0x0(a0)
++	sw	t2,  0x4(a0)
++	sw	t3,  0x8(a0)
++	sw	t4,  0xc(a0)
++
++	LWHI	t6,  0x10(a1)
++	LWHI	t2,  0x14(a1)
++	LWHI	t3,  0x18(a1)
++	LWHI	t4,  0x1c(a1)
++	LWLO	t6,  0x13(a1)
++	LWLO	t2,  0x17(a1)
++	LWLO	t3,  0x1b(a1)
++	LWLO	t4,  0x1f(a1)
++
++	sw	t6,  0x10(a0)
++	sw	t2,  0x14(a0)
++	sw	t3,  0x18(a0)
++	sw	t4,  0x1c(a0)
++
++	addiu	a0,  0x20
++	bne	a0,  a3, L(uaRemain64LoopBack)
++	addiu	a1,  0x20
++
++	addu	a3,  a2
++
++	/*--------------------------------------------------------------------
++	 * SRC and DEST are NOT Aligned, <512B, copy using LW/SW WITHOUT pref
++	 *--------------------------------------------------------------------*/
++L(uaCheck4w): andi	t0, a2, 0xf	# 16 or more bytes left?
++	beq	t0, a2, L(uaCheck1w)	#   NO, <16 bytes, proceed to process 1w
++	subu	a3, a2, t0		#   Yes, >16, copy 16 bytes at a time.
++
++	addu	a3, a1			# a3 = end address.
++	move	a2, t0
++
++L(ua4wLoopBack):			# loop 16 bytes/4 words at a time.
++	LWHI	t0, 0(a1)
++	LWHI	t1, 4(a1)
++	LWHI	t2, 8(a1)
++	LWHI	t3, 0xc(a1)
++	LWLO	t0, 3(a1)
++	LWLO	t1, 7(a1)
++	LWLO	t2, 0xb(a1)
++	LWLO	t3, 0xf(a1)
++	sw	t0, 0(a0)
++	sw	t1, 4(a0)
++	sw	t2, 8(a0)
++	addiu	a0, 16
++	addiu	a1, 16
++	bne	a1, a3, L(ua4wLoopBack)
++	sw	t3, -4(a0)
++
++L(uaCheck1w): andi	t0, a2, 0x3		# 4 or more bytes left?
++	beq	t0, a2, L(last8ByteCopy)	#   NO, <4 bytes, proceed to 8-bytes-copy
++	subu	a3, a2, t0
++
++	addu	a3, a0			#   YES, >4 bytes, can use LW/SW.
++
++L(uaRemain):
++	LWHI	t1, 0(a1)		# copy 1 word/4 bytes at a time.
++	LWLO	t1, 3(a1)
++	addiu	a0, 4
++	addiu	a1, 4
++	bne	a0, a3, L(uaRemain)
++	sw	t1, -4(a0)
++
++	b	L(last8ByteCopy)		# handle anything that may be left.
++	move	a2, t0
++
++detect_cpu:
++	lw	v0, __auxv_platform
++	la	t6, __uclibc_memcpy
++	beqz	v0, 6f			# just fall back to the normal uClibc
++	nop				# memcpy() if we are called before
++					# uClibc_main(), or missing auxv data
++
++	la	t5, __cpulist		# scan __cpulist for the right match
++1:
++	lw	t0, 0(t5)		# pointer to memcpy implementation
++	beqz	t0, 4f
++	lw	t2, 4(t5)		# pointer to ID string
++
++	move	t1, v0
++2:
++	lb	t3, 0(t1)		# simple string compare ($t1 vs $t2)
++	lb	t4, 0(t2)
++	bne	t3, t4, 3f
++	addiu	t1, 1
++	beqz	t3, 5f
++	addiu	t2, 1
++	bnez	t4, 2b
++	nop
++
++3:
++	b	1b			# no match on this string; loop
++	addiu	t5, 8
++
++4:
++	move	t0, t6			# no match on any string
++
++5:
++	la	t1, __memcpy_impl	# store the pointer to the right code
++	jr	t0
++	sw	t0, 0(t1)
++
++6:
++	jr	t6
++	nop
++
++	.set	reorder
++END (memcpy)
++
++libc_hidden_def (memcpy)
++
++#endif /* !defined(__mips64) */
+diff --git a/libc/string/mips/memcpy.S b/libc/string/mips/memcpy.S
+index 9b05ee6..8ee76fd 100644
+--- a/libc/string/mips/memcpy.S
++++ b/libc/string/mips/memcpy.S
+@@ -40,7 +40,7 @@
+ #  define SDLO	sdl		/* low part is left in little-endian	*/
+ #endif
+ 
+-ENTRY (memcpy)
++ENTRY (__uclibc_memcpy)
+ 	.set	noreorder
+ 
+ 	slti	t0, a2, 16		# Less than 16?
+@@ -137,7 +137,7 @@ L(shfth):
+ 	move	a2, t0
+ 
+ 	.set	reorder
+-END (memcpy)
++END (__uclibc_memcpy)
+ 
+ #else /* !__mips64 */
+ 
+@@ -153,7 +153,7 @@ END (memcpy)
+ #  define SWLO	swl		/* low part is left in little-endian	*/
+ #endif
+ 
+-ENTRY (memcpy)
++ENTRY (__uclibc_memcpy)
+ 	.set	noreorder
+ 
+ 	slti	t0, a2, 8		# Less than 8?
+@@ -250,8 +250,8 @@ L(shfth):
+ 	move	a2, t0
+ 
+ 	.set	reorder
+-END (memcpy)
++END (__uclibc_memcpy)
+ 
+ #endif /* !__mips64 */
+ 
+-libc_hidden_def(memcpy)
++libc_hidden_def(__uclibc_memcpy)
+diff --git a/extra/Configs/Config.mips b/extra/Configs/Config.mips
+index 063b07c..4482ea3 100644
+--- a/extra/Configs/Config.mips
++++ b/extra/Configs/Config.mips
+@@ -71,3 +71,7 @@ config CONFIG_MIPS_ISA_MIPS64
+ 	bool "MIPS64"
+ 
+ endchoice
++
++config ARCH_HAS_BWD_MEMCPY
++       bool
++       default y
-- 
2.1.0.rc2.206.gedb03e5