~ubuntu-branches/ubuntu/precise/eglibc/precise-201308281639

« back to all changes in this revision

Viewing changes to sysdeps/i386/i686/multiarch/wcscmp-sse2.S

  • Committer: Package Import Robot
  • Author(s): Matthias Klose
  • Date: 2012-02-08 01:58:09 UTC
  • mfrom: (1.5.3) (288.1.12 precise)
  • Revision ID: package-import@ubuntu.com-20120208015809-ulscst7uteq3e22z
Tags: 2.15~pre6-0ubuntu10
Merge from Debian (r5151, 2.13-26).

Show diffs side-by-side

added added

removed removed

Lines of Context:
 
1
/* wcscmp with SSE2
 
2
   Copyright (C) 2011 Free Software Foundation, Inc.
 
3
   Contributed by Intel Corporation.
 
4
   This file is part of the GNU C Library.
 
5
 
 
6
   The GNU C Library is free software; you can redistribute it and/or
 
7
   modify it under the terms of the GNU Lesser General Public
 
8
   License as published by the Free Software Foundation; either
 
9
   version 2.1 of the License, or (at your option) any later version.
 
10
 
 
11
   The GNU C Library is distributed in the hope that it will be useful,
 
12
   but WITHOUT ANY WARRANTY; without even the implied warranty of
 
13
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 
14
   Lesser General Public License for more details.
 
15
 
 
16
   You should have received a copy of the GNU Lesser General Public
 
17
   License along with the GNU C Library; if not, write to the Free
 
18
   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
 
19
   02111-1307 USA.  */
 
20
 
 
21
#ifndef NOT_IN_libc
 
22
 
 
23
# include <sysdep.h>
 
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
# define ENTRANCE PUSH(%esi); PUSH(%edi)
 
37
# define RETURN  POP(%edi); POP(%esi); ret; CFI_PUSH(%esi); CFI_PUSH(%edi);
 
38
# define PARMS  4
 
39
# define STR1  PARMS
 
40
# define STR2  STR1+4
 
41
 
 
42
/* Note: wcscmp uses signed comparison, not unsugned as in strcmp function. */
 
43
 
 
44
        .text
 
45
ENTRY (__wcscmp_sse2)
 
46
/*
 
47
        * This implementation uses SSE to compare up to 16 bytes at a time.
 
48
*/
 
49
        mov     STR1(%esp), %edx
 
50
        mov     STR2(%esp), %eax
 
51
 
 
52
        mov     (%eax), %ecx
 
53
        cmp     %ecx, (%edx)
 
54
        jne     L(neq)
 
55
        test    %ecx, %ecx
 
56
        jz      L(eq)
 
57
 
 
58
        mov     4(%eax), %ecx
 
59
        cmp     %ecx, 4(%edx)
 
60
        jne     L(neq)
 
61
        test    %ecx, %ecx
 
62
        jz      L(eq)
 
63
 
 
64
        mov     8(%eax), %ecx
 
65
        cmp     %ecx, 8(%edx)
 
66
        jne     L(neq)
 
67
        test    %ecx, %ecx
 
68
        jz      L(eq)
 
69
 
 
70
        mov     12(%eax), %ecx
 
71
        cmp     %ecx, 12(%edx)
 
72
        jne     L(neq)
 
73
        test    %ecx, %ecx
 
74
        jz      L(eq)
 
75
 
 
76
        ENTRANCE
 
77
        add     $16, %eax
 
78
        add     $16, %edx
 
79
 
 
80
        mov     %eax, %esi
 
81
        mov     %edx, %edi
 
82
        pxor    %xmm0, %xmm0            /* clear %xmm0 for null char checks */
 
83
        mov     %al, %ch
 
84
        mov     %dl, %cl
 
85
        and     $63, %eax               /* esi alignment in cache line */
 
86
        and     $63, %edx               /* edi alignment in cache line */
 
87
        and     $15, %cl
 
88
        jz      L(continue_00)
 
89
        cmp     $16, %edx
 
90
        jb      L(continue_0)
 
91
        cmp     $32, %edx
 
92
        jb      L(continue_16)
 
93
        cmp     $48, %edx
 
94
        jb      L(continue_32)
 
95
 
 
96
L(continue_48):
 
97
        and     $15, %ch
 
98
        jz      L(continue_48_00)
 
99
        cmp     $16, %eax
 
100
        jb      L(continue_0_48)
 
101
        cmp     $32, %eax
 
102
        jb      L(continue_16_48)
 
103
        cmp     $48, %eax
 
104
        jb      L(continue_32_48)
 
105
 
 
106
        .p2align 4
 
107
L(continue_48_48):
 
108
        mov     (%esi), %ecx
 
109
        cmp     %ecx, (%edi)
 
110
        jne     L(nequal)
 
111
        test    %ecx, %ecx
 
112
        jz      L(equal)
 
113
 
 
114
        mov     4(%esi), %ecx
 
115
        cmp     %ecx, 4(%edi)
 
116
        jne     L(nequal)
 
117
        test    %ecx, %ecx
 
118
        jz      L(equal)
 
119
 
 
120
        mov     8(%esi), %ecx
 
121
        cmp     %ecx, 8(%edi)
 
122
        jne     L(nequal)
 
123
        test    %ecx, %ecx
 
124
        jz      L(equal)
 
125
 
 
126
        mov     12(%esi), %ecx
 
127
        cmp     %ecx, 12(%edi)
 
128
        jne     L(nequal)
 
129
        test    %ecx, %ecx
 
130
        jz      L(equal)
 
131
 
 
132
        movdqu  16(%edi), %xmm1
 
133
        movdqu  16(%esi), %xmm2
 
134
        pcmpeqd %xmm1, %xmm0            /* Any null double_word? */
 
135
        pcmpeqd %xmm2, %xmm1            /* compare first 4 double_words for equality */
 
136
        psubb   %xmm0, %xmm1            /* packed sub of comparison results*/
 
137
        pmovmskb %xmm1, %edx
 
138
        sub     $0xffff, %edx           /* if first 4 double_words are same, edx == 0xffff */
 
