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 46stxncpy_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 1041: 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 2651: 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 2821: 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 3121: 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 347