1 /* { dg-do run } */
2 /* { dg-options "-O2 -msse2" } */
3 /* { dg-require-effective-target sse2 } */
4
5 #include "sse2-check.h"
6
7 #include <emmintrin.h>
8 #include <string.h>
9
10 #define SHIFT (4)
11
12 typedef union {
13 __m128i v;
14 unsigned int s[4];
15 unsigned short int t[8];
16 unsigned long long u[2];
17 unsigned char c[16];
18 }vecInLong;
19
20 void sse2_tests (void) __attribute__((noinline));
21 void dump128_16 (char *, char *, vecInLong);
22 void dump128_32 (char *, char *, vecInLong);
23 void dump128_64 (char *, char *, vecInLong);
24 void dump128_128 (char *, char *, vecInLong);
25 int check (const char *, const char *[]);
26
27 char buf[8000];
28 char comparison[8000];
29 static int errors = 0;
30
31 vecInLong a128, b128, c128, d128, e128, f128;
32 __m128i m128_16, m128_32, s128, m128_64, m128_128;
33 __m64 m64_16, s64, m64_32, m64_64;
34
35 const char *reference_sse2[] = {
36 "_mm_srai_epi16 0012 0012 0012 0012 0012 0012 0012 0012 \n",
37 "_mm_sra_epi16 0012 0012 0012 0012 0012 0012 0012 0012 \n",
38 "_mm_srai_epi32 00123456 00123456 00123456 00123456 \n",
39 "_mm_sra_epi32 00123456 00123456 00123456 00123456 \n",
40 "_mm_srli_epi16 0012 0012 0012 0012 0012 0012 0012 0012 \n",
41 "_mm_srl_epi16 0012 0012 0012 0012 0012 0012 0012 0012 \n",
42 "_mm_srli_epi32 00123456 00123456 00123456 00123456 \n",
43 "_mm_srl_epi32 00123456 00123456 00123456 00123456 \n",
44 "_mm_srli_epi64 00123456789abcde 00123456789abcde \n",
45 "_mm_srl_epi64 00123456789abcde 00123456789abcde \n",
46 "_mm_srli_si128 (byte shift) 00000000ffeeddccbbaa998877665544\n",
47 "_mm_slli_epi16 1230 1230 1230 1230 1230 1230 1230 1230 \n",
48 "_mm_sll_epi16 1230 1230 1230 1230 1230 1230 1230 1230 \n",
49 "_mm_slli_epi32 12345670 12345670 12345670 12345670 \n",
50 "_mm_sll_epi32 12345670 12345670 12345670 12345670 \n",
51 "_mm_slli_epi64 123456789abcdef0 123456789abcdef0 \n",
52 "_mm_sll_epi64 123456789abcdef0 123456789abcdef0 \n",
53 "_mm_sll_si128 (byte shift) bbaa9988776655443322110000000000\n",
54 "_mm_shuffle_epi32 ffeeddcc bbaa9988 77665544 33221100 \n",
55 "_mm_shuffelo_epi16 7766 5544 3322 1100 9988 bbaa ddcc ffee \n",
56 "_mm_shuffehi_epi16 1100 3322 5544 7766 ffee ddcc bbaa 9988 \n",
57 ""
58 };
59
60 static void
61 sse2_test (void)
62 {
63 a128.s[0] = 0x01234567;
64 a128.s[1] = 0x01234567;
65 a128.s[2] = 0x01234567;
66 a128.s[3] = 0x01234567;
67
68 m128_32 = a128.v;
69
70 d128.u[0] = 0x0123456789abcdefULL;
71 d128.u[1] = 0x0123456789abcdefULL;
72
73 m128_64 = d128.v;
74
75 /* This is the 128-bit constant 0x00112233445566778899aabbccddeeff,
76 expressed as two little-endian 64-bit words. */
77 e128.u[0] = 0x7766554433221100ULL;
78 e128.u[1] = 0xffeeddccbbaa9988ULL;
79
80 f128.t[0] = 0x0123;
81 f128.t[1] = 0x0123;
82 f128.t[2] = 0x0123;
83 f128.t[3] = 0x0123;
84 f128.t[4] = 0x0123;
85 f128.t[5] = 0x0123;
86 f128.t[6] = 0x0123;
87 f128.t[7] = 0x0123;
88
89 m128_16 = f128.v;
90
91 m128_128 = e128.v;
92
93 b128.s[0] = SHIFT;
94 b128.s[1] = 0;
95 b128.s[2] = 0;
96 b128.s[3] = 0;
97
98 s128 = b128.v;
99
100 sse2_tests();
101 check (buf, reference_sse2);
102 #ifdef DEBUG
103 printf ("sse2 testing:\n");
104 printf (buf);
105 printf ("\ncomparison:\n");
106 printf (comparison);
107 #endif
108 buf[0] = '\0';
109
110 if (errors != 0)
111 abort ();
112 }
113
114 void __attribute__((noinline))
115 sse2_tests (void)
116 {
117 /* psraw */
118 c128.v = _mm_srai_epi16 (m128_16, SHIFT);
119 dump128_16 (buf, "_mm_srai_epi16", c128);
120 c128.v = _mm_sra_epi16 (m128_16, s128);
121 dump128_16 (buf, "_mm_sra_epi16", c128);
122
123 /* psrad */
124 c128.v = _mm_srai_epi32 (m128_32, SHIFT);
125 dump128_32 (buf, "_mm_srai_epi32", c128);
126 c128.v = _mm_sra_epi32 (m128_32, s128);
127 dump128_32 (buf, "_mm_sra_epi32", c128);
128
129 /* psrlw */
130 c128.v = _mm_srli_epi16 (m128_16, SHIFT);
131 dump128_16 (buf, "_mm_srli_epi16", c128);
132 c128.v = _mm_srl_epi16 (m128_16, s128);
133 dump128_16 (buf, "_mm_srl_epi16", c128);
134
135 /* psrld */
136 c128.v = _mm_srli_epi32 (m128_32, SHIFT);
137 dump128_32 (buf, "_mm_srli_epi32", c128);
138 c128.v = _mm_srl_epi32 (m128_32, s128);
139 dump128_32 (buf, "_mm_srl_epi32", c128);
140
141 /* psrlq */
142 c128.v = _mm_srli_epi64 (m128_64, SHIFT);
143 dump128_64 (buf, "_mm_srli_epi64", c128);
144 c128.v = _mm_srl_epi64 (m128_64, s128);
145 dump128_64 (buf, "_mm_srl_epi64", c128);
146
147 /* psrldq */
148 c128.v = _mm_srli_si128 (m128_128, SHIFT);
149 dump128_128 (buf, "_mm_srli_si128 (byte shift) ", c128);
150
151 /* psllw */
152 c128.v = _mm_slli_epi16 (m128_16, SHIFT);
153 dump128_16 (buf, "_mm_slli_epi16", c128);
154 c128.v = _mm_sll_epi16 (m128_16, s128);
155 dump128_16 (buf, "_mm_sll_epi16", c128);
156
157 /* pslld */
158 c128.v = _mm_slli_epi32 (m128_32, SHIFT);
159 dump128_32 (buf, "_mm_slli_epi32", c128);
160 c128.v = _mm_sll_epi32 (m128_32, s128);
161 dump128_32 (buf, "_mm_sll_epi32", c128);
162
163 /* psllq */
164 c128.v = _mm_slli_epi64 (m128_64, SHIFT);
165 dump128_64 (buf, "_mm_slli_epi64", c128);
166 c128.v = _mm_sll_epi64 (m128_64, s128);
167 dump128_64 (buf, "_mm_sll_epi64", c128);
168
169 /* pslldq */
170 c128.v = _mm_slli_si128 (m128_128, SHIFT);
171 dump128_128 (buf, "_mm_sll_si128 (byte shift)", c128);
172
173 /* Shuffle constant 0x1b == 0b_00_01_10_11, e.g. swap words: ABCD => DCBA. */
174
175 /* pshufd */
176 c128.v = _mm_shuffle_epi32 (m128_128, 0x1b);
177 dump128_32 (buf, "_mm_shuffle_epi32", c128);
178
179 /* pshuflw */
180 c128.v = _mm_shufflelo_epi16 (m128_128, 0x1b);
181 dump128_16 (buf, "_mm_shuffelo_epi16", c128);
182
183 /* pshufhw */
184 c128.v = _mm_shufflehi_epi16 (m128_128, 0x1b);
185 dump128_16 (buf, "_mm_shuffehi_epi16", c128);
186 }
187
188 void
189 dump128_16 (char *buf, char *name, vecInLong x)
190 {
191 int i;
192 char *p = buf + strlen (buf);
193
194 sprintf (p, "%s ", name);
195 p += strlen (p);
196
197 for (i=0; i<8; i++)
198 {
199 sprintf (p, "%4.4x ", x.t[i]);
200 p += strlen (p);
201 }
202 strcat (p, "\n");
203 }
204
205 void
206 dump128_32 (char *buf, char *name, vecInLong x)
207 {
208 int i;
209 char *p = buf + strlen (buf);
210
211 sprintf (p, "%s ", name);
212 p += strlen (p);
213
214 for (i=0; i<4; i++)
215 {
216 sprintf (p, "%8.8x ", x.s[i]);
217 p += strlen (p);
218 }
219 strcat (p, "\n");
220 }
221
222 void
223 dump128_64 (char *buf, char *name, vecInLong x)
224 {
225 int i;
226 char *p = buf + strlen (buf);
227
228 sprintf (p, "%s ", name);
229 p += strlen (p);
230
231 for (i=0; i<2; i++)
232 {
233 #if defined(_WIN32) && !defined(__CYGWIN__)
234 sprintf (p, "%16.16I64x ", x.u[i]);
235 #else
236 sprintf (p, "%16.16llx ", x.u[i]);
237 #endif
238 p += strlen (p);
239 }
240 strcat (p, "\n");
241 }
242
243 void
244 dump128_128 (char *buf, char *name, vecInLong x)
245 {
246 int i;
247 char *p = buf + strlen (buf);
248
249 sprintf (p, "%s ", name);
250 p += strlen (p);
251
252 for (i=15; i>=0; i--)
253 {
254 /* This is cheating; we don't have a 128-bit int format code.
255 Running the loop backwards to compensate for the
256 little-endian layout. */
257 sprintf (p, "%2.2x", x.c[i]);
258 p += strlen (p);
259 }
260 strcat (p, "\n");
261 }
262
263 int
264 check (const char *input, const char *reference[])
265 {
266 int broken, i, j, len;
267 const char *p_input;
268 char *p_comparison;
269 int new_errors = 0;
270
271 p_comparison = &comparison[0];
272 p_input = input;
273
274 for (i = 0; *reference[i] != '\0'; i++)
275 {
276 broken = 0;
277 len = strlen (reference[i]);
278 for (j = 0; j < len; j++)
279 {
280 /* Ignore the terminating NUL characters at the end of every string in 'reference[]'. */
281 if (!broken && *p_input != reference[i][j])
282 {
283 *p_comparison = '\0';
284 strcat (p_comparison, " >>> ");
285 p_comparison += strlen (p_comparison);
286 new_errors++;
287 broken = 1;
288 }
289 *p_comparison = *p_input;
290 p_comparison++;
291 p_input++;
292 }
293 if (broken)
294 {
295 *p_comparison = '\0';
296 strcat (p_comparison, "expected:\n");
297 strcat (p_comparison, reference[i]);
298 p_comparison += strlen (p_comparison);
299 }
300 }
301 *p_comparison = '\0';
302 strcat (p_comparison, new_errors ? "failure\n\n" : "O.K.\n\n") ;
303 errors += new_errors;
304 return 0;
305 }