2 /* { dg-options "-O2 -msse2" } */
4 #include "sse2-check.h"
14 unsigned short int t[8];
15 unsigned long long u[2];
19 void sse2_tests (void) __attribute__((noinline));
20 void dump128_16 (char *, char *, vecInLong);
21 void dump128_32 (char *, char *, vecInLong);
22 void dump128_64 (char *, char *, vecInLong);
23 void dump128_128 (char *, char *, vecInLong);
24 int check (const char *, const char *[]);
27 char comparison[8000];
28 static int errors = 0;
30 vecInLong a128, b128, c128, d128, e128, f128;
31 __m128i m128_16, m128_32, s128, m128_64, m128_128;
32 __m64 m64_16, s64, m64_32, m64_64;
34 const char *reference_sse2[] = {
35 "_mm_srai_epi16 0012 0012 0012 0012 0012 0012 0012 0012 \n",
36 "_mm_sra_epi16 0012 0012 0012 0012 0012 0012 0012 0012 \n",
37 "_mm_srai_epi32 00123456 00123456 00123456 00123456 \n",
38 "_mm_sra_epi32 00123456 00123456 00123456 00123456 \n",
39 "_mm_srli_epi16 0012 0012 0012 0012 0012 0012 0012 0012 \n",
40 "_mm_srl_epi16 0012 0012 0012 0012 0012 0012 0012 0012 \n",
41 "_mm_srli_epi32 00123456 00123456 00123456 00123456 \n",
42 "_mm_srl_epi32 00123456 00123456 00123456 00123456 \n",
43 "_mm_srli_epi64 00123456789abcde 00123456789abcde \n",
44 "_mm_srl_epi64 00123456789abcde 00123456789abcde \n",
45 "_mm_srli_si128 (byte shift) 00000000ffeeddccbbaa998877665544\n",
46 "_mm_slli_epi16 1230 1230 1230 1230 1230 1230 1230 1230 \n",
47 "_mm_sll_epi16 1230 1230 1230 1230 1230 1230 1230 1230 \n",
48 "_mm_slli_epi32 12345670 12345670 12345670 12345670 \n",
49 "_mm_sll_epi32 12345670 12345670 12345670 12345670 \n",
50 "_mm_slli_epi64 123456789abcdef0 123456789abcdef0 \n",
51 "_mm_sll_epi64 123456789abcdef0 123456789abcdef0 \n",
52 "_mm_sll_si128 (byte shift) bbaa9988776655443322110000000000\n",
53 "_mm_shuffle_epi32 ffeeddcc bbaa9988 77665544 33221100 \n",
54 "_mm_shuffelo_epi16 7766 5544 3322 1100 9988 bbaa ddcc ffee \n",
55 "_mm_shuffehi_epi16 1100 3322 5544 7766 ffee ddcc bbaa 9988 \n",
62 a128.s[0] = 0x01234567;
63 a128.s[1] = 0x01234567;
64 a128.s[2] = 0x01234567;
65 a128.s[3] = 0x01234567;
69 d128.u[0] = 0x0123456789abcdefULL;
70 d128.u[1] = 0x0123456789abcdefULL;
74 /* This is the 128-bit constant 0x00112233445566778899aabbccddeeff,
75 expressed as two little-endian 64-bit words. */
76 e128.u[0] = 0x7766554433221100ULL;
77 e128.u[1] = 0xffeeddccbbaa9988ULL;
100 check (buf, reference_sse2);
102 printf ("sse2 testing:\n");
104 printf ("\ncomparison:\n");
113 void __attribute__((noinline))
117 c128.v = _mm_srai_epi16 (m128_16, SHIFT);
118 dump128_16 (buf, "_mm_srai_epi16", c128);
119 c128.v = _mm_sra_epi16 (m128_16, s128);
120 dump128_16 (buf, "_mm_sra_epi16", c128);
123 c128.v = _mm_srai_epi32 (m128_32, SHIFT);
124 dump128_32 (buf, "_mm_srai_epi32", c128);
125 c128.v = _mm_sra_epi32 (m128_32, s128);
126 dump128_32 (buf, "_mm_sra_epi32", c128);
129 c128.v = _mm_srli_epi16 (m128_16, SHIFT);
130 dump128_16 (buf, "_mm_srli_epi16", c128);
131 c128.v = _mm_srl_epi16 (m128_16, s128);
132 dump128_16 (buf, "_mm_srl_epi16", c128);
135 c128.v = _mm_srli_epi32 (m128_32, SHIFT);
136 dump128_32 (buf, "_mm_srli_epi32", c128);
137 c128.v = _mm_srl_epi32 (m128_32, s128);
138 dump128_32 (buf, "_mm_srl_epi32", c128);
141 c128.v = _mm_srli_epi64 (m128_64, SHIFT);
142 dump128_64 (buf, "_mm_srli_epi64", c128);
143 c128.v = _mm_srl_epi64 (m128_64, s128);
144 dump128_64 (buf, "_mm_srl_epi64", c128);
147 c128.v = _mm_srli_si128 (m128_128, SHIFT);
148 dump128_128 (buf, "_mm_srli_si128 (byte shift) ", c128);
151 c128.v = _mm_slli_epi16 (m128_16, SHIFT);
152 dump128_16 (buf, "_mm_slli_epi16", c128);
153 c128.v = _mm_sll_epi16 (m128_16, s128);
154 dump128_16 (buf, "_mm_sll_epi16", c128);
157 c128.v = _mm_slli_epi32 (m128_32, SHIFT);
158 dump128_32 (buf, "_mm_slli_epi32", c128);
159 c128.v = _mm_sll_epi32 (m128_32, s128);
160 dump128_32 (buf, "_mm_sll_epi32", c128);
163 c128.v = _mm_slli_epi64 (m128_64, SHIFT);
164 dump128_64 (buf, "_mm_slli_epi64", c128);
165 c128.v = _mm_sll_epi64 (m128_64, s128);
166 dump128_64 (buf, "_mm_sll_epi64", c128);
169 c128.v = _mm_slli_si128 (m128_128, SHIFT);
170 dump128_128 (buf, "_mm_sll_si128 (byte shift)", c128);
172 /* Shuffle constant 0x1b == 0b_00_01_10_11, e.g. swap words: ABCD => DCBA. */
175 c128.v = _mm_shuffle_epi32 (m128_128, 0x1b);
176 dump128_32 (buf, "_mm_shuffle_epi32", c128);
179 c128.v = _mm_shufflelo_epi16 (m128_128, 0x1b);
180 dump128_16 (buf, "_mm_shuffelo_epi16", c128);
183 c128.v = _mm_shufflehi_epi16 (m128_128, 0x1b);
184 dump128_16 (buf, "_mm_shuffehi_epi16", c128);
188 dump128_16 (char *buf, char *name, vecInLong x)
191 char *p = buf + strlen (buf);
193 sprintf (p, "%s ", name);
198 sprintf (p, "%4.4x ", x.t[i]);
205 dump128_32 (char *buf, char *name, vecInLong x)
208 char *p = buf + strlen (buf);
210 sprintf (p, "%s ", name);
215 sprintf (p, "%8.8x ", x.s[i]);
222 dump128_64 (char *buf, char *name, vecInLong x)
225 char *p = buf + strlen (buf);
227 sprintf (p, "%s ", name);
232 sprintf (p, "%16.16llx ", x.u[i]);
239 dump128_128 (char *buf, char *name, vecInLong x)
242 char *p = buf + strlen (buf);
244 sprintf (p, "%s ", name);
247 for (i=15; i>=0; i--)
249 /* This is cheating; we don't have a 128-bit int format code.
250 Running the loop backwards to compensate for the
251 little-endian layout. */
252 sprintf (p, "%2.2x", x.c[i]);
259 check (const char *input, const char *reference[])
261 int broken, i, j, len;
266 p_comparison = &comparison[0];
269 for (i = 0; *reference[i] != '\0'; i++)
272 len = strlen (reference[i]);
273 for (j = 0; j < len; j++)
275 /* Ignore the terminating NUL characters at the end of every string in 'reference[]'. */
276 if (!broken && *p_input != reference[i][j])
278 *p_comparison = '\0';
279 strcat (p_comparison, " >>> ");
280 p_comparison += strlen (p_comparison);
284 *p_comparison = *p_input;
290 *p_comparison = '\0';
291 strcat (p_comparison, "expected:\n");
292 strcat (p_comparison, reference[i]);
293 p_comparison += strlen (p_comparison);
296 *p_comparison = '\0';
297 strcat (p_comparison, new_errors ? "failure\n\n" : "O.K.\n\n") ;
298 errors += new_errors;