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