OpenCores
URL https://opencores.org/ocsvn/openrisc_me/openrisc_me/trunk

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gcc-4.2.2/] [gcc/] [config/] [arm/] [mmintrin.h] - Blame information for rev 154

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 38 julius
/* Copyright (C) 2002, 2003, 2004 Free Software Foundation, Inc.
2
 
3
   This file is part of GCC.
4
 
5
   GCC is free software; you can redistribute it and/or modify it
6
   under the terms of the GNU General Public License as published
7
   by the Free Software Foundation; either version 2, or (at your
8
   option) any later version.
9
 
10
   GCC is distributed in the hope that it will be useful, but WITHOUT
11
   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
12
   or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
13
   License for more details.
14
 
15
   You should have received a copy of the GNU General Public License
16
   along with GCC; see the file COPYING.  If not, write to the Free
17
   Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
18
   02110-1301, USA.  */
19
 
20
/* As a special exception, if you include this header file into source
21
   files compiled by GCC, this header file does not by itself cause
22
   the resulting executable to be covered by the GNU General Public
23
   License.  This exception does not however invalidate any other
24
   reasons why the executable file might be covered by the GNU General
25
   Public License.  */
26
 
27
#ifndef _MMINTRIN_H_INCLUDED
28
#define _MMINTRIN_H_INCLUDED
29
 
30
/* The data type intended for user use.  */
31
typedef unsigned long long __m64, __int64;
32
 
33
/* Internal data types for implementing the intrinsics.  */
34
typedef int __v2si __attribute__ ((vector_size (8)));
35
typedef short __v4hi __attribute__ ((vector_size (8)));
36
typedef char __v8qi __attribute__ ((vector_size (8)));
37
 
38
/* "Convert" __m64 and __int64 into each other.  */
39
static __inline __m64
40
_mm_cvtsi64_m64 (__int64 __i)
41
{
42
  return __i;
43
}
44
 
45
static __inline __int64
46
_mm_cvtm64_si64 (__m64 __i)
47
{
48
  return __i;
49
}
50
 
51
static __inline int
52
_mm_cvtsi64_si32 (__int64 __i)
53
{
54
  return __i;
55
}
56
 
57
static __inline __int64
58
_mm_cvtsi32_si64 (int __i)
59
{
60
  return __i;
61
}
62
 
63
/* Pack the four 16-bit values from M1 into the lower four 8-bit values of
64
   the result, and the four 16-bit values from M2 into the upper four 8-bit
65
   values of the result, all with signed saturation.  */
66
static __inline __m64
67
_mm_packs_pi16 (__m64 __m1, __m64 __m2)
68
{
69
  return (__m64) __builtin_arm_wpackhss ((__v4hi)__m1, (__v4hi)__m2);
70
}
71
 
72
/* Pack the two 32-bit values from M1 in to the lower two 16-bit values of
73
   the result, and the two 32-bit values from M2 into the upper two 16-bit
74
   values of the result, all with signed saturation.  */
75
static __inline __m64
76
_mm_packs_pi32 (__m64 __m1, __m64 __m2)
77
{
78
  return (__m64) __builtin_arm_wpackwss ((__v2si)__m1, (__v2si)__m2);
79
}
80
 
81
/* Copy the 64-bit value from M1 into the lower 32-bits of the result, and
82
   the 64-bit value from M2 into the upper 32-bits of the result, all with
83
   signed saturation for values that do not fit exactly into 32-bits.  */
84
static __inline __m64
85
_mm_packs_pi64 (__m64 __m1, __m64 __m2)
86
{
87
  return (__m64) __builtin_arm_wpackdss ((long long)__m1, (long long)__m2);
88
}
89
 
90
/* Pack the four 16-bit values from M1 into the lower four 8-bit values of
91
   the result, and the four 16-bit values from M2 into the upper four 8-bit
92
   values of the result, all with unsigned saturation.  */
93
static __inline __m64
94
_mm_packs_pu16 (__m64 __m1, __m64 __m2)
95
{
96
  return (__m64) __builtin_arm_wpackhus ((__v4hi)__m1, (__v4hi)__m2);
97
}
98
 
99
/* Pack the two 32-bit values from M1 into the lower two 16-bit values of
100
   the result, and the two 32-bit values from M2 into the upper two 16-bit
101
   values of the result, all with unsigned saturation.  */
102
static __inline __m64
103
_mm_packs_pu32 (__m64 __m1, __m64 __m2)
104
{
105
  return (__m64) __builtin_arm_wpackwus ((__v2si)__m1, (__v2si)__m2);
106
}
107
 
108
/* Copy the 64-bit value from M1 into the lower 32-bits of the result, and
109
   the 64-bit value from M2 into the upper 32-bits of the result, all with
110
   unsigned saturation for values that do not fit exactly into 32-bits.  */
111
static __inline __m64
112
_mm_packs_pu64 (__m64 __m1, __m64 __m2)
113
{
114
  return (__m64) __builtin_arm_wpackdus ((long long)__m1, (long long)__m2);
115
}
116
 
117
/* Interleave the four 8-bit values from the high half of M1 with the four
118
   8-bit values from the high half of M2.  */
119
static __inline __m64
120
_mm_unpackhi_pi8 (__m64 __m1, __m64 __m2)
121
{
122
  return (__m64) __builtin_arm_wunpckihb ((__v8qi)__m1, (__v8qi)__m2);
123
}
124
 
125
/* Interleave the two 16-bit values from the high half of M1 with the two
126
   16-bit values from the high half of M2.  */
127
static __inline __m64
128
_mm_unpackhi_pi16 (__m64 __m1, __m64 __m2)
129
{
130
  return (__m64) __builtin_arm_wunpckihh ((__v4hi)__m1, (__v4hi)__m2);
131
}
132
 
133
/* Interleave the 32-bit value from the high half of M1 with the 32-bit
134
   value from the high half of M2.  */
135
static __inline __m64
136
_mm_unpackhi_pi32 (__m64 __m1, __m64 __m2)
137
{
138
  return (__m64) __builtin_arm_wunpckihw ((__v2si)__m1, (__v2si)__m2);
139
}
140
 
141
/* Interleave the four 8-bit values from the low half of M1 with the four
142
   8-bit values from the low half of M2.  */
143
static __inline __m64
144
_mm_unpacklo_pi8 (__m64 __m1, __m64 __m2)
145
{
146
  return (__m64) __builtin_arm_wunpckilb ((__v8qi)__m1, (__v8qi)__m2);
147
}
148
 
149
/* Interleave the two 16-bit values from the low half of M1 with the two
150
   16-bit values from the low half of M2.  */
151
static __inline __m64
152
_mm_unpacklo_pi16 (__m64 __m1, __m64 __m2)
153
{
154
  return (__m64) __builtin_arm_wunpckilh ((__v4hi)__m1, (__v4hi)__m2);
155
}
156
 
157
/* Interleave the 32-bit value from the low half of M1 with the 32-bit
158
   value from the low half of M2.  */
