Subversion Repositories openrisc_me

/* a-memcpy.s -- memcpy, optimised for m68k asm

 *

 * Copyright (c) 2007 mocom software GmbH & Co KG)

 *

 * The authors hereby grant permission to use, copy, modify, distribute,

 * and license this software and its documentation for any purpose, provided

 * that existing copyright notices are retained in all copies and that this

 * notice is included verbatim in any distributions. No written agreement,

 * license, or royalty fee is required for any of the authorized uses.

 * Modifications to this software may be copyrighted by their authors

 * and need not follow the licensing terms described here, provided that

 * the new terms are clearly indicated on the first page of each file where

 * they apply.

 */

#include "m68kasm.h"

#if defined (__mcoldfire__) || defined (__mcpu32__) || defined (__mc68010__) || defined (__mc68020__) || defined (__mc68030__) || defined (__mc68040__) || defined (__mc68060__)

# define MISALIGNED_OK 1

#else

# define MISALIGNED_OK 0

#endif

        .text

        .align  4

        .globl  SYM(memcpy)

        .type   SYM(memcpy), @function

/*   memcpy, optimised

 *

 *   strategy:

 *       - no argument testing (the original memcpy from the GNU lib does

 *         no checking either)

 *       - make sure the destination pointer (the write pointer) is long word

 *         aligned. This is the best you can do, because writing to unaligned

 *         addresses can be the most costfull thing you could do.

 *       - Once you have figured that out, we do a little loop unrolling

 *         to further improve speed.

 */

SYM(memcpy):

        move.l  4(sp),a0        | dest ptr

        move.l  8(sp),a1        | src ptr

        move.l  12(sp),d1       | len

        cmp.l   #8,d1           | if fewer than 8 bytes to transfer,

        blo     .Lresidue       | do not optimise

#if !MISALIGNED_OK

        /* Goto .Lresidue if either dest or src is not 4-byte aligned */

        move.l  a0,d0

        and.l   #3,d0

        bne     .Lresidue

        move.l  a1,d0

        and.l   #3,d0

        bne     .Lresidue

#else /* MISALIGNED_OK */

        /* align dest */

        move.l  a0,d0           | copy of dest

        neg.l   d0

        and.l   #3,d0           | look for the lower two only

        beq     2f              | is aligned?

        sub.l   d0,d1

        lsr.l   #1,d0           | word align needed?

        bcc     1f

        move.b  (a1)+,(a0)+

1:

        lsr.l   #1,d0           | long align needed?

        bcc     2f

        move.w  (a1)+,(a0)+

2:

#endif /* !MISALIGNED_OK */

        /* long word transfers */

        move.l  d1,d0

        and.l   #3,d1           | byte residue

        lsr.l   #3,d0

        bcc     1f              | carry set for 4-byte residue

        move.l  (a1)+,(a0)+

1:

        lsr.l   #1,d0           | number of 16-byte transfers

        bcc     .Lcopy          | carry set for 8-byte residue

        bra     .Lcopy8

1:

        move.l  (a1)+,(a0)+

        move.l  (a1)+,(a0)+

.Lcopy8:

        move.l  (a1)+,(a0)+

        move.l  (a1)+,(a0)+

.Lcopy:

#if !defined (__mcoldfire__)

        dbra    d0,1b

        sub.l   #0x10000,d0

#else

        subq.l  #1,d0

#endif

        bpl     1b

        bra     .Lresidue

1:

        move.b  (a1)+,(a0)+     | move residue bytes

.Lresidue:

#if !defined (__mcoldfire__)

        dbra    d1,1b           | loop until done

#else

        subq.l  #1,d1

        bpl     1b

#endif

        move.l  4(sp),d0        | return value

        rts