139
        jnz     L(less4_double_words_16)
 
140
 
 
141
        movdqu  32(%edi), %xmm1
 
142
        movdqu  32(%esi), %xmm2
 
143
        pcmpeqd %xmm1, %xmm0            /* Any null double_word? */
 
144
        pcmpeqd %xmm2, %xmm1            /* compare first 4 double_words for equality */
 
145
        psubb   %xmm0, %xmm1            /* packed sub of comparison results*/
 
146
        pmovmskb %xmm1, %edx
 
147
        sub     $0xffff, %edx           /* if first 4 double_words are same, edx == 0xffff */
 
148
        jnz     L(less4_double_words_32)
 
149
 
 
150
        movdqu  48(%edi), %xmm1
 
151
        movdqu  48(%esi), %xmm2
 
152
        pcmpeqd %xmm1, %xmm0            /* Any null double_word? */
 
153
        pcmpeqd %xmm2, %xmm1            /* compare first 4 double_words for equality */
 
154
        psubb   %xmm0, %xmm1            /* packed sub of comparison results*/
 
155
        pmovmskb %xmm1, %edx
 
156
        sub     $0xffff, %edx           /* if first 4 double_words are same, edx == 0xffff */
 
157
        jnz     L(less4_double_words_48)
 
158
 
 
159
        add     $64, %esi
 
160
        add     $64, %edi
 
161
        jmp     L(continue_48_48)
 
162
 
 
163
L(continue_0):
 
164
        and     $15, %ch
 
165
        jz      L(continue_0_00)
 
166
        cmp     $16, %eax
 
167
        jb      L(continue_0_0)
 
168
        cmp     $32, %eax
 
169
        jb      L(continue_0_16)
 
170
        cmp     $48, %eax
 
171
        jb      L(continue_0_32)
 
172
 
 
173
        .p2align 4
 
174
L(continue_0_48):
 
175
        mov     (%esi), %ecx
 
176
        cmp     %ecx, (%edi)
 
177
        jne     L(nequal)
 
178
        test    %ecx, %ecx
 
179
        jz      L(equal)
 
180
 
 
181
        mov     4(%esi), %ecx
 
182
        cmp     %ecx, 4(%edi)
 
183
        jne     L(nequal)
 
184
        test    %ecx, %ecx
 
185
        jz      L(equal)
 
186
 
 
187
        mov     8(%esi), %ecx
 
188
        cmp     %ecx, 8(%edi)
 
189
        jne     L(nequal)
 
190
        test    %ecx, %ecx
 
191
        jz      L(equal)
 
192
 
 
193
        mov     12(%esi), %ecx
 
194
        cmp     %ecx, 12(%edi)
 
195
        jne     L(nequal)
 
196
        test    %ecx, %ecx
 
197
        jz      L(equal)
 
198
 
 
199
        movdqu  16(%edi), %xmm1
 
200
        movdqu  16(%esi), %xmm2
 
201
        pcmpeqd %xmm1, %xmm0            /* Any null double_word? */
 
202
        pcmpeqd %xmm2, %xmm1            /* compare first 4 double_words for equality */
 
203
        psubb   %xmm0, %xmm1            /* packed sub of comparison results*/
 
204
        pmovmskb %xmm1, %edx
 
205
        sub     $0xffff, %edx           /* if first 4 double_words are same, edx == 0xffff */
 
206
        jnz     L(less4_double_words_16)
 
207
 
 
208
        movdqu  32(%edi), %xmm1
 
209
        movdqu  32(%esi), %xmm2
 
210
        pcmpeqd %xmm1, %xmm0            /* Any null double_word? */
 
211
        pcmpeqd %xmm2, %xmm1            /* compare first 4 double_words for equality */
 
212
        psubb   %xmm0, %xmm1            /* packed sub of comparison results*/
 
213
        pmovmskb %xmm1, %edx
 
214
        sub     $0xffff, %edx           /* if first 4 double_words are same, edx == 0xffff */
 
215
        jnz     L(less4_double_words_32)
 
216
 
 
217
        mov     48(%esi), %ecx
 
218
        cmp     %ecx, 48(%edi)
 
219
        jne     L(nequal)
 
220
        test    %ecx, %ecx
 
221
        jz      L(equal)
 
222
 
 
223
        mov     52(%esi), %ecx
 
224
        cmp     %ecx, 52(%edi)
 
225
        jne     L(nequal)
 
226
        test    %ecx, %ecx
 
227
        jz      L(equal)
 
228
 
 
229
        mov     56(%esi), %ecx
 
230
        cmp     %ecx, 56(%edi)
 
231
        jne     L(nequal)
 
232
        test    %ecx, %ecx
 
233
        jz      L(equal)
 
234
 
 
235
        mov     60(%esi), %ecx
 
236
        cmp     %ecx, 60(%edi)
 
237
        jne     L(nequal)
 
238
        test    %ecx, %ecx
 
239
        jz      L(equal)
 
240
 
 
241
        add     $64, %esi
 
242
        add     $64, %edi
 
243
        jmp     L(continue_0_48)
 
244
 
 
245
        .p2align 4
 
246
L(continue_00):
 
247
        and     $15, %ch
 
248
        jz      L(continue_00_00)
 
249
        cmp     $16, %eax
 
250
        jb      L(continue_00_0)
 
251
        cmp     $32, %eax
 
252
        jb      L(continue_00_16)
 
253
        cmp     $48, %eax
 
254
        jb      L(continue_00_32)
 
255
 
 
256
        .p2align 4
 
257
L(continue_00_48):
 
258
        pcmpeqd (%edi), %xmm0
 
259
        mov     (%edi), %eax
 
260
        pmovmskb %xmm0, %ecx
 
261
        test    %ecx, %ecx
 
262
        jnz     L(less4_double_words1)
 
263
 
 
264
        cmp     (%esi), %eax
 
265
        jne     L(nequal)
 
266
 
 
267
        mov     4(%edi), %eax
 
268
        cmp     4(%esi), %eax
 
269
        jne     L(nequal)
 
270
 
 
271
        mov     8(%edi), %eax
 
