Subversion Repositories or1k

/*
 *  (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.
 */

/*
        A faster strcpy.

        by

        Jerry Huck (aligned case)
        Daryl Odnert (equal-alignment case)
        Edgar Circenis (non-aligned case)
*/
/*
 * strcpy(s1, s2)
 *
 * Copy string s2 to s1.  s1 must be large enough.
 * return s1
 */

#include "DEFS.h"

#define d_addr          r26
#define s_addr          r25
#define tmp6            r24
#define tmp1            r19
#define evenside        r19
#define tmp2            r20
#define oddside         r20
#define tmp3            r21
#define tmp4            r22
#define tmp5            arg3
#define save            r1


ENTRY(strcpy)
/* Do some quick alignment checking on and fast path both word aligned */
        extru,<>   s_addr,31,2,tmp6    /*Is source word aligned? */
        ldwm       4(0,s_addr),oddside /*Assume yes and guess that it
                                          is double-word aligned. */
        dep,=      d_addr,29,2,tmp6    /*Is target word aligned? */
        b          case_analysis
        copy       d_addr,ret0
/* Both are aligned.  First source word already loaded assuming that
   source was oddword aligned.  Fall through (therefore fastest) code
   shuffles the registers to join the main loop */
bothaligned:
        bb,>=    s_addr,29,twoatatime  /*Branch if source was odd aligned*/
        uxor,nbz oddside,r0,save

/* Even aligned source.  save holds that operand.
   Do one iteration of the main copy loop juggling the registers to avoid
   one copy. */
        b,n      nullfound
        ldwm     4(s_addr),oddside
        stwm     save,4(d_addr)
        uxor,nbz oddside,r0,save
        b,n      nullfound
        ldwm     4(s_addr),evenside
        stwm     oddside,4(d_addr)
        uxor,nbz evenside,r0,save
        b,n      nullfound
        ldwm     4(s_addr),oddside

/* Main loop body.  Entry expects evenside still to be stored, oddside
   just loaded. */
loop:
        stwm     evenside,4(d_addr)
        uxor,nbz oddside,r0,save

/* mid loop entry */
twoatatime:
        b,n      nullfound
        ldwm     4(s_addr),evenside
        stwm     oddside,4(d_addr)
        uxor,sbz evenside,r0,save
        b        loop
        ldwm     4(s_addr),oddside

/* fall through when null found in evenside.  oddside actually loaded */
nullfound:                              /* adjust d_addr and store final word */

        extru,<>        save,7,8,r0         /* pick up leftmost byte */
        addib,tr,n      1,d_addr,store_final
        extru,<>        save,15,8,r0
        addib,tr,n      2,d_addr,store_final
        extru,<>        save,23,8,r0
        addib,tr        3,d_addr,store_final2
        bv              0(rp)
        stw             save,0(d_addr)

store_final:
        bv              0(rp)
store_final2:
        stbys,e         save,0(d_addr)  /* delay slot */
        
case_analysis:

        blr         tmp6,r0
        nop

        /* NOTE: the delay slots for the non-aligned cases load a   */
        /* shift quantity which is TGT-SRC into tmp3.               */
        /* Note also, the case for both strings being word aligned  */
        /* is already checked before the BLR is executed, so that   */
        /* case can never occur.                                    */

                                       /* TGT SRC */
        nop                            /* 00  00  can't happen */
        nop
        b           neg_aligned_copy   /* 00  01  */
        ldi         -1,tmp3            /* load shift quantity. delay slot */
        b           neg_aligned_copy   /* 00  10  */
        ldi         -2,tmp3            /* load shift quantity. delay slot */
        b           neg_aligned_copy   /* 00  11  */
        ldi         -3,tmp3            /* load shift quantity. delay slot */
        b           pos_aligned_copy0  /* 01  00  */
        ldi         1,tmp3            /* load shift quantity. delay slot */
        b           equal_alignment_1  /* 01  01  */
        ldbs,ma     1(s_addr),tmp1
        b           neg_aligned_copy   /* 01  10  */
        ldi         -1,tmp3            /* load shift quantity. delay slot */
        b           neg_aligned_copy   /* 01  11  */
        ldi         -2,tmp3            /* load shift quantity. delay slot */
        b           pos_aligned_copy0  /* 10  00  */
        ldi         2,tmp3            /* load shift quantity. delay slot */
        b           pos_aligned_copy   /* 10  01  */
        ldi         1,tmp3            /* load shift quantity. delay slot */
        b           equal_alignment_2  /* 10  10  */
        ldhs,ma     2(s_addr),tmp1
        b           neg_aligned_copy   /* 10  11  */
        ldi         -1,tmp3            /* load shift quantity. delay slot */
        b           pos_aligned_copy0  /* 11  00  */
        ldi         3,tmp3            /* load shift quantity. delay slot */
        b           pos_aligned_copy   /* 11  01  */
        ldi         2,tmp3            /* load shift quantity. delay slot */
        b           pos_aligned_copy   /* 11  10  */
        ldi         1,tmp3            /* load shift quantity. delay slot */
        ldbs,ma     1(s_addr),tmp1     /* 11  11  */
        comiclr,<>  r0,tmp1,r0
        bv          0(rp)              /* return if 1st byte was null */
        stbs,ma     tmp1,1(d_addr)     /* store a byte to dst string  */
        b           bothaligned       /* can now goto word_aligned   */
        ldwm        4(s_addr),oddside     /* load next word of source    */

equal_alignment_1:
        comiclr,<>  r0,tmp1,r0      /* nullify next if tmp1 <> 0  */
        bv          0(rp)           /* return if null byte found  */
        stbs,ma     tmp1,1(d_addr)  /* store a byte to dst string */
        ldhs,ma     2(s_addr),tmp1  /* load next halfword         */
