Subversion Repositories or1k

!
! Fast SH memcpy
!
! by Toshiyasu Morita (tm@netcom.com)
! hacked by J"orn Rernnecke (amylaar@cygnus.co.uk) ("o for o-umlaut)
!
! Entry: r4: destination pointer
!        r5: source pointer
!        r6: byte count
!
! Exit:  r0: destination pointer
!        r1-r7: trashed
!
! Notes: Usually one wants to do small reads and write a longword, but
!        unfortunately it is difficult in some cases to concatanate bytes
!        into a longword on the SH, so this does a longword read and small
!        writes.
!
! This implementation makes two assumptions about how it is called:
!
! 1.: If the byte count is nonzero, the address of the last byte to be
!     copied is unsigned greater than the address of the first byte to
!     be copied.  This could be easily swapped for a signed comparison,
!     but the algorithm used needs some comparison.
!
! 2.: When there are two or three bytes in the last word of an 11-or-bore
!     bytes memory chunk to b copied, the rest of the word can be read
!     without size effects.
!     This could be easily changed by increasing the minumum size of
!     a fast memcpy and the amount subtracted from r7 before L_2l_loop be 2,
!     however, this would cost a few extra cyles on average.
!

#include "asm.h"

ENTRY(memcpy)
#ifdef __LITTLE_ENDIAN__
        ! Little endian version copies with increasing addresses.
        mov r4,r3       ! Save return value
        mov #11,r0      ! Check if small number of bytes
        cmp/hs r0,r6
                        ! r6 becomes src end address
        SL(bf, L_small, add r5,r6)
        mov #1,r1
        tst r1,r5       ! check if source even
        SL(bt, L_even, mov r6,r7)
        mov.b @r5+,r0   ! no, make it even.
        mov.b r0,@r4
        add #1,r4
L_even: tst r1,r4       ! check if destination is even
        add #-3,r7
        SL(bf, L_odddst, mov #2,r1)
        tst r1,r4       ! check if destination is 4-byte aligned
        mov r4,r0
        SL(bt, L_al4dst, sub r5,r0)
        mov.w @r5+,r2
        mov.w r2,@r4
        ! add #2,r4  r4 is dead here.
L_al4dst:
        tst r1,r5
        bt L_al4both
        mov.w @r5+,r1
        swap.w r1,r1
        add #-6,r0
        add #-6,r7      ! r7 := src end address minus 9.
        .align 2
L_2l_loop:
        mov.l @r5+,r2 ! Read & write two longwords per iteration
        xtrct r2,r1
        mov.l r1,@(r0,r5)
        cmp/hs r7,r5
        mov.l @r5+,r1
        xtrct r1,r2
        mov.l r2,@(r0,r5)
        bf L_2l_loop
        add #-2,r5
        bra  L_cleanup
        add #5,r0
L_al4both:
        add #-4,r0
        .align 2
L_al4both_loop:
        mov.l @r5+,r4   ! Read longword, write longword per iteration
        cmp/hs r7,r5
        SL(bf, L_al4both_loop, mov.l r4,@(r0,r5))

        bra L_cleanup
        add #3,r0

L_odddst:
        tst r1,r5
        SL(bt, L_al4src, add #-1,r4)
        mov.w @r5+,r0
        mov.b r0,@(1,r4)
        shlr8 r0
        mov.b r0,@(2,r4)
        add #2,r4
L_al4src:
        .align 2
L_odd_loop:
        mov.l @r5+,r0   ! Read longword, write byte, word, byte per iteration
        cmp/hs r7,r5
        mov.b r0,@(1,r4)
        shlr8 r0
        mov.w r0,@(2,r4)
        shlr16 r0
        mov.b r0,@(4,r4)
        SL(bf, L_odd_loop, add #4,r4)
        .align 2 ! avoid nop in more frequently executed code.
L_cleanup2:
        mov     r4,r0
        sub     r5,r0
L_cleanup:
        cmp/eq  r6,r5
        bt      L_ready
        .align 2
L_cleanup_loop:
        mov.b   @r5+,r1
        cmp/eq  r6,r5
        mov.b   r1,@(r0,r5)
        bf      L_cleanup_loop
L_ready:
        rts
        mov     r3,r0
L_small:
        bra L_cleanup2
        add #-1,r4
#else
        ! Big endian version copies with decreasing addresses.
        mov r4,r0
        add r6,r0
        sub r4,r5
        mov #11,r1
        cmp/hs r1,r6
        SL(bf, L_small, add #-1,r5)
        mov r5,r3
        add r0,r3
        shlr r3
        SL(bt, L_even,
        mov r4,r7)
        mov.b @(r0,r5),r2
        add #-1,r3
        mov.b r2,@-r0
L_even:
        tst #1,r0
        add #-1,r5
        SL(bf, L_odddst, add #8,r7)
        tst #2,r0
        bt L_al4dst
        add #-1,r3
        mov.w @(r0,r5),r1
        mov.w r1,@-r0
L_al4dst:
        shlr r3
        bt L_al4both
        mov.w @(r0,r5),r1
        swap.w r1,r1
        add #4,r7
        add #-4,r5
        .align 2
L_2l_loop:
        mov.l @(r0,r5),r2
        xtrct r2,r1
        mov.l r1,@-r0
        cmp/hs r7,r0
        mov.l @(r0,r5),r1
        xtrct r1,r2
        mov.l r2,@-r0
        bt L_2l_loop
        bra L_cleanup
        add #5,r5

        nop ! avoid nop in executed code.
L_al4both:
        add #-2,r5
        .align 2
L_al4both_loop:
        mov.l @(r0,r5),r1
        cmp/hs r7,r0
        SL(bt, L_al4both_loop,
        mov.l r1,@-r0)
        bra L_cleanup
        add #3,r5

        nop ! avoid nop in executed code.
L_odddst:
        shlr r3
        bt L_al4src
        mov.w @(r0,r5),r1
        mov.b r1,@-r0
        shlr8 r1
        mov.b r1,@-r0
L_al4src:
        add #-2,r5
        .align 2
L_odd_loop:
        mov.l @(r0,r5),r2
        cmp/hs r7,r0
        mov.b r2,@-r0
        shlr8 r2
        mov.w r2,@-r0
        shlr16 r2
        mov.b r2,@-r0
        bt L_odd_loop

        add #3,r5
L_cleanup:
L_small:
        cmp/eq r4,r0
        bt L_ready
        add #1,r4
        .align 2
L_cleanup_loop:
        mov.b @(r0,r5),r2
        cmp/eq r4,r0
        mov.b r2,@-r0
        bf L_cleanup_loop
L_ready:
        rts
        nop
#endif