1 | /* strcat with SSE2 |
2 | Copyright (C) 2011-2024 Free Software Foundation, Inc. |
3 | This file is part of the GNU C Library. |
4 | |
5 | The GNU C Library is free software; you can redistribute it and/or |
6 | modify it under the terms of the GNU Lesser General Public |
7 | License as published by the Free Software Foundation; either |
8 | version 2.1 of the License, or (at your option) any later version. |
9 | |
10 | The GNU C Library is distributed in the hope that it will be useful, |
11 | but WITHOUT ANY WARRANTY; without even the implied warranty of |
12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
13 | Lesser General Public License for more details. |
14 | |
15 | You should have received a copy of the GNU Lesser General Public |
16 | License along with the GNU C Library; if not, see |
17 | <https://www.gnu.org/licenses/>. */ |
18 | |
19 | |
20 | #if IS_IN (libc) |
21 | |
22 | # include <sysdep.h> |
23 | |
24 | |
25 | # define CFI_PUSH(REG) \ |
26 | cfi_adjust_cfa_offset (4); \ |
27 | cfi_rel_offset (REG, 0) |
28 | |
29 | # define CFI_POP(REG) \ |
30 | cfi_adjust_cfa_offset (-4); \ |
31 | cfi_restore (REG) |
32 | |
33 | # define PUSH(REG) pushl REG; CFI_PUSH (REG) |
34 | # define POP(REG) popl REG; CFI_POP (REG) |
35 | |
36 | # ifdef PIC |
37 | # define JMPTBL(I, B) I - B |
38 | |
39 | /* Load an entry in a jump table into ECX and branch to it. TABLE is a |
40 | jump table with relative offsets. INDEX is a register contains the |
41 | index into the jump table. SCALE is the scale of INDEX. */ |
42 | |
43 | # define BRANCH_TO_JMPTBL_ENTRY(TABLE, INDEX, SCALE) \ |
44 | /* We first load PC into ECX. */ \ |
45 | SETUP_PIC_REG(cx); \ |
46 | /* Get the address of the jump table. */ \ |
47 | addl $(TABLE - .), %ecx; \ |
48 | /* Get the entry and convert the relative offset to the \ |
49 | absolute address. */ \ |
50 | addl (%ecx,INDEX,SCALE), %ecx; \ |
51 | /* We loaded the jump table and adjusted ECX. Go. */ \ |
52 | jmp *%ecx |
53 | # else |
54 | # define JMPTBL(I, B) I |
55 | |
56 | /* Branch to an entry in a jump table. TABLE is a jump table with |
57 | absolute offsets. INDEX is a register contains the index into the |
58 | jump table. SCALE is the scale of INDEX. */ |
59 | |
60 | # define BRANCH_TO_JMPTBL_ENTRY(TABLE, INDEX, SCALE) \ |
61 | jmp *TABLE(,INDEX,SCALE) |
62 | # endif |
63 | |
64 | # ifndef STRCAT |
65 | # define STRCAT __strcat_sse2 |
66 | # endif |
67 | |
68 | # define PARMS 4 |
69 | # define STR1 PARMS+4 |
70 | # define STR2 STR1+4 |
71 | |
72 | # ifdef USE_AS_STRNCAT |
73 | # define LEN STR2+8 |
74 | # define STR3 STR1+4 |
75 | # else |
76 | # define STR3 STR1 |
77 | # endif |
78 | |
79 | # define USE_AS_STRCAT |
80 | # ifdef USE_AS_STRNCAT |
81 | # define RETURN POP(%ebx); POP(%esi); ret; CFI_PUSH(%ebx); CFI_PUSH(%esi); |
82 | # else |
83 | # define RETURN POP(%esi); ret; CFI_PUSH(%esi); |
84 | # endif |
85 | |
86 | .text |
87 | ENTRY (STRCAT) |
88 | PUSH (%esi) |
89 | mov STR1(%esp), %eax |
90 | mov STR2(%esp), %esi |
91 | # ifdef USE_AS_STRNCAT |
92 | PUSH (%ebx) |
93 | movl LEN(%esp), %ebx |
94 | test %ebx, %ebx |
95 | jz L(ExitZero) |
96 | # endif |
97 | cmpb $0, (%esi) |
98 | mov %esi, %ecx |
99 | mov %eax, %edx |
100 | jz L(ExitZero) |
101 | |
102 | and $63, %ecx |
103 | and $63, %edx |
104 | cmp $32, %ecx |
105 | ja L(StrlenCore7_1) |
106 | cmp $48, %edx |
107 | ja L(alignment_prolog) |
108 | |
109 | pxor %xmm0, %xmm0 |
110 | pxor %xmm4, %xmm4 |
111 | pxor %xmm7, %xmm7 |
112 | movdqu (%eax), %xmm1 |
113 | movdqu (%esi), %xmm5 |
114 | pcmpeqb %xmm1, %xmm0 |
115 | movdqu 16(%esi), %xmm6 |
116 | pmovmskb %xmm0, %ecx |
117 | pcmpeqb %xmm5, %xmm4 |
118 | pcmpeqb %xmm6, %xmm7 |
119 | test %ecx, %ecx |
120 | jnz L(exit_less16_) |
121 | mov %eax, %ecx |
122 | and $-16, %eax |
123 | jmp L(loop_prolog) |
124 | |
125 | L(alignment_prolog): |
126 | pxor %xmm0, %xmm0 |
127 | pxor %xmm4, %xmm4 |
128 | mov %edx, %ecx |
129 | pxor %xmm7, %xmm7 |
130 | and $15, %ecx |
131 | and $-16, %eax |
132 | pcmpeqb (%eax), %xmm0 |
133 | movdqu (%esi), %xmm5 |
134 | movdqu 16(%esi), %xmm6 |
135 | pmovmskb %xmm0, %edx |
136 | pcmpeqb %xmm5, %xmm4 |
137 | shr %cl, %edx |
138 | pcmpeqb %xmm6, %xmm7 |
139 | test %edx, %edx |
140 | jnz L(exit_less16) |
141 | add %eax, %ecx |
142 | |
143 | pxor %xmm0, %xmm0 |
144 | L(loop_prolog): |
145 | pxor %xmm1, %xmm1 |
146 | pxor %xmm2, %xmm2 |
147 | pxor %xmm3, %xmm3 |
148 | .p2align 4 |
149 | L(align16_loop): |
150 | pcmpeqb 16(%eax), %xmm0 |
151 | pmovmskb %xmm0, %edx |
152 | test %edx, %edx |
153 | jnz L(exit16) |
154 | |
155 | pcmpeqb 32(%eax), %xmm1 |
156 | pmovmskb %xmm1, %edx |
157 | test %edx, %edx |
158 | jnz L(exit32) |
159 | |
160 | pcmpeqb 48(%eax), %xmm2 |
161 | pmovmskb %xmm2, %edx |
162 | test %edx, %edx |
163 | jnz L(exit48) |
164 | |
165 | pcmpeqb 64(%eax), %xmm3 |
166 | pmovmskb %xmm3, %edx |
167 | lea 64(%eax), %eax |
168 | test %edx, %edx |
169 | jz L(align16_loop) |
170 | bsf %edx, %edx |
171 | add %edx, %eax |
172 | jmp L(StartStrcpyPart) |
173 | |
174 | .p2align 4 |
175 | L(exit16): |
176 | bsf %edx, %edx |
177 | lea 16(%eax, %edx), %eax |
178 | jmp L(StartStrcpyPart) |
179 | |
180 | .p2align 4 |
181 | L(exit32): |
182 | bsf %edx, %edx |
183 | lea 32(%eax, %edx), %eax |
184 | jmp L(StartStrcpyPart) |
185 | |
186 | .p2align 4 |
187 | L(exit48): |
188 | bsf %edx, %edx |
189 | lea 48(%eax, %edx), %eax |
190 | jmp L(StartStrcpyPart) |
191 | |
192 | .p2align 4 |
193 | L(exit_less16): |
194 | bsf %edx, %edx |
195 | add %ecx, %eax |
196 | add %edx, %eax |
197 | jmp L(StartStrcpyPart) |
198 | |
199 | .p2align 4 |
200 | L(exit_less16_): |
201 | bsf %ecx, %ecx |
202 | add %ecx, %eax |
203 | |
204 | .p2align 4 |
205 | L(StartStrcpyPart): |
206 | pmovmskb %xmm4, %edx |
207 | # ifdef USE_AS_STRNCAT |
208 | cmp $16, %ebx |
209 | jbe L(CopyFrom1To16BytesTail1Case2OrCase3) |
210 | # endif |
211 | test %edx, %edx |
212 | jnz L(CopyFrom1To16BytesTail1) |
213 | |
214 | movdqu %xmm5, (%eax) |
215 | pmovmskb %xmm7, %edx |
216 | # ifdef USE_AS_STRNCAT |
217 | cmp $32, %ebx |
218 | jbe L(CopyFrom1To32Bytes1Case2OrCase3) |
219 | # endif |
220 | test %edx, %edx |
221 | jnz L(CopyFrom1To32Bytes1) |
222 | |
223 | mov %esi, %ecx |
224 | and $-16, %esi |
225 | and $15, %ecx |
226 | pxor %xmm0, %xmm0 |
227 | # ifdef USE_AS_STRNCAT |
228 | add %ecx, %ebx |
229 | sbb %edx, %edx |
230 | or %edx, %ebx |
231 | # endif |
232 | sub %ecx, %eax |
233 | jmp L(Unalign16Both) |
234 | |
235 | L(StrlenCore7_1): |
236 | mov %eax, %ecx |
237 | pxor %xmm0, %xmm0 |
238 | and $15, %ecx |
239 | and $-16, %eax |
240 | pcmpeqb (%eax), %xmm0 |
241 | pmovmskb %xmm0, %edx |
242 | shr %cl, %edx |
243 | test %edx, %edx |
244 | jnz L(exit_less16_1) |
245 | add %eax, %ecx |
246 | |
247 | pxor %xmm0, %xmm0 |
248 | pxor %xmm1, %xmm1 |
249 | pxor %xmm2, %xmm2 |
250 | pxor %xmm3, %xmm3 |
251 | |
252 | .p2align 4 |
253 | L(align16_loop_1): |
254 | pcmpeqb 16(%eax), %xmm0 |
255 | pmovmskb %xmm0, %edx |
256 | test %edx, %edx |
257 | jnz L(exit16_1) |
258 | |
259 | pcmpeqb 32(%eax), %xmm1 |
260 | pmovmskb %xmm1, %edx |
261 | test %edx, %edx |
262 | jnz L(exit32_1) |
263 | |
264 | pcmpeqb 48(%eax), %xmm2 |
265 | pmovmskb %xmm2, %edx |
266 | test %edx, %edx |
267 | jnz L(exit48_1) |
268 | |
269 | pcmpeqb 64(%eax), %xmm3 |
270 | pmovmskb %xmm3, %edx |
271 | lea 64(%eax), %eax |
272 | test %edx, %edx |
273 | jz L(align16_loop_1) |
274 | bsf %edx, %edx |
275 | add %edx, %eax |
276 | jmp L(StartStrcpyPart_1) |
277 | |
278 | .p2align 4 |
279 | L(exit16_1): |
280 | bsf %edx, %edx |
281 | lea 16(%eax, %edx), %eax |
282 | jmp L(StartStrcpyPart_1) |
283 | |
284 | .p2align 4 |
285 | L(exit32_1): |
286 | bsf %edx, %edx |
287 | lea 32(%eax, %edx), %eax |
288 | jmp L(StartStrcpyPart_1) |
289 | |
290 | .p2align 4 |
291 | L(exit48_1): |
292 | bsf %edx, %edx |
293 | lea 48(%eax, %edx), %eax |
294 | jmp L(StartStrcpyPart_1) |
295 | |
296 | .p2align 4 |
297 | L(exit_less16_1): |
298 | bsf %edx, %edx |
299 | add %ecx, %eax |
300 | add %edx, %eax |
301 | |
302 | .p2align 4 |
303 | L(StartStrcpyPart_1): |
304 | mov %esi, %ecx |
305 | and $15, %ecx |
306 | and $-16, %esi |
307 | pxor %xmm0, %xmm0 |
308 | pxor %xmm1, %xmm1 |
309 | |
310 | # ifdef USE_AS_STRNCAT |
311 | cmp $48, %ebx |
312 | ja L(BigN) |
313 | # endif |
314 | pcmpeqb (%esi), %xmm1 |
315 | # ifdef USE_AS_STRNCAT |
316 | add %ecx, %ebx |
317 | # endif |
318 | pmovmskb %xmm1, %edx |
319 | shr %cl, %edx |
320 | # ifdef USE_AS_STRNCAT |
321 | cmp $16, %ebx |
322 | jbe L(CopyFrom1To16BytesTailCase2OrCase3) |
323 | # endif |
324 | test %edx, %edx |
325 | jnz L(CopyFrom1To16BytesTail) |
326 | |
327 | pcmpeqb 16(%esi), %xmm0 |
328 | pmovmskb %xmm0, %edx |
329 | # ifdef USE_AS_STRNCAT |
330 | cmp $32, %ebx |
331 | jbe L(CopyFrom1To32BytesCase2OrCase3) |
332 | # endif |
333 | test %edx, %edx |
334 | jnz L(CopyFrom1To32Bytes) |
335 | |
336 | movdqu (%esi, %ecx), %xmm1 /* copy 16 bytes */ |
337 | movdqu %xmm1, (%eax) |
338 | sub %ecx, %eax |
339 | |
340 | .p2align 4 |
341 | L(Unalign16Both): |
342 | mov $16, %ecx |
343 | movdqa (%esi, %ecx), %xmm1 |
344 | movaps 16(%esi, %ecx), %xmm2 |
345 | movdqu %xmm1, (%eax, %ecx) |
346 | pcmpeqb %xmm2, %xmm0 |
347 | pmovmskb %xmm0, %edx |
348 | add $16, %ecx |
349 | # ifdef USE_AS_STRNCAT |
350 | sub $48, %ebx |
351 | jbe L(CopyFrom1To16BytesCase2OrCase3) |
352 | # endif |
353 | test %edx, %edx |
354 | jnz L(CopyFrom1To16Bytes) |
355 | L(Unalign16BothBigN): |
356 | movaps 16(%esi, %ecx), %xmm3 |
357 | movdqu %xmm2, (%eax, %ecx) |
358 | pcmpeqb %xmm3, %xmm0 |
359 | pmovmskb %xmm0, %edx |
360 | add $16, %ecx |
361 | # ifdef USE_AS_STRNCAT |
362 | sub $16, %ebx |
363 | jbe L(CopyFrom1To16BytesCase2OrCase3) |
364 | # endif |
365 | test %edx, %edx |
366 | jnz L(CopyFrom1To16Bytes) |
367 | |
368 | movaps 16(%esi, %ecx), %xmm4 |
369 | movdqu %xmm3, (%eax, %ecx) |
370 | pcmpeqb %xmm4, %xmm0 |
371 | pmovmskb %xmm0, %edx |
372 | add $16, %ecx |
373 | # ifdef USE_AS_STRNCAT |
374 | sub $16, %ebx |
375 | jbe L(CopyFrom1To16BytesCase2OrCase3) |
376 | # endif |
377 | test %edx, %edx |
378 | jnz L(CopyFrom1To16Bytes) |
379 | |
380 | movaps 16(%esi, %ecx), %xmm1 |
381 | movdqu %xmm4, (%eax, %ecx) |
382 | pcmpeqb %xmm1, %xmm0 |
383 | pmovmskb %xmm0, %edx |
384 | add $16, %ecx |
385 | # ifdef USE_AS_STRNCAT |
386 | sub $16, %ebx |
387 | jbe L(CopyFrom1To16BytesCase2OrCase3) |
388 | # endif |
389 | test %edx, %edx |
390 | jnz L(CopyFrom1To16Bytes) |
391 | |
392 | movaps 16(%esi, %ecx), %xmm2 |
393 | movdqu %xmm1, (%eax, %ecx) |
394 | pcmpeqb %xmm2, %xmm0 |
395 | pmovmskb %xmm0, %edx |
396 | add $16, %ecx |
397 | # ifdef USE_AS_STRNCAT |
398 | sub $16, %ebx |
399 | jbe L(CopyFrom1To16BytesCase2OrCase3) |
400 | # endif |
401 | test %edx, %edx |
402 | jnz L(CopyFrom1To16Bytes) |
403 | |
404 | movaps 16(%esi, %ecx), %xmm3 |
405 | movdqu %xmm2, (%eax, %ecx) |
406 | pcmpeqb %xmm3, %xmm0 |
407 | pmovmskb %xmm0, %edx |
408 | add $16, %ecx |
409 | # ifdef USE_AS_STRNCAT |
410 | sub $16, %ebx |
411 | jbe L(CopyFrom1To16BytesCase2OrCase3) |
412 | # endif |
413 | test %edx, %edx |
414 | jnz L(CopyFrom1To16Bytes) |
415 | |
416 | movdqu %xmm3, (%eax, %ecx) |
417 | mov %esi, %edx |
418 | lea 16(%esi, %ecx), %esi |
419 | and $-0x40, %esi |
420 | sub %esi, %edx |
421 | sub %edx, %eax |
422 | # ifdef USE_AS_STRNCAT |
423 | lea 128(%ebx, %edx), %ebx |
424 | # endif |
425 | movaps (%esi), %xmm2 |
426 | movaps %xmm2, %xmm4 |
427 | movaps 16(%esi), %xmm5 |
428 | movaps 32(%esi), %xmm3 |
429 | movaps %xmm3, %xmm6 |
430 | movaps 48(%esi), %xmm7 |
431 | pminub %xmm5, %xmm2 |
432 | pminub %xmm7, %xmm3 |
433 | pminub %xmm2, %xmm3 |
434 | pcmpeqb %xmm0, %xmm3 |
435 | pmovmskb %xmm3, %edx |
436 | # ifdef USE_AS_STRNCAT |
437 | sub $64, %ebx |
438 | jbe L(UnalignedLeaveCase2OrCase3) |
439 | # endif |
440 | test %edx, %edx |
441 | jnz L(Unaligned64Leave) |
442 | |
443 | .p2align 4 |
444 | L(Unaligned64Loop_start): |
445 | add $64, %eax |
446 | add $64, %esi |
447 | movdqu %xmm4, -64(%eax) |
448 | movaps (%esi), %xmm2 |
449 | movdqa %xmm2, %xmm4 |
450 | movdqu %xmm5, -48(%eax) |
451 | movaps 16(%esi), %xmm5 |
452 | pminub %xmm5, %xmm2 |
453 | movaps 32(%esi), %xmm3 |
454 | movdqu %xmm6, -32(%eax) |
455 | movaps %xmm3, %xmm6 |
456 | movdqu %xmm7, -16(%eax) |
457 | movaps 48(%esi), %xmm7 |
458 | pminub %xmm7, %xmm3 |
459 | pminub %xmm2, %xmm3 |
460 | pcmpeqb %xmm0, %xmm3 |
461 | pmovmskb %xmm3, %edx |
462 | # ifdef USE_AS_STRNCAT |
463 | sub $64, %ebx |
464 | jbe L(UnalignedLeaveCase2OrCase3) |
465 | # endif |
466 | test %edx, %edx |
467 | jz L(Unaligned64Loop_start) |
468 | |
469 | L(Unaligned64Leave): |
470 | pxor %xmm1, %xmm1 |
471 | |
472 | pcmpeqb %xmm4, %xmm0 |
473 | pcmpeqb %xmm5, %xmm1 |
474 | pmovmskb %xmm0, %edx |
475 | pmovmskb %xmm1, %ecx |
476 | test %edx, %edx |
477 | jnz L(CopyFrom1To16BytesUnaligned_0) |
478 | test %ecx, %ecx |
479 | jnz L(CopyFrom1To16BytesUnaligned_16) |
480 | |
481 | pcmpeqb %xmm6, %xmm0 |
482 | pcmpeqb %xmm7, %xmm1 |
483 | pmovmskb %xmm0, %edx |
484 | pmovmskb %xmm1, %ecx |
485 | test %edx, %edx |
486 | jnz L(CopyFrom1To16BytesUnaligned_32) |
487 | |
488 | bsf %ecx, %edx |
489 | movdqu %xmm4, (%eax) |
490 | movdqu %xmm5, 16(%eax) |
491 | movdqu %xmm6, 32(%eax) |
492 | add $48, %esi |
493 | add $48, %eax |
494 | BRANCH_TO_JMPTBL_ENTRY (L(ExitTable), %edx, 4) |
495 | |
496 | # ifdef USE_AS_STRNCAT |
497 | .p2align 4 |
498 | L(BigN): |
499 | pcmpeqb (%esi), %xmm1 |
500 | pmovmskb %xmm1, %edx |
501 | shr %cl, %edx |
502 | test %edx, %edx |
503 | jnz L(CopyFrom1To16BytesTail) |
504 | |
505 | pcmpeqb 16(%esi), %xmm0 |
506 | pmovmskb %xmm0, %edx |
507 | test %edx, %edx |
508 | jnz L(CopyFrom1To32Bytes) |
509 | |
510 | movdqu (%esi, %ecx), %xmm1 /* copy 16 bytes */ |
511 | movdqu %xmm1, (%eax) |
512 | sub %ecx, %eax |
513 | sub $48, %ebx |
514 | add %ecx, %ebx |
515 | |
516 | mov $16, %ecx |
517 | movdqa (%esi, %ecx), %xmm1 |
518 | movaps 16(%esi, %ecx), %xmm2 |
519 | movdqu %xmm1, (%eax, %ecx) |
520 | pcmpeqb %xmm2, %xmm0 |
521 | pmovmskb %xmm0, %edx |
522 | add $16, %ecx |
523 | test %edx, %edx |
524 | jnz L(CopyFrom1To16Bytes) |
525 | jmp L(Unalign16BothBigN) |
526 | # endif |
527 | |
528 | /*------------end of main part-------------------------------*/ |
529 | |
530 | /* Case1 */ |
531 | .p2align 4 |
532 | L(CopyFrom1To16Bytes): |
533 | add %ecx, %eax |
534 | add %ecx, %esi |
535 | bsf %edx, %edx |
536 | BRANCH_TO_JMPTBL_ENTRY (L(ExitTable), %edx, 4) |
537 | |
538 | .p2align 4 |
539 | L(CopyFrom1To16BytesTail): |
540 | add %ecx, %esi |
541 | bsf %edx, %edx |
542 | BRANCH_TO_JMPTBL_ENTRY (L(ExitTable), %edx, 4) |
543 | |
544 | .p2align 4 |
545 | L(CopyFrom1To32Bytes1): |
546 | add $16, %esi |
547 | add $16, %eax |
548 | L(CopyFrom1To16BytesTail1): |
549 | bsf %edx, %edx |
550 | BRANCH_TO_JMPTBL_ENTRY (L(ExitTable), %edx, 4) |
551 | |
552 | .p2align 4 |
553 | L(CopyFrom1To32Bytes): |
554 | bsf %edx, %edx |
555 | add %ecx, %esi |
556 | add $16, %edx |
557 | sub %ecx, %edx |
558 | BRANCH_TO_JMPTBL_ENTRY (L(ExitTable), %edx, 4) |
559 | |
560 | .p2align 4 |
561 | L(CopyFrom1To16BytesUnaligned_0): |
562 | bsf %edx, %edx |
563 | BRANCH_TO_JMPTBL_ENTRY (L(ExitTable), %edx, 4) |
564 | |
565 | .p2align 4 |
566 | L(CopyFrom1To16BytesUnaligned_16): |
567 | bsf %ecx, %edx |
568 | movdqu %xmm4, (%eax) |
569 | add $16, %esi |
570 | add $16, %eax |
571 | BRANCH_TO_JMPTBL_ENTRY (L(ExitTable), %edx, 4) |
572 | |
573 | .p2align 4 |
574 | L(CopyFrom1To16BytesUnaligned_32): |
575 | bsf %edx, %edx |
576 | movdqu %xmm4, (%eax) |
577 | movdqu %xmm5, 16(%eax) |
578 | add $32, %esi |
579 | add $32, %eax |
580 | BRANCH_TO_JMPTBL_ENTRY (L(ExitTable), %edx, 4) |
581 | |
582 | # ifdef USE_AS_STRNCAT |
583 | |
584 | .p2align 4 |
585 | L(CopyFrom1To16BytesExit): |
586 | BRANCH_TO_JMPTBL_ENTRY (L(ExitTable), %edx, 4) |
587 | |
588 | /* Case2 */ |
589 | |
590 | .p2align 4 |
591 | L(CopyFrom1To16BytesCase2): |
592 | add $16, %ebx |
593 | add %ecx, %eax |
594 | add %ecx, %esi |
595 | bsf %edx, %edx |
596 | cmp %ebx, %edx |
597 | jb L(CopyFrom1To16BytesExit) |
598 | BRANCH_TO_JMPTBL_ENTRY (L(ExitStrncatTable), %ebx, 4) |
599 | |
600 | .p2align 4 |
601 | L(CopyFrom1To32BytesCase2): |
602 | sub %ecx, %ebx |
603 | add %ecx, %esi |
604 | bsf %edx, %edx |
605 | add $16, %edx |
606 | sub %ecx, %edx |
607 | cmp %ebx, %edx |
608 | jb L(CopyFrom1To16BytesExit) |
609 | BRANCH_TO_JMPTBL_ENTRY (L(ExitStrncatTable), %ebx, 4) |
610 | |
611 | L(CopyFrom1To16BytesTailCase2): |
612 | sub %ecx, %ebx |
613 | add %ecx, %esi |
614 | bsf %edx, %edx |
615 | cmp %ebx, %edx |
616 | jb L(CopyFrom1To16BytesExit) |
617 | BRANCH_TO_JMPTBL_ENTRY (L(ExitStrncatTable), %ebx, 4) |
618 | |
619 | L(CopyFrom1To16BytesTail1Case2): |
620 | bsf %edx, %edx |
621 | cmp %ebx, %edx |
622 | jb L(CopyFrom1To16BytesExit) |
623 | BRANCH_TO_JMPTBL_ENTRY (L(ExitStrncatTable), %ebx, 4) |
624 | |
625 | /* Case2 or Case3, Case3 */ |
626 | |
627 | .p2align 4 |
628 | L(CopyFrom1To16BytesCase2OrCase3): |
629 | test %edx, %edx |
630 | jnz L(CopyFrom1To16BytesCase2) |
631 | L(CopyFrom1To16BytesCase3): |
632 | add $16, %ebx |
633 | add %ecx, %eax |
634 | add %ecx, %esi |
635 | BRANCH_TO_JMPTBL_ENTRY (L(ExitStrncatTable), %ebx, 4) |
636 | |
637 | .p2align 4 |
638 | L(CopyFrom1To32BytesCase2OrCase3): |
639 | test %edx, %edx |
640 | jnz L(CopyFrom1To32BytesCase2) |
641 | sub %ecx, %ebx |
642 | add %ecx, %esi |
643 | BRANCH_TO_JMPTBL_ENTRY (L(ExitStrncatTable), %ebx, 4) |
644 | |
645 | .p2align 4 |
646 | L(CopyFrom1To16BytesTailCase2OrCase3): |
647 | test %edx, %edx |
648 | jnz L(CopyFrom1To16BytesTailCase2) |
649 | sub %ecx, %ebx |
650 | add %ecx, %esi |
651 | BRANCH_TO_JMPTBL_ENTRY (L(ExitStrncatTable), %ebx, 4) |
652 | |
653 | .p2align 4 |
654 | L(CopyFrom1To32Bytes1Case2OrCase3): |
655 | add $16, %eax |
656 | add $16, %esi |
657 | sub $16, %ebx |
658 | L(CopyFrom1To16BytesTail1Case2OrCase3): |
659 | test %edx, %edx |
660 | jnz L(CopyFrom1To16BytesTail1Case2) |
661 | BRANCH_TO_JMPTBL_ENTRY (L(ExitStrncatTable), %ebx, 4) |
662 | |
663 | # endif |
664 | |
665 | # ifdef USE_AS_STRNCAT |
666 | .p2align 4 |
667 | L(StrncatExit0): |
668 | movb %bh, (%eax) |
669 | mov STR3(%esp), %eax |
670 | RETURN |
671 | # endif |
672 | |
673 | .p2align 4 |
674 | # ifdef USE_AS_STRNCAT |
675 | L(StrncatExit1): |
676 | movb %bh, 1(%eax) |
677 | # endif |
678 | L(Exit1): |
679 | # ifdef USE_AS_STRNCAT |
680 | movb (%esi), %dh |
681 | # endif |
682 | movb %dh, (%eax) |
683 | mov STR3(%esp), %eax |
684 | RETURN |
685 | |
686 | .p2align 4 |
687 | # ifdef USE_AS_STRNCAT |
688 | L(StrncatExit2): |
689 | movb %bh, 2(%eax) |
690 | # endif |
691 | L(Exit2): |
692 | movw (%esi), %dx |
693 | movw %dx, (%eax) |
694 | mov STR3(%esp), %eax |
695 | RETURN |
696 | |
697 | .p2align 4 |
698 | # ifdef USE_AS_STRNCAT |
699 | L(StrncatExit3): |
700 | movb %bh, 3(%eax) |
701 | # endif |
702 | L(Exit3): |
703 | movw (%esi), %cx |
704 | movw %cx, (%eax) |
705 | # ifdef USE_AS_STRNCAT |
706 | movb 2(%esi), %dh |
707 | # endif |
708 | movb %dh, 2(%eax) |
709 | mov STR3(%esp), %eax |
710 | RETURN |
711 | |
712 | .p2align 4 |
713 | # ifdef USE_AS_STRNCAT |
714 | L(StrncatExit4): |
715 | movb %bh, 4(%eax) |
716 | # endif |
717 | L(Exit4): |
718 | movl (%esi), %edx |
719 | movl %edx, (%eax) |
720 | mov STR3(%esp), %eax |
721 | RETURN |
722 | |
723 | .p2align 4 |
724 | # ifdef USE_AS_STRNCAT |
725 | L(StrncatExit5): |
726 | movb %bh, 5(%eax) |
727 | # endif |
728 | L(Exit5): |
729 | movl (%esi), %ecx |
730 | # ifdef USE_AS_STRNCAT |
731 | movb 4(%esi), %dh |
732 | # endif |
733 | movb %dh, 4(%eax) |
734 | movl %ecx, (%eax) |
735 | mov STR3(%esp), %eax |
736 | RETURN |
737 | |
738 | .p2align 4 |
739 | # ifdef USE_AS_STRNCAT |
740 | L(StrncatExit6): |
741 | movb %bh, 6(%eax) |
742 | # endif |
743 | L(Exit6): |
744 | movl (%esi), %ecx |
745 | movw 4(%esi), %dx |
746 | movl %ecx, (%eax) |
747 | movw %dx, 4(%eax) |
748 | mov STR3(%esp), %eax |
749 | RETURN |
750 | |
751 | .p2align 4 |
752 | # ifdef USE_AS_STRNCAT |
753 | L(StrncatExit7): |
754 | movb %bh, 7(%eax) |
755 | # endif |
756 | L(Exit7): |
757 | movl (%esi), %ecx |
758 | movl 3(%esi), %edx |
759 | movl %ecx, (%eax) |
760 | movl %edx, 3(%eax) |
761 | mov STR3(%esp), %eax |
762 | RETURN |
763 | |
764 | .p2align 4 |
765 | # ifdef USE_AS_STRNCAT |
766 | L(StrncatExit8): |
767 | movb %bh, 8(%eax) |
768 | # endif |
769 | L(Exit8): |
770 | movlpd (%esi), %xmm0 |
771 | movlpd %xmm0, (%eax) |
772 | mov STR3(%esp), %eax |
773 | RETURN |
774 | |
775 | .p2align 4 |
776 | # ifdef USE_AS_STRNCAT |
777 | L(StrncatExit9): |
778 | movb %bh, 9(%eax) |
779 | # endif |
780 | L(Exit9): |
781 | movlpd (%esi), %xmm0 |
782 | # ifdef USE_AS_STRNCAT |
783 | movb 8(%esi), %dh |
784 | # endif |
785 | movb %dh, 8(%eax) |
786 | movlpd %xmm0, (%eax) |
787 | mov STR3(%esp), %eax |
788 | RETURN |
789 | |
790 | .p2align 4 |
791 | # ifdef USE_AS_STRNCAT |
792 | L(StrncatExit10): |
793 | movb %bh, 10(%eax) |
794 | # endif |
795 | L(Exit10): |
796 | movlpd (%esi), %xmm0 |
797 | movw 8(%esi), %dx |
798 | movlpd %xmm0, (%eax) |
799 | movw %dx, 8(%eax) |
800 | mov STR3(%esp), %eax |
801 | RETURN |
802 | |
803 | .p2align 4 |
804 | # ifdef USE_AS_STRNCAT |
805 | L(StrncatExit11): |
806 | movb %bh, 11(%eax) |
807 | # endif |
808 | L(Exit11): |
809 | movlpd (%esi), %xmm0 |
810 | movl 7(%esi), %edx |
811 | movlpd %xmm0, (%eax) |
812 | movl %edx, 7(%eax) |
813 | mov STR3(%esp), %eax |
814 | RETURN |
815 | |
816 | .p2align 4 |
817 | # ifdef USE_AS_STRNCAT |
818 | L(StrncatExit12): |
819 | movb %bh, 12(%eax) |
820 | # endif |
821 | L(Exit12): |
822 | movlpd (%esi), %xmm0 |
823 | movl 8(%esi), %edx |
824 | movlpd %xmm0, (%eax) |
825 | movl %edx, 8(%eax) |
826 | mov STR3(%esp), %eax |
827 | RETURN |
828 | |
829 | .p2align 4 |
830 | # ifdef USE_AS_STRNCAT |
831 | L(StrncatExit13): |
832 | movb %bh, 13(%eax) |
833 | # endif |
834 | L(Exit13): |
835 | movlpd (%esi), %xmm0 |
836 | movlpd 5(%esi), %xmm1 |
837 | movlpd %xmm0, (%eax) |
838 | movlpd %xmm1, 5(%eax) |
839 | mov STR3(%esp), %eax |
840 | RETURN |
841 | |
842 | .p2align 4 |
843 | # ifdef USE_AS_STRNCAT |
844 | L(StrncatExit14): |
845 | movb %bh, 14(%eax) |
846 | # endif |
847 | L(Exit14): |
848 | movlpd (%esi), %xmm0 |
849 | movlpd 6(%esi), %xmm1 |
850 | movlpd %xmm0, (%eax) |
851 | movlpd %xmm1, 6(%eax) |
852 | mov STR3(%esp), %eax |
853 | RETURN |
854 | |
855 | .p2align 4 |
856 | # ifdef USE_AS_STRNCAT |
857 | L(StrncatExit15): |
858 | movb %bh, 15(%eax) |
859 | # endif |
860 | L(Exit15): |
861 | movlpd (%esi), %xmm0 |
862 | movlpd 7(%esi), %xmm1 |
863 | movlpd %xmm0, (%eax) |
864 | movlpd %xmm1, 7(%eax) |
865 | mov STR3(%esp), %eax |
866 | RETURN |
867 | |
868 | .p2align 4 |
869 | # ifdef USE_AS_STRNCAT |
870 | L(StrncatExit16): |
871 | movb %bh, 16(%eax) |
872 | # endif |
873 | L(Exit16): |
874 | movdqu (%esi), %xmm0 |
875 | movdqu %xmm0, (%eax) |
876 | mov STR3(%esp), %eax |
877 | RETURN |
878 | |
879 | .p2align 4 |
880 | # ifdef USE_AS_STRNCAT |
881 | L(StrncatExit17): |
882 | movb %bh, 17(%eax) |
883 | # endif |
884 | L(Exit17): |
885 | movdqu (%esi), %xmm0 |
886 | # ifdef USE_AS_STRNCAT |
887 | movb 16(%esi), %dh |
888 | # endif |
889 | movdqu %xmm0, (%eax) |
890 | movb %dh, 16(%eax) |
891 | mov STR3(%esp), %eax |
892 | RETURN |
893 | |
894 | .p2align 4 |
895 | # ifdef USE_AS_STRNCAT |
896 | L(StrncatExit18): |
897 | movb %bh, 18(%eax) |
898 | # endif |
899 | L(Exit18): |
900 | movdqu (%esi), %xmm0 |
901 | movw 16(%esi), %cx |
902 | movdqu %xmm0, (%eax) |
903 | movw %cx, 16(%eax) |
904 | mov STR3(%esp), %eax |
905 | RETURN |
906 | |
907 | .p2align 4 |
908 | # ifdef USE_AS_STRNCAT |
909 | L(StrncatExit19): |
910 | movb %bh, 19(%eax) |
911 | # endif |
912 | L(Exit19): |
913 | movdqu (%esi), %xmm0 |
914 | movl 15(%esi), %ecx |
915 | movdqu %xmm0, (%eax) |
916 | movl %ecx, 15(%eax) |
917 | mov STR3(%esp), %eax |
918 | RETURN |
919 | |
920 | .p2align 4 |
921 | # ifdef USE_AS_STRNCAT |
922 | L(StrncatExit20): |
923 | movb %bh, 20(%eax) |
924 | # endif |
925 | L(Exit20): |
926 | movdqu (%esi), %xmm0 |
927 | movl 16(%esi), %ecx |
928 | movdqu %xmm0, (%eax) |
929 | movl %ecx, 16(%eax) |
930 | mov STR3(%esp), %eax |
931 | RETURN |
932 | |
933 | .p2align 4 |
934 | # ifdef USE_AS_STRNCAT |
935 | L(StrncatExit21): |
936 | movb %bh, 21(%eax) |
937 | # endif |
938 | L(Exit21): |
939 | movdqu (%esi), %xmm0 |
940 | movl 16(%esi), %ecx |
941 | # ifdef USE_AS_STRNCAT |
942 | movb 20(%esi), %dh |
943 | # endif |
944 | movdqu %xmm0, (%eax) |
945 | movl %ecx, 16(%eax) |
946 | movb %dh, 20(%eax) |
947 | mov STR3(%esp), %eax |
948 | RETURN |
949 | |
950 | .p2align 4 |
951 | # ifdef USE_AS_STRNCAT |
952 | L(StrncatExit22): |
953 | movb %bh, 22(%eax) |
954 | # endif |
955 | L(Exit22): |
956 | movdqu (%esi), %xmm0 |
957 | movlpd 14(%esi), %xmm3 |
958 | movdqu %xmm0, (%eax) |
959 | movlpd %xmm3, 14(%eax) |
960 | mov STR3(%esp), %eax |
961 | RETURN |
962 | |
963 | .p2align 4 |
964 | # ifdef USE_AS_STRNCAT |
965 | L(StrncatExit23): |
966 | movb %bh, 23(%eax) |
967 | # endif |
968 | L(Exit23): |
969 | movdqu (%esi), %xmm0 |
970 | movlpd 15(%esi), %xmm3 |
971 | movdqu %xmm0, (%eax) |
972 | movlpd %xmm3, 15(%eax) |
973 | mov STR3(%esp), %eax |
974 | RETURN |
975 | |
976 | .p2align 4 |
977 | # ifdef USE_AS_STRNCAT |
978 | L(StrncatExit24): |
979 | movb %bh, 24(%eax) |
980 | # endif |
981 | L(Exit24): |
982 | movdqu (%esi), %xmm0 |
983 | movlpd 16(%esi), %xmm2 |
984 | movdqu %xmm0, (%eax) |
985 | movlpd %xmm2, 16(%eax) |
986 | mov STR3(%esp), %eax |
987 | RETURN |
988 | |
989 | .p2align 4 |
990 | # ifdef USE_AS_STRNCAT |
991 | L(StrncatExit25): |
992 | movb %bh, 25(%eax) |
993 | # endif |
994 | L(Exit25): |
995 | movdqu (%esi), %xmm0 |
996 | movlpd 16(%esi), %xmm2 |
997 | # ifdef USE_AS_STRNCAT |
998 | movb 24(%esi), %dh |
999 | # endif |
1000 | movdqu %xmm0, (%eax) |
1001 | movlpd %xmm2, 16(%eax) |
1002 | movb %dh, 24(%eax) |
1003 | mov STR3(%esp), %eax |
1004 | RETURN |
1005 | |
1006 | .p2align 4 |
1007 | # ifdef USE_AS_STRNCAT |
1008 | L(StrncatExit26): |
1009 | movb %bh, 26(%eax) |
1010 | # endif |
1011 | L(Exit26): |
1012 | movdqu (%esi), %xmm0 |
1013 | movlpd 16(%esi), %xmm2 |
1014 | movw 24(%esi), %cx |
1015 | movdqu %xmm0, (%eax) |
1016 | movlpd %xmm2, 16(%eax) |
1017 | movw %cx, 24(%eax) |
1018 | mov STR3(%esp), %eax |
1019 | RETURN |
1020 | |
1021 | .p2align 4 |
1022 | # ifdef USE_AS_STRNCAT |
1023 | L(StrncatExit27): |
1024 | movb %bh, 27(%eax) |
1025 | # endif |
1026 | L(Exit27): |
1027 | movdqu (%esi), %xmm0 |
1028 | movlpd 16(%esi), %xmm2 |
1029 | movl 23(%esi), %ecx |
1030 | movdqu %xmm0, (%eax) |
1031 | movlpd %xmm2, 16(%eax) |
1032 | movl %ecx, 23(%eax) |
1033 | mov STR3(%esp), %eax |
1034 | RETURN |
1035 | |
1036 | .p2align 4 |
1037 | # ifdef USE_AS_STRNCAT |
1038 | L(StrncatExit28): |
1039 | movb %bh, 28(%eax) |
1040 | # endif |
1041 | L(Exit28): |
1042 | movdqu (%esi), %xmm0 |
1043 | movlpd 16(%esi), %xmm2 |
1044 | movl 24(%esi), %ecx |
1045 | movdqu %xmm0, (%eax) |
1046 | movlpd %xmm2, 16(%eax) |
1047 | movl %ecx, 24(%eax) |
1048 | mov STR3(%esp), %eax |
1049 | RETURN |
1050 | |
1051 | .p2align 4 |
1052 | # ifdef USE_AS_STRNCAT |
1053 | L(StrncatExit29): |
1054 | movb %bh, 29(%eax) |
1055 | # endif |
1056 | L(Exit29): |
1057 | movdqu (%esi), %xmm0 |
1058 | movdqu 13(%esi), %xmm2 |
1059 | movdqu %xmm0, (%eax) |
1060 | movdqu %xmm2, 13(%eax) |
1061 | mov STR3(%esp), %eax |
1062 | RETURN |
1063 | |
1064 | .p2align 4 |
1065 | # ifdef USE_AS_STRNCAT |
1066 | L(StrncatExit30): |
1067 | movb %bh, 30(%eax) |
1068 | # endif |
1069 | L(Exit30): |
1070 | movdqu (%esi), %xmm0 |
1071 | movdqu 14(%esi), %xmm2 |
1072 | movdqu %xmm0, (%eax) |
1073 | movdqu %xmm2, 14(%eax) |
1074 | mov STR3(%esp), %eax |
1075 | RETURN |
1076 | |
1077 | .p2align 4 |
1078 | # ifdef USE_AS_STRNCAT |
1079 | L(StrncatExit31): |
1080 | movb %bh, 31(%eax) |
1081 | # endif |
1082 | L(Exit31): |
1083 | movdqu (%esi), %xmm0 |
1084 | movdqu 15(%esi), %xmm2 |
1085 | movdqu %xmm0, (%eax) |
1086 | movdqu %xmm2, 15(%eax) |
1087 | mov STR3(%esp), %eax |
1088 | RETURN |
1089 | |
1090 | .p2align 4 |
1091 | # ifdef USE_AS_STRNCAT |
1092 | L(StrncatExit32): |
1093 | movb %bh, 32(%eax) |
1094 | # endif |
1095 | L(Exit32): |
1096 | movdqu (%esi), %xmm0 |
1097 | movdqu 16(%esi), %xmm2 |
1098 | movdqu %xmm0, (%eax) |
1099 | movdqu %xmm2, 16(%eax) |
1100 | mov STR3(%esp), %eax |
1101 | RETURN |
1102 | |
1103 | # ifdef USE_AS_STRNCAT |
1104 | |
1105 | .p2align 4 |
1106 | L(UnalignedLeaveCase2OrCase3): |
1107 | test %edx, %edx |
1108 | jnz L(Unaligned64LeaveCase2) |
1109 | L(Unaligned64LeaveCase3): |
1110 | lea 64(%ebx), %ecx |
1111 | and $-16, %ecx |
1112 | add $48, %ebx |
1113 | jl L(CopyFrom1To16BytesCase3) |
1114 | movdqu %xmm4, (%eax) |
1115 | sub $16, %ebx |
1116 | jb L(CopyFrom1To16BytesCase3) |
1117 | movdqu %xmm5, 16(%eax) |
1118 | sub $16, %ebx |
1119 | jb L(CopyFrom1To16BytesCase3) |
1120 | movdqu %xmm6, 32(%eax) |
1121 | sub $16, %ebx |
1122 | jb L(CopyFrom1To16BytesCase3) |
1123 | movdqu %xmm7, 48(%eax) |
1124 | xor %bh, %bh |
1125 | movb %bh, 64(%eax) |
1126 | mov STR3(%esp), %eax |
1127 | RETURN |
1128 | |
1129 | .p2align 4 |
1130 | L(Unaligned64LeaveCase2): |
1131 | xor %ecx, %ecx |
1132 | pcmpeqb %xmm4, %xmm0 |
1133 | pmovmskb %xmm0, %edx |
1134 | add $48, %ebx |
1135 | jle L(CopyFrom1To16BytesCase2OrCase3) |
1136 | test %edx, %edx |
1137 | jnz L(CopyFrom1To16Bytes) |
1138 | |
1139 | pcmpeqb %xmm5, %xmm0 |
1140 | pmovmskb %xmm0, %edx |
1141 | movdqu %xmm4, (%eax) |
1142 | add $16, %ecx |
1143 | sub $16, %ebx |
1144 | jbe L(CopyFrom1To16BytesCase2OrCase3) |
1145 | test %edx, %edx |
1146 | jnz L(CopyFrom1To16Bytes) |
1147 | |
1148 | pcmpeqb %xmm6, %xmm0 |
1149 | pmovmskb %xmm0, %edx |
1150 | movdqu %xmm5, 16(%eax) |
1151 | add $16, %ecx |
1152 | sub $16, %ebx |
1153 | jbe L(CopyFrom1To16BytesCase2OrCase3) |
1154 | test %edx, %edx |
1155 | jnz L(CopyFrom1To16Bytes) |
1156 | |
1157 | pcmpeqb %xmm7, %xmm0 |
1158 | pmovmskb %xmm0, %edx |
1159 | movdqu %xmm6, 32(%eax) |
1160 | lea 16(%eax, %ecx), %eax |
1161 | lea 16(%esi, %ecx), %esi |
1162 | bsf %edx, %edx |
1163 | cmp %ebx, %edx |
1164 | jb L(CopyFrom1To16BytesExit) |
1165 | BRANCH_TO_JMPTBL_ENTRY (L(ExitStrncatTable), %ebx, 4) |
1166 | # endif |
1167 | .p2align 4 |
1168 | L(ExitZero): |
1169 | RETURN |
1170 | |
1171 | END (STRCAT) |
1172 | |
1173 | .p2align 4 |
1174 | .section .rodata |
1175 | L(ExitTable): |
1176 | .int JMPTBL(L(Exit1), L(ExitTable)) |
1177 | .int JMPTBL(L(Exit2), L(ExitTable)) |
1178 | .int JMPTBL(L(Exit3), L(ExitTable)) |
1179 | .int JMPTBL(L(Exit4), L(ExitTable)) |
1180 | .int JMPTBL(L(Exit5), L(ExitTable)) |
1181 | .int JMPTBL(L(Exit6), L(ExitTable)) |
1182 | .int JMPTBL(L(Exit7), L(ExitTable)) |
1183 | .int JMPTBL(L(Exit8), L(ExitTable)) |
1184 | .int JMPTBL(L(Exit9), L(ExitTable)) |
1185 | .int JMPTBL(L(Exit10), L(ExitTable)) |
1186 | .int JMPTBL(L(Exit11), L(ExitTable)) |
1187 | .int JMPTBL(L(Exit12), L(ExitTable)) |
1188 | .int JMPTBL(L(Exit13), L(ExitTable)) |
1189 | .int JMPTBL(L(Exit14), L(ExitTable)) |
1190 | .int JMPTBL(L(Exit15), L(ExitTable)) |
1191 | .int JMPTBL(L(Exit16), L(ExitTable)) |
1192 | .int JMPTBL(L(Exit17), L(ExitTable)) |
1193 | .int JMPTBL(L(Exit18), L(ExitTable)) |
1194 | .int JMPTBL(L(Exit19), L(ExitTable)) |
1195 | .int JMPTBL(L(Exit20), L(ExitTable)) |
1196 | .int JMPTBL(L(Exit21), L(ExitTable)) |
1197 | .int JMPTBL(L(Exit22), L(ExitTable)) |
1198 | .int JMPTBL(L(Exit23), L(ExitTable)) |
1199 | .int JMPTBL(L(Exit24), L(ExitTable)) |
1200 | .int JMPTBL(L(Exit25), L(ExitTable)) |
1201 | .int JMPTBL(L(Exit26), L(ExitTable)) |
1202 | .int JMPTBL(L(Exit27), L(ExitTable)) |
1203 | .int JMPTBL(L(Exit28), L(ExitTable)) |
1204 | .int JMPTBL(L(Exit29), L(ExitTable)) |
1205 | .int JMPTBL(L(Exit30), L(ExitTable)) |
1206 | .int JMPTBL(L(Exit31), L(ExitTable)) |
1207 | .int JMPTBL(L(Exit32), L(ExitTable)) |
1208 | # ifdef USE_AS_STRNCAT |
1209 | L(ExitStrncatTable): |
1210 | .int JMPTBL(L(StrncatExit0), L(ExitStrncatTable)) |
1211 | .int JMPTBL(L(StrncatExit1), L(ExitStrncatTable)) |
1212 | .int JMPTBL(L(StrncatExit2), L(ExitStrncatTable)) |
1213 | .int JMPTBL(L(StrncatExit3), L(ExitStrncatTable)) |
1214 | .int JMPTBL(L(StrncatExit4), L(ExitStrncatTable)) |
1215 | .int JMPTBL(L(StrncatExit5), L(ExitStrncatTable)) |
1216 | .int JMPTBL(L(StrncatExit6), L(ExitStrncatTable)) |
1217 | .int JMPTBL(L(StrncatExit7), L(ExitStrncatTable)) |
1218 | .int JMPTBL(L(StrncatExit8), L(ExitStrncatTable)) |
1219 | .int JMPTBL(L(StrncatExit9), L(ExitStrncatTable)) |
1220 | .int JMPTBL(L(StrncatExit10), L(ExitStrncatTable)) |
1221 | .int JMPTBL(L(StrncatExit11), L(ExitStrncatTable)) |
1222 | .int JMPTBL(L(StrncatExit12), L(ExitStrncatTable)) |
1223 | .int JMPTBL(L(StrncatExit13), L(ExitStrncatTable)) |
1224 | .int JMPTBL(L(StrncatExit14), L(ExitStrncatTable)) |
1225 | .int JMPTBL(L(StrncatExit15), L(ExitStrncatTable)) |
1226 | .int JMPTBL(L(StrncatExit16), L(ExitStrncatTable)) |
1227 | .int JMPTBL(L(StrncatExit17), L(ExitStrncatTable)) |
1228 | .int JMPTBL(L(StrncatExit18), L(ExitStrncatTable)) |
1229 | .int JMPTBL(L(StrncatExit19), L(ExitStrncatTable)) |
1230 | .int JMPTBL(L(StrncatExit20), L(ExitStrncatTable)) |
1231 | .int JMPTBL(L(StrncatExit21), L(ExitStrncatTable)) |
1232 | .int JMPTBL(L(StrncatExit22), L(ExitStrncatTable)) |
1233 | .int JMPTBL(L(StrncatExit23), L(ExitStrncatTable)) |
1234 | .int JMPTBL(L(StrncatExit24), L(ExitStrncatTable)) |
1235 | .int JMPTBL(L(StrncatExit25), L(ExitStrncatTable)) |
1236 | .int JMPTBL(L(StrncatExit26), L(ExitStrncatTable)) |
1237 | .int JMPTBL(L(StrncatExit27), L(ExitStrncatTable)) |
1238 | .int JMPTBL(L(StrncatExit28), L(ExitStrncatTable)) |
1239 | .int JMPTBL(L(StrncatExit29), L(ExitStrncatTable)) |
1240 | .int JMPTBL(L(StrncatExit30), L(ExitStrncatTable)) |
1241 | .int JMPTBL(L(StrncatExit31), L(ExitStrncatTable)) |
1242 | .int JMPTBL(L(StrncatExit32), L(ExitStrncatTable)) |
1243 | # endif |
1244 | #endif |
1245 | |