equal_alignment_2:
        extru,<>    tmp1,23,8,tmp6  /* look at left byte of halfword */
        bv          0(rp)           /* return if 1st byte was null */
        stbs,ma     tmp6,1(d_addr)
        extru,<>    tmp1,31,8,r0
        bv          0(rp)           /* return if 2nd byte was null */
        stbs,ma     tmp1,1(d_addr)
        b           bothaligned
        ldwm        4(s_addr),oddside  /* load next word              */

/* source and destination are not aligned, so we do it the hard way. */

/* target alignment is greater than source alignment */
pos_aligned_copy0:
        addi            -4,s_addr,s_addr
pos_aligned_copy:
        extru       d_addr,31,2,tmp6   /* Extract low 2 bits of the dest addr */
        extru       s_addr,31,2,tmp1   /* Extract low 2 bits of the src addr */
        dep         r0,31,2,s_addr     /* Compute word address of the source. */
        sh3add          tmp3,r0,tmp4        /* compute shift amt */
        ldwm            4(0,s_addr),tmp2    /* get 1st source word */
        sh3add          tmp1,r0,save        /* setup mask shift amount */
        mtctl           save,r11            /* set-up cr11 for mask */
        zvdepi          -2,32,save          /* create mask */
        or              save,tmp2,tmp2      /* mask unused bytes in src */
        ldi             -1,tmp1             /* load tmp1 with 0xffffffff */
        mtctl           tmp4,r11            /* shift count -> shift count reg */
        vshd            tmp1,tmp2,tmp3      /* position data ! */
        uxor,nbz        tmp3,r0,save
        b,n             first_null
        uxor,nbz        tmp2,r0,save
        b               nullfound1
        mtctl           tmp4,r11            /* re-load shift cnt (delay slot) */
        b               loop_entry
        ldwm            4(0,s_addr),tmp1    /* get next word. delay slot */

neg_aligned_copy:
        extru       d_addr,31,2,tmp6   /* Extract low 2 bits of the dest addr */
        extru       s_addr,31,2,tmp2   /* Extract low 2 bits of the src addr */
        dep         r0,31,2,s_addr     /* Compute word address of the source. */
        sh3add          tmp3,r0,tmp4        /* compute shift amt */
        ldwm            4(0,s_addr),tmp1    /* load first word from source. */
/* check to see if next word can be read safely */
        sh3add          tmp2,r0,save
        mtctl           save,r11            /* shift count -> shift count reg */
        zvdepi          -2,32,save
        or              save, tmp1, tmp1
        uxor,nbz        tmp1,r0,save        /* any nulls in first word? */
        b               first_null0
        mtctl           tmp4,r11
        ldwm            4(0,s_addr),tmp2    /* load second word from source */
        combt,=         tmp6,r0,chunk1      /* don't mask if whole word valid */
        vshd            tmp1,tmp2,tmp3      /* position data ! */
        sh3add          tmp6,r0,save        /* setup r1 */
        mtctl           save,r11            /* set-up cr11 for mask */
        zvdepi          -2,32,save
        or              save, tmp3, tmp3
        uxor,nbz        tmp3,r0,save
        b,n             first_null
        uxor,nbz        tmp2,r0,save
        b               nullfound1
        mtctl           tmp4,r11            /* re-load shift cnt (delay slot) */
        b               loop_entry
        ldwm            4(0,s_addr),tmp1    /* get next word. delay slot */

chunk1:
        uxor,nbz        tmp2,r0,save
        b               nullfound0
        vshd            tmp1,tmp2,tmp3
did_mask:
        ldwm            4(0,s_addr),tmp1    /* get next word !  */
loop_entry:
        stbys,b,m       tmp3,4(0,d_addr)    /* store !  */

        uxor,nbz        tmp1, r0, save
        b               nullfound2
        vshd            tmp2,tmp1,tmp3      /* position data !  */
        ldwm            4(s_addr),tmp2
        stwm            tmp3,4(d_addr)
        uxor,sbz        tmp2,r0,save
        b               did_mask
nullfound0:
        vshd            tmp1,tmp2,tmp3      /* delay slot */
        uxor,nbz        tmp3,r0,save
        b,n             nullfound
nullfound1:
        stbys,b,m       tmp3,4(0,d_addr)
        b               nullfound
        vshd            tmp2,r0,save        /* delay slot */

nullfound2:
        uxor,nbz        tmp3,r0,save
        b,n             nullfound
        stwm            tmp3,4(d_addr)
        b               nullfound
        /* notice that delay slot is in next routine */

first_null0:    /* null found in first word of non-aligned (wrt d_addr) */
        vshd            tmp1,r0,save        /* delay slot */
        combt,=         tmp6,r0,check4
        extru           save,7,8,tmp4
first_null:
        addibt,=        -1,tmp6,check3  /* check last 3 bytes of word */
        extru           save,15,8,tmp4
        addibt,=,n      -1,tmp6,check2  /* check last 2 bytes */
        bv              0(rp)           /* null in last byte--store and exit */
        stbys,b         save, 0(d_addr)

check4:
        combt,=         tmp4,r0,done
        stbs,ma         tmp4,1(d_addr)
        extru,<>        save,15,8,tmp4
check3:
        combt,=         tmp4,r0,done
        stbs,ma         tmp4,1(d_addr)
check2:
        extru,<>        save,23,8,tmp4
        bv              0(rp)
        stbs,ma         tmp4,1(d_addr)
        bv              0(rp)
        stbs            r0,0(d_addr)

done:    
EXIT(strcpy)