1 #include <nmmintrin.h>
2 #include <string.h>
3
4 #define CFLAG 0x00000001
5 #define ZFLAG 0x00000002
6 #define SFLAG 0x00000004
7 #define OFLAG 0x00000008
8 #define AFLAG 0x00000010
9 #define PFLAG 0x00000020
10
11 #define PCMPSTR_EQ(X, Y, RES) \
12 { \
13 int __size = (sizeof (*X) ^ 3) * 8; \
14 int __i, __j; \
15 for (__i = 0; __i < __size; __i++) \
16 for (__j = 0; __j < __size; __j++) \
17 RES[__j][__i] = (X[__i] == Y[__j]); \
18 }
19
20 #define PCMPSTR_RNG(X, Y, RES) \
21 { \
22 int __size = (sizeof (*X) ^ 3) * 8; \
23 int __i, __j; \
24 for (__j = 0; __j < __size; __j++) \
25 for (__i = 0; __i < __size - 1; __i += 2) \
26 { \
27 RES[__j][__i] = (Y[__j] >= X[__i]); \
28 RES[__j][__i+1] = (Y[__j] <= X[__i + 1]); \
29 } \
30 }
31
32 static void
33 override_invalid (unsigned char res[16][16], int la, int lb,
34 const int mode, int dim)
35 {
36 int i, j;
37
38 for (j = 0; j < dim; j++)
39 for (i = 0; i < dim; i++)
40 if (i < la && j >= lb)
41 res[j][i] = 0;
42 else if (i >= la)
43 switch ((mode & 0x0C))
44 {
45 case _SIDD_CMP_EQUAL_ANY:
46 case _SIDD_CMP_RANGES:
47 res[j][i] = 0;
48 break;
49 case _SIDD_CMP_EQUAL_EACH:
50 res[j][i] = (j >= lb) ? 1: 0;
51 break;
52 case _SIDD_CMP_EQUAL_ORDERED:
53 res[j][i] = 1;
54 break;
55 }
56 }
57
58 static void
59 calc_matrix (__m128i a, int la, __m128i b, int lb, const int mode,
60 unsigned char res[16][16])
61 {
62 union
63 {
64 __m128i x;
65 signed char sc[16];
66 unsigned char uc[16];
67 signed short ss[8];
68 unsigned short us[8];
69 } d, s;
70
71 d.x = a;
72 s.x = b;
73
74 switch ((mode & 3))
75 {
76 case _SIDD_UBYTE_OPS:
77 if ((mode & 0x0C) == _SIDD_CMP_RANGES)
78 {
79 PCMPSTR_RNG (d.uc, s.uc, res);
80 }
81 else
82 {
83 PCMPSTR_EQ (d.uc, s.uc, res);
84 }
85 break;
86 case _SIDD_UWORD_OPS:
87 if ((mode & 0x0C) == _SIDD_CMP_RANGES)
88 {
89 PCMPSTR_RNG (d.us, s.us, res);
90 }
91 else
92 {
93 PCMPSTR_EQ (d.us, s.us, res);
94 }
95 break;
96 case _SIDD_SBYTE_OPS:
97 if ((mode & 0x0C) == _SIDD_CMP_RANGES)
98 {
99 PCMPSTR_RNG (d.sc, s.sc, res);
100 }
101 else
102 {
103 PCMPSTR_EQ (d.sc, s.sc, res);
104 }
105 break;
106 case _SIDD_SWORD_OPS:
107 if ((mode & 0x0C) == _SIDD_CMP_RANGES)
108 {
109 PCMPSTR_RNG (d.ss, s.ss, res);
110 }
111 else
112 {
113 PCMPSTR_EQ (d.ss, s.ss, res);
114 }
115 break;
116 }
117
118 override_invalid (res, la, lb, mode, (mode & 1) == 0 ? 16 : 8);
119 }
120
121 static int
122 calc_res (__m128i a, int la, __m128i b, int lb, const int mode)
123 {
124 unsigned char mtx[16][16];
125 int i, j, k, dim, res = 0;
126
127 memset (mtx, 0, sizeof (mtx));
128
129 dim = (mode & 1) == 0 ? 16 : 8;
130
131 if (la < 0)
132 la = -la;
133
134 if (lb < 0)
135 lb = -lb;
136
137 if (la > dim)
138 la = dim;
139
140 if (lb > dim)
141 lb = dim;
142
143 calc_matrix (a, la, b, lb, mode, mtx);
144
145 switch ((mode & 0x0C))
146 {
147 case _SIDD_CMP_EQUAL_ANY:
148 for (i = 0; i < dim; i++)
149 for (j = 0; j < dim; j++)
150 if (mtx[i][j])
151 res |= (1 << i);
152 break;
153
154 case _SIDD_CMP_RANGES:
155 for (i = 0; i < dim; i += 2)
156 for(j = 0; j < dim; j++)
157 if (mtx[j][i] && mtx[j][i+1])
158 res |= (1 << j);
159 break;
160
161 case _SIDD_CMP_EQUAL_EACH:
162 for(i = 0; i < dim; i++)
163 if (mtx[i][i])
164 res |= (1 << i);
165 break;
166
167 case _SIDD_CMP_EQUAL_ORDERED:
168 for(i = 0; i < dim; i++)
169 {
170 unsigned char val = 1;
171
172 for (j = 0, k = i; j < dim - i && k < dim; j++, k++)
173 val &= mtx[k][j];
174
175 if (val)
176 res |= (1 << i);
177 else
178 res &= ~(1 << i);
179 }
180 break;
181 }
182
183 switch ((mode & 0x30))
184 {
185 case _SIDD_POSITIVE_POLARITY:
186 case _SIDD_MASKED_POSITIVE_POLARITY:
187 break;
188
189 case _SIDD_NEGATIVE_POLARITY:
190 res ^= -1;
191 break;
192
193 case _SIDD_MASKED_NEGATIVE_POLARITY:
194 for (i = 0; i < lb; i++)
195 if (res & (1 << i))
196 res &= ~(1 << i);
197 else
198 res |= (1 << i);
199 break;
200 }
201
202 return res & ((dim == 8) ? 0xFF : 0xFFFF);
203 }
204
205 static int
206 cmp_flags (__m128i a, int la, __m128i b, int lb,
207 int mode, int res2, int is_implicit)
208 {
209 int i;
210 int flags = 0;
211 int is_bytes_mode = (mode & 1) == 0;
212 union
213 {
214 __m128i x;
215 unsigned char uc[16];
216 unsigned short us[8];
217 } d, s;
218
219 d.x = a;
220 s.x = b;
221
222 /* CF: reset if (RES2 == 0), set otherwise. */
223 if (res2 != 0)
224 flags |= CFLAG;
225
226 if (is_implicit)
227 {
228 /* ZF: set if any byte/word of src xmm operand is null, reset
229 otherwise.
230 SF: set if any byte/word of dst xmm operand is null, reset
231 otherwise. */
232
233 if (is_bytes_mode)
234 {
235 for (i = 0; i < 16; i++)
236 {
237 if (s.uc[i] == 0)
238 flags |= ZFLAG;
239 if (d.uc[i] == 0)
240 flags |= SFLAG;
241 }
242 }
243 else
244 {
245 for (i = 0; i < 8; i++)
246 {
247 if (s.us[i] == 0)
248 flags |= ZFLAG;
249 if (d.us[i] == 0)
250 flags |= SFLAG;
251 }
252 }
253 }
254 else
255 {
256 /* ZF: set if abs value of EDX/RDX < 16 (8), reset otherwise.
257 SF: set if abs value of EAX/RAX < 16 (8), reset otherwise. */
258 int max_ind = is_bytes_mode ? 16 : 8;
259
260 if (la < 0)
261 la = -la;
262 if (lb < 0)
263 lb = -lb;
264
265 if (lb < max_ind)
266 flags |= ZFLAG;
267 if (la < max_ind)
268 flags |= SFLAG;
269 }
270
271 /* OF: equal to RES2[0]. */
272 if ((res2 & 0x1))
273 flags |= OFLAG;
274
275 /* AF: Reset.
276 PF: Reset. */
277 return flags;
278 }
279
280 static int
281 cmp_indexed (__m128i a, int la, __m128i b, int lb,
282 const int mode, int *res2)
283 {
284 int i, ndx;
285 int dim = (mode & 1) == 0 ? 16 : 8;
286 int r2;
287
288 r2 = calc_res (a, la, b, lb, mode);
289
290 ndx = dim;
291 if ((mode & 0x40))
292 {
293 for (i = dim - 1; i >= 0; i--)
294 if (r2 & (1 << i))
295 {
296 ndx = i;
297 break;
298 }
299 }
300 else
301 {
302 for (i = 0; i < dim; i++)
303 if ((r2 & (1 << i)))
304 {
305 ndx = i;
306 break;
307 }
308 }
309
310 *res2 = r2;
311 return ndx;
312 }
313
314 static __m128i
315 cmp_masked (__m128i a, int la, __m128i b, int lb,
316 const int mode, int *res2)
317 {
318 union
319 {
320 __m128i x;
321 char c[16];
322 short s[8];
323 } ret;
324 int i;
325 int dim = (mode & 1) == 0 ? 16 : 8;
326 union
327 {
328 int i;
329 char c[4];
330 short s[2];
331 } r2;
332
333 r2.i = calc_res (a, la, b, lb, mode);
334
335 memset (&ret, 0, sizeof (ret));
336
337 if (mode & 0x40)
338 {
339 for (i = 0; i < dim; i++)
340 if (dim == 8)
341 ret.s [i] = (r2.i & (1 << i)) ? -1 : 0;
342 else
343 ret.c [i] = (r2.i & (1 << i)) ? -1 : 0;
344 }
345 else
346 {
347 if (dim == 16)
348 ret.s[0] = r2.s[0];
349 else
350 ret.c[0] = r2.c[0];
351 }
352
353 *res2 = r2.i;
354
355 return ret.x;
356 }
357
358 static int
359 calc_str_len (__m128i a, const int mode)
360 {
361 union
362 {
363 __m128i x;
364 char c[16];
365 short s[8];
366 } s;
367 int i;
368 int dim = (mode & 1) == 0 ? 16 : 8;
369
370 s.x = a;
371
372 if ((mode & 1))
373 {
374 for (i = 0; i < dim; i++)
375 if (s.s[i] == 0)
376 break;
377 }
378 else
379 {
380 for (i = 0; i < dim; i++)
381 if (s.c[i] == 0)
382 break;
383 }
384
385 return i;
386 }
387
388 static inline int
389 cmp_ei (__m128i *a, int la, __m128i *b, int lb,
390 const int mode, int *flags)
391 {
392 int res2;
393 int index = cmp_indexed (*a, la, *b, lb, mode, &res2);
394
395 if (flags != NULL)
396 *flags = cmp_flags (*a, la, *b, lb, mode, res2, 0);
397
398 return index;
399 }
400
401 static inline int
402 cmp_ii (__m128i *a, __m128i *b, const int mode, int *flags)
403 {
404 int la, lb;
405 int res2;
406 int index;
407
408 la = calc_str_len (*a, mode);
409 lb = calc_str_len (*b, mode);
410
411 index = cmp_indexed (*a, la, *b, lb, mode, &res2);
412
413 if (flags != NULL)
414 *flags = cmp_flags (*a, la, *b, lb, mode, res2, 1);
415
416 return index;
417 }
418
419 static inline __m128i
420 cmp_em (__m128i *a, int la, __m128i *b, int lb,
421 const int mode, int *flags )
422 {
423 int res2;
424 __m128i mask = cmp_masked (*a, la, *b, lb, mode, &res2);
425
426 if (flags != NULL)
427 *flags = cmp_flags (*a, la, *b, lb, mode, res2, 0);
428
429 return mask;
430 }
431
432 static inline __m128i
433 cmp_im (__m128i *a, __m128i *b, const int mode, int *flags)
434 {
435 int la, lb;
436 int res2;
437 __m128i mask;
438
439 la = calc_str_len (*a, mode);
440 lb = calc_str_len (*b, mode);
441
442 mask = cmp_masked (*a, la, *b, lb, mode, &res2);
443 if (flags != NULL)
444 *flags = cmp_flags (*a, la, *b, lb, mode, res2, 1);
445
446 return mask;
447 }