| /*#************************************************************************#*/ |
| /*#-------------------------------------------------------------------------*/ |
| /*# */ |
| /*# FUNCTION NAME: memcpy() */ |
| /*# */ |
| /*# PARAMETERS: void* dst; Destination address. */ |
| /*# void* src; Source address. */ |
| /*# int len; Number of bytes to copy. */ |
| /*# */ |
| /*# RETURNS: dst. */ |
| /*# */ |
| /*# DESCRIPTION: Copies len bytes of memory from src to dst. No guarantees */ |
| /*# about copying of overlapping memory areas. This routine is */ |
| /*# very sensitive to compiler changes in register allocation. */ |
| /*# Should really be rewritten to avoid this problem. */ |
| /*# */ |
| /*#-------------------------------------------------------------------------*/ |
| /*# */ |
| /*# HISTORY */ |
| /*# */ |
| /*# DATE NAME CHANGES */ |
| /*# ---- ---- ------- */ |
| /*# 941007 Kenny R Creation */ |
| /*# 941011 Kenny R Lots of optimizations and inlining. */ |
| /*# 941129 Ulf A Adapted for use in libc. */ |
| /*# 950216 HP N==0 forgotten if non-aligned src/dst. */ |
| /*# Added some optimizations. */ |
| /*# 001025 HP Make src and dst char *. Align dst to */ |
| /*# dword, not just word-if-both-src-and-dst- */ |
| /*# are-misaligned. */ |
| /*# */ |
| /*#-------------------------------------------------------------------------*/ |
| |
| #include <linux/types.h> |
| |
| void *memcpy(void *pdst, |
| const void *psrc, |
| size_t pn) |
| { |
| /* Ok. Now we want the parameters put in special registers. |
| Make sure the compiler is able to make something useful of this. |
| As it is now: r10 -> r13; r11 -> r11 (nop); r12 -> r12 (nop). |
| |
| If gcc was alright, it really would need no temporaries, and no |
| stack space to save stuff on. */ |
| |
| register void *return_dst __asm__ ("r10") = pdst; |
| register char *dst __asm__ ("r13") = pdst; |
| register const char *src __asm__ ("r11") = psrc; |
| register int n __asm__ ("r12") = pn; |
| |
| |
| /* When src is aligned but not dst, this makes a few extra needless |
| cycles. I believe it would take as many to check that the |
| re-alignment was unnecessary. */ |
| if (((unsigned long) dst & 3) != 0 |
| /* Don't align if we wouldn't copy more than a few bytes; so we |
| don't have to check further for overflows. */ |
| && n >= 3) |
| { |
| if ((unsigned long) dst & 1) |
| { |
| n--; |
| *(char*)dst = *(char*)src; |
| src++; |
| dst++; |
| } |
| |
| if ((unsigned long) dst & 2) |
| { |
| n -= 2; |
| *(short*)dst = *(short*)src; |
| src += 2; |
| dst += 2; |
| } |
| } |
| |
| /* Decide which copying method to use. Movem is dirt cheap, so the |
| overheap is low enough to always use the minimum block size as the |
| threshold. */ |
| if (n >= 44) |
| { |
| /* For large copies we use 'movem' */ |
| |
| /* It is not optimal to tell the compiler about clobbering any |
| registers; that will move the saving/restoring of those registers |
| to the function prologue/epilogue, and make non-movem sizes |
| suboptimal. */ |
| __asm__ volatile (" \n\ |
| ;; Check that the register asm declaration got right. \n\ |
| ;; The GCC manual explicitly says TRT will happen. \n\ |
| .ifnc %0-%1-%2,$r13-$r11-$r12 \n\ |
| .err \n\ |
| .endif \n\ |
| \n\ |
| ;; Save the registers we'll use in the movem process \n\ |
| \n\ |
| ;; on the stack. \n\ |
| subq 11*4,$sp \n\ |
| movem $r10,[$sp] \n\ |
| \n\ |
| ;; Now we've got this: \n\ |
| ;; r11 - src \n\ |
| ;; r13 - dst \n\ |
| ;; r12 - n \n\ |
| \n\ |
| ;; Update n for the first loop \n\ |
| subq 44,$r12 \n\ |
| 0: \n\ |
| movem [$r11+],$r10 \n\ |
| subq 44,$r12 \n\ |
| bge 0b \n\ |
| movem $r10,[$r13+] \n\ |
| \n\ |
| addq 44,$r12 ;; compensate for last loop underflowing n \n\ |
| \n\ |
| ;; Restore registers from stack \n\ |
| movem [$sp+],$r10" |
| |
| /* Outputs */ : "=r" (dst), "=r" (src), "=r" (n) |
| /* Inputs */ : "0" (dst), "1" (src), "2" (n)); |
| |
| } |
| |
| /* Either we directly starts copying, using dword copying |
| in a loop, or we copy as much as possible with 'movem' |
| and then the last block (<44 bytes) is copied here. |
| This will work since 'movem' will have updated src,dst,n. */ |
| |
| while ( n >= 16 ) |
| { |
| *((long*)dst)++ = *((long*)src)++; |
| *((long*)dst)++ = *((long*)src)++; |
| *((long*)dst)++ = *((long*)src)++; |
| *((long*)dst)++ = *((long*)src)++; |
| n -= 16; |
| } |
| |
| /* A switch() is definitely the fastest although it takes a LOT of code. |
| * Particularly if you inline code this. |
| */ |
| switch (n) |
| { |
| case 0: |
| break; |
| case 1: |
| *(char*)dst = *(char*)src; |
| break; |
| case 2: |
| *(short*)dst = *(short*)src; |
| break; |
| case 3: |
| *((short*)dst)++ = *((short*)src)++; |
| *(char*)dst = *(char*)src; |
| break; |
| case 4: |
| *((long*)dst)++ = *((long*)src)++; |
| break; |
| case 5: |
| *((long*)dst)++ = *((long*)src)++; |
| *(char*)dst = *(char*)src; |
| break; |
| case 6: |
| *((long*)dst)++ = *((long*)src)++; |
| *(short*)dst = *(short*)src; |
| break; |
| case 7: |
| *((long*)dst)++ = *((long*)src)++; |
| *((short*)dst)++ = *((short*)src)++; |
| *(char*)dst = *(char*)src; |
| break; |
| case 8: |
| *((long*)dst)++ = *((long*)src)++; |
| *((long*)dst)++ = *((long*)src)++; |
| break; |
| case 9: |
| *((long*)dst)++ = *((long*)src)++; |
| *((long*)dst)++ = *((long*)src)++; |
| *(char*)dst = *(char*)src; |
| break; |
| case 10: |
| *((long*)dst)++ = *((long*)src)++; |
| *((long*)dst)++ = *((long*)src)++; |
| *(short*)dst = *(short*)src; |
| break; |
| case 11: |
| *((long*)dst)++ = *((long*)src)++; |
| *((long*)dst)++ = *((long*)src)++; |
| *((short*)dst)++ = *((short*)src)++; |
| *(char*)dst = *(char*)src; |
| break; |
| case 12: |
| *((long*)dst)++ = *((long*)src)++; |
| *((long*)dst)++ = *((long*)src)++; |
| *((long*)dst)++ = *((long*)src)++; |
| break; |
| case 13: |
| *((long*)dst)++ = *((long*)src)++; |
| *((long*)dst)++ = *((long*)src)++; |
| *((long*)dst)++ = *((long*)src)++; |
| *(char*)dst = *(char*)src; |
| break; |
| case 14: |
| *((long*)dst)++ = *((long*)src)++; |
| *((long*)dst)++ = *((long*)src)++; |
| *((long*)dst)++ = *((long*)src)++; |
| *(short*)dst = *(short*)src; |
| break; |
| case 15: |
| *((long*)dst)++ = *((long*)src)++; |
| *((long*)dst)++ = *((long*)src)++; |
| *((long*)dst)++ = *((long*)src)++; |
| *((short*)dst)++ = *((short*)src)++; |
| *(char*)dst = *(char*)src; |
| break; |
| } |
| |
| return return_dst; /* destination pointer. */ |
| } /* memcpy() */ |