gcc/config/arm/mmintrin.h

   1 /* 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 */