/*
 * 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.
 * - the overlap occurs only if src < dst < src + len, which, in unsigned
 *   arithmetic, is equivalent to (dst - src) < len.
 * - if no overlap, copy forward by jumping into memcpy; if overlap, copy
 *   backwards.
 * - 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(memmove)

#define SAVE_DST        %r2     /* never modified */
#define SRC             %r3
#define LEN             %r4
#define UNIT            %r5
#define TMP             %r6
#define TMP2            %r7
#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! */
         subu   TMP2, SAVE_DST, SRC
        cmp     UNIT, TMP2, LEN
        bb1.n   lo, UNIT, .L_overlap
         or     DST, SAVE_DST, %r0

        /* no overlap, delegate operation to memcpy() */
#ifdef __PIC__
        br      _HIDDEN(memcpy)#plt
#else
        br      _HIDDEN(memcpy)
#endif

.L_overlap:
         addu   SRC, SRC, LEN
        bb1.n   0, TMP, .L_byte
         addu   DST, DST, LEN
        bb1     1, TMP, .L_half

        /* word copy, backwards */

        /* 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_half
        subu    SRC, SRC, 1
        subu    DST, DST, 1
        subu    LEN, LEN, 1
        ld.b    TMP, SRC, 0
        st.b    TMP, DST, 0
.L_word_maybe_half:
        bb0     1, SRC, .L_word_copy
        subu    SRC, SRC, 2
        subu    DST, DST, 2
        subu    LEN, LEN, 2
        ld.h    TMP, SRC, 0
        st.h    TMP, DST, 0

.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:
        bcnd    eq0, UNIT, .L_word_done
        subu    SRC, SRC, 4
        subu    DST, DST, 4
        subu    UNIT, UNIT, 1
        ld      TMP, SRC, 0
        br.n    .L_word_loop
         st     TMP, DST, 0
.L_word_done:
        bb0     1, LEN, .L_word_maybe_final_byte
        subu    SRC, SRC, 2
        subu    DST, DST, 2
        ld.h    TMP, SRC, 0
        st.h    TMP, DST, 0
.L_word_maybe_final_byte:
        bb0     0, LEN, .L_done
        subu    SRC, SRC, 1
        subu    DST, DST, 1
        ld.b    TMP, SRC, 0
        jmp.n   %r1
         st.b   TMP, DST, 0
        
        /* halfword copy, backwards */

.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
        subu    SRC, SRC, 1
        subu    DST, DST, 1
        subu    LEN, LEN, 1
        ld.b    TMP, SRC, 0
        st.b    TMP, DST, 0

        /* 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:
        bcnd    eq0, UNIT, .L_half_done
        subu    SRC, SRC, 2
        subu    DST, DST, 2
        subu    UNIT, UNIT, 1
        ld.h    TMP, SRC, 0
        br.n    .L_half_loop
         st.h   TMP, DST, 0
.L_half_done:
        bb0     0, LEN, .L_done
        subu    SRC, SRC, 1
        subu    DST, DST, 1
        ld.b    TMP, SRC, 0
        jmp.n   %r1
         st.b   TMP, DST, 0

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

        END_STRONG(memmove)