159
static __inline __m64
160
_mm_unpacklo_pi32 (__m64 __m1, __m64 __m2)
161
{
162
  return (__m64) __builtin_arm_wunpckilw ((__v2si)__m1, (__v2si)__m2);
163
}
164
 
165
/* Take the four 8-bit values from the low half of M1, sign extend them,
166
   and return the result as a vector of four 16-bit quantities.  */
167
static __inline __m64
168
_mm_unpackel_pi8 (__m64 __m1)
169
{
170
  return (__m64) __builtin_arm_wunpckelsb ((__v8qi)__m1);
171
}
172
 
173
/* Take the two 16-bit values from the low half of M1, sign extend them,
174
   and return the result as a vector of two 32-bit quantities.  */
175
static __inline __m64
176
_mm_unpackel_pi16 (__m64 __m1)
177
{
178
  return (__m64) __builtin_arm_wunpckelsh ((__v4hi)__m1);
179
}
180
 
181
/* Take the 32-bit value from the low half of M1, and return it sign extended
182
  to 64 bits.  */
183
static __inline __m64
184
_mm_unpackel_pi32 (__m64 __m1)
185
{
186
  return (__m64) __builtin_arm_wunpckelsw ((__v2si)__m1);
187
}
188
 
189
/* Take the four 8-bit values from the high half of M1, sign extend them,
190
   and return the result as a vector of four 16-bit quantities.  */
191
static __inline __m64
192
_mm_unpackeh_pi8 (__m64 __m1)
193
{
194
  return (__m64) __builtin_arm_wunpckehsb ((__v8qi)__m1);
195
}
196
 
197
/* Take the two 16-bit values from the high half of M1, sign extend them,
198
   and return the result as a vector of two 32-bit quantities.  */
199
static __inline __m64
200
_mm_unpackeh_pi16 (__m64 __m1)
201
{
202
  return (__m64) __builtin_arm_wunpckehsh ((__v4hi)__m1);
203
}
204
 
205
/* Take the 32-bit value from the high half of M1, and return it sign extended
206
  to 64 bits.  */
207
static __inline __m64
208
_mm_unpackeh_pi32 (__m64 __m1)
209
{
210
  return (__m64) __builtin_arm_wunpckehsw ((__v2si)__m1);
211
}
212
 
213
/* Take the four 8-bit values from the low half of M1, zero extend them,
214
   and return the result as a vector of four 16-bit quantities.  */
215
static __inline __m64
216
_mm_unpackel_pu8 (__m64 __m1)
217
{
218
  return (__m64) __builtin_arm_wunpckelub ((__v8qi)__m1);
219
}
220
 
221
/* Take the two 16-bit values from the low half of M1, zero extend them,
222
   and return the result as a vector of two 32-bit quantities.  */
223
static __inline __m64
224
_mm_unpackel_pu16 (__m64 __m1)
225
{
226
  return (__m64) __builtin_arm_wunpckeluh ((__v4hi)__m1);
227
}
228
 
229
/* Take the 32-bit value from the low half of M1, and return it zero extended
230
  to 64 bits.  */
231
static __inline __m64
232
_mm_unpackel_pu32 (__m64 __m1)
233
{
234
  return (__m64) __builtin_arm_wunpckeluw ((__v2si)__m1);
235
}
236
 
237
/* Take the four 8-bit values from the high half of M1, zero extend them,
238
   and return the result as a vector of four 16-bit quantities.  */
239
static __inline __m64
240
_mm_unpackeh_pu8 (__m64 __m1)
241
{
242
  return (__m64) __builtin_arm_wunpckehub ((__v8qi)__m1);
243
}
244
 
245
/* Take the two 16-bit values from the high half of M1, zero extend them,
246
   and return the result as a vector of two 32-bit quantities.  */
247
static __inline __m64
248
_mm_unpackeh_pu16 (__m64 __m1)
249
{
250
  return (__m64) __builtin_arm_wunpckehuh ((__v4hi)__m1);
251
}
252
 
253
/* Take the 32-bit value from the high half of M1, and return it zero extended
254
  to 64 bits.  */
255
static __inline __m64
256
_mm_unpackeh_pu32 (__m64 __m1)
257
{
258
  return (__m64) __builtin_arm_wunpckehuw ((__v2si)__m1);
259
}
260
 
261
/* Add the 8-bit values in M1 to the 8-bit values in M2.  */
262
static __inline __m64
263
_mm_add_pi8 (__m64 __m1, __m64 __m2)
264
{
265
  return (__m64) __builtin_arm_waddb ((__v8qi)__m1, (__v8qi)__m2);
266
}
267
 
268
/* Add the 16-bit values in M1 to the 16-bit values in M2.  */
269
static __inline __m64
270
_mm_add_pi16 (__m64 __m1, __m64 __m2)
271
{
272
  return (__m64) __builtin_arm_waddh ((__v4hi)__m1, (__v4hi)__m2);
273
}
274
 
275
/* Add the 32-bit values in M1 to the 32-bit values in M2.  */
276
static __inline __m64
277
_mm_add_pi32 (__m64 __m1, __m64 __m2)
278
{
279
  return (__m64) __builtin_arm_waddw ((__v2si)__m1, (__v2si)__m2);
280
}
281
 
282
/* Add the 8-bit values in M1 to the 8-bit values in M2 using signed
283
   saturated arithmetic.  */
284
static __inline __m64
285
_mm_adds_pi8 (__m64 __m1, __m64 __m2)
286
{
287
  return (__m64) __builtin_arm_waddbss ((__v8qi)__m1, (__v8qi)__m2);
288
}
289
 
290
/* Add the 16-bit values in M1 to the 16-bit values in M2 using signed
291
   saturated arithmetic.  */
292
static __inline __m64
293
_mm_adds_pi16 (__m64 __m1, __m64 __m2)
294
{
295
  return (__m64) __builtin_arm_waddhss ((__v4hi)__m1, (__v4hi)__m2);
296
}
297
 
298
/* Add the 32-bit values in M1 to the 32-bit values in M2 using signed
299
   saturated arithmetic.  */
300
static __inline __m64
301
_mm_adds_pi32 (__m64 __m1, __m64 __m2)
302
{
303
  return (__m64) __builtin_arm_waddwss ((__v2si)__m1, (__v2si)__m2);
304
}
305
 
306
/* Add the 8-bit values in M1 to the 8-bit values in M2 using unsigned
307
   saturated arithmetic.  */
308
static __inline __m64
309
_mm_adds_pu8 (__m64 __m1, __m64 __m2)
310
{
311
  return (__m64) __builtin_arm_waddbus ((__v8qi)__m1, (__v8qi)__m2);
312
}
313
 
314
/* Add the 16-bit values in M1 to the 16-bit values in M2 using unsigned
315
   saturated arithmetic.  */
316
static __inline __m64
317
_mm_adds_pu16 (__m64 __m1, __m64 __m2)
318
{
319
  return (__m64) __builtin_arm_waddhus ((__v4hi)__m1, (__v4hi)__m2);
320
}
321
 
