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