/*
 * Copyright (c) 2025, Miodrag Vallat.
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

/*
 * This tries to be as efficient as possible, by performing 32-bit loads and
 * stores, while keeping the logic deciding what to do as short as possible
 * to be as less hurtful as possible to small copies, and those which, due
 * to alignment constraints, have to be performed byte by byte anyway.
 *
 * The general logic is as follows:
 * - check the low two bits of the difference between src and dst. If bit 0 set,
 *   perform byte-by-byte copies; if bit 1 is set, perform halfword-by-halfword
 *   copies; otherwise, perform word-by-word copies.
 * - assume no overlap, copy forward.
 * - copy the necessary byte and/or halfword to reach copy unit alignment,
 *   do the bulk of the copy, and copy any possibly remaining byte and/or
 *   halfword to complete.
 */

#include "DEFS.h"

        ENTRY(memcpy)

#define SAVE_DST        %r2     /* never modified */
#define SRC             %r3
#define LEN             %r4
#define UNIT            %r5
#define TMP             %r6
#define DST             %r8

        bcnd.n  eq0, LEN, .L_done       /* nothing to do! */
         xor    TMP, SAVE_DST, SRC
        bcnd.n  eq0, TMP, .L_done       /* nothing to do! */
         or     DST, SAVE_DST, %r0

        bb1     0, TMP, .L_byte
        bb1     1, TMP, .L_half

        /* word copy */

        /* compute the number of words to copy */
        extu    UNIT, LEN, 0<2>
        bcnd    eq0, UNIT, .L_byte

        /* align to word boundary */
        bb0     0, SRC, .L_word_maybe_early_half
        ld.b    TMP, SRC, 0
        addu    SRC, SRC, 1
        st.b    TMP, DST, 0
        subu    LEN, LEN, 1
        addu    DST, DST, 1
.L_word_maybe_early_half:
        bb0     1, SRC, .L_word_copy
        ld.h    TMP, SRC, 0
        addu    SRC, SRC, 2
        st.h    TMP, DST, 0
        subu    LEN, LEN, 2
        addu    DST, DST, 2

.L_word_copy:
        /* worst case of 4 <= initial len < 7 and src and dst not aligned */
        /* in this case len may be < 4 at this point */
        extu    UNIT, LEN, 0<2>
        bcnd    eq0, UNIT, .L_byte

.L_word_loop:
        ld      TMP, SRC, 0
        subu    UNIT, UNIT, 1
        st      TMP, DST, 0
        addu    SRC, SRC, 4
        bcnd.n  ne0, UNIT, .L_word_loop
         addu   DST, DST, 4
.L_word_remainder:
        bb0     1, LEN, .L_word_maybe_byte
        ld.h    TMP, SRC, 0
        st.h    TMP, DST, 0
        addu    SRC, SRC, 2
        addu    DST, DST, 2
.L_word_maybe_byte:
        bb0     0, LEN, .L_done
        ld.b    TMP, SRC, 0
        jmp.n   %r1
         st.b   TMP, DST, 0
        
        /* halfword copy */

.L_half:
        /* compute the number of halfwords to copy */
        extu    UNIT, LEN, 0<1>
        bcnd    eq0, UNIT, .L_byte

        /* align to halfword boundary */
        bb0     0, SRC, .L_half_copy
        ld.b    TMP, SRC, 0
        addu    SRC, SRC, 1
        st.b    TMP, DST, 0
        subu    LEN, LEN, 1
        addu    DST, DST, 1

        /* worst case of initial len == 2 and src and dst not aligned */
        /* in this case len may be < 2 at this point */
        extu    UNIT, LEN, 0<1>
        bcnd    eq0, UNIT, .L_byte

.L_half_copy:
.L_half_loop:
        ld.h    TMP, SRC, 0
        subu    UNIT, UNIT, 1
        st.h    TMP, DST, 0
        addu    SRC, SRC, 2
        bcnd.n  ne0, UNIT, .L_half_loop
         addu   DST, DST, 2
.L_half_remainder:
        bb0     0, LEN, .L_done
        ld.b    TMP, SRC, 0
        jmp.n   %r1
         st.b   TMP, DST, 0

        /* byte copy */
#undef UNIT
.L_byte:
.L_byte_loop:
        ld.b    TMP, SRC, 0
        subu    LEN, LEN, 1
        st.b    TMP, DST, 0
        addu    SRC, SRC, 1
        bcnd.n  ne0, LEN, .L_byte_loop
         addu   DST, DST, 1
.L_done:
        jmp     %r1

        END_STRONG(memcpy)