322
/* Add the 32-bit values in M1 to the 32-bit values in M2 using unsigned
323
   saturated arithmetic.  */
324
static __inline __m64
325
_mm_adds_pu32 (__m64 __m1, __m64 __m2)
326
{
327
  return (__m64) __builtin_arm_waddwus ((__v2si)__m1, (__v2si)__m2);
328
}
329
 
330
/* Subtract the 8-bit values in M2 from the 8-bit values in M1.  */
331
static __inline __m64
332
_mm_sub_pi8 (__m64 __m1, __m64 __m2)
333
{
334
  return (__m64) __builtin_arm_wsubb ((__v8qi)__m1, (__v8qi)__m2);
335
}
336
 
337
/* Subtract the 16-bit values in M2 from the 16-bit values in M1.  */
338
static __inline __m64
339
_mm_sub_pi16 (__m64 __m1, __m64 __m2)
340
{
341
  return (__m64) __builtin_arm_wsubh ((__v4hi)__m1, (__v4hi)__m2);
342
}
343
 
344
/* Subtract the 32-bit values in M2 from the 32-bit values in M1.  */
345
static __inline __m64
346
_mm_sub_pi32 (__m64 __m1, __m64 __m2)
347
{
348
  return (__m64) __builtin_arm_wsubw ((__v2si)__m1, (__v2si)__m2);
349
}
350
 
351
/* Subtract the 8-bit values in M2 from the 8-bit values in M1 using signed
352
   saturating arithmetic.  */
353
static __inline __m64
354
_mm_subs_pi8 (__m64 __m1, __m64 __m2)
355
{
356
  return (__m64) __builtin_arm_wsubbss ((__v8qi)__m1, (__v8qi)__m2);
357
}
358
 
359
/* Subtract the 16-bit values in M2 from the 16-bit values in M1 using
360
   signed saturating arithmetic.  */
361
static __inline __m64
362
_mm_subs_pi16 (__m64 __m1, __m64 __m2)
363
{
364
  return (__m64) __builtin_arm_wsubhss ((__v4hi)__m1, (__v4hi)__m2);
365
}
366
 
367
/* Subtract the 32-bit values in M2 from the 32-bit values in M1 using
368
   signed saturating arithmetic.  */
369
static __inline __m64
370
_mm_subs_pi32 (__m64 __m1, __m64 __m2)
371
{
372
  return (__m64) __builtin_arm_wsubwss ((__v2si)__m1, (__v2si)__m2);
373
}
374
 
375
/* Subtract the 8-bit values in M2 from the 8-bit values in M1 using
376
   unsigned saturating arithmetic.  */
377
static __inline __m64
378
_mm_subs_pu8 (__m64 __m1, __m64 __m2)
379
{
380
  return (__m64) __builtin_arm_wsubbus ((__v8qi)__m1, (__v8qi)__m2);
381
}
382
 
383
/* Subtract the 16-bit values in M2 from the 16-bit values in M1 using
384
   unsigned saturating arithmetic.  */
385
static __inline __m64
386
_mm_subs_pu16 (__m64 __m1, __m64 __m2)
387
{
388
  return (__m64) __builtin_arm_wsubhus ((__v4hi)__m1, (__v4hi)__m2);
389
}
390
 
391
/* Subtract the 32-bit values in M2 from the 32-bit values in M1 using
392
   unsigned saturating arithmetic.  */
393
static __inline __m64
394
_mm_subs_pu32 (__m64 __m1, __m64 __m2)
395
{
396
  return (__m64) __builtin_arm_wsubwus ((__v2si)__m1, (__v2si)__m2);
397
}
398
 
399
/* Multiply four 16-bit values in M1 by four 16-bit values in M2 producing
400
   four 32-bit intermediate results, which are then summed by pairs to
401
   produce two 32-bit results.  */
402
static __inline __m64
403
_mm_madd_pi16 (__m64 __m1, __m64 __m2)
404
{
405
  return (__m64) __builtin_arm_wmadds ((__v4hi)__m1, (__v4hi)__m2);
406
}
407
 
408
/* Multiply four 16-bit values in M1 by four 16-bit values in M2 producing
409
   four 32-bit intermediate results, which are then summed by pairs to
410
   produce two 32-bit results.  */
411
static __inline __m64
412
_mm_madd_pu16 (__m64 __m1, __m64 __m2)
413
{
414
  return (__m64) __builtin_arm_wmaddu ((__v4hi)__m1, (__v4hi)__m2);
415
}
416
 
417
/* Multiply four signed 16-bit values in M1 by four signed 16-bit values in
418
   M2 and produce the high 16 bits of the 32-bit results.  */
419
static __inline __m64
420
_mm_mulhi_pi16 (__m64 __m1, __m64 __m2)
421
{
422
  return (__m64) __builtin_arm_wmulsm ((__v4hi)__m1, (__v4hi)__m2);
423
}
424
 
425
/* Multiply four signed 16-bit values in M1 by four signed 16-bit values in
426
   M2 and produce the high 16 bits of the 32-bit results.  */
427
static __inline __m64
428
_mm_mulhi_pu16 (__m64 __m1, __m64 __m2)
429
{
430
  return (__m64) __builtin_arm_wmulum ((__v4hi)__m1, (__v4hi)__m2);
431
}
432
 
433
/* Multiply four 16-bit values in M1 by four 16-bit values in M2 and produce
434
   the low 16 bits of the results.  */
435
static __inline __m64
436
_mm_mullo_pi16 (__m64 __m1, __m64 __m2)
437
{
438
  return (__m64) __builtin_arm_wmulul ((__v4hi)__m1, (__v4hi)__m2);
439
}
440
 
441
/* Shift four 16-bit values in M left by COUNT.  */
442
static __inline __m64
443
_mm_sll_pi16 (__m64 __m, __m64 __count)
444
{
445
  return (__m64) __builtin_arm_wsllh ((__v4hi)__m, __count);
446
}
447
 
448
static __inline __m64
449
_mm_slli_pi16 (__m64 __m, int __count)
450
{
451
  return (__m64) __builtin_arm_wsllhi ((__v4hi)__m, __count);
452
}
453
 
454
/* Shift two 32-bit values in M left by COUNT.  */
455
static __inline __m64
456
_mm_sll_pi32 (__m64 __m, __m64 __count)
457
{
458
  return (__m64) __builtin_arm_wsllw ((__v2si)__m, __count);
459
}
460
 
461
static __inline __m64
462
_mm_slli_pi32 (__m64 __m, int __count)
463
{
464
  return (__m64) __builtin_arm_wsllwi ((__v2si)__m, __count);
465
}
466
 
467
/* Shift the 64-bit value in M left by COUNT.  */
468
static __inline __m64
469
_mm_sll_si64 (__m64 __m, __m64 __count)
470
{
471
  return (__m64) __builtin_arm_wslld (__m, __count);
472
}
473
 
474
static __inline __m64
475
_mm_slli_si64 (__m64 __m, int __count)
476
{
477
  return (__m64) __builtin_arm_wslldi (__m, __count);
478
}
479
 
