1 /* strcspn with SSE4.2 intrinsics
2 Copyright (C) 2009 Free Software Foundation, Inc.
3 Contributed by Intel Corporation.
4 This file is part of the GNU C Library.
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.
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.
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
21 #include <nmmintrin.h>
27 | _SIDD_POSITIVE_POLARITY
28 | _SIDD_LEAST_SIGNIFICANT
29 on pcmpistri to compare xmm/mem128
31 0 1 2 3 4 5 6 7 8 9 A B C D E F
32 X X X X X X X X X X X X X X X X
36 0 1 2 3 4 5 6 7 8 9 A B C D E F
37 A A A A A A A A A A A A A A A A
39 to find out if the first 16byte data element has any byte A and
40 the offset of the first byte. There are 3 cases:
42 1. The first 16byte data element has the byte A at the offset X.
43 2. The first 16byte data element has EOS and doesn't have the byte A.
44 3. The first 16byte data element is valid and doesn't have the byte A.
46 Here is the table of ECX, CFlag, ZFlag and SFlag for 2 cases:
52 We exit from the loop for cases 1 and 2 with jbe which branches
53 when either CFlag or ZFlag is 1. If CFlag == 1, ECX has the offset
57 # define STRCSPN_SSE2 __strcspn_sse2
58 # define STRCSPN_SSE42 __strcspn_sse42
62 # define RETURN(val1, val2) return val1
64 # define RETURN(val1, val2) return val2
73 STRCSPN_SSE2 (const char *, const char *);
81 __attribute__ ((section (".text.sse4.2")))
82 STRCSPN_SSE42 (const char *s
, const char *a
)
85 RETURN (NULL
, strlen (s
));
89 /* Fake initialization. gcc otherwise will warn. */
90 asm ("" : "=xm" (mask
));
91 int offset
= (int) ((size_t) a
& 15);
95 aligned
= (const char *) ((size_t) a
& -16L);
96 __m128i mask0
= _mm_load_si128 ((__m128i
*) aligned
);
101 mask
= _mm_srli_si128 (mask0
, 1);
104 mask
= _mm_srli_si128 (mask0
, 2);
107 mask
= _mm_srli_si128 (mask0
, 3);
110 mask
= _mm_srli_si128 (mask0
, 4);
113 mask
= _mm_srli_si128 (mask0
, 5);
116 mask
= _mm_srli_si128 (mask0
, 6);
119 mask
= _mm_srli_si128 (mask0
, 7);
122 mask
= _mm_srli_si128 (mask0
, 8);
125 mask
= _mm_srli_si128 (mask0
, 9);
128 mask
= _mm_srli_si128 (mask0
, 10);
131 mask
= _mm_srli_si128 (mask0
, 11);
134 mask
= _mm_srli_si128 (mask0
, 12);
137 mask
= _mm_srli_si128 (mask0
, 13);
140 mask
= _mm_srli_si128 (mask0
, 14);
143 mask
= _mm_srli_si128 (mask0
, 15);
147 /* Find where the NULL terminator is. */
148 int length
= _mm_cmpistri (mask
, mask
, 0x3a);
149 if (length
== 16 - offset
)
151 /* There is no NULL terminator. */
152 __m128i mask1
= _mm_load_si128 ((__m128i
*) (aligned
+ 16));
153 int index
= _mm_cmpistri (mask1
, mask1
, 0x3a);
156 /* Don't use SSE4.2 if the length of A > 16. */
158 return STRCSPN_SSE2 (s
, a
);
162 /* Combine mask0 and mask1. */
166 mask
= _mm_alignr_epi8 (mask1
, mask0
, 1);
169 mask
= _mm_alignr_epi8 (mask1
, mask0
, 2);
172 mask
= _mm_alignr_epi8 (mask1
, mask0
, 3);
175 mask
= _mm_alignr_epi8 (mask1
, mask0
, 4);
178 mask
= _mm_alignr_epi8 (mask1
, mask0
, 5);
181 mask
= _mm_alignr_epi8 (mask1
, mask0
, 6);
184 mask
= _mm_alignr_epi8 (mask1
, mask0
, 7);
187 mask
= _mm_alignr_epi8 (mask1
, mask0
, 8);
190 mask
= _mm_alignr_epi8 (mask1
, mask0
, 9);
193 mask
= _mm_alignr_epi8 (mask1
, mask0
, 10);
196 mask
= _mm_alignr_epi8 (mask1
, mask0
, 11);
199 mask
= _mm_alignr_epi8 (mask1
, mask0
, 12);
202 mask
= _mm_alignr_epi8 (mask1
, mask0
, 13);
205 mask
= _mm_alignr_epi8 (mask1
, mask0
, 14);
208 mask
= _mm_alignr_epi8 (mask1
, mask0
, 15);
217 mask
= _mm_load_si128 ((__m128i
*) a
);
219 /* Find where the NULL terminator is. */
220 int length
= _mm_cmpistri (mask
, mask
, 0x3a);
223 /* There is no NULL terminator. Don't use SSE4.2 if the length
226 return STRCSPN_SSE2 (s
, a
);
230 offset
= (int) ((size_t) s
& 15);
233 /* Check partial string. */
234 aligned
= (const char *) ((size_t) s
& -16L);
235 __m128i value
= _mm_load_si128 ((__m128i
*) aligned
);
240 value
= _mm_srli_si128 (value
, 1);
243 value
= _mm_srli_si128 (value
, 2);
246 value
= _mm_srli_si128 (value
, 3);
249 value
= _mm_srli_si128 (value
, 4);
252 value
= _mm_srli_si128 (value
, 5);
255 value
= _mm_srli_si128 (value
, 6);
258 value
= _mm_srli_si128 (value
, 7);
261 value
= _mm_srli_si128 (value
, 8);
264 value
= _mm_srli_si128 (value
, 9);
267 value
= _mm_srli_si128 (value
, 10);
270 value
= _mm_srli_si128 (value
, 11);
273 value
= _mm_srli_si128 (value
, 12);
276 value
= _mm_srli_si128 (value
, 13);
279 value
= _mm_srli_si128 (value
, 14);
282 value
= _mm_srli_si128 (value
, 15);
286 int length
= _mm_cmpistri (mask
, value
, 0x2);
287 /* No need to check ZFlag since ZFlag is always 1. */
288 int cflag
= _mm_cmpistrc (mask
, value
, 0x2);
290 RETURN ((char *) (s
+ length
), length
);
291 /* Find where the NULL terminator is. */
292 int index
= _mm_cmpistri (value
, value
, 0x3a);
293 if (index
< 16 - offset
)
294 RETURN (NULL
, index
);
302 __m128i value
= _mm_load_si128 ((__m128i
*) aligned
);
303 int index
= _mm_cmpistri (mask
, value
, 0x2);
304 int cflag
= _mm_cmpistrc (mask
, value
, 0x2);
305 int zflag
= _mm_cmpistrz (mask
, value
, 0x2);
307 RETURN ((char *) (aligned
+ index
), (size_t) (aligned
+ index
- s
));
310 /* Find where the NULL terminator is. */
311 (size_t) (aligned
+ _mm_cmpistri (value
, value
, 0x3a) - s
));