arch/alpha/lib/stxcpy.S

   1 /* SPDX-License-Identifier: GPL-2.0 */
   2 /*
   3  * arch/alpha/lib/stxcpy.S
   4  * Contributed by Richard Henderson (rth@tamu.edu)
   5  *
   6  * Copy a null-terminated string from SRC to DST.
   7  *
   8  * This is an internal routine used by strcpy, stpcpy, and strcat.
   9  * As such, it uses special linkage conventions to make implementation
  10  * of these public functions more efficient.
  11  *
  12  * On input:
  13  *      t9 = return address
  14  *      a0 = DST
  15  *      a1 = SRC
  16  *
  17  * On output:
  18  *      t12 = bitmask (with one bit set) indicating the last byte written
  19  *      a0  = unaligned address of the last *word* written
  20  *
  21  * Furthermore, v0, a3-a5, t11, and t12 are untouched.
  22  */
  23
  24 #include <asm/regdef.h>
  25
  26         .set noat
  27         .set noreorder
  28
  29         .text
  30
  31 /* There is a problem with either gdb (as of 4.16) or gas (as of 2.7) that
  32    doesn't like putting the entry point for a procedure somewhere in the
  33    middle of the procedure descriptor.  Work around this by putting the
  34    aligned copy in its own procedure descriptor */
  35
  36         .ent stxcpy_aligned
  37         .align 3
  38 stxcpy_aligned:
  39         .frame sp, 0, t9
  40         .prologue 0
  41
  42         /* On entry to this basic block:
  43            t0 == the first destination word for masking back in
  44            t1 == the first source word.  */
  45
  46         /* Create the 1st output word and detect 0's in the 1st input word.  */
  47         lda     t2, -1          # e1    : build a mask against false zero
  48         mskqh   t2, a1, t2      # e0    :   detection in the src word
  49         mskqh   t1, a1, t3      # e0    :
  50         ornot   t1, t2, t2      # .. e1 :
  51         mskql   t0, a1, t0      # e0    : assemble the first output word
  52         cmpbge  zero, t2, t8    # .. e1 : bits set iff null found
  53         or      t0, t3, t1      # e0    :
  54         bne     t8, $a_eos      # .. e1 :
  55
  56         /* On entry to this basic block:
  57            t0 == the first destination word for masking back in
  58            t1 == a source word not containing a null.  */
  59
  60 $a_loop:
  61         stq_u   t1, 0(a0)       # e0    :
  62         addq    a0, 8, a0       # .. e1 :
  63         ldq_u   t1, 0(a1)       # e0    :
  64         addq    a1, 8, a1       # .. e1 :
  65         cmpbge  zero, t1, t8    # e0 (stall)
  66         beq     t8, $a_loop     # .. e1 (zdb)
  67
  68         /* Take care of the final (partial) word store.
  69            On entry to this basic block we have:
  70            t1 == the source word containing the null
  71            t8 == the cmpbge mask that found it.  */
  72 $a_eos:
  73         negq    t8, t6          # e0    : find low bit set
  74         and     t8, t6, t12     # e1 (stall)
  75
  76         /* For the sake of the cache, don't read a destination word
  77            if we're not going to need it.  */
  78         and     t12, 0x80, t6   # e0    :
  79         bne     t6, 1f          # .. e1 (zdb)
  80
  81         /* We're doing a partial word store and so need to combine
  82            our source and original destination words.  */
  83         ldq_u   t0, 0(a0)       # e0    :
  84         subq    t12, 1, t6      # .. e1 :
  85         zapnot  t1, t6, t1      # e0    : clear src bytes >= null
  86         or      t12, t6, t8     # .. e1 :
  87         zap     t0, t8, t0      # e0    : clear dst bytes <= null
  88         or      t0, t1, t1      # e1    :
  89
  90 1:      stq_u   t1, 0(a0)       # e0    :
  91         ret     (t9)            # .. e1 :
  92
  93         .end stxcpy_aligned
  94
  95         .align 3
  96         .ent __stxcpy
  97         .globl __stxcpy
  98 __stxcpy:
  99         .frame sp, 0, t9
 100         .prologue 0
 101
 102         /* Are source and destination co-aligned?  */
 103         xor     a0, a1, t0      # e0    :
 104         unop                    #       :
 105         and     t0, 7, t0       # e0    :
 106         bne     t0, $unaligned  # .. e1 :
 107
 108         /* We are co-aligned; take care of a partial first word.  */
 109         ldq_u   t1, 0(a1)       # e0    : load first src word
 110         and     a0, 7, t0       # .. e1 : take care not to load a word ...
 111         addq    a1, 8, a1               # e0    :
 112         beq     t0, stxcpy_aligned      # .. e1 : ... if we wont need it
 113         ldq_u   t0, 0(a0)       # e0    :
 114         br      stxcpy_aligned  # .. e1 :
 115
 116
 117 /* The source and destination are not co-aligned.  Align the destination
 118    and cope.  We have to be very careful about not reading too much and
 119    causing a SEGV.  */
 120
 121         .align 3
 122 $u_head:
 123         /* We know just enough now to be able to assemble the first
 124            full source word.  We can still find a zero at the end of it
 125            that prevents us from outputting the whole thing.
 126
 127            On entry to this basic block:
 128            t0 == the first dest word, for masking back in, if needed else 0
 129            t1 == the low bits of the first source word
 130            t6 == bytemask that is -1 in dest word bytes */
 131
 132         ldq_u   t2, 8(a1)       # e0    :
 133         addq    a1, 8, a1       # .. e1 :
 134
 135         extql   t1, a1, t1      # e0    :
 136         extqh   t2, a1, t4      # e0    :
 137         mskql   t0, a0, t0      # e0    :
 138         or      t1, t4, t1      # .. e1 :
 139         mskqh   t1, a0, t1      # e0    :
 140         or      t0, t1, t1      # e1    :
 141
 142         or      t1, t6, t6      # e0    :
 143         cmpbge  zero, t6, t8    # .. e1 :
 144         lda     t6, -1          # e0    : for masking just below
 145         bne     t8, $u_final    # .. e1 :
 146
 147         mskql   t6, a1, t6              # e0    : mask out the bits we have
 148         or      t6, t2, t2              # e1    :   already extracted before
 149         cmpbge  zero, t2, t8            # e0    :   testing eos
 150         bne     t8, $u_late_head_exit   # .. e1 (zdb)
 151
 152         /* Finally, we've got all the stupid leading edge cases taken care
 153            of and we can set up to enter the main loop.  */
 154
 155         stq_u   t1, 0(a0)       # e0    : store first output word
 156         addq    a0, 8, a0       # .. e1 :
 157         extql   t2, a1, t0      # e0    : position ho-bits of lo word
 158         ldq_u   t2, 8(a1)       # .. e1 : read next high-order source word
 159         addq    a1, 8, a1       # e0    :
 160         cmpbge  zero, t2, t8    # .. e1 :
 161         nop                     # e0    :
 162         bne     t8, $u_eos      # .. e1 :
 163
 164         /* Unaligned copy main loop.  In order to avoid reading too much,
 165            the loop is structured to detect zeros in aligned source words.
 166            This has, unfortunately, effectively pulled half of a loop
 167            iteration out into the head and half into the tail, but it does
 168            prevent nastiness from accumulating in the very thing we want
 169            to run as fast as possible.
 170
 171            On entry to this basic block:
 172            t0 == the shifted high-order bits from the previous source word
 173            t2 == the unshifted current source word
 174
 175            We further know that t2 does not contain a null terminator.  */
 176
 177         .align 3
 178 $u_loop:
 179         extqh   t2, a1, t1      # e0    : extract high bits for current word
 180         addq    a1, 8, a1       # .. e1 :
 181         extql   t2, a1, t3      # e0    : extract low bits for next time
 182         addq    a0, 8, a0       # .. e1 :
 183         or      t0, t1, t1      # e0    : current dst word now complete
 184         ldq_u   t2, 0(a1)       # .. e1 : load high word for next time
 185         stq_u   t1, -8(a0)      # e0    : save the current word
 186         mov     t3, t0          # .. e1 :
 187         cmpbge  zero, t2, t8    # e0    : test new word for eos
 188         beq     t8, $u_loop     # .. e1 :
 189
 190         /* We've found a zero somewhere in the source word we just read.
 191            If it resides in the lower half, we have one (probably partial)
 192            word to write out, and if it resides in the upper half, we
 193            have one full and one partial word left to write out.
 194
 195            On entry to this basic block:
 196            t0 == the shifted high-order bits from the previous source word
 197            t2 == the unshifted current source word.  */
 198 $u_eos:
 199         extqh   t2, a1, t1      # e0    :
 200         or      t0, t1, t1      # e1    : first (partial) source word complete
 201
 202         cmpbge  zero, t1, t8    # e0    : is the null in this first bit?
 203         bne     t8, $u_final    # .. e1 (zdb)
 204
 205 $u_late_head_exit:
 206         stq_u   t1, 0(a0)       # e0    : the null was in the high-order bits
 207         addq    a0, 8, a0       # .. e1 :
 208         extql   t2, a1, t1      # e0    :
 209         cmpbge  zero, t1, t8    # .. e1 :
 210
 211         /* Take care of a final (probably partial) result word.
 212            On entry to this basic block:
 213            t1 == assembled source word
 214            t8 == cmpbge mask that found the null.  */
 215 $u_final:
 216         negq    t8, t6          # e0    : isolate low bit set
 217         and     t6, t8, t12     # e1    :
 218
 219         and     t12, 0x80, t6   # e0    : avoid dest word load if we can
 220         bne     t6, 1f          # .. e1 (zdb)
 221
 222         ldq_u   t0, 0(a0)       # e0    :
 223         subq    t12, 1, t6      # .. e1 :
 224         or      t6, t12, t8     # e0    :
 225         zapnot  t1, t6, t1      # .. e1 : kill source bytes >= null
 226         zap     t0, t8, t0      # e0    : kill dest bytes <= null
 227         or      t0, t1, t1      # e1    :
 228
 229 1:      stq_u   t1, 0(a0)       # e0    :
 230         ret     (t9)            # .. e1 :
 231
 232         /* Unaligned copy entry point.  */
 233         .align 3
 234 $unaligned:
 235
 236         ldq_u   t1, 0(a1)       # e0    : load first source word
 237
 238         and     a0, 7, t4       # .. e1 : find dest misalignment
 239         and     a1, 7, t5       # e0    : find src misalignment
 240
 241         /* Conditionally load the first destination word and a bytemask
 242            with 0xff indicating that the destination byte is sacrosanct.  */
 243
 244         mov     zero, t0        # .. e1 :
 245         mov     zero, t6        # e0    :
 246         beq     t4, 1f          # .. e1 :
 247         ldq_u   t0, 0(a0)       # e0    :
 248         lda     t6, -1          # .. e1 :
 249         mskql   t6, a0, t6      # e0    :
 250 1:
 251         subq    a1, t4, a1      # .. e1 : sub dest misalignment from src addr
 252
 253         /* If source misalignment is larger than dest misalignment, we need
 254            extra startup checks to avoid SEGV.  */
 255
 256         cmplt   t4, t5, t12     # e0    :
 257         beq     t12, $u_head    # .. e1 (zdb)
 258
 259         lda     t2, -1          # e1    : mask out leading garbage in source
 260         mskqh   t2, t5, t2      # e0    :
 261         nop                     # e0    :
 262         ornot   t1, t2, t3      # .. e1 :
 263         cmpbge  zero, t3, t8    # e0    : is there a zero?
 264         beq     t8, $u_head     # .. e1 (zdb)
 265
 266         /* At this point we've found a zero in the first partial word of
 267            the source.  We need to isolate the valid source data and mask
 268            it into the original destination data.  (Incidentally, we know
 269            that we'll need at least one byte of that original dest word.) */
 270
 271         ldq_u   t0, 0(a0)       # e0    :
 272
 273         negq    t8, t6          # .. e1 : build bitmask of bytes <= zero
 274         and     t6, t8, t12     # e0    :
 275         and     a1, 7, t5       # .. e1 :
 276         subq    t12, 1, t6      # e0    :
 277         or      t6, t12, t8     # e1    :
 278         srl     t12, t5, t12    # e0    : adjust final null return value
 279
 280         zapnot  t2, t8, t2      # .. e1 : prepare source word; mirror changes
 281         and     t1, t2, t1      # e1    : to source validity mask
 282         extql   t2, a1, t2      # .. e0 :
 283         extql   t1, a1, t1      # e0    :
 284
 285         andnot  t0, t2, t0      # .. e1 : zero place for source to reside
 286         or      t0, t1, t1      # e1    : and put it there
 287         stq_u   t1, 0(a0)       # .. e0 :
 288         ret     (t9)            # e1    :
 289
 290         .end __stxcpy