arch/alpha/lib/stxncpy.S

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