480
/* Shift four 16-bit values in M right by COUNT; shift in the sign bit.  */
481
static __inline __m64
482
_mm_sra_pi16 (__m64 __m, __m64 __count)
483
{
484
  return (__m64) __builtin_arm_wsrah ((__v4hi)__m, __count);
485
}
486
 
487
static __inline __m64
488
_mm_srai_pi16 (__m64 __m, int __count)
489
{
490
  return (__m64) __builtin_arm_wsrahi ((__v4hi)__m, __count);
491
}
492
 
493
/* Shift two 32-bit values in M right by COUNT; shift in the sign bit.  */
494
static __inline __m64
495
_mm_sra_pi32 (__m64 __m, __m64 __count)
496
{
497
  return (__m64) __builtin_arm_wsraw ((__v2si)__m, __count);
498
}
499
 
500
static __inline __m64
501
_mm_srai_pi32 (__m64 __m, int __count)
502
{
503
  return (__m64) __builtin_arm_wsrawi ((__v2si)__m, __count);
504
}
505
 
506
/* Shift the 64-bit value in M right by COUNT; shift in the sign bit.  */
507
static __inline __m64
508
_mm_sra_si64 (__m64 __m, __m64 __count)
509
{
510
  return (__m64) __builtin_arm_wsrad (__m, __count);
511
}
512
 
513
static __inline __m64
514
_mm_srai_si64 (__m64 __m, int __count)
515
{
516
  return (__m64) __builtin_arm_wsradi (__m, __count);
517
}
518
 
519
/* Shift four 16-bit values in M right by COUNT; shift in zeros.  */
520
static __inline __m64
521
_mm_srl_pi16 (__m64 __m, __m64 __count)
522
{
523
  return (__m64) __builtin_arm_wsrlh ((__v4hi)__m, __count);
524
}
525
 
526
static __inline __m64
527
_mm_srli_pi16 (__m64 __m, int __count)
528
{
529
  return (__m64) __builtin_arm_wsrlhi ((__v4hi)__m, __count);
530
}
531
 
532
/* Shift two 32-bit values in M right by COUNT; shift in zeros.  */
533
static __inline __m64
534
_mm_srl_pi32 (__m64 __m, __m64 __count)
535
{
536
  return (__m64) __builtin_arm_wsrlw ((__v2si)__m, __count);
537
}
538
 
539
static __inline __m64
540
_mm_srli_pi32 (__m64 __m, int __count)
541
{
542
  return (__m64) __builtin_arm_wsrlwi ((__v2si)__m, __count);
543
}
544
 
545
/* Shift the 64-bit value in M left by COUNT; shift in zeros.  */
546
static __inline __m64
547
_mm_srl_si64 (__m64 __m, __m64 __count)
548
{
549
  return (__m64) __builtin_arm_wsrld (__m, __count);
550
}
551
 
552
static __inline __m64
553
_mm_srli_si64 (__m64 __m, int __count)
554
{
555
  return (__m64) __builtin_arm_wsrldi (__m, __count);
556
}
557
 
558
/* Rotate four 16-bit values in M right by COUNT.  */
559
static __inline __m64
560
_mm_ror_pi16 (__m64 __m, __m64 __count)
561
{
562
  return (__m64) __builtin_arm_wrorh ((__v4hi)__m, __count);
563
}
564
 
565
static __inline __m64
566
_mm_rori_pi16 (__m64 __m, int __count)
567
{
568
  return (__m64) __builtin_arm_wrorhi ((__v4hi)__m, __count);
569
}
570
 
571
/* Rotate two 32-bit values in M right by COUNT.  */
572
static __inline __m64
573
_mm_ror_pi32 (__m64 __m, __m64 __count)
574
{
575
  return (__m64) __builtin_arm_wrorw ((__v2si)__m, __count);
576
}
577
 
578
static __inline __m64
579
_mm_rori_pi32 (__m64 __m, int __count)
580
{
581
  return (__m64) __builtin_arm_wrorwi ((__v2si)__m, __count);
582
}
583
 
584
/* Rotate two 64-bit values in M right by COUNT.  */
585
static __inline __m64
586
_mm_ror_si64 (__m64 __m, __m64 __count)
587
{
588
  return (__m64) __builtin_arm_wrord (__m, __count);
589
}
590
 
591
static __inline __m64
592
_mm_rori_si64 (__m64 __m, int __count)
593
{
594
  return (__m64) __builtin_arm_wrordi (__m, __count);
595
}
596
 
597
/* Bit-wise AND the 64-bit values in M1 and M2.  */
598
static __inline __m64
599
_mm_and_si64 (__m64 __m1, __m64 __m2)
600
{
601
  return __builtin_arm_wand (__m1, __m2);
602
}
603
 
604
/* Bit-wise complement the 64-bit value in M1 and bit-wise AND it with the
605
   64-bit value in M2.  */
606
static __inline __m64
607
_mm_andnot_si64 (__m64 __m1, __m64 __m2)
608
{
609
  return __builtin_arm_wandn (__m1, __m2);
610
}
611
 
612
/* Bit-wise inclusive OR the 64-bit values in M1 and M2.  */
613
static __inline __m64
614
_mm_or_si64 (__m64 __m1, __m64 __m2)
615
{
616
  return __builtin_arm_wor (__m1, __m2);
617
}
618
 
619
/* Bit-wise exclusive OR the 64-bit values in M1 and M2.  */
620
static __inline __m64
621
_mm_xor_si64 (__m64 __m1, __m64 __m2)
622
{
623
  return __builtin_arm_wxor (__m1, __m2);
624
}
625
 
626
/* Compare eight 8-bit values.  The result of the comparison is 0xFF if the
627
   test is true and zero if false.  */
628
static __inline __m64
629
_mm_cmpeq_pi8 (__m64 __m1, __m64 __m2)
630
{
631
  return (__m64) __builtin_arm_wcmpeqb ((__v8qi)__m1, (__v8qi)__m2);
632
}
633
 
634
static __inline __m64
635
_mm_cmpgt_pi8 (__m64 __m1, __m64 __m2)
636
{
637
  return (__m64) __builtin_arm_wcmpgtsb ((__v8qi)__m1, (__v8qi)__m2);
638
}
639
 
640
static __inline __m64
641
_mm_cmpgt_pu8 (__m64 __m1, __m64 __m2)
642
{
643
  return (__m64) __builtin_arm_wcmpgtub ((__v8qi)__m1, (__v8qi)__m2);
644
}
645
 
646
/* Compare four 16-bit values.  The result of the comparison is 0xFFFF if
647
   the test is true and zero if false.  */
648
static __inline __m64
649
_mm_cmpeq_pi16 (__m64 __m1, __m64 __m2)
650
{
651
  return (__m64) __builtin_arm_wcmpeqh ((__v4hi)__m1, (__v4hi)__m2);
652
}
653
 
654
static __inline __m64
655
_mm_cmpgt_pi16 (__m64 __m1, __m64 __m2)
656
{
657
  return (__m64) __builtin_arm_wcmpgtsh ((__v4hi)__m1, (__v4hi)__m2);
658
}
659
 