272
        cmp     8(%esi), %eax
 
273
        jne     L(nequal)
 
274
 
 
275
        mov     12(%edi), %eax
 
276
        cmp     12(%esi), %eax
 
277
        jne     L(nequal)
 
278
 
 
279
        movdqu  16(%esi), %xmm2
 
280
        pcmpeqd %xmm2, %xmm0            /* Any null double_word? */
 
281
        pcmpeqd 16(%edi), %xmm2         /* compare first 4 double_words for equality */
 
282
        psubb   %xmm0, %xmm2            /* packed sub of comparison results*/
 
283
        pmovmskb %xmm2, %edx
 
284
        sub     $0xffff, %edx           /* if first 4 double_words are same, edx == 0xffff */
 
285
        jnz     L(less4_double_words_16)
 
286
 
 
287
        movdqu  32(%esi), %xmm2
 
288
        pcmpeqd %xmm2, %xmm0            /* Any null double_word? */
 
289
        pcmpeqd 32(%edi), %xmm2         /* compare first 4 double_words for equality */
 
290
        psubb   %xmm0, %xmm2            /* packed sub of comparison results*/
 
291
        pmovmskb %xmm2, %edx
 
292
        sub     $0xffff, %edx           /* if first 4 double_words are same, edx == 0xffff */
 
293
        jnz     L(less4_double_words_32)
 
294
 
 
295
        movdqu  48(%esi), %xmm2
 
296
        pcmpeqd %xmm2, %xmm0            /* Any null double_word? */
 
297
        pcmpeqd 48(%edi), %xmm2         /* compare first 4 double_words for equality */
 
298
        psubb   %xmm0, %xmm2            /* packed sub of comparison results*/
 
299
        pmovmskb %xmm2, %edx
 
300
        sub     $0xffff, %edx           /* if first 4 double_words are same, edx == 0xffff */
 
301
        jnz     L(less4_double_words_48)
 
302
 
 
303
        add     $64, %esi
 
304
        add     $64, %edi
 
305
        jmp     L(continue_00_48)
 
306
 
 
307
        .p2align 4
 
308
L(continue_32):
 
309
        and     $15, %ch
 
310
        jz      L(continue_32_00)
 
311
        cmp     $16, %eax
 
312
        jb      L(continue_0_32)
 
313
        cmp     $32, %eax
 
314
        jb      L(continue_16_32)
 
315
        cmp     $48, %eax
 
316
        jb      L(continue_32_32)
 
317
 
 
318
        .p2align 4
 
319
L(continue_32_48):
 
320
        mov     (%esi), %ecx
 
321
        cmp     %ecx, (%edi)
 
322
        jne     L(nequal)
 
323
        test    %ecx, %ecx
 
324
        jz      L(equal)
 
325
 
 
326
        mov     4(%esi), %ecx
 
327
        cmp     %ecx, 4(%edi)
 
328
        jne     L(nequal)
 
329
        test    %ecx, %ecx
 
330
        jz      L(equal)
 
331
 
 
332
        mov     8(%esi), %ecx
 
333
        cmp     %ecx, 8(%edi)
 
334
        jne     L(nequal)
 
335
        test    %ecx, %ecx
 
336
        jz      L(equal)
 
337
 
 
338
        mov     12(%esi), %ecx
 
339
        cmp     %ecx, 12(%edi)
 
340
        jne     L(nequal)
 
341
        test    %ecx, %ecx
 
342
        jz      L(equal)
 
343
 
 
344
        mov     16(%esi), %ecx
 
345
        cmp     %ecx, 16(%edi)
 
346
        jne     L(nequal)
 
347
        test    %ecx, %ecx
 
348
        jz      L(equal)
 
349
 
 
350
        mov     20(%esi), %ecx
 
351
        cmp     %ecx, 20(%edi)
 
352
        jne     L(nequal)
 
353
        test    %ecx, %ecx
 
354
        jz      L(equal)
 
355
 
 
356
        mov     24(%esi), %ecx
 
357
        cmp     %ecx, 24(%edi)
 
358
        jne     L(nequal)
 
359
        test    %ecx, %ecx
 
360
        jz      L(equal)
 
361
 
 
362
        mov     28(%esi), %ecx
 
363
        cmp     %ecx, 28(%edi)
 
364
        jne     L(nequal)
 
365
        test    %ecx, %ecx
 
366
        jz      L(equal)
 
367
 
 
368
        movdqu  32(%edi), %xmm1
 
369
        movdqu  32(%esi), %xmm2
 
370
        pcmpeqd %xmm1, %xmm0            /* Any null double_word? */
 
371
        pcmpeqd %xmm2, %xmm1            /* compare first 4 double_words for equality */
 
372
        psubb   %xmm0, %xmm1            /* packed sub of comparison results*/
 
373
        pmovmskb %xmm1, %edx
 
374
        sub     $0xffff, %edx           /* if first 4 double_words are same, edx == 0xffff */
 
375
        jnz     L(less4_double_words_32)
 
376
 
 
377
        movdqu  48(%edi), %xmm1
 
378
        movdqu  48(%esi), %xmm2
 
379
        pcmpeqd %xmm1, %xmm0            /* Any null double_word? */
 
380
        pcmpeqd %xmm2, %xmm1            /* compare first 4 double_words for equality */
 
381
        psubb   %xmm0, %xmm1            /* packed sub of comparison results */
 
382
        pmovmskb %xmm1, %edx
 
383
        sub     $0xffff, %edx           /* if first 4 double_words are same, edx == 0xffff */
 
384
        jnz     L(less4_double_words_48)
 
385
 
 
386
        add     $64, %esi
 
387
        add     $64, %edi
 
388
        jmp     L(continue_32_48)
 
389
 
 
390
        .p2align 4
 
391
L(continue_16):
 
392
        and     $15, %ch
 
393
        jz      L(continue_16_00)
 
394
        cmp     $16, %eax
 
395
        jb      L(continue_0_16)
 
396
        cmp     $32, %eax
 
397
        jb      L(continue_16_16)
 
398
        cmp     $48, %eax
 
399
        jb      L(continue_16_32)
 
