← Back to branch summary

~ubuntu-branches/ubuntu/vivid/emscripten/vivid-proposed

« back to all changes in this revision

Viewing changes to tests/core/test_simd3.in

  • Committer: Package Import Robot
  • Author(s): Sylvestre Ledru
  • Date: 2014-01-19 14:12:40 UTC
  • mfrom: (4.1.2 sid)
  • Revision ID: package-import@ubuntu.com-20140119141240-nfiw0p8033oitpfz
Tags: 1.9.0~20140119~7dc8c2f-1
http://bugs.debian.org/733714
http://bugs.debian.org/735903
* New snapshot release (Closes: #733714)
* Provide sources for javascript and flash. Done in orig-tar.sh
  Available in third_party/websockify/include/web-socket-js/src/
  (Closes: #735903)

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/core/test_simd3.in
 
1
#include <iostream>
 
2
#include <emmintrin.h>
 
3
#include <assert.h>
 
4
#include <stdint.h>
 
5
#include <bitset>
 
6
 
 
7
using namespace std;
 
8
 
 
9
void testSetPs() {
 
10
  float __attribute__((__aligned__(16))) ar[4];
 
11
  __m128 v = _mm_set_ps(1.0, 2.0, 3.0, 4.0);
 
12
  _mm_store_ps(ar, v);
 
13
  assert(ar[0] == 4.0);
 
14
  assert(ar[1] == 3.0);
 
15
  assert(ar[2] == 2.0);
 
16
  assert(ar[3] == 1.0);
 
17
}
 
18
 
 
19
void testSet1Ps() {
 
20
  float __attribute__((__aligned__(16))) ar[4];
 
21
  __m128 v = _mm_set1_ps(5.5);
 
22
  _mm_store_ps(ar, v);
 
23
  assert(ar[0] == 5.5);
 
24
  assert(ar[1] == 5.5);
 
25
  assert(ar[2] == 5.5);
 
26
  assert(ar[3] == 5.5);
 
27
}
 
28
 
 
29
void testSetZeroPs() {
 
30
  float __attribute__((__aligned__(16))) ar[4];
 
31
  __m128 v = _mm_setzero_ps();
 
32
  _mm_store_ps(ar, v);
 
33
  assert(ar[0] == 0);
 
34
  assert(ar[1] == 0);
 
35
  assert(ar[2] == 0);
 
36
  assert(ar[3] == 0);
 
37
}
 
38
 
 
39
void testSetEpi32() {
 
40
  int32_t __attribute__((__aligned__(16))) ar[4];
 
41
  __m128i v = _mm_set_epi32(5, 7, 126, 381);
 
42
  _mm_store_si128((__m128i *)ar, v);
 
43
  assert(ar[0] == 381);
 
44
  assert(ar[1] == 126);
 
45
  assert(ar[2] == 7);
 
46
  assert(ar[3] == 5);
 
47
  v = _mm_set_epi32(0x55555555, 0xaaaaaaaa, 0xffffffff, 0x12345678);
 
48
  _mm_store_si128((__m128i *)ar, v);
 
49
  assert(ar[0] == 0x12345678);
 
50
  assert(ar[1] == 0xffffffff);
 
51
  assert(ar[2] == 0xaaaaaaaa);
 
52
  assert(ar[3] == 0x55555555);
 
53
}
 
54
 
 
55
void testSet1Epi32() {
 
56
  int32_t __attribute__((__aligned__(16))) ar[4];
 
57
  __m128i v = _mm_set1_epi32(-5);
 
58
  _mm_store_si128((__m128i *)ar, v);
 
59
  assert(ar[0] == -5);
 
60
  assert(ar[1] == -5);
 
61
  assert(ar[2] == -5);
 
62
  assert(ar[3] == -5);
 
63
}
 
64
 
 
65
void testSetZeroSi128() {
 
66
  int32_t __attribute__((__aligned__(16))) ar[4];
 
67
  __m128i v = _mm_setzero_si128();
 
68
  _mm_store_si128((__m128i *)ar, v);
 
69
  assert(ar[0] == 0);
 
70
  assert(ar[1] == 0);
 
71
  assert(ar[2] == 0);
 
72
  assert(ar[3] == 0);
 
73
}
 
74
 
 
75
void testBitCasts() {
 
76
  int32_t __attribute__((__aligned__(16))) ar1[4];
 
77
  float __attribute__((__aligned__(16))) ar2[4];
 
78
  __m128i v1 = _mm_set_epi32(0x3f800000, 0x40000000, 0x40400000, 0x40800000);
 
79
  __m128 v2 = _mm_castsi128_ps(v1);
 
80
  _mm_store_ps(ar2, v2);
 
81
  assert(ar2[0] == 4.0);
 
82
  assert(ar2[1] == 3.0);
 
83
  assert(ar2[2] == 2.0);
 
84
  assert(ar2[3] == 1.0);
 
85
  v2 = _mm_set_ps(5.0, 6.0, 7.0, 8.0);
 
86
  v1 = _mm_castps_si128(v2);
 
87
  _mm_store_si128((__m128i *)ar1, v1);
 
88
  assert(ar1[0] == 0x41000000);
 
89
  assert(ar1[1] == 0x40e00000);
 
90
  assert(ar1[2] == 0x40c00000);
 
91
  assert(ar1[3] == 0x40a00000);
 
92
  float w = 0;
 
93
  float z = -278.3;
 
94
  float y = 5.2;
 
95
  float x = -987654321;
 
96
  v1 = _mm_castps_si128(_mm_set_ps(w, z, y, x));
 
97
  _mm_store_ps(ar2, _mm_castsi128_ps(v1));
 
98
  assert(ar2[0] == x);
 
99
  assert(ar2[1] == y);
 
100
  assert(ar2[2] == z);
 
101
  assert(ar2[3] == w);
 
102
  /*
 
103
  std::bitset<sizeof(float)*CHAR_BIT> bits1x(*reinterpret_cast<unsigned
 
104
  long*>(&(ar2[0])));
 
105
  std::bitset<sizeof(float)*CHAR_BIT> bits1y(*reinterpret_cast<unsigned
 
106
  long*>(&(ar2[1])));
 
107
  std::bitset<sizeof(float)*CHAR_BIT> bits1z(*reinterpret_cast<unsigned
 
108
  long*>(&(ar2[2])));
 
109
  std::bitset<sizeof(float)*CHAR_BIT> bits1w(*reinterpret_cast<unsigned
 
110
  long*>(&(ar2[3])));
 
111
  std::bitset<sizeof(float)*CHAR_BIT> bits2x(*reinterpret_cast<unsigned
 
112
  long*>(&x));
 
113
  std::bitset<sizeof(float)*CHAR_BIT> bits2y(*reinterpret_cast<unsigned
 
114
  long*>(&y));
 
115
  std::bitset<sizeof(float)*CHAR_BIT> bits2z(*reinterpret_cast<unsigned
 
116
  long*>(&z));
 
117
  std::bitset<sizeof(float)*CHAR_BIT> bits2w(*reinterpret_cast<unsigned
 
118
  long*>(&w));
 
119
  assert(bits1x == bits2x);
 
120
  assert(bits1y == bits2y);
 
121
  assert(bits1z == bits2z);
 
122
  assert(bits1w == bits2w);
 
123
  */
 
124
  v2 = _mm_castsi128_ps(_mm_set_epi32(0xffffffff, 0, 0x5555cccc, 0xaaaaaaaa));
 
125
  _mm_store_si128((__m128i *)ar1, _mm_castps_si128(v2));
 
126
  assert(ar1[0] == 0xaaaaaaaa);
 
127
  assert(ar1[1] == 0x5555cccc);
 
128
  assert(ar1[2] == 0);
 
129
  assert(ar1[3] == 0xffffffff);
 
130
}
 
131
 
 
132
void testConversions() {
 
133
  int32_t __attribute__((__aligned__(16))) ar1[4];
 
134
  float __attribute__((__aligned__(16))) ar2[4];
 
135
  __m128i v1 = _mm_set_epi32(0, -3, -517, 256);
 
136
  __m128 v2 = _mm_cvtepi32_ps(v1);
 
137
  _mm_store_ps(ar2, v2);
 
138
  assert(ar2[0] == 256.0);
 
139
  assert(ar2[1] == -517.0);
 
140
  assert(ar2[2] == -3.0);
 
141
  assert(ar2[3] == 0);
 
142
  v2 = _mm_set_ps(5.0, 6.0, 7.45, -8.0);
 
143
  v1 = _mm_cvtps_epi32(v2);
 
144
  _mm_store_si128((__m128i *)ar1, v1);
 
145
  assert(ar1[0] == -8);
 
146
  assert(ar1[1] == 7);
 
147
  assert(ar1[2] == 6);
 
148
  assert(ar1[3] == 5);
 
149
}
 
150
 
 
151
void testMoveMaskPs() {
 
152
  __m128 v =
 
153
      _mm_castsi128_ps(_mm_set_epi32(0xffffffff, 0xffffffff, 0, 0xffffffff));
 
154
  int mask = _mm_movemask_ps(v);
 
155
  assert(mask == 13);
 
156
}
 
157
 
 
158
void testAddPs() {
 
159
  float __attribute__((__aligned__(16))) ar[4];
 
160
  __m128 v1 = _mm_set_ps(4.0, 3.0, 2.0, 1.0);
 
161
  __m128 v2 = _mm_set_ps(10.0, 20.0, 30.0, 40.0);
 
162
  __m128 v = _mm_add_ps(v1, v2);
 
163
  _mm_store_ps(ar, v);
 
164
  assert(ar[0] == 41.0);
 
165
  assert(ar[1] == 32.0);
 
166
  assert(ar[2] == 23.0);
 
167
  assert(ar[3] == 14.0);
 
168
}
 
169
 
 
170
void testSubPs() {
 
171
  float __attribute__((__aligned__(16))) ar[4];
 
172
  __m128 v1 = _mm_set_ps(4.0, 3.0, 2.0, 1.0);
 
173
  __m128 v2 = _mm_set_ps(10.0, 20.0, 30.0, 40.0);
 
174
  __m128 v = _mm_sub_ps(v1, v2);
 
175
  _mm_store_ps(ar, v);
 
176
  assert(ar[0] == -39.0);
 
177
  assert(ar[1] == -28.0);
 
178
  assert(ar[2] == -17.0);
 
179
  assert(ar[3] == -6.0);
 
180
}
 
181
 
 
182
void testMulPs() {
 
183
  float __attribute__((__aligned__(16))) ar[4];
 
184
  __m128 v1 = _mm_set_ps(4.0, 3.0, 2.0, 1.0);
 
185
  __m128 v2 = _mm_set_ps(10.0, 20.0, 30.0, 40.0);
 
186
  __m128 v = _mm_mul_ps(v1, v2);
 
187
  _mm_store_ps(ar, v);
 
188
  assert(ar[0] == 40.0);
 
189
  assert(ar[1] == 60.0);
 
190
  assert(ar[2] == 60.0);
 
191
  assert(ar[3] == 40.0);
 
192
}
 
193
 
 
194
void testDivPs() {
 
195
  float __attribute__((__aligned__(16))) ar[4];
 
196
  __m128 v1 = _mm_set_ps(4.0, 9.0, 8.0, 1.0);
 
197
  __m128 v2 = _mm_set_ps(2.0, 3.0, 1.0, 0.5);
 
198
  __m128 v = _mm_div_ps(v1, v2);
 
199
  _mm_store_ps(ar, v);
 
200
  assert(ar[0] == 2.0);
 
201
  assert(ar[1] == 8.0);
 
202
  assert(ar[2] == 3.0);
 
203
  assert(ar[3] == 2.0);
 
204
}
 
205
 
 
206
void testMinPs() {
 
207
  float __attribute__((__aligned__(16))) ar[4];
 
208
  __m128 v1 = _mm_set_ps(-20.0, 10.0, 30.0, 0.5);
 
209
  __m128 v2 = _mm_set_ps(2.0, 1.0, 50.0, 0.0);
 
210
  __m128 v = _mm_min_ps(v1, v2);
 
211
  _mm_store_ps(ar, v);
 
212
  assert(ar[0] == 0.0);
 
213
  assert(ar[1] == 30.0);
 
214
  assert(ar[2] == 1.0);
 
215
  assert(ar[3] == -20.0);
 
216
}
 
217
 
 
218
void testMaxPs() {
 
219
  float __attribute__((__aligned__(16))) ar[4];
 
220
  __m128 v1 = _mm_set_ps(-20.0, 10.0, 30.0, 0.5);
 
221
  __m128 v2 = _mm_set_ps(2.5, 5.0, 55.0, 1.0);
 
222
  __m128 v = _mm_max_ps(v1, v2);
 
223
  _mm_store_ps(ar, v);
 
224
  assert(ar[0] == 1.0);
 
225
  assert(ar[1] == 55.0);
 
226
  assert(ar[2] == 10.0);
 
227
  assert(ar[3] == 2.5);
 
228
}
 
229
 
 
230
void testSqrtPs() {
 
231
  float __attribute__((__aligned__(16))) ar[4];
 
232
  __m128 v1 = _mm_set_ps(16.0, 9.0, 4.0, 1.0);
 
233
  __m128 v = _mm_sqrt_ps(v1);
 
234
  _mm_store_ps(ar, v);
 
235
  assert(ar[0] == 1.0);
 
236
  assert(ar[1] == 2.0);
 
237
  assert(ar[2] == 3.0);
 
238
  assert(ar[3] == 4.0);
 
239
}
 
240
 
 
241
void testCmpLtPs() {
 
242
  int32_t __attribute__((__aligned__(16))) ar[4];
 
243
  __m128 v1 = _mm_set_ps(1.0, 2.0, 0.1, 0.001);
 
244
  __m128 v2 = _mm_set_ps(2.0, 2.0, 0.001, 0.1);
 
245
  __m128 v = _mm_cmplt_ps(v1, v2);
 
246
  _mm_store_si128((__m128i *)ar, _mm_castps_si128(v));
 
247
  assert(ar[0] == 0xffffffff);
 
248
  assert(ar[1] == 0);
 
249
  assert(ar[2] == 0);
 
250
  assert(ar[3] == 0xffffffff);
 
251
  assert(_mm_movemask_ps(v) == 9);
 
252
}
 
253
 
 
254
void testCmpLePs() {
 
255
  int32_t __attribute__((__aligned__(16))) ar[4];
 
256
  __m128 v1 = _mm_set_ps(1.0, 2.0, 0.1, 0.001);
 
257
  __m128 v2 = _mm_set_ps(2.0, 2.0, 0.001, 0.1);
 
258
  __m128 v = _mm_cmple_ps(v1, v2);
 
259
  _mm_store_si128((__m128i *)ar, _mm_castps_si128(v));
 
260
  assert(ar[0] == 0xffffffff);
 
261
  assert(ar[1] == 0);
 
262
  assert(ar[2] == 0xffffffff);
 
263
  assert(ar[3] == 0xffffffff);
 
264
  assert(_mm_movemask_ps(v) == 13);
 
265
}
 
266
 
 
267
void testCmpEqPs() {
 
268
  int32_t __attribute__((__aligned__(16))) ar[4];
 
269
  __m128 v1 = _mm_set_ps(1.0, 2.0, 0.1, 0.001);
 
270
  __m128 v2 = _mm_set_ps(2.0, 2.0, 0.001, 0.1);
 
271
  __m128 v = _mm_cmpeq_ps(v1, v2);
 
272
  _mm_store_si128((__m128i *)ar, _mm_castps_si128(v));
 
273
  assert(ar[0] == 0);
 
274
  assert(ar[1] == 0);
 
275
  assert(ar[2] == 0xffffffff);
 
276
  assert(ar[3] == 0);
 
277
  assert(_mm_movemask_ps(v) == 4);
 
278
}
 
279
 
 
280
void testCmpGePs() {
 
281
  int32_t __attribute__((__aligned__(16))) ar[4];
 
282
  __m128 v1 = _mm_set_ps(1.0, 2.0, 0.1, 0.001);
 
283
  __m128 v2 = _mm_set_ps(2.0, 2.0, 0.001, 0.1);
 
284
  __m128 v = _mm_cmpge_ps(v1, v2);
 
285
  _mm_store_si128((__m128i *)ar, _mm_castps_si128(v));
 
286
  assert(ar[0] == 0);
 
287
  assert(ar[1] == 0xffffffff);
 
288
  assert(ar[2] == 0xffffffff);
 
289
  assert(ar[3] == 0);
 
290
  assert(_mm_movemask_ps(v) == 6);
 
291
}
 
292
 
 
293
void testCmpGtPs() {
 
294
  int32_t __attribute__((__aligned__(16))) ar[4];
 
295
  __m128 v1 = _mm_set_ps(1.0, 2.0, 0.1, 0.001);
 
296
  __m128 v2 = _mm_set_ps(2.0, 2.0, 0.001, 0.1);
 
297
  __m128 v = _mm_cmpgt_ps(v1, v2);
 
298
  _mm_store_si128((__m128i *)ar, _mm_castps_si128(v));
 
299
  assert(ar[0] == 0);
 
300
  assert(ar[1] == 0xffffffff);
 
301
  assert(ar[2] == 0);
 
302
  assert(ar[3] == 0);
 
303
  assert(_mm_movemask_ps(v) == 2);
 
304
}
 
305
 
 
306
void testAndPs() {
 
307
  float __attribute__((__aligned__(16))) ar[4];
 
308
  __m128 v1 = _mm_set_ps(425, -501, -32, 68);
 
309
  __m128 v2 =
 
310
      _mm_castsi128_ps(_mm_set_epi32(0xffffffff, 0xffffffff, 0, 0xffffffff));
 
311
  __m128 v = _mm_and_ps(v1, v2);
 
312
  _mm_store_ps(ar, v);
 
313
  assert(ar[0] == 68);
 
314
  assert(ar[1] == 0);
 
315
  assert(ar[2] == -501);
 
316
  assert(ar[3] == 425);
 
317
  int32_t __attribute__((__aligned__(16))) ar2[4];
 
318
  v1 = _mm_castsi128_ps(
 
319
      _mm_set_epi32(0xaaaaaaaa, 0xaaaaaaaa, -1431655766, 0xaaaaaaaa));
 
320
  v2 = _mm_castsi128_ps(
 
321
      _mm_set_epi32(0x55555555, 0x55555555, 0x55555555, 0x55555555));
 
322
  v = _mm_and_ps(v1, v2);
 
323
  _mm_store_si128((__m128i *)ar2, _mm_castps_si128(v));
 
324
  assert(ar2[0] == 0);
 
325
  assert(ar2[1] == 0);
 
326
  assert(ar2[2] == 0);
 
327
  assert(ar2[3] == 0);
 
328
}
 
329
 
 
330
void testAndNotPs() {
 
331
  float __attribute__((__aligned__(16))) ar[4];
 
332
  __m128 v1 = _mm_set_ps(425, -501, -32, 68);
 
333
  __m128 v2 =
 
334
      _mm_castsi128_ps(_mm_set_epi32(0xffffffff, 0xffffffff, 0, 0xffffffff));
 
335
  __m128 v = _mm_andnot_ps(v2, v1);
 
336
  _mm_store_ps(ar, v);
 
337
  assert(ar[0] == 0);
 
338
  assert(ar[1] == -32);
 
339
  assert(ar[2] == 0);
 
340
  assert(ar[3] == 0);
 
341
  int32_t __attribute__((__aligned__(16))) ar2[4];
 
342
  v1 = _mm_castsi128_ps(
 
343
      _mm_set_epi32(0xaaaaaaaa, 0xaaaaaaaa, -1431655766, 0xaaaaaaaa));
 
344
  v2 = _mm_castsi128_ps(
 
345
      _mm_set_epi32(0x55555555, 0x55555555, 0x55555555, 0x55555555));
 
346
  v = _mm_andnot_ps(v1, v2);
 
347
  _mm_store_si128((__m128i *)ar2, _mm_castps_si128(v));
 
348
  assert(ar2[0] == 0x55555555);
 
349
  assert(ar2[1] == 0x55555555);
 
350
  assert(ar2[2] == 0x55555555);
 
351
  assert(ar2[3] == 0x55555555);
 
352
}
 
353
 
 
354
void testOrPs() {
 
355
  int32_t __attribute__((__aligned__(16))) ar[4];
 
356
  __m128 v1 =
 
357
      _mm_castsi128_ps(_mm_set_epi32(0xaaaaaaaa, 0xaaaaaaaa, 0xffffffff, 0));
 
358
  __m128 v2 = _mm_castsi128_ps(
 
359
      _mm_set_epi32(0x55555555, 0x55555555, 0x55555555, 0x55555555));
 
360
  __m128 v = _mm_or_ps(v1, v2);
 
361
  _mm_store_si128((__m128i *)ar, _mm_castps_si128(v));
 
362
  assert(ar[0] == 0x55555555);
 
363
  assert(ar[1] == 0xffffffff);
 
364
  assert(ar[2] == 0xffffffff);
 
365
  assert(ar[3] == 0xffffffff);
 
366
}
 
367
 
 
368
void testXorPs() {
 
369
  int32_t __attribute__((__aligned__(16))) ar[4];
 
370
  __m128 v1 =
 
371
      _mm_castsi128_ps(_mm_set_epi32(0xaaaaaaaa, 0xaaaaaaaa, 0xffffffff, 0));
 
372
  __m128 v2 = _mm_castsi128_ps(
 
373
      _mm_set_epi32(0x55555555, 0x55555555, 0x55555555, 0x55555555));
 
374
  __m128 v = _mm_xor_ps(v1, v2);
 
375
  _mm_store_si128((__m128i *)ar, _mm_castps_si128(v));
 
376
  assert(ar[0] == 0x55555555);
 
377
  assert(ar[1] == 0xaaaaaaaa);
 
378
  assert(ar[2] == 0xffffffff);
 
379
  assert(ar[3] == 0xffffffff);
 
380
}
 
381
 
 
382
void testAndSi128() {
 
383
  int32_t __attribute__((__aligned__(16))) ar[4];
 
384
  __m128i v1 = _mm_set_epi32(0xaaaaaaaa, 0xaaaaaaaa, -1431655766, 0xaaaaaaaa);
 
385
  __m128i v2 = _mm_set_epi32(0x55555555, 0x55555555, 0x55555555, 0x55555555);
 
386
  __m128i v = _mm_and_si128(v1, v2);
 
387
  _mm_store_si128((__m128i *)ar, v);
 
388
  assert(ar[0] == 0);
 
389
  assert(ar[1] == 0);
 
390
  assert(ar[2] == 0);
 
391
  assert(ar[3] == 0);
 
392
}
 
393
 
 
394
void testAndNotSi128() {
 
395
  int32_t __attribute__((__aligned__(16))) ar[4];
 
396
  __m128i v1 = _mm_set_epi32(0xaaaaaaaa, 0xaaaaaaaa, -1431655766, 0xaaaaaaaa);
 
397
  __m128i v2 = _mm_set_epi32(0x55555555, 0x55555555, 0x55555555, 0x55555555);
 
398
  __m128i v = _mm_andnot_si128(v1, v2);
 
399
  _mm_store_si128((__m128i *)ar, v);
 
400
  assert(ar[0] == 0x55555555);
 
401
  assert(ar[1] == 0x55555555);
 
402
  assert(ar[2] == 0x55555555);
 
403
  assert(ar[3] == 0x55555555);
 
404
}
 
405
 
 
406
void testOrSi128() {
 
407
  int32_t __attribute__((__aligned__(16))) ar[4];
 
408
  __m128i v1 = _mm_set_epi32(0xaaaaaaaa, 0xaaaaaaaa, 0xffffffff, 0);
 
409
  __m128i v2 = _mm_set_epi32(0x55555555, 0x55555555, 0x55555555, 0x55555555);
 
410
  __m128i v = _mm_or_si128(v1, v2);
 
411
  _mm_store_si128((__m128i *)ar, v);
 
412
  assert(ar[0] == 0x55555555);
 
413
  assert(ar[1] == 0xffffffff);
 
414
  assert(ar[2] == 0xffffffff);
 
415
  assert(ar[3] == 0xffffffff);
 
416
}
 
417
 
 
418
void testXorSi128() {
 
419
  int32_t __attribute__((__aligned__(16))) ar[4];
 
420
  __m128i v1 = _mm_set_epi32(0xaaaaaaaa, 0xaaaaaaaa, 0xffffffff, 0);
 
421
  __m128i v2 = _mm_set_epi32(0x55555555, 0x55555555, 0x55555555, 0x55555555);
 
422
  __m128i v = _mm_xor_si128(v1, v2);
 
423
  _mm_store_si128((__m128i *)ar, v);
 
424
  assert(ar[0] == 0x55555555);
 
425
  assert(ar[1] == 0xaaaaaaaa);
 
426
  assert(ar[2] == 0xffffffff);
 
427
  assert(ar[3] == 0xffffffff);
 
428
}
 
429
 
 
430
void testAddEpi32() {
 
431
  int32_t __attribute__((__aligned__(16))) ar[4];
 
432
  __m128i v1 = _mm_set_epi32(4, 3, 2, 1);
 
433
  __m128i v2 = _mm_set_epi32(10, 20, 30, 40);
 
434
  __m128i v = _mm_add_epi32(v1, v2);
 
435
  _mm_store_si128((__m128i *)ar, v);
 
436
  assert(ar[0] == 41);
 
437
  assert(ar[1] == 32);
 
438
  assert(ar[2] == 23);
 
439
  assert(ar[3] == 14);
 
440
}
 
441
 
 
442
void testSubEpi32() {
 
443
  int32_t __attribute__((__aligned__(16))) ar[4];
 
444
  __m128i v1 = _mm_set_epi32(4, 3, 2, 1);
 
445
  __m128i v2 = _mm_set_epi32(10, 20, 30, 40);
 
446
  __m128i v = _mm_sub_epi32(v1, v2);
 
447
  _mm_store_si128((__m128i *)ar, v);
 
448
  assert(ar[0] == -39);
 
449
  assert(ar[1] == -28);
 
450
  assert(ar[2] == -17);
 
451
  assert(ar[3] == -6);
 
452
}
 
453
 
 
454
int main(int argc, char **argv) {
 
455
  testSetPs();
 
456
  testSet1Ps();
 
457
  testSetZeroPs();
 
458
  testSetEpi32();
 
459
  testSet1Epi32();
 
460
  testSetZeroSi128();
 
461
  testBitCasts();
 
462
  testConversions();
 
463
  testMoveMaskPs();
 
464
  testAddPs();
 
465
  testSubPs();
 
466
  testMulPs();
 
467
  testDivPs();
 
468
  testMaxPs();
 
469
  testMinPs();
 
470
  testSqrtPs();
 
471
  testCmpLtPs();
 
472
  testCmpLePs();
 
473
  testCmpEqPs();
 
474
  testCmpGePs();
 
475
  testCmpGtPs();
 
476
  testAndPs();
 
477
  testAndNotPs();
 
478
  testOrPs();
 
479
  testXorPs();
 
480
  testAndSi128();
 
481
  testAndNotSi128();
 
482
  testOrSi128();
 
483
  testXorSi128();
 
484
  testAddEpi32();
 
485
  testSubEpi32();
 
486
  printf("DONE");
 
487
  return 0;
 
488
}