| 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,2048 @@ |
| +/* 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 __cputype, @object |
| + .size __cputype, 4 |
| +__cputype: |
| + .word 0 |
| + |
| +__str_bmips4380: |
| + .string "bmips4380" |
| +__str_bmips5000: |
| + .string "bmips5000" |
| + |
| + |
| + .text |
| + |
| +ENTRY (memcpy) |
| + .set noreorder |
| +#ifdef __PIC__ |
| + .cpload t9 |
| +#endif |
| + |
| + lw t0, __cputype |
| + beqz t0, detect_cpu # based on cpu type |
| + nop |
| + |
| +detect_done: |
| + li t1, 4380 |
| + beq t0, t1, _4380_memcpy |
| + nop |
| + |
| + li t1, 5000 |
| + beq t0, t1, _5000_memcpy |
| + nop |
| + |
| + /* default case: BMIPS3300 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 31, 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: |
| + li t0, 3300 # 3300 = default setting |
| + lw v0, __auxv_platform |
| + beqz v0, detect_done # don't store the result, because |
| + nop # memcpy() can be called before |
| + # uClibc_main() |
| + |
| + li t0, 4380 |
| + move t1, v0 |
| + la t2, __str_bmips4380 |
| + |
| +1: |
| + lb t3, 0(t1) # simple string compare |
| + lb t4, 0(t2) |
| + bne t3, t4, 2f |
| + addiu t1, 1 |
| + beqz t3, 3f |
| + addiu t2, 1 |
| + bnez t4, 1b |
| + nop |
| + |
| +2: |
| + li t0, 5000 |
| + move t1, v0 |
| + la t2, __str_bmips5000 |
| + |
| +1: |
| + lb t3, 0(t1) |
| + lb t4, 0(t2) |
| + bne t3, t4, 2f |
| + addiu t1, 1 |
| + beqz t3, 3f |
| + addiu t2, 1 |
| + bnez t4, 1b |
| + nop |
| + |
| +2: |
| + li t0, 3300 |
| +3: |
| + sw t0, __cputype |
| + b detect_done |
| + 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) |