660
static __inline __m64
661
_mm_cmpgt_pu16 (__m64 __m1, __m64 __m2)
662
{
663
  return (__m64) __builtin_arm_wcmpgtuh ((__v4hi)__m1, (__v4hi)__m2);
664
}
665
 
666
/* Compare two 32-bit values.  The result of the comparison is 0xFFFFFFFF if
667
   the test is true and zero if false.  */
668
static __inline __m64
669
_mm_cmpeq_pi32 (__m64 __m1, __m64 __m2)
670
{
671
  return (__m64) __builtin_arm_wcmpeqw ((__v2si)__m1, (__v2si)__m2);
672
}
673
 
674
static __inline __m64
675
_mm_cmpgt_pi32 (__m64 __m1, __m64 __m2)
676
{
677
  return (__m64) __builtin_arm_wcmpgtsw ((__v2si)__m1, (__v2si)__m2);
678
}
679
 
680
static __inline __m64
681
_mm_cmpgt_pu32 (__m64 __m1, __m64 __m2)
682
{
683
  return (__m64) __builtin_arm_wcmpgtuw ((__v2si)__m1, (__v2si)__m2);
684
}
685
 
686
/* Element-wise multiplication of unsigned 16-bit values __B and __C, followed
687
   by accumulate across all elements and __A.  */
688
static __inline __m64
689
_mm_mac_pu16 (__m64 __A, __m64 __B, __m64 __C)
690
{
691
  return __builtin_arm_wmacu (__A, (__v4hi)__B, (__v4hi)__C);
692
}
693
 
694
/* Element-wise multiplication of signed 16-bit values __B and __C, followed
695
   by accumulate across all elements and __A.  */
696
static __inline __m64
697
_mm_mac_pi16 (__m64 __A, __m64 __B, __m64 __C)
698
{
699
  return __builtin_arm_wmacs (__A, (__v4hi)__B, (__v4hi)__C);
700
}
701
 
702
/* Element-wise multiplication of unsigned 16-bit values __B and __C, followed
703
   by accumulate across all elements.  */
704
static __inline __m64
705
_mm_macz_pu16 (__m64 __A, __m64 __B)
706
{
707
  return __builtin_arm_wmacuz ((__v4hi)__A, (__v4hi)__B);
708
}
709
 
710
/* Element-wise multiplication of signed 16-bit values __B and __C, followed
711
   by accumulate across all elements.  */
712
static __inline __m64
713
_mm_macz_pi16 (__m64 __A, __m64 __B)
714
{
715
  return __builtin_arm_wmacsz ((__v4hi)__A, (__v4hi)__B);
716
}
717
 
718
/* Accumulate across all unsigned 8-bit values in __A.  */
719
static __inline __m64
720
_mm_acc_pu8 (__m64 __A)
721
{
722
  return __builtin_arm_waccb ((__v8qi)__A);
723
}
724
 
725
/* Accumulate across all unsigned 16-bit values in __A.  */
726
static __inline __m64
727
_mm_acc_pu16 (__m64 __A)
728
{
729
  return __builtin_arm_wacch ((__v4hi)__A);
730
}
731
 
732
/* Accumulate across all unsigned 32-bit values in __A.  */
733
static __inline __m64
734
_mm_acc_pu32 (__m64 __A)
735
{
736
  return __builtin_arm_waccw ((__v2si)__A);
737
}
738
 
739
static __inline __m64
740
_mm_mia_si64 (__m64 __A, int __B, int __C)
741
{
742
  return __builtin_arm_tmia (__A, __B, __C);
743
}
744
 
745
static __inline __m64
746
_mm_miaph_si64 (__m64 __A, int __B, int __C)
747
{
748
  return __builtin_arm_tmiaph (__A, __B, __C);
749
}
750
 
751
static __inline __m64
752
_mm_miabb_si64 (__m64 __A, int __B, int __C)
753
{
754
  return __builtin_arm_tmiabb (__A, __B, __C);
755
}
756
 
757
static __inline __m64
758
_mm_miabt_si64 (__m64 __A, int __B, int __C)
759
{
760
  return __builtin_arm_tmiabt (__A, __B, __C);
761
}
762
 
763
static __inline __m64
764
_mm_miatb_si64 (__m64 __A, int __B, int __C)
765
{
766
  return __builtin_arm_tmiatb (__A, __B, __C);
767
}
768
 
769
static __inline __m64
770
_mm_miatt_si64 (__m64 __A, int __B, int __C)
771
{
772
  return __builtin_arm_tmiatt (__A, __B, __C);
773
}
774
 
775
/* Extract one of the elements of A and sign extend.  The selector N must
776
   be immediate.  */
777
#define _mm_extract_pi8(A, N) __builtin_arm_textrmsb ((__v8qi)(A), (N))
778
#define _mm_extract_pi16(A, N) __builtin_arm_textrmsh ((__v4hi)(A), (N))
779
#define _mm_extract_pi32(A, N) __builtin_arm_textrmsw ((__v2si)(A), (N))
780
 
781
/* Extract one of the elements of A and zero extend.  The selector N must
782
   be immediate.  */
783
#define _mm_extract_pu8(A, N) __builtin_arm_textrmub ((__v8qi)(A), (N))
784
#define _mm_extract_pu16(A, N) __builtin_arm_textrmuh ((__v4hi)(A), (N))
785
#define _mm_extract_pu32(A, N) __builtin_arm_textrmuw ((__v2si)(A), (N))
786
 
787
/* Inserts word D into one of the elements of A.  The selector N must be
788
   immediate.  */
789
#define _mm_insert_pi8(A, D, N) \
790
  ((__m64) __builtin_arm_tinsrb ((__v8qi)(A), (D), (N)))
791
#define _mm_insert_pi16(A, D, N) \
792
  ((__m64) __builtin_arm_tinsrh ((__v4hi)(A), (D), (N)))
793
#define _mm_insert_pi32(A, D, N) \
794
  ((__m64) __builtin_arm_tinsrw ((__v2si)(A), (D), (N)))
795
 
796
/* Compute the element-wise maximum of signed 8-bit values.  */
797
static __inline __m64
798
_mm_max_pi8 (__m64 __A, __m64 __B)
799
{
800
  return (__m64) __builtin_arm_wmaxsb ((__v8qi)__A, (__v8qi)__B);
801
}
802
 
803
/* Compute the element-wise maximum of signed 16-bit values.  */
804
static __inline __m64
805
_mm_max_pi16 (__m64 __A, __m64 __B)
806
{
807
  return (__m64) __builtin_arm_wmaxsh ((__v4hi)__A, (__v4hi)__B);
808
}
809
 
810
/* Compute the element-wise maximum of signed 32-bit values.  */
811
static __inline __m64
812
_mm_max_pi32 (__m64 __A, __m64 __B)
813
{
814
  return (__m64) __builtin_arm_wmaxsw ((__v2si)__A, (__v2si)__B);
815
}
816
 
