Subversion Repositories openrisc_me

#include "setarch.h"

#include "defines.h"

#ifdef __H8300SX__

        .global _memcpy

_memcpy:

        stm.l   er4-er6,@-er7

        ; Set up source and destination pointers for movmd.

        mov.l   er0,er6

        mov.l   er1,er5

        ; See whether the copy is long enough to use the movmd.l code.

        ; Although the code can handle anything longer than 6 bytes,

        ; it can be more expensive than movmd.b for small moves.

        ; It's better to use a higher threshold to account for this.

        ;

        ; Note that the exact overhead of the movmd.l checks depends on

        ; the alignments of the length and pointers.  They are faster when

        ; er0 & 3 == er1 & 3 == er2 & 3, faster still when these values

        ; are 0.  This threshold is a compromise between the various cases.

        cmp     #16,LEN(r2)

        blo     simple

        ; movmd.l only works for even addresses.  If one of the addresses

        ; is odd and the other is not, fall back on a simple move.

        bld     #0,r5l

        bxor    #0,r6l

        bcs     simple

        ; Make the addresses even.

        bld     #0,r5l

        bcc     word_aligned

        mov.b   @er5+,@er6+

        sub     #1,LEN(r2)

word_aligned:

        ; See if copying one word would make the first operand longword

        ; aligned.  Although this is only really worthwhile if it aligns

        ; the second operand as well, it's no worse if doesn't, so it

        ; hardly seems worth the overhead of a "band" check.

        bld     #1,r6l

        bcc     fast_copy

        mov.w   @er5+,@er6+

        sub     #2,LEN(r2)

fast_copy:

        ; Set (e)r4 to the number of longwords to copy.

        mov     LEN(r2),LEN(r4)

        shlr    #2,LEN(r4)

#ifdef __NORMAL_MODE__

        ; 16-bit pointers and size_ts: one movmd.l is enough.  This code

        ; is never reached with r4 == 0.

        movmd.l

        and.w   #3,r2

simple:

        mov.w   r2,r4

        beq     quit

        movmd.b

quit:

        rts/l   er4-er6

#else

        ; Skip the first iteration if the number of longwords is divisible

        ; by 0x10000.

        mov.w   r4,r4

        beq     fast_loop_next

        ; This loop copies r4 (!= 0) longwords the first time round and 65536

        ; longwords on each iteration after that.

fast_loop:

        movmd.l

fast_loop_next:

        sub.w   #1,e4

        bhs     fast_loop

        ; Mop up any left-over bytes.  We could just fall through to the

        ; simple code after the "and" but the version below is quicker

        ; and only takes 10 more bytes.

        and.w   #3,r2

        beq     quit

        mov.w   r2,r4

        movmd.b

quit:

        rts/l   er4-er6

simple:

        ; Simple bytewise copy.  We need to handle all lengths, including zero.

        mov.w   r2,r4

        beq     simple_loop_next

simple_loop:

        movmd.b

simple_loop_next:

        sub.w   #1,e2

        bhs     simple_loop

        rts/l   er4-er6

#endif

#else

        .global _memcpy

_memcpy:

;       MOVP    @(2/4,r7),A0P   ; dst

;       MOVP    @(4/8,r7),A1P   ; src

;       MOVP    @(6/12,r7),A2P  ; len

        MOVP    A0P,A3P ; keep copy of final dst

        ADDP    A2P,A0P ; point to end of dst

        CMPP    A0P,A3P ; see if anything to do

        beq     quit

        ADDP    A2P,A1P ; point to end of src

        ; lets see if we can do this in words

        or      A0L,A2L ; or in the dst address

        or      A3L,A2L ; or the length

        or      A1L,A2L ; or the src address

        btst    #0,A2L  ; see if the lsb is zero

        bne     byteloop

wordloop:

#ifdef __NORMAL_MODE__

        sub     #2,A1P

#else

        subs    #2,A1P          ; point to word

#endif

        mov.w   @A1P,A2         ; get word

        mov.w   A2,@-A0P        ; save word

        CMPP    A0P,A3P         ; at the front again ?

        bne     wordloop

        rts

byteloop:

#ifdef __NORMAL_MODE__

        sub     #1,A1P

#else

        subs    #1,A1P          ; point to byte

#endif

        mov.b   @A1P,A2L        ; get byte

        mov.b   A2L,@-A0P       ; save byte

        CMPP    A0P,A3P         ; at the front again ?

        bne     byteloop

        ; return with A0 pointing to dst

quit:   rts

#endif