Subversion Repositories openrisc_me

/*
 *  (c) Copyright 1986 HEWLETT-PACKARD COMPANY
 *
 *  To anyone who acknowledges that this file is provided "AS IS"
 *  without any express or implied warranty:
 *      permission to use, copy, modify, and distribute this file
 *  for any purpose is hereby granted without fee, provided that
 *  the above copyright notice and this notice appears in all
 *  copies, and that the name of Hewlett-Packard Company not be
 *  used in advertising or publicity pertaining to distribution
 *  of the software without specific, written prior permission.
 *  Hewlett-Packard Company makes no representations about the
 *  suitability of this software for any purpose.
 */

/* HPUX_ID:     @(#) $Revision: 1.1 $   */
/*
 * memcpy(s1, s2, n)
 *
 * Copy n characters from s2 to s1; returns s1.
 */

#define d_addr  arg0
#define s_addr  arg1
#define count   arg2
#define tmp5    arg3
#define tmp1    r19
#define tmp2    r20
#define tmp3    r21
#define tmp4    r22
#define tmp6    r31

#include "DEFS.h"

ENTRY(memcpy)
        comib,>=  5,count,byteloop     /* If count is <= 6 don't get fancy.*/ 
        movb,=,n      d_addr,ret0,done    /* The return value is defined to be the value of d_addr. DELAY SLOT */
                                        /* if d_addr is null then exit */
        extru       s_addr,31,2,tmp1   /* Extract the low two bits of the source address. */
        extru       d_addr,31,2,tmp2   /* Extract the low two bits of the destination address. */
        add         count,tmp2,count   /* pre increment the count to adjust for alignment of s1 */
        comb,<>       tmp2,tmp1,not_aligned /* see if s1 is aligned w.r.t. s2. */
        dep         0,31,2,s_addr      /* Compute the word address of the source.  DELAY SLOT. */

/* aligned */

/* We will now begin the 16 byte at a time word move if count >= 16 ! */
/* Else we will branch to the  4 byte-at-a time word move ! */

        addibt,<,n -16,count,chekchunk  /* If count < 16 then we can't move 16 byte chunks ! */
                                        /*   actually we can legally move 13 or more bytes on the first loop.  */
        /* These loads and stores are done so as to prevent processor interlock. */
chunks:
        ldwm        16(0,s_addr),tmp1   /* tmp1 = *s_addr   s_addr += 16 */
        ldw         -12(0,s_addr),tmp2  /* tmp2 = 2nd word */
        ldw         -8(0,s_addr),tmp3   /* tmp3 = 3rd word */
        ldw         -4(0,s_addr),tmp4   /* tmp4 = 4th word */
        /* Now store the results !  */
        stbys,b,m   tmp1,4(0,d_addr)   /* tmp1 = 1st word stored d_addr += 16 also take care of front porch. */
        stwm        tmp2,4(0,d_addr)    /* tmp2 = 2nd word stored. */
        stwm        tmp3,4(0,d_addr)   /* tmp3 = 3rd word stored. */
        addibf,<    -16,count,chunks    /* If count is still >= 16 do another loop. */
        stwm        tmp4,4(0,d_addr)   /* tmp4 = 4th word stored. DELAY SLOT */

chekchunk:
        addibt,<,n  12,count,back_porch /* since the count is already decremented by -16 we're testing */
                                        /*   to see if there are at least 4 bytes left ? */
subchunk:
        ldws,ma      4(s_addr),tmp1     /* tmp1 = *s_addr++ */
        addibf,<     -4,count,subchunk  /* count -= 4 */
        stbys,b,m    tmp1,4(d_addr)     /* *d_addr++ = tmp1 */


back_porch:
         addibt,=,n  4,count,done       /* if count = 0 we're, of course, done ! */
         ldws        0(s_addr),tmp1     /* load up the back_porch */
         add         d_addr,count,d_addr/* final store address  is +1 too high ! */
         bv             0(r2)           /* return--were done. */
         stbys,e     tmp1,0(d_addr)    /* kerplunk! whew !  */

/* Begin non_aligned code. (no refrence to politics) */
not_aligned:
        sub,>=       tmp2,tmp1,tmp3     /* compute the shift quantity again and skip the load if tmp2 > tmp1. */
        ldwm         4(0,s_addr),tmp1   /* load up the first word from the source. tmp1 = *s_addr++ */
        zdep         tmp3,28,29,tmp4    /* compute the number of bits to shift based on the number of bytes above. */
        mtctl        tmp4,11            /* load the shift count into cr11 = shift count register. */

        addibt,<,n   -16,count,chkchnk2 /* first step in pre adjustment of count for looping. */

chunk2:   
        ldwm            16(0,s_addr),tmp2    /* get either first or second word . tmp2 = *s_addr++ */
        ldw             -12(s_addr),tmp3
        ldw             -8(s_addr),tmp4
        ldw             -4(s_addr),tmp5
        vshd            tmp1,tmp2,tmp6      /* position data !  */
        stbys,b,m       tmp6,4(0,d_addr)    /* store !  */

        vshd            tmp2,tmp3,tmp6      /* position data !  */
        stwm            tmp6,4(0,d_addr)    /* store ! */

        vshd            tmp3,tmp4,tmp6      /* position data ! */
        stwm            tmp6,4(0,d_addr)    /* store ! */

        vshd            tmp4,tmp5,tmp6      /* position data ! */
        stwm            tmp6,4(0,d_addr)    /* store the data ! */
        addibf,<    -16,count,chunk2    /* If count is still >= 16 do another loop. */
        copy            tmp5,tmp1
        

chkchnk2:
        addibt,<,n  12,count,bp_0       /* if we don't have 4 bytes left then do the back porch (bp_0) */

subchnk2: 
        ldwm        4(0,s_addr),tmp2    /* get next word ! */
        vshd        tmp1,tmp2,tmp3      /* position data ! */
        addibt,<    -4,count,bp_1       /* decrement count and when count < 4 goto back_porch (bp_1) */
        stbys,b,m   tmp3,4(0,d_addr)    /* store ! */

        ldwm        4(0,s_addr),tmp1    /* get 4th word ! */
        vshd        tmp2,tmp1,tmp3      /* position data ! */
        addib,>=    -4,count,subchnk2   /* decrement count and when count <= 4 go to back porch (bp_2) */
        stbys,b,m   tmp3,4(0,d_addr)    /* store the data ! */

bp_0:    copy        tmp1,tmp2           /* switch registers used in the shift process. */
bp_1:    addibt,<=,n  4,count,done        /* if count = -4 this implies that count = 0 -> done  */
        add         d_addr,count,d_addr /* bump destination address to be +1 too high ! */
        mfctl           sar,tmp3        /* suppress final ldwm unless result used */
        extru           tmp3,28,2,tmp3  /* convert bitshift to byteshift */
        sub,<=          count,tmp3,r0   /* bytes unused if (count-byteshift <= 0*/

        ldwm        4(0,s_addr),tmp1    /* get final word !         */
        vshd        tmp2,tmp1,tmp3      /* position data ! */
        bv              0(r2)           /* return */
        stbys,e     tmp3,0(0,d_addr)    /* store the data ! */

/* here we do ye old byte-at-a-time moves. */
byteloop: 
        comb,>=,n    0,count,done

encore:
        ldbs,ma     1(s_addr),tmp1
        addibf,=   -1,count,encore
        stbs,ma     tmp1,1(d_addr) 

done:
EXIT(memcpy)