817
/* Compute the element-wise maximum of unsigned 8-bit values.  */
818
static __inline __m64
819
_mm_max_pu8 (__m64 __A, __m64 __B)
820
{
821
  return (__m64) __builtin_arm_wmaxub ((__v8qi)__A, (__v8qi)__B);
822
}
823
 
824
/* Compute the element-wise maximum of unsigned 16-bit values.  */
825
static __inline __m64
826
_mm_max_pu16 (__m64 __A, __m64 __B)
827
{
828
  return (__m64) __builtin_arm_wmaxuh ((__v4hi)__A, (__v4hi)__B);
829
}
830
 
831
/* Compute the element-wise maximum of unsigned 32-bit values.  */
832
static __inline __m64
833
_mm_max_pu32 (__m64 __A, __m64 __B)
834
{
835
  return (__m64) __builtin_arm_wmaxuw ((__v2si)__A, (__v2si)__B);
836
}
837
 
838
/* Compute the element-wise minimum of signed 16-bit values.  */
839
static __inline __m64
840
_mm_min_pi8 (__m64 __A, __m64 __B)
841
{
842
  return (__m64) __builtin_arm_wminsb ((__v8qi)__A, (__v8qi)__B);
843
}
844
 
845
/* Compute the element-wise minimum of signed 16-bit values.  */
846
static __inline __m64
847
_mm_min_pi16 (__m64 __A, __m64 __B)
848
{
849
  return (__m64) __builtin_arm_wminsh ((__v4hi)__A, (__v4hi)__B);
850
}
851
 
852
/* Compute the element-wise minimum of signed 32-bit values.  */
853
static __inline __m64
854
_mm_min_pi32 (__m64 __A, __m64 __B)
855
{
856
  return (__m64) __builtin_arm_wminsw ((__v2si)__A, (__v2si)__B);
857
}
858
 
859
/* Compute the element-wise minimum of unsigned 16-bit values.  */
860
static __inline __m64
861
_mm_min_pu8 (__m64 __A, __m64 __B)
862
{
863
  return (__m64) __builtin_arm_wminub ((__v8qi)__A, (__v8qi)__B);
864
}
865
 
866
/* Compute the element-wise minimum of unsigned 16-bit values.  */
867
static __inline __m64
868
_mm_min_pu16 (__m64 __A, __m64 __B)
869
{
870
  return (__m64) __builtin_arm_wminuh ((__v4hi)__A, (__v4hi)__B);
871
}
872
 
873
/* Compute the element-wise minimum of unsigned 32-bit values.  */
874
static __inline __m64
875
_mm_min_pu32 (__m64 __A, __m64 __B)
876
{
877
  return (__m64) __builtin_arm_wminuw ((__v2si)__A, (__v2si)__B);
878
}
879
 
880
/* Create an 8-bit mask of the signs of 8-bit values.  */
881
static __inline int
882
_mm_movemask_pi8 (__m64 __A)
883
{
884
  return __builtin_arm_tmovmskb ((__v8qi)__A);
885
}
886
 
887
/* Create an 8-bit mask of the signs of 16-bit values.  */
888
static __inline int
889
_mm_movemask_pi16 (__m64 __A)
890
{
891
  return __builtin_arm_tmovmskh ((__v4hi)__A);
892
}
893
 
894
/* Create an 8-bit mask of the signs of 32-bit values.  */
895
static __inline int
896
_mm_movemask_pi32 (__m64 __A)
897
{
898
  return __builtin_arm_tmovmskw ((__v2si)__A);
899
}
900
 
901
/* Return a combination of the four 16-bit values in A.  The selector
902
   must be an immediate.  */
903
#define _mm_shuffle_pi16(A, N) \
904
  ((__m64) __builtin_arm_wshufh ((__v4hi)(A), (N)))
905
 
906
 
907
/* Compute the rounded averages of the unsigned 8-bit values in A and B.  */
908
static __inline __m64
909
_mm_avg_pu8 (__m64 __A, __m64 __B)
910
{
911
  return (__m64) __builtin_arm_wavg2br ((__v8qi)__A, (__v8qi)__B);
912
}
913
 
914
/* Compute the rounded averages of the unsigned 16-bit values in A and B.  */
915
static __inline __m64
916
_mm_avg_pu16 (__m64 __A, __m64 __B)
917
{
918
  return (__m64) __builtin_arm_wavg2hr ((__v4hi)__A, (__v4hi)__B);
919
}
920
 
921
/* Compute the averages of the unsigned 8-bit values in A and B.  */
922
static __inline __m64
923
_mm_avg2_pu8 (__m64 __A, __m64 __B)
924
{
925
  return (__m64) __builtin_arm_wavg2b ((__v8qi)__A, (__v8qi)__B);
926
}
927
 
928
/* Compute the averages of the unsigned 16-bit values in A and B.  */
929
static __inline __m64
930
_mm_avg2_pu16 (__m64 __A, __m64 __B)
931
{
932
  return (__m64) __builtin_arm_wavg2h ((__v4hi)__A, (__v4hi)__B);
933
}
934
 
935
/* Compute the sum of the absolute differences of the unsigned 8-bit
936
   values in A and B.  Return the value in the lower 16-bit word; the
937
   upper words are cleared.  */
938
static __inline __m64
939
_mm_sad_pu8 (__m64 __A, __m64 __B)
940
{
941
  return (__m64) __builtin_arm_wsadb ((__v8qi)__A, (__v8qi)__B);
942
}
943
 
944
/* Compute the sum of the absolute differences of the unsigned 16-bit
945
   values in A and B.  Return the value in the lower 32-bit word; the
946
   upper words are cleared.  */
947
static __inline __m64
948
_mm_sad_pu16 (__m64 __A, __m64 __B)
949
{
950
  return (__m64) __builtin_arm_wsadh ((__v4hi)__A, (__v4hi)__B);
951
}
952
 
953
/* Compute the sum of the absolute differences of the unsigned 8-bit
954
   values in A and B.  Return the value in the lower 16-bit word; the
955
   upper words are cleared.  */
956
static __inline __m64
957
_mm_sadz_pu8 (__m64 __A, __m64 __B)
958
{
959
  return (__m64) __builtin_arm_wsadbz ((__v8qi)__A, (__v8qi)__B);
960
}
961
 
962
/* Compute the sum of the absolute differences of the unsigned 16-bit
963
   values in A and B.  Return the value in the lower 32-bit word; the
964
   upper words are cleared.  */
965
static __inline __m64
966
_mm_sadz_pu16 (__m64 __A, __m64 __B)
967
{
968
  return (__m64) __builtin_arm_wsadhz ((__v4hi)__A, (__v4hi)__B);
969
}
970
 
971
static __inline __m64
972
_mm_align_si64 (__m64 __A, __m64 __B, int __C)
973
{
974
  return (__m64) __builtin_arm_walign ((__v8qi)__A, (__v8qi)__B, __C);
975
}
976
 