400
 
 
401
        .p2align 4
 
402
L(continue_16_48):
 
403
        mov     (%esi), %ecx
 
404
        cmp     %ecx, (%edi)
 
405
        jne     L(nequal)
 
406
        test    %ecx, %ecx
 
407
        jz      L(equal)
 
408
 
 
409
        mov     4(%esi), %ecx
 
410
        cmp     %ecx, 4(%edi)
 
411
        jne     L(nequal)
 
412
        test    %ecx, %ecx
 
413
        jz      L(equal)
 
414
 
 
415
        mov     8(%esi), %ecx
 
416
        cmp     %ecx, 8(%edi)
 
417
        jne     L(nequal)
 
418
        test    %ecx, %ecx
 
419
        jz      L(equal)
 
420
 
 
421
        mov     12(%esi), %ecx
 
422
        cmp     %ecx, 12(%edi)
 
423
        jne     L(nequal)
 
424
        test    %ecx, %ecx
 
425
        jz      L(equal)
 
426
 
 
427
        movdqu  16(%edi), %xmm1
 
428
        movdqu  16(%esi), %xmm2
 
429
        pcmpeqd %xmm1, %xmm0            /* Any null double_word? */
 
430
        pcmpeqd %xmm2, %xmm1            /* compare first 4 double_words for equality */
 
431
        psubb   %xmm0, %xmm1            /* packed sub of comparison results*/
 
432
        pmovmskb %xmm1, %edx
 
433
        sub     $0xffff, %edx           /* if first 4 double_words are same, edx == 0xffff */
 
434
        jnz     L(less4_double_words_16)
 
435
 
 
436
        mov     32(%esi), %ecx
 
437
        cmp     %ecx, 32(%edi)
 
438
        jne     L(nequal)
 
439
        test    %ecx, %ecx
 
440
        jz      L(equal)
 
441
 
 
442
        mov     36(%esi), %ecx
 
443
        cmp     %ecx, 36(%edi)
 
444
        jne     L(nequal)
 
445
        test    %ecx, %ecx
 
446
        jz      L(equal)
 
447
 
 
448
        mov     40(%esi), %ecx
 
449
        cmp     %ecx, 40(%edi)
 
450
        jne     L(nequal)
 
451
        test    %ecx, %ecx
 
452
        jz      L(equal)
 
453
 
 
454
        mov     44(%esi), %ecx
 
455
        cmp     %ecx, 44(%edi)
 
456
        jne     L(nequal)
 
457
        test    %ecx, %ecx
 
458
        jz      L(equal)
 
459
 
 
460
        movdqu  48(%edi), %xmm1
 
461
        movdqu  48(%esi), %xmm2
 
462
        pcmpeqd %xmm1, %xmm0            /* Any null double_word? */
 
463
        pcmpeqd %xmm2, %xmm1            /* compare first 4 double_words for equality */
 
464
        psubb   %xmm0, %xmm1            /* packed sub of comparison results*/
 
465
        pmovmskb %xmm1, %edx
 
466
        sub     $0xffff, %edx           /* if first 4 double_words are same, edx == 0xffff */
 
467
        jnz     L(less4_double_words_48)
 
468
 
 
469
        add     $64, %esi
 
470
        add     $64, %edi
 
471
        jmp     L(continue_16_48)
 
472
 
 
473
        .p2align 4
 
474
L(continue_00_00):
 
475
        movdqa  (%edi), %xmm1
 
476
        pcmpeqd %xmm1, %xmm0            /* Any null double_word? */
 
477
        pcmpeqd (%esi), %xmm1           /* compare first 4 double_words for equality */
 
478
        psubb   %xmm0, %xmm1            /* packed sub of comparison results*/
 
479
        pmovmskb %xmm1, %edx
 
480
        sub     $0xffff, %edx           /* if first 4 double_words are same, edx == 0xffff */
 
481
        jnz     L(less4_double_words)
 
482
 
 
483
        movdqa  16(%edi), %xmm3
 
484
        pcmpeqd %xmm3, %xmm0            /* Any null double_word? */
 
485
        pcmpeqd 16(%esi), %xmm3         /* compare first 4 double_words for equality */
 
486
        psubb   %xmm0, %xmm3            /* packed sub of comparison results*/
 
487
        pmovmskb %xmm3, %edx
 
488
        sub     $0xffff, %edx           /* if first 4 double_words are same, edx == 0xffff */
 
489
        jnz     L(less4_double_words_16)
 
490
 
 
491
        movdqa  32(%edi), %xmm5
 
492
        pcmpeqd %xmm5, %xmm0            /* Any null double_word? */
 
493
        pcmpeqd 32(%esi), %xmm5         /* compare first 4 double_words for equality */
 
494
        psubb   %xmm0, %xmm5            /* packed sub of comparison results*/
 
495
        pmovmskb %xmm5, %edx
 
496
        sub     $0xffff, %edx           /* if first 4 double_words are same, edx == 0xffff */
 
497
        jnz     L(less4_double_words_32)
 
498
 
 
499
        movdqa  48(%edi), %xmm1
 
500
        pcmpeqd %xmm1, %xmm0            /* Any null double_word? */
 
501
        pcmpeqd 48(%esi), %xmm1         /* compare first 4 double_words for equality */
 
502
        psubb   %xmm0, %xmm1            /* packed sub of comparison results*/
 
503
        pmovmskb %xmm1, %edx
 
504
        sub     $0xffff, %edx           /* if first 4 double_words are same, edx == 0xffff */
 
505
        jnz     L(less4_double_words_48)
 
506
 
 
507
        add     $64, %esi
 
508
        add     $64, %edi
 
509
        jmp     L(continue_00_00)
 
510
 
 
511
        .p2align 4
 
512
L(continue_00_32):
 
513
        movdqu  (%esi), %xmm2
 
514
        pcmpeqd %xmm2, %xmm0            /* Any null double_word? */
 
515
        pcmpeqd (%edi), %xmm2           /* compare first 4 double_words for equality */
 
516
        psubb   %xmm0, %xmm2            /* packed sub of comparison results*/
 
