root/arch/alpha/lib/ev6-stxncpy.S

   1 /* SPDX-License-Identifier: GPL-2.0 */
   2 /*
   3  * arch/alpha/lib/ev6-stxncpy.S
   4  * 21264 version contributed by Rick Gorton <rick.gorton@api-networks.com>
   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  * Much of the information about 21264 scheduling/coding comes from:
  32  *      Compiler Writer's Guide for the Alpha 21264
  33  *      abbreviated as 'CWG' in other comments here
  34  *      ftp.digital.com/pub/Digital/info/semiconductor/literature/dsc-library.html
  35  * Scheduling notation:
  36  *      E       - either cluster
  37  *      U       - upper subcluster; U0 - subcluster U0; U1 - subcluster U1
  38  *      L       - lower subcluster; L0 - subcluster L0; L1 - subcluster L1
  39  * Try not to change the actual algorithm if possible for consistency.
  40  */
  41 
  42 #include <asm/regdef.h>
  43 
  44         .set noat
  45         .set noreorder
  46 
  47         .text
  48 
  49 /* There is a problem with either gdb (as of 4.16) or gas (as of 2.7) that
  50    doesn't like putting the entry point for a procedure somewhere in the
  51    middle of the procedure descriptor.  Work around this by putting the
  52    aligned copy in its own procedure descriptor */
  53 
  54 
  55         .ent stxncpy_aligned
  56         .align 4
  57 stxncpy_aligned:
  58         .frame sp, 0, t9, 0
  59         .prologue 0
  60 
  61         /* On entry to this basic block:
  62            t0 == the first destination word for masking back in
  63            t1 == the first source word.  */
  64 
  65         /* Create the 1st output word and detect 0's in the 1st input word.  */
  66         lda     t2, -1          # E : build a mask against false zero
  67         mskqh   t2, a1, t2      # U :   detection in the src word (stall)
  68         mskqh   t1, a1, t3      # U :
  69         ornot   t1, t2, t2      # E : (stall)
  70 
  71         mskql   t0, a1, t0      # U : assemble the first output word
  72         cmpbge  zero, t2, t8    # E : bits set iff null found
  73         or      t0, t3, t0      # E : (stall)
  74         beq     a2, $a_eoc      # U :
  75 
  76         bne     t8, $a_eos      # U :
  77         nop
  78         nop
  79         nop
  80 
  81         /* On entry to this basic block:
  82            t0 == a source word not containing a null.  */
  83 
  84         /*
  85          * nops here to:
  86          *      separate store quads from load quads
  87          *      limit of 1 bcond/quad to permit training
  88          */
  89 $a_loop:
  90         stq_u   t0, 0(a0)       # L :
  91         addq    a0, 8, a0       # E :
  92         subq    a2, 1, a2       # E :
  93         nop
  94 
  95         ldq_u   t0, 0(a1)       # L :
  96         addq    a1, 8, a1       # E :
  97         cmpbge  zero, t0, t8    # E :
  98         beq     a2, $a_eoc      # U :
  99 
 100         beq     t8, $a_loop     # U :
 101         nop
 102         nop
 103         nop
 104 
 105         /* Take care of the final (partial) word store.  At this point
 106            the end-of-count bit is set in t8 iff it applies.
 107 
 108            On entry to this basic block we have:
 109            t0 == the source word containing the null
 110            t8 == the cmpbge mask that found it.  */
 111 
 112 $a_eos:
 113         negq    t8, t12         # E : find low bit set
 114         and     t8, t12, t12    # E : (stall)
 115         /* For the sake of the cache, don't read a destination word
 116            if we're not going to need it.  */
 117         and     t12, 0x80, t6   # E : (stall)
 118         bne     t6, 1f          # U : (stall)
 119 
 120         /* We're doing a partial word store and so need to combine
 121            our source and original destination words.  */
 122         ldq_u   t1, 0(a0)       # L :
 123         subq    t12, 1, t6      # E :
 124         or      t12, t6, t8     # E : (stall)
 125         zapnot  t0, t8, t0      # U : clear src bytes > null (stall)
 126 
 127         zap     t1, t8, t1      # .. e1 : clear dst bytes <= null
 128         or      t0, t1, t0      # e1    : (stall)
 129         nop
 130         nop
 131 
 132 1:      stq_u   t0, 0(a0)       # L :
 133         ret     (t9)            # L0 : Latency=3
 134         nop
 135         nop
 136 
 137         /* Add the end-of-count bit to the eos detection bitmask.  */
 138 $a_eoc:
 139         or      t10, t8, t8     # E :
 140         br      $a_eos          # L0 : Latency=3
 141         nop
 142         nop
 143 
 144         .end stxncpy_aligned
 145 
 146         .align 4
 147         .ent __stxncpy
 148         .globl __stxncpy
 149 __stxncpy:
 150         .frame sp, 0, t9, 0
 151         .prologue 0
 152 
 153         /* Are source and destination co-aligned?  */
 154         xor     a0, a1, t1      # E :
 155         and     a0, 7, t0       # E : find dest misalignment
 156         and     t1, 7, t1       # E : (stall)
 157         addq    a2, t0, a2      # E : bias count by dest misalignment (stall)
 158 
 159         subq    a2, 1, a2       # E :
 160         and     a2, 7, t2       # E : (stall)
 161         srl     a2, 3, a2       # U : a2 = loop counter = (count - 1)/8 (stall)
 162         addq    zero, 1, t10    # E :
 163 
 164         sll     t10, t2, t10    # U : t10 = bitmask of last count byte
 165         bne     t1, $unaligned  # U :
 166         /* We are co-aligned; take care of a partial first word.  */
 167         ldq_u   t1, 0(a1)       # L : load first src word
 168         addq    a1, 8, a1       # E :
 169 
 170         beq     t0, stxncpy_aligned     # U : avoid loading dest word if not needed
 171         ldq_u   t0, 0(a0)       # L :
 172         nop
 173         nop
 174 
 175         br      stxncpy_aligned # .. e1 :
 176         nop
 177         nop
 178         nop
 179 
 180 
 181 
 182 /* The source and destination are not co-aligned.  Align the destination
 183    and cope.  We have to be very careful about not reading too much and
 184    causing a SEGV.  */
 185 
 186         .align 4
 187 $u_head:
 188         /* We know just enough now to be able to assemble the first
 189            full source word.  We can still find a zero at the end of it
 190            that prevents us from outputting the whole thing.
 191 
 192            On entry to this basic block:
 193            t0 == the first dest word, unmasked
 194            t1 == the shifted low bits of the first source word
 195            t6 == bytemask that is -1 in dest word bytes */
 196 
 197         ldq_u   t2, 8(a1)       # L : Latency=3 load second src word
 198         addq    a1, 8, a1       # E :
 199         mskql   t0, a0, t0      # U : mask trailing garbage in dst
 200         extqh   t2, a1, t4      # U : (3 cycle stall on t2)
 201 
 202         or      t1, t4, t1      # E : first aligned src word complete (stall)
 203         mskqh   t1, a0, t1      # U : mask leading garbage in src (stall)
 204         or      t0, t1, t0      # E : first output word complete (stall)
 205         or      t0, t6, t6      # E : mask original data for zero test (stall)
 206 
 207         cmpbge  zero, t6, t8    # E :
 208         beq     a2, $u_eocfin   # U :
 209         lda     t6, -1          # E :
 210         nop
 211 
 212         bne     t8, $u_final    # U :
 213         mskql   t6, a1, t6      # U : mask out bits already seen
 214         stq_u   t0, 0(a0)       # L : store first output word
 215         or      t6, t2, t2      # E : (stall)
 216 
 217         cmpbge  zero, t2, t8    # E : find nulls in second partial
 218         addq    a0, 8, a0       # E :
 219         subq    a2, 1, a2       # E :
 220         bne     t8, $u_late_head_exit   # U :
 221 
 222         /* Finally, we've got all the stupid leading edge cases taken care
 223            of and we can set up to enter the main loop.  */
 224         extql   t2, a1, t1      # U : position hi-bits of lo word
 225         beq     a2, $u_eoc      # U :
 226         ldq_u   t2, 8(a1)       # L : read next high-order source word
 227         addq    a1, 8, a1       # E :
 228 
 229         extqh   t2, a1, t0      # U : position lo-bits of hi word (stall)
 230         cmpbge  zero, t2, t8    # E :
 231         nop
 232         bne     t8, $u_eos      # U :
 233 
 234         /* Unaligned copy main loop.  In order to avoid reading too much,
 235            the loop is structured to detect zeros in aligned source words.
 236            This has, unfortunately, effectively pulled half of a loop
 237            iteration out into the head and half into the tail, but it does
 238            prevent nastiness from accumulating in the very thing we want
 239            to run as fast as possible.
 240 
 241            On entry to this basic block:
 242            t0 == the shifted low-order bits from the current source word
 243            t1 == the shifted high-order bits from the previous source word
 244            t2 == the unshifted current source word
 245 
 246            We further know that t2 does not contain a null terminator.  */
 247 
 248         .align 4
 249 $u_loop:
 250         or      t0, t1, t0      # E : current dst word now complete
 251         subq    a2, 1, a2       # E : decrement word count
 252         extql   t2, a1, t1      # U : extract low bits for next time
 253         addq    a0, 8, a0       # E :
 254 
 255         stq_u   t0, -8(a0)      # U : save the current word
 256         beq     a2, $u_eoc      # U :
 257         ldq_u   t2, 8(a1)       # U : Latency=3 load high word for next time
 258         addq    a1, 8, a1       # E :
 259 
 260         extqh   t2, a1, t0      # U : extract low bits (2 cycle stall)
 261         cmpbge  zero, t2, t8    # E : test new word for eos
 262         nop
 263         beq     t8, $u_loop     # U :
 264 
 265         /* We've found a zero somewhere in the source word we just read.
 266            If it resides in the lower half, we have one (probably partial)
 267            word to write out, and if it resides in the upper half, we
 268            have one full and one partial word left to write out.
 269 
 270            On entry to this basic block:
 271            t0 == the shifted low-order bits from the current source word
 272            t1 == the shifted high-order bits from the previous source word
 273            t2 == the unshifted current source word.  */
 274 $u_eos:
 275         or      t0, t1, t0      # E : first (partial) source word complete
 276         nop
 277         cmpbge  zero, t0, t8    # E : is the null in this first bit? (stall)
 278         bne     t8, $u_final    # U : (stall)
 279 
 280         stq_u   t0, 0(a0)       # L : the null was in the high-order bits
 281         addq    a0, 8, a0       # E :
 282         subq    a2, 1, a2       # E :
 283         nop
 284 
 285 $u_late_head_exit:
 286         extql   t2, a1, t0      # U :
 287         cmpbge  zero, t0, t8    # E :
 288         or      t8, t10, t6     # E : (stall)
 289         cmoveq  a2, t6, t8      # E : Latency=2, extra map slot (stall)
 290 
 291         /* Take care of a final (probably partial) result word.
 292            On entry to this basic block:
 293            t0 == assembled source word
 294            t8 == cmpbge mask that found the null.  */
 295 $u_final:
 296         negq    t8, t6          # E : isolate low bit set
 297         and     t6, t8, t12     # E : (stall)
 298         and     t12, 0x80, t6   # E : avoid dest word load if we can (stall)
 299         bne     t6, 1f          # U : (stall)
 300 
 301         ldq_u   t1, 0(a0)       # L :
 302         subq    t12, 1, t6      # E :
 303         or      t6, t12, t8     # E : (stall)
 304         zapnot  t0, t8, t0      # U : kill source bytes > null
 305 
 306         zap     t1, t8, t1      # U : kill dest bytes <= null
 307         or      t0, t1, t0      # E : (stall)
 308         nop
 309         nop
 310 
 311 1:      stq_u   t0, 0(a0)       # L :
 312         ret     (t9)            # L0 : Latency=3
 313 
 314           /* Got to end-of-count before end of string.  
 315              On entry to this basic block:
 316              t1 == the shifted high-order bits from the previous source word  */
 317 $u_eoc:
 318         and     a1, 7, t6       # E : avoid final load if possible
 319         sll     t10, t6, t6     # U : (stall)
 320         and     t6, 0xff, t6    # E : (stall)
 321         bne     t6, 1f          # U : (stall)
 322 
 323         ldq_u   t2, 8(a1)       # L : load final src word
 324         nop
 325         extqh   t2, a1, t0      # U : extract low bits for last word (stall)
 326         or      t1, t0, t1      # E : (stall)
 327 
 328 1:      cmpbge  zero, t1, t8    # E :
 329         mov     t1, t0          # E :
 330 
 331 $u_eocfin:                      # end-of-count, final word
 332         or      t10, t8, t8     # E :
 333         br      $u_final        # L0 : Latency=3
 334 
 335         /* Unaligned copy entry point.  */
 336         .align 4
 337 $unaligned:
 338 
 339         ldq_u   t1, 0(a1)       # L : load first source word
 340         and     a0, 7, t4       # E : find dest misalignment
 341         and     a1, 7, t5       # E : find src misalignment
 342         /* Conditionally load the first destination word and a bytemask
 343            with 0xff indicating that the destination byte is sacrosanct.  */
 344         mov     zero, t0        # E :
 345 
 346         mov     zero, t6        # E :
 347         beq     t4, 1f          # U :
 348         ldq_u   t0, 0(a0)       # L :
 349         lda     t6, -1          # E :
 350 
 351         mskql   t6, a0, t6      # U :
 352         nop
 353         nop
 354         subq    a1, t4, a1      # E : sub dest misalignment from src addr
 355 
 356         /* If source misalignment is larger than dest misalignment, we need
 357            extra startup checks to avoid SEGV.  */
 358 
 359 1:      cmplt   t4, t5, t12     # E :
 360         extql   t1, a1, t1      # U : shift src into place
 361         lda     t2, -1          # E : for creating masks later
 362         beq     t12, $u_head    # U : (stall)
 363 
 364         extql   t2, a1, t2      # U :
 365         cmpbge  zero, t1, t8    # E : is there a zero?
 366         andnot  t2, t6, t2      # E : dest mask for a single word copy
 367         or      t8, t10, t5     # E : test for end-of-count too
 368 
 369         cmpbge  zero, t2, t3    # E :
 370         cmoveq  a2, t5, t8      # E : Latency=2, extra map slot
 371         nop                     # E : keep with cmoveq
 372         andnot  t8, t3, t8      # E : (stall)
 373 
 374         beq     t8, $u_head     # U :
 375         /* At this point we've found a zero in the first partial word of
 376            the source.  We need to isolate the valid source data and mask
 377            it into the original destination data.  (Incidentally, we know
 378            that we'll need at least one byte of that original dest word.) */
 379         ldq_u   t0, 0(a0)       # L :
 380         negq    t8, t6          # E : build bitmask of bytes <= zero
 381         mskqh   t1, t4, t1      # U :
 382 
 383         and     t6, t8, t12     # E :
 384         subq    t12, 1, t6      # E : (stall)
 385         or      t6, t12, t8     # E : (stall)
 386         zapnot  t2, t8, t2      # U : prepare source word; mirror changes (stall)
 387 
 388         zapnot  t1, t8, t1      # U : to source validity mask
 389         andnot  t0, t2, t0      # E : zero place for source to reside
 390         or      t0, t1, t0      # E : and put it there (stall both t0, t1)
 391         stq_u   t0, 0(a0)       # L : (stall)
 392 
 393         ret     (t9)            # L0 : Latency=3
 394         nop
 395         nop
 396         nop
 397 
 398         .end __stxncpy