977
/* Creates a 64-bit zero.  */
978
static __inline __m64
979
_mm_setzero_si64 (void)
980
{
981
  return __builtin_arm_wzero ();
982
}
983
 
984
/* Set and Get arbitrary iWMMXt Control registers.
985
   Note only registers 0-3 and 8-11 are currently defined,
986
   the rest are reserved.  */
987
 
988
static __inline void
989
_mm_setwcx (const int __value, const int __regno)
990
{
991
  switch (__regno)
992
    {
993
    case 0:  __builtin_arm_setwcx (__value, 0); break;
994
    case 1:  __builtin_arm_setwcx (__value, 1); break;
995
    case 2:  __builtin_arm_setwcx (__value, 2); break;
996
    case 3:  __builtin_arm_setwcx (__value, 3); break;
997
    case 8:  __builtin_arm_setwcx (__value, 8); break;
998
    case 9:  __builtin_arm_setwcx (__value, 9); break;
999
    case 10: __builtin_arm_setwcx (__value, 10); break;
1000
    case 11: __builtin_arm_setwcx (__value, 11); break;
1001
    default: break;
1002
    }
1003
}
1004
 
1005
static __inline int
1006
_mm_getwcx (const int __regno)
1007
{
1008
  switch (__regno)
1009
    {
1010
    case 0:  return __builtin_arm_getwcx (0);
1011
    case 1:  return __builtin_arm_getwcx (1);
1012
    case 2:  return __builtin_arm_getwcx (2);
1013
    case 3:  return __builtin_arm_getwcx (3);
1014
    case 8:  return __builtin_arm_getwcx (8);
1015
    case 9:  return __builtin_arm_getwcx (9);
1016
    case 10: return __builtin_arm_getwcx (10);
1017
    case 11: return __builtin_arm_getwcx (11);
1018
    default: return 0;
1019
    }
1020
}
1021
 
1022
/* Creates a vector of two 32-bit values; I0 is least significant.  */
1023
static __inline __m64
1024
_mm_set_pi32 (int __i1, int __i0)
1025
{
1026
  union {
1027
    __m64 __q;
1028
    struct {
1029
      unsigned int __i0;
1030
      unsigned int __i1;
1031
    } __s;
1032
  } __u;
1033
 
1034
  __u.__s.__i0 = __i0;
1035
  __u.__s.__i1 = __i1;
1036
 
1037
  return __u.__q;
1038
}
1039
 
1040
/* Creates a vector of four 16-bit values; W0 is least significant.  */
1041
static __inline __m64
1042
_mm_set_pi16 (short __w3, short __w2, short __w1, short __w0)
1043
{
1044
  unsigned int __i1 = (unsigned short)__w3 << 16 | (unsigned short)__w2;
1045
  unsigned int __i0 = (unsigned short)__w1 << 16 | (unsigned short)__w0;
1046
  return _mm_set_pi32 (__i1, __i0);
1047
 
1048
}
1049
 
1050
/* Creates a vector of eight 8-bit values; B0 is least significant.  */
1051
static __inline __m64
1052
_mm_set_pi8 (char __b7, char __b6, char __b5, char __b4,
1053
             char __b3, char __b2, char __b1, char __b0)
1054
{
1055
  unsigned int __i1, __i0;
1056
 
1057
  __i1 = (unsigned char)__b7;
1058
  __i1 = __i1 << 8 | (unsigned char)__b6;
1059
  __i1 = __i1 << 8 | (unsigned char)__b5;
1060
  __i1 = __i1 << 8 | (unsigned char)__b4;
1061
 
1062
  __i0 = (unsigned char)__b3;
1063
  __i0 = __i0 << 8 | (unsigned char)__b2;
1064
  __i0 = __i0 << 8 | (unsigned char)__b1;
1065
  __i0 = __i0 << 8 | (unsigned char)__b0;
1066
 
1067
  return _mm_set_pi32 (__i1, __i0);
1068
}
1069
 
1070
/* Similar, but with the arguments in reverse order.  */
1071
static __inline __m64
1072
_mm_setr_pi32 (int __i0, int __i1)
1073
{
1074
  return _mm_set_pi32 (__i1, __i0);
1075
}
1076
 
1077
static __inline __m64
1078
_mm_setr_pi16 (short __w0, short __w1, short __w2, short __w3)
1079
{
1080
  return _mm_set_pi16 (__w3, __w2, __w1, __w0);
1081
}
1082
 
1083
static __inline __m64
1084
_mm_setr_pi8 (char __b0, char __b1, char __b2, char __b3,
1085
              char __b4, char __b5, char __b6, char __b7)
1086
{
1087
  return _mm_set_pi8 (__b7, __b6, __b5, __b4, __b3, __b2, __b1, __b0);
1088
}
1089
 
1090
/* Creates a vector of two 32-bit values, both elements containing I.  */
1091
static __inline __m64
1092
_mm_set1_pi32 (int __i)
1093
{
1094
  return _mm_set_pi32 (__i, __i);
1095
}
1096
 
1097
/* Creates a vector of four 16-bit values, all elements containing W.  */
1098
static __inline __m64
1099
_mm_set1_pi16 (short __w)
1100
{
1101
  unsigned int __i = (unsigned short)__w << 16 | (unsigned short)__w;
1102
  return _mm_set1_pi32 (__i);
1103
}
1104
 
1105
/* Creates a vector of four 16-bit values, all elements containing B.  */
1106
static __inline __m64
1107
_mm_set1_pi8 (char __b)
1108
{
1109
  unsigned int __w = (unsigned char)__b << 8 | (unsigned char)__b;
1110
  unsigned int __i = __w << 16 | __w;
1111
  return _mm_set1_pi32 (__i);
1112
}
1113
 
1114
/* Convert an integer to a __m64 object.  */
1115
static __inline __m64
1116
_m_from_int (int __a)
1117
{
1118
  return (__m64)__a;
1119
}
1120
 