517
        pmovmskb %xmm2, %edx
 
518
        sub     $0xffff, %edx           /* if first 4 double_words are same, edx == 0xffff */
 
519
        jnz     L(less4_double_words)
 
520
 
 
521
        add     $16, %esi
 
522
        add     $16, %edi
 
523
        jmp     L(continue_00_48)
 
524
 
 
525
        .p2align 4
 
526
L(continue_00_16):
 
527
        movdqu  (%esi), %xmm2
 
528
        pcmpeqd %xmm2, %xmm0            /* Any null double_word? */
 
529
        pcmpeqd (%edi), %xmm2           /* compare first 4 double_words for equality */
 
530
        psubb   %xmm0, %xmm2            /* packed sub of comparison results*/
 
531
        pmovmskb %xmm2, %edx
 
532
        sub     $0xffff, %edx           /* if first 4 double_words are same, edx == 0xffff */
 
533
        jnz     L(less4_double_words)
 
534
 
 
535
        movdqu  16(%esi), %xmm2
 
536
        pcmpeqd %xmm2, %xmm0            /* Any null double_word? */
 
537
        pcmpeqd 16(%edi), %xmm2         /* compare first 4 double_words for equality */
 
538
        psubb   %xmm0, %xmm2            /* packed sub of comparison results*/
 
539
        pmovmskb %xmm2, %edx
 
540
        sub     $0xffff, %edx           /* if first 4 double_words are same, edx == 0xffff */
 
541
        jnz     L(less4_double_words_16)
 
542
 
 
543
        add     $32, %esi
 
544
        add     $32, %edi
 
545
        jmp     L(continue_00_48)
 
546
 
 
547
        .p2align 4
 
548
L(continue_00_0):
 
549
        movdqu  (%esi), %xmm2
 
550
        pcmpeqd %xmm2, %xmm0            /* Any null double_word? */
 
551
        pcmpeqd (%edi), %xmm2           /* compare first 4 double_words for equality */
 
552
        psubb   %xmm0, %xmm2            /* packed sub of comparison results*/
 
553
        pmovmskb %xmm2, %edx
 
554
        sub     $0xffff, %edx           /* if first 4 double_words are same, edx == 0xffff */
 
555
        jnz     L(less4_double_words)
 
556
 
 
557
        movdqu  16(%esi), %xmm2
 
558
        pcmpeqd %xmm2, %xmm0            /* Any null double_word? */
 
559
        pcmpeqd 16(%edi), %xmm2         /* compare first 4 double_words for equality */
 
560
        psubb   %xmm0, %xmm2            /* packed sub of comparison results*/
 
561
        pmovmskb %xmm2, %edx
 
562
        sub     $0xffff, %edx           /* if first 4 double_words are same, edx == 0xffff */
 
563
        jnz     L(less4_double_words_16)
 
564
 
 
565
        movdqu  32(%esi), %xmm2
 
566
        pcmpeqd %xmm2, %xmm0            /* Any null double_word? */
 
567
        pcmpeqd 32(%edi), %xmm2         /* compare first 4 double_words for equality */
 
568
        psubb   %xmm0, %xmm2            /* packed sub of comparison results*/
 
569
        pmovmskb %xmm2, %edx
 
570
        sub     $0xffff, %edx           /* if first 4 double_words are same, edx == 0xffff */
 
571
        jnz     L(less4_double_words_32)
 
572
 
 
573
        add     $48, %esi
 
574
        add     $48, %edi
 
575
        jmp     L(continue_00_48)
 
576
 
 
577
        .p2align 4
 
578
L(continue_48_00):
 
579
        pcmpeqd (%esi), %xmm0
 
580
        mov     (%edi), %eax
 
581
        pmovmskb %xmm0, %ecx
 
582
        test    %ecx, %ecx
 
583
        jnz     L(less4_double_words1)
 
584
 
 
585
        cmp     (%esi), %eax
 
586
        jne     L(nequal)
 
587
 
 
588
        mov     4(%edi), %eax
 
589
        cmp     4(%esi), %eax
 
590
        jne     L(nequal)
 
591
 
 
592
        mov     8(%edi), %eax
 
593
        cmp     8(%esi), %eax
 
594
        jne     L(nequal)
 
595
 
 
596
        mov     12(%edi), %eax
 
597
        cmp     12(%esi), %eax
 
598
        jne     L(nequal)
 
599
 
 
600
        movdqu  16(%edi), %xmm1
 
601
        pcmpeqd %xmm1, %xmm0            /* Any null double_word? */
 
602
        pcmpeqd 16(%esi), %xmm1         /* compare first 4 double_words for equality */
 
603
        psubb   %xmm0, %xmm1            /* packed sub of comparison results*/
 
604
        pmovmskb %xmm1, %edx
 
605
        sub     $0xffff, %edx           /* if first 4 double_words are same, edx == 0xffff */
 
606
        jnz     L(less4_double_words_16)
 
607
 
 
608
        movdqu  32(%edi), %xmm1
 
609
        pcmpeqd %xmm1, %xmm0            /* Any null double_word? */
 
610
        pcmpeqd 32(%esi), %xmm1         /* compare first 4 double_words for equality */
 
611
        psubb   %xmm0, %xmm1            /* packed sub of comparison results*/
 
612
        pmovmskb %xmm1, %edx
 
613
        sub     $0xffff, %edx           /* if first 4 double_words are same, edx == 0xffff */
 
614
        jnz     L(less4_double_words_32)
 
615
 
 
616
        movdqu  48(%edi), %xmm1
 
617
        pcmpeqd %xmm1, %xmm0            /* Any null double_word? */
 
618
        pcmpeqd 48(%esi), %xmm1         /* compare first 4 double_words for equality */
 
619
        psubb   %xmm0, %xmm1            /* packed sub of comparison results*/
 
620
        pmovmskb %xmm1, %edx
 
621
        sub     $0xffff, %edx           /* if first 4 double_words are same, edx == 0xffff */
 
622
        jnz     L(less4_double_words_48)
 
623
 
 
624
        add     $64, %esi
 
625
        add     $64, %edi
 
626
        jmp     L(continue_48_00)
 
627
 
 
628
        .p2align 4
 
629
L(continue_32_00):
 
630
        movdqu  (%edi), %xmm1
 
631
        pcmpeqd %xmm1, %xmm0            /* Any null double_word? */
 
632
        pcmpeqd (%esi), %xmm1           /* compare first 4 double_words for equality */
 
633
        psubb   %xmm0, %xmm1            /* packed sub of comparison results*/
 
634
        pmovmskb %xmm1, %edx
 
635
        sub     $0xffff, %edx           /* if first 4 double_words are same, edx == 0xffff */
 
636
        jnz     L(less4_double_words)
 
637
 
 
638
        add     $16, %esi
 
639
        add     $16, %edi
 
640
        jmp     L(continue_48_00)
 
641
 
 
642
        .p2align 4
 
643
L(continue_16_00):
 
644
        movdqu  (%edi), %xmm1
 
645
        pcmpeqd %xmm1, %xmm0            /* Any null double_word? */
 
646
        pcmpeqd (%esi), %xmm1           /* compare first 4 double_words for equality */
 
647
        psubb   %xmm0, %xmm1            /* packed sub of comparison results*/
 
648
        pmovmskb %xmm1, %edx
 
649
        sub     $0xffff, %edx           /* if first 4 double_words are same, edx == 0xffff */
 
650
        jnz     L(less4_double_words)
 
651
 
 
652
        movdqu  16(%edi), %xmm1
 
653
        pcmpeqd %xmm1, %xmm0            /* Any null double_word? */
 
654
        pcmpeqd 16(%esi), %xmm1         /* compare first 4 double_words for equality */
 
655
        psubb   %xmm0, %xmm1            /* packed sub of comparison results*/
 
656
        pmovmskb %xmm1, %edx
 
657
        sub     $0xffff, %edx           /* if first 4 double_words are same, edx == 0xffff */
 
658
        jnz     L(less4_double_words_16)
 
659
 
 
660
        add     $32, %esi
 
661
        add     $32, %edi
 
662
        jmp     L(continue_48_00)
 
663
 
 
664
        .p2align 4
 
665
L(continue_0_00):
 
666
        movdqu  (%edi), %xmm1
 
667
        pcmpeqd %xmm1, %xmm0            /* Any null double_word? */
 
668
        pcmpeqd (%esi), %xmm1           /* compare first 4 double_words for equality */
 
669
        psubb   %xmm0, %xmm1            /* packed sub of comparison results*/
 
670
        pmovmskb %xmm1, %edx
 
671
        sub     $0xffff, %edx           /* if first 4 double_words are same, edx == 0xffff */
 
672
        jnz     L(less4_double_words)
 
673
 
 
674
        movdqu  16(%edi), %xmm1
 
675
        pcmpeqd %xmm1, %xmm0            /* Any null double_word? */
 
676
        pcmpeqd 16(%esi), %xmm1         /* compare first 4 double_words for equality */
 
677
        psubb   %xmm0, %xmm1            /* packed sub of comparison results*/
 
678
        pmovmskb %xmm1, %edx
 
679
        sub     $0xffff, %edx           /* if first 4 double_words are same, edx == 0xffff */
 
680
        jnz     L(less4_double_words_16)
 
681
 
 
682
        movdqu  32(%edi), %xmm1
 
683
        pcmpeqd %xmm1, %xmm0            /* Any null double_word? */
 
684
        pcmpeqd 32(%esi), %xmm1         /* compare first 4 double_words for equality */
 
685
        psubb   %xmm0, %xmm1            /* packed sub of comparison results*/
 
686
        pmovmskb %xmm1, %edx
 
687
        sub     $0xffff, %edx           /* if first 4 double_words are same, edx == 0xffff */
 
688
        jnz     L(less4_double_words_32)
 
689
 
 
690
        add     $48, %esi
 
691
        add     $48, %edi
 
692
        jmp     L(continue_48_00)
 
693
 
 
694
        .p2align 4
 
695
L(continue_32_32):
 
696
        movdqu  (%edi), %xmm1
 
697
        movdqu  (%esi), %xmm2
 
698
        pcmpeqd %xmm1, %xmm0            /* Any null double_word? */
 
699
        pcmpeqd %xmm2, %xmm1            /* compare first 4 double_words for equality */
 
700
        psubb   %xmm0, %xmm1            /* packed sub of comparison results*/
 
701
        pmovmskb %xmm1, %edx
 
702
        sub     $0xffff, %edx           /* if first 4 double_words are same, edx == 0xffff */
 
703
        jnz     L(less4_double_words)
 
704
 
 
705
        add     $16, %esi
 
706
        add     $16, %edi
 
707
        jmp     L(continue_48_48)
 
708
 
 
709
        .p2align 4
 
710
L(continue_16_16):
 
711
        movdqu  (%edi), %xmm1
 
712
        movdqu  (%esi), %xmm2
 
713
        pcmpeqd %xmm1, %xmm0            /* Any null double_word? */
 
714
        pcmpeqd %xmm2, %xmm1            /* compare first 4 double_words for equality */
 
715
        psubb   %xmm0, %xmm1            /* packed sub of comparison results*/
 
716
        pmovmskb %xmm1, %edx
 
717
        sub     $0xffff, %edx           /* if first 4 double_words are same, edx == 0xffff */
 
718
        jnz     L(less4_double_words)
 
719
 
 
720
        movdqu  16(%edi), %xmm3
 
721
        movdqu  16(%esi), %xmm4
 
722
        pcmpeqd %xmm3, %xmm0            /* Any null double_word? */
 
723
        pcmpeqd %xmm4, %xmm3            /* compare first 4 double_words for equality */
 
724
        psubb   %xmm0, %xmm3            /* packed sub of comparison results*/
 
725
        pmovmskb %xmm3, %edx
 
726
        sub     $0xffff, %edx           /* if first 4 double_words are same, edx == 0xffff */
 
727
        jnz     L(less4_double_words_16)
 
728
 
 
729
        add     $32, %esi
 
730
        add     $32, %edi
 