1121
#define _m_packsswb _mm_packs_pi16
1122
#define _m_packssdw _mm_packs_pi32
1123
#define _m_packuswb _mm_packs_pu16
1124
#define _m_packusdw _mm_packs_pu32
1125
#define _m_packssqd _mm_packs_pi64
1126
#define _m_packusqd _mm_packs_pu64
1127
#define _mm_packs_si64 _mm_packs_pi64
1128
#define _mm_packs_su64 _mm_packs_pu64
1129
#define _m_punpckhbw _mm_unpackhi_pi8
1130
#define _m_punpckhwd _mm_unpackhi_pi16
1131
#define _m_punpckhdq _mm_unpackhi_pi32
1132
#define _m_punpcklbw _mm_unpacklo_pi8
1133
#define _m_punpcklwd _mm_unpacklo_pi16
1134
#define _m_punpckldq _mm_unpacklo_pi32
1135
#define _m_punpckehsbw _mm_unpackeh_pi8
1136
#define _m_punpckehswd _mm_unpackeh_pi16
1137
#define _m_punpckehsdq _mm_unpackeh_pi32
1138
#define _m_punpckehubw _mm_unpackeh_pu8
1139
#define _m_punpckehuwd _mm_unpackeh_pu16
1140
#define _m_punpckehudq _mm_unpackeh_pu32
1141
#define _m_punpckelsbw _mm_unpackel_pi8
1142
#define _m_punpckelswd _mm_unpackel_pi16
1143
#define _m_punpckelsdq _mm_unpackel_pi32
1144
#define _m_punpckelubw _mm_unpackel_pu8
1145
#define _m_punpckeluwd _mm_unpackel_pu16
1146
#define _m_punpckeludq _mm_unpackel_pu32
1147
#define _m_paddb _mm_add_pi8
1148
#define _m_paddw _mm_add_pi16
1149
#define _m_paddd _mm_add_pi32
1150
#define _m_paddsb _mm_adds_pi8
1151
#define _m_paddsw _mm_adds_pi16
1152
#define _m_paddsd _mm_adds_pi32
1153
#define _m_paddusb _mm_adds_pu8
1154
#define _m_paddusw _mm_adds_pu16
1155
#define _m_paddusd _mm_adds_pu32
1156
#define _m_psubb _mm_sub_pi8
1157
#define _m_psubw _mm_sub_pi16
1158
#define _m_psubd _mm_sub_pi32
1159
#define _m_psubsb _mm_subs_pi8
1160
#define _m_psubsw _mm_subs_pi16
1161
#define _m_psubuw _mm_subs_pi32
1162
#define _m_psubusb _mm_subs_pu8
1163
#define _m_psubusw _mm_subs_pu16
1164
#define _m_psubusd _mm_subs_pu32
1165
#define _m_pmaddwd _mm_madd_pi16
1166
#define _m_pmadduwd _mm_madd_pu16
1167
#define _m_pmulhw _mm_mulhi_pi16
1168
#define _m_pmulhuw _mm_mulhi_pu16
1169
#define _m_pmullw _mm_mullo_pi16
1170
#define _m_pmacsw _mm_mac_pi16
1171
#define _m_pmacuw _mm_mac_pu16
1172
#define _m_pmacszw _mm_macz_pi16
1173
#define _m_pmacuzw _mm_macz_pu16
1174
#define _m_paccb _mm_acc_pu8
1175
#define _m_paccw _mm_acc_pu16
1176
#define _m_paccd _mm_acc_pu32
1177
#define _m_pmia _mm_mia_si64
1178
#define _m_pmiaph _mm_miaph_si64
1179
#define _m_pmiabb _mm_miabb_si64
1180
#define _m_pmiabt _mm_miabt_si64
1181
#define _m_pmiatb _mm_miatb_si64
1182
#define _m_pmiatt _mm_miatt_si64
1183
#define _m_psllw _mm_sll_pi16
1184
#define _m_psllwi _mm_slli_pi16
1185
#define _m_pslld _mm_sll_pi32
1186
#define _m_pslldi _mm_slli_pi32
1187
#define _m_psllq _mm_sll_si64
1188
#define _m_psllqi _mm_slli_si64
1189
#define _m_psraw _mm_sra_pi16
1190
#define _m_psrawi _mm_srai_pi16
1191
#define _m_psrad _mm_sra_pi32
1192
#define _m_psradi _mm_srai_pi32
1193
#define _m_psraq _mm_sra_si64
1194
#define _m_psraqi _mm_srai_si64
1195
#define _m_psrlw _mm_srl_pi16
1196
#define _m_psrlwi _mm_srli_pi16
1197
#define _m_psrld _mm_srl_pi32
1198
#define _m_psrldi _mm_srli_pi32
1199
#define _m_psrlq _mm_srl_si64
1200
#define _m_psrlqi _mm_srli_si64
1201
#define _m_prorw _mm_ror_pi16
1202
#define _m_prorwi _mm_rori_pi16
1203
#define _m_prord _mm_ror_pi32
1204
#define _m_prordi _mm_rori_pi32
1205
#define _m_prorq _mm_ror_si64
1206
#define _m_prorqi _mm_rori_si64
1207
#define _m_pand _mm_and_si64
1208
#define _m_pandn _mm_andnot_si64
1209
#define _m_por _mm_or_si64
1210
#define _m_pxor _mm_xor_si64
1211
#define _m_pcmpeqb _mm_cmpeq_pi8
1212
#define _m_pcmpeqw _mm_cmpeq_pi16
1213
#define _m_pcmpeqd _mm_cmpeq_pi32
1214
#define _m_pcmpgtb _mm_cmpgt_pi8
1215
#define _m_pcmpgtub _mm_cmpgt_pu8
1216
#define _m_pcmpgtw _mm_cmpgt_pi16
1217
#define _m_pcmpgtuw _mm_cmpgt_pu16
1218
#define _m_pcmpgtd _mm_cmpgt_pi32
1219
#define _m_pcmpgtud _mm_cmpgt_pu32
1220
#define _m_pextrb _mm_extract_pi8
1221
#define _m_pextrw _mm_extract_pi16
1222
#define _m_pextrd _mm_extract_pi32
1223
#define _m_pextrub _mm_extract_pu8
1224
#define _m_pextruw _mm_extract_pu16
1225
#define _m_pextrud _mm_extract_pu32
1226
#define _m_pinsrb _mm_insert_pi8
1227
#define _m_pinsrw _mm_insert_pi16
1228
#define _m_pinsrd _mm_insert_pi32
1229
#define _m_pmaxsb _mm_max_pi8
1230
#define _m_pmaxsw _mm_max_pi16
1231
#define _m_pmaxsd _mm_max_pi32
1232
#define _m_pmaxub _mm_max_pu8
1233
#define _m_pmaxuw _mm_max_pu16
1234
#define _m_pmaxud _mm_max_pu32
1235
#define _m_pminsb _mm_min_pi8
1236
#define _m_pminsw _mm_min_pi16
1237
#define _m_pminsd _mm_min_pi32
1238
#define _m_pminub _mm_min_pu8
1239
#define _m_pminuw _mm_min_pu16
1240
#define _m_pminud _mm_min_pu32
1241
#define _m_pmovmskb _mm_movemask_pi8
1242
#define _m_pmovmskw _mm_movemask_pi16
1243
#define _m_pmovmskd _mm_movemask_pi32
1244
#define _m_pshufw _mm_shuffle_pi16
1245
#define _m_pavgb _mm_avg_pu8
1246
#define _m_pavgw _mm_avg_pu16
1247
#define _m_pavg2b _mm_avg2_pu8
1248
#define _m_pavg2w _mm_avg2_pu16
1249
#define _m_psadbw _mm_sad_pu8
1250
#define _m_psadwd _mm_sad_pu16
1251
#define _m_psadzbw _mm_sadz_pu8
1252
#define _m_psadzwd _mm_sadz_pu16
1253
#define _m_paligniq _mm_align_si64
1254
#define _m_cvt_si2pi _mm_cvtsi64_m64
1255
#define _m_cvt_pi2si _mm_cvtm64_si64
1256
 
1257
#endif /* _MMINTRIN_H_INCLUDED */

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.