731
        jmp     L(continue_48_48)
 
732
 
 
733
        .p2align 4
 
734
L(continue_0_0):
 
735
        movdqu  (%edi), %xmm1
 
736
        movdqu  (%esi), %xmm2
 
737
        pcmpeqd %xmm1, %xmm0            /* Any null double_word? */
 
738
        pcmpeqd %xmm2, %xmm1            /* compare first 4 double_words for equality */
 
739
        psubb   %xmm0, %xmm1            /* packed sub of comparison results*/
 
740
        pmovmskb %xmm1, %edx
 
741
        sub     $0xffff, %edx           /* if first 4 double_words are same, edx == 0xffff */
 
742
        jnz     L(less4_double_words)
 
743
 
 
744
        movdqu  16(%edi), %xmm3
 
745
        movdqu  16(%esi), %xmm4
 
746
        pcmpeqd %xmm3, %xmm0            /* Any null double_word? */
 
747
        pcmpeqd %xmm4, %xmm3            /* compare first 4 double_words for equality */
 
748
        psubb   %xmm0, %xmm3            /* packed sub of comparison results*/
 
749
        pmovmskb %xmm3, %edx
 
750
        sub     $0xffff, %edx           /* if first 4 double_words are same, edx == 0xffff */
 
751
        jnz     L(less4_double_words_16)
 
752
 
 
753
        movdqu  32(%edi), %xmm1
 
754
        movdqu  32(%esi), %xmm2
 
755
        pcmpeqd %xmm1, %xmm0            /* Any null double_word? */
 
756
        pcmpeqd %xmm2, %xmm1            /* compare first 4 double_words for equality */
 
757
        psubb   %xmm0, %xmm1            /* packed sub of comparison results*/
 
758
        pmovmskb %xmm1, %edx
 
759
        sub     $0xffff, %edx           /* if first 4 double_words are same, edx == 0xffff */
 
760
        jnz     L(less4_double_words_32)
 
761
 
 
762
        add     $48, %esi
 
763
        add     $48, %edi
 
764
        jmp     L(continue_48_48)
 
765
 
 
766
        .p2align 4
 
767
L(continue_0_16):
 
768
        movdqu  (%edi), %xmm1
 
769
        movdqu  (%esi), %xmm2
 
770
        pcmpeqd %xmm1, %xmm0            /* Any null double_word? */
 
771
        pcmpeqd %xmm2, %xmm1            /* compare first 4 double_words for equality */
 
772
        psubb   %xmm0, %xmm1            /* packed sub of comparison results*/
 
773
        pmovmskb %xmm1, %edx
 
774
        sub     $0xffff, %edx           /* if first 4 double_words are same, edx == 0xffff */
 
775
        jnz     L(less4_double_words)
 
776
 
 
777
        movdqu  16(%edi), %xmm1
 
778
        movdqu  16(%esi), %xmm2
 
779
        pcmpeqd %xmm1, %xmm0            /* Any null double_word? */
 
780
        pcmpeqd %xmm2, %xmm1            /* compare first 4 double_words for equality */
 
781
        psubb   %xmm0, %xmm1            /* packed sub of comparison results*/
 
782
        pmovmskb %xmm1, %edx
 
783
        sub     $0xffff, %edx           /* if first 4 double_words are same, edx == 0xffff */
 
784
        jnz     L(less4_double_words_16)
 
785
 
 
786
        add     $32, %esi
 
787
        add     $32, %edi
 
788
        jmp     L(continue_32_48)
 
789
 
 
790
        .p2align 4
 
791
L(continue_0_32):
 
792
        movdqu  (%edi), %xmm1
 
793
        movdqu  (%esi), %xmm2
 
794
        pcmpeqd %xmm1, %xmm0            /* Any null double_word? */
 
795
        pcmpeqd %xmm2, %xmm1            /* compare first 4 double_words for equality */
 
796
        psubb   %xmm0, %xmm1            /* packed sub of comparison results*/
 
797
        pmovmskb %xmm1, %edx
 
798
        sub     $0xffff, %edx           /* if first 4 double_words are same, edx == 0xffff */
 
799
        jnz     L(less4_double_words)
 
800
 
 
801
        add     $16, %esi
 
802
        add     $16, %edi
 
803
        jmp     L(continue_16_48)
 
804
 
 
805
        .p2align 4
 
806
L(continue_16_32):
 
807
        movdqu  (%edi), %xmm1
 
808
        movdqu  (%esi), %xmm2
 
809
        pcmpeqd %xmm1, %xmm0            /* Any null double_word? */
 
810
        pcmpeqd %xmm2, %xmm1            /* compare first 4 double_words for equality */
 
811
        psubb   %xmm0, %xmm1            /* packed sub of comparison results*/
 
812
        pmovmskb %xmm1, %edx
 
813
        sub     $0xffff, %edx           /* if first 4 double_words are same, edx == 0xffff */
 
814
        jnz     L(less4_double_words)
 
815
 
 
816
        add     $16, %esi
 
817
        add     $16, %edi
 
818
        jmp     L(continue_32_48)
 
819
 
 
820
        .p2align 4
 
821
L(less4_double_words1):
 
822
        cmp     (%esi), %eax
 
823
        jne     L(nequal)
 
824
        test    %eax, %eax
 
825
        jz      L(equal)
 
826
 
 
827
        mov     4(%esi), %ecx
 
828
        cmp     %ecx, 4(%edi)
 
829
        jne     L(nequal)
 
830
        test    %ecx, %ecx
 
831
        jz      L(equal)
 
832
 
 
833
        mov     8(%esi), %ecx
 
834
        cmp     %ecx, 8(%edi)
 
835
        jne     L(nequal)
 
836
        test    %ecx, %ecx
 
837
        jz      L(equal)
 
838
 
 
839
        mov     12(%esi), %ecx
 
840
        cmp     %ecx, 12(%edi)
 
841
        jne     L(nequal)
 
842
        xor     %eax, %eax
 
843
        RETURN
 
844
 
 
845
        .p2align 4
 
846
L(less4_double_words):
 
847
        xor     %eax, %eax
 
848
        test    %dl, %dl
 
849
        jz      L(next_two_double_words)
 
850
        and     $15, %dl
 
851
        jz      L(second_double_word)
 
852
        mov     (%esi), %ecx
 
853
        cmp     %ecx, (%edi)
 
854
        jne     L(nequal)
 
855
        RETURN
 
856
 
 
857
        .p2align 4
 
858
L(second_double_word):
 
859
        mov     4(%esi), %ecx
 
860
        cmp     %ecx, 4(%edi)
 
861
        jne     L(nequal)
 
862
        RETURN
 
863
 
 
864
        .p2align 4
 
865
L(next_two_double_words):
 
866
        and     $15, %dh
 
867
        jz      L(fourth_double_word)
 
868
        mov     8(%esi), %ecx
 
869
        cmp     %ecx, 8(%edi)
 
870
        jne     L(nequal)
 
871
        RETURN
 
872
 
 
873
        .p2align 4
 
874
L(fourth_double_word):
 
875
        mov     12(%esi), %ecx
 
876
        cmp     %ecx, 12(%edi)
 
877
        jne     L(nequal)
 
878
        RETURN
 
879
 
 
880
        .p2align 4
 
881
L(less4_double_words_16):
 
882
        xor     %eax, %eax
 
883
        test    %dl, %dl
 
884
        jz      L(next_two_double_words_16)
 
885
        and     $15, %dl
 
886
        jz      L(second_double_word_16)
 
887
        mov     16(%esi), %ecx
 
888
        cmp     %ecx, 16(%edi)
 
889
        jne     L(nequal)
 
890
        RETURN
 
891
 
 
892
        .p2align 4
 
893
L(second_double_word_16):
 
894
        mov     20(%esi), %ecx
 
895
        cmp     %ecx, 20(%edi)
 
896
        jne     L(nequal)
 
897
        RETURN
 
898
 
 
899
        .p2align 4
 
900
L(next_two_double_words_16):
 
901
        and     $15, %dh
 
902
        jz      L(fourth_double_word_16)
 
903
        mov     24(%esi), %ecx
 
904
        cmp     %ecx, 24(%edi)
 
905
        jne     L(nequal)
 
906
        RETURN
 
907
 
 
908
        .p2align 4
 
909
L(fourth_double_word_16):
 
910
        mov     28(%esi), %ecx
 
911
        cmp     %ecx, 28(%edi)
 
912
        jne     L(nequal)
 
913
        RETURN
 
914
 
 
915
        .p2align 4
 
916
L(less4_double_words_32):
 
917
        xor     %eax, %eax
 
918
        test    %dl, %dl
 
919
        jz      L(next_two_double_words_32)
 
920
        and     $15, %dl
 
921
        jz      L(second_double_word_32)
 
922
        mov     32(%esi), %ecx
 
923
        cmp     %ecx, 32(%edi)
 
924
        jne     L(nequal)
 
925
        RETURN
 
926
 
 
927
        .p2align 4
 
928
L(second_double_word_32):
 
929
        mov     36(%esi), %ecx
 
930
        cmp     %ecx, 36(%edi)
 
931
        jne     L(nequal)
 
932
        RETURN
 
933
 
 
934
        .p2align 4
 
935
L(next_two_double_words_32):
 
936
        and     $15, %dh
 
937
        jz      L(fourth_double_word_32)
 
938
        mov     40(%esi), %ecx
 
939
        cmp     %ecx, 40(%edi)
 
940
        jne     L(nequal)
 
941
        RETURN
 
942
 
 
943
        .p2align 4
 
944
L(fourth_double_word_32):
 
945
        mov     44(%esi), %ecx
 
946
        cmp     %ecx, 44(%edi)
 
947
        jne     L(nequal)
 
948
        RETURN
 
949
 
 
950
        .p2align 4
 
951
L(less4_double_words_48):
 
952
        xor     %eax, %eax
 
953
        test    %dl, %dl
 
954
        jz      L(next_two_double_words_48)
 
955
        and     $15, %dl
 
956
        jz      L(second_double_word_48)
 
957
        mov     48(%esi), %ecx
 
958
        cmp     %ecx, 48(%edi)
 
959
        jne     L(nequal)
 
960
        RETURN
 
961
 
 
962
        .p2align 4
 
963
L(second_double_word_48):
 
964
        mov     52(%esi), %ecx
 
965
        cmp     %ecx, 52(%edi)
 
966
        jne     L(nequal)
 
967
        RETURN
 
968
 
 
969
        .p2align 4
 
970
L(next_two_double_words_48):
 
971
        and     $15, %dh
 
972
        jz      L(fourth_double_word_48)
 
973
        mov     56(%esi), %ecx
 
974
        cmp     %ecx, 56(%edi)
 
975
        jne     L(nequal)
 
976
        RETURN
 
977
 
 
978
        .p2align 4
 
979
L(fourth_double_word_48):
 
980
        mov     60(%esi), %ecx
 
981
        cmp     %ecx, 60(%edi)
 
982
        jne     L(nequal)
 
983
        RETURN
 
984
 
 
985
        .p2align 4
 
986
L(nequal):
 
987
        mov     $1, %eax
 
988
        jg      L(return)
 
989
        neg     %eax
 
990
        RETURN
 
991
 
 
992
        .p2align 4
 
993
L(return):
 
994
        RETURN
 
995
 
 
996
        .p2align 4
 
997
L(equal):
 
998
        xorl    %eax, %eax
 
999
        RETURN
 
1000
 
 
1001
        CFI_POP (%edi)
 
1002
        CFI_POP (%esi)
 
1003
 
 
1004
        .p2align 4
 
1005
L(neq):
 
1006
        mov     $1, %eax
 
1007
        jg      L(neq_bigger)
 
1008
        neg     %eax
 
1009
 
 
1010
L(neq_bigger):
 
1011
        ret
 
1012
 
 
1013
        .p2align 4
 
1014
L(eq):
 
1015
        xorl    %eax, %eax
 
1016
        ret
 
1017
 
 
1018
END (__wcscmp_sse2)
 
1019
#endif