常用SSE指令集介绍

最新推荐文章于 2024-05-10 09:11:00 发布
最新推荐文章于 2024-05-10 09:11:00 发布
阅读量2.6k 收藏 6
点赞数 1
分类专栏： 计算机底层 程序员必知系列

SIMD相关头文件包括：

[cpp]  view plain  copy
  1. //#include <ivec.h>//MMX  
  2. //#include <fvec.h>//SSE(also include ivec.h)  
  3. //#include <dvec.h>//SSE2(also include fvec.h)  
  4.   
  5.   
  6. #include <mmintrin.h> //MMX  
  7. #include <xmmintrin.h> //SSE(include mmintrin.h)  
  8. #include <emmintrin.h> //SSE2(include xmmintrin.h)  
  9. #include <pmmintrin.h> //SSE3(include emmintrin.h)  
  10. #include <tmmintrin.h>//SSSE3(include pmmintrin.h)  
  11. #include <smmintrin.h>//SSE4.1(include tmmintrin.h)  
  12. #include <nmmintrin.h>//SSE4.2(include smmintrin.h)  
  13. #include <wmmintrin.h>//AES(include nmmintrin.h)  
  14. #include <immintrin.h>//AVX(include wmmintrin.h)  
  15. #include <intrin.h>//(include immintrin.h)  

mmintrin.h为MMX 头文件，其中__m64的定义为：

[cpp]  view plain  copy
  1. typedef union __declspec(intrin_type) _CRT_ALIGN(8) __m64  
  2. {  
  3.     unsigned __int64    m64_u64;  
  4.     float               m64_f32[2];  
  5.     __int8              m64_i8[8];  
  6.     __int16             m64_i16[4];  
  7.     __int32             m64_i32[2];      
  8.     __int64             m64_i64;  
  9.     unsigned __int8     m64_u8[8];  
  10.     unsigned __int16    m64_u16[4];  
  11.     unsigned __int32    m64_u32[2];  
  12. } __m64;  

xmmintrin.h为SSE 头文件，此头文件里包含MMX头文件，其中__m128的定义为：

[cpp]  view plain  copy
  1. typedef union __declspec(intrin_type) _CRT_ALIGN(16) __m128 {  
  2.      float               m128_f32[4];  
  3.      unsigned __int64    m128_u64[2];  
  4.      __int8              m128_i8[16];  
  5.      __int16             m128_i16[8];  
  6.      __int32             m128_i32[4];  
  7.      __int64             m128_i64[2];  
  8.      unsigned __int8     m128_u8[16];  
  9.      unsigned __int16    m128_u16[8];  
  10.      unsigned __int32    m128_u32[4];  
  11.  } __m128;  

emmintrin.h为SSE2头文件，此头文件里包含SSE头文件，其中__m128i和__m128d的定义为：

[cpp]  view plain  copy
  1. typedef union __declspec(intrin_type) _CRT_ALIGN(16) __m128i {  
  2.     __int8              m128i_i8[16];  
  3.     __int16             m128i_i16[8];  
  4.     __int32             m128i_i32[4];      
  5.     __int64             m128i_i64[2];  
  6.     unsigned __int8     m128i_u8[16];  
  7.     unsigned __int16    m128i_u16[8];  
  8.     unsigned __int32    m128i_u32[4];  
  9.     unsigned __int64    m128i_u64[2];  
  10. } __m128i;  
  11.   
  12. typedef struct __declspec(intrin_type) _CRT_ALIGN(16) __m128d {  
  13.     double              m128d_f64[2];  
  14. } __m128d;  

emmintrin.h文件中各函数的介绍：

[cpp]  view plain  copy
  1. /*----Floating-Point Intrinsics Using Streaming SIMD Extension 2 Instructions----*/  
  2. //Arithmetic Operations(Floating Point):add、sub、mul、div、sqrt、min、max  
  3. //返回一个__m128d的寄存器，r0=_A0+_B0, r1=_A1  
  4. extern __m128d _mm_add_sd(__m128d _A, __m128d _B);  
  5. //返回一个__m128d的寄存器，r0=_A0+_B0, r1=_A1+_B1  
  6. extern __m128d _mm_add_pd(__m128d _A, __m128d _B);  
  7. //返回一个__m128d的寄存器，r0=_A0-_B0, r1=_A1  
  8. extern __m128d _mm_sub_sd(__m128d _A, __m128d _B);  
  9. //返回一个__m128d的寄存器，r0=_A0-_B0, r1=_A1-_B1  
  10. extern __m128d _mm_sub_pd(__m128d _A, __m128d _B);  
  11. //返回一个__m128d的寄存器，r0=_A0*_B0, r1=_A1  
  12. extern __m128d _mm_mul_sd(__m128d _A, __m128d _B);  
  13. //返回一个__m128d的寄存器，r0=_A0*_B0, r1=_A1*_B1  
  14. extern __m128d _mm_mul_pd(__m128d _A, __m128d _B);  
  15. //返回一个__m128d的寄存器，r0=sqrt(_B0), r1=_A1  
  16. extern __m128d _mm_sqrt_sd(__m128d _A, __m128d _B);  
  17. //返回一个__m128d的寄存器，r0=sqrt(_A0), r1=sqrt(_A1)  
  18. extern __m128d _mm_sqrt_pd(__m128d _A);  
  19. //返回一个__m128d的寄存器，r0=_A0/_B0, r1=_A1  
  20. extern __m128d _mm_div_sd(__m128d _A, __m128d _B);  
  21. //返回一个__m128d的寄存器，r0=_A0/_B0, r1=_A1/_B1  
  22. extern __m128d _mm_div_pd(__m128d _A, __m128d _B);  
  23. //返回一个__m128d的寄存器，r0=min(_A0,_B0), r1=_A1  
  24. extern __m128d _mm_min_sd(__m128d _A, __m128d _B);  
  25. //返回一个__m128d的寄存器，r0=min(_A0,_B0), r1=min(_A1,_B1)  
  26. extern __m128d _mm_min_pd(__m128d _A, __m128d _B);  
  27. //返回一个__m128d的寄存器，r0=max(_A0,_B0), r1=_A1  
  28. extern __m128d _mm_max_sd(__m128d _A, __m128d _B);  
  29. //返回一个__m128d的寄存器，r0=max(_A0,_B0), r1=max(_A1,_B1)  
  30. extern __m128d _mm_max_pd(__m128d _A, __m128d _B);  
  31.   
  32. //Logical Operations(Floating Point SSE2 Intrinsics):and、or、xor、 andnot  
  33. //返回一个__m128d的寄存器，r0=_A0 & _B0, r1=_A1 & _B1  
  34. extern __m128d _mm_and_pd(__m128d _A, __m128d _B);  
  35. //返回一个__m128d的寄存器，r0=(~_A0) & _B0, r1=(~_A1) & _B1  
  36. extern __m128d _mm_andnot_pd(__m128d _A, __m128d _B);  
  37. //返回一个__m128d的寄存器，r0=_A0 | _B0, r1=_A1 | _B1  
  38. extern __m128d _mm_or_pd(__m128d _A, __m128d _B);  
  39. //返回一个__m128d的寄存器，r0=_A0 ^ _B0, r1=_A1 ^ _B1  
  40. extern __m128d _mm_xor_pd(__m128d _A, __m128d _B);  
  41.   
  42. //Comparisions:==、<、<=、>、>=、!=  
  43. //返回一个__m128d的寄存器，r0=(_A0 == _B0) ? 0xffffffffffffffff : 0x0, r1=_A1  
  44. extern __m128d _mm_cmpeq_sd(__m128d _A, __m128d _B);  
  45. //返回一个__m128d的寄存器，r0=(_A0 == _B0) ? 0xffffffffffffffff : 0x0,   
  46. //r1=(_A1 == _B1) ? 0xffffffffffffffff : 0x0  
  47. extern __m128d _mm_cmpeq_pd(__m128d _A, __m128d _B);  
  48. //返回一个__m128d的寄存器，r0=(_A0 < _B0) ? 0xffffffffffffffff : 0x0, r1=_A1  
  49. extern __m128d _mm_cmplt_sd(__m128d _A, __m128d _B);  
  50. //返回一个__m128d的寄存器，r0=(_A0 < _B0) ? 0xffffffffffffffff : 0x0,   
  51. //r1=(_A1 < _B1) ? 0xffffffffffffffff : 0x0  
  52. extern __m128d _mm_cmplt_pd(__m128d _A, __m128d _B);  
  53. //返回一个__m128d的寄存器，r0=(_A0 <= _B0) ? 0xffffffffffffffff : 0x0, r1=_A1  
  54. extern __m128d _mm_cmple_sd(__m128d _A, __m128d _B);  
  55. //返回一个__m128d的寄存器，r0=(_A0 <= _B0) ? 0xffffffffffffffff : 0x0,   
  56. //r1=(_A1 <= _B1) ? 0xffffffffffffffff : 0x0  
  57. extern __m128d _mm_cmple_pd(__m128d _A, __m128d _B);  
  58. //返回一个__m128d的寄存器，r0=(_A0 > _B0) ? 0xffffffffffffffff : 0x0, r1=_A1  
  59. extern __m128d _mm_cmpgt_sd(__m128d _A, __m128d _B);  
  60. //返回一个__m128d的寄存器，r0=(_A0 > _B0) ? 0xffffffffffffffff : 0x0,   
  61. //r1=(_A1 > _B1) ? 0xffffffffffffffff : 0x0  
  62. extern __m128d _mm_cmpgt_pd(__m128d _A, __m128d _B);  
  63. //返回一个__m128d的寄存器，r0=(_A0 >= _B0) ? 0xffffffffffffffff : 0x0, r1=_A1  
  64. extern __m128d _mm_cmpge_sd(__m128d _A, __m128d _B);  
  65. //返回一个__m128d的寄存器，r0=(_A0 >= _B0) ? 0xffffffffffffffff : 0x0,   
  66. //r1=(_A1 >= _B1) ? 0xffffffffffffffff : 0x0  
  67. extern __m128d _mm_cmpge_pd(__m128d _A, __m128d _B);  
  68. //返回一个__m128d的寄存器，r0=(_A0 != _B0) ? 0xffffffffffffffff : 0x0, r1=_A1  
  69. extern __m128d _mm_cmpneq_sd(__m128d _A, __m128d _B);  
  70. //返回一个__m128d的寄存器，r0=(_A0 != _B0) ? 0xffffffffffffffff : 0x0,   
  71. //r1=(_A1 != _B1) ? 0xffffffffffffffff : 0x0  
  72. extern __m128d _mm_cmpneq_pd(__m128d _A, __m128d _B);  
  73. //返回一个__m128d的寄存器，r0=!(_A0 < _B0) ? 0xffffffffffffffff : 0x0, r1=_A1  
  74. extern __m128d _mm_cmpnlt_sd(__m128d _A, __m128d _B);  
  75. //返回一个__m128d的寄存器，r0=!(_A0 < _B0) ? 0xffffffffffffffff : 0x0,   
  76. //r1=!(_A1 < _B1) ? 0xffffffffffffffff : 0x0  
  77. extern __m128d _mm_cmpnlt_pd(__m128d _A, __m128d _B);  
  78. //返回一个__m128d的寄存器，r0=!(_A0 <= _B0) ? 0xffffffffffffffff : 0x0, r1=_A1  
  79. extern __m128d _mm_cmpnle_sd(__m128d _A, __m128d _B);  
  80. //返回一个__m128d的寄存器，r0=!(_A0 <= _B0) ? 0xffffffffffffffff : 0x0,   
  81. //r1=!(_A1 <= _B1) ? 0xffffffffffffffff : 0x0  
  82. extern __m128d _mm_cmpnle_pd(__m128d _A, __m128d _B);  
  83. //返回一个__m128d的寄存器，r0=!(_A0 > _B0) ? 0xffffffffffffffff : 0x0, r1=_A1  
  84. extern __m128d _mm_cmpngt_sd(__m128d _A, __m128d _B);  
  85. //返回一个__m128d的寄存器，r0=!(_A0 > _B0) ? 0xffffffffffffffff : 0x0,   
  86. //r1=!(_A1 > _B1) ? 0xffffffffffffffff : 0x0  
  87. extern __m128d _mm_cmpngt_pd(__m128d _A, __m128d _B);  
  88. //返回一个__m128d的寄存器，r0=!(_A0 >= _B0) ? 0xffffffffffffffff : 0x0, r1=_A1  
  89. extern __m128d _mm_cmpnge_sd(__m128d _A, __m128d _B);  
  90. //返回一个__m128d的寄存器，r0=!(_A0 >= _B0) ? 0xffffffffffffffff : 0x0,  
  91. //r1=!(_A1 >= _B1) ? 0xffffffffffffffff : 0x0  
  92. extern __m128d _mm_cmpnge_pd(__m128d _A, __m128d _B);  
  93. //返回一个__m128d的寄存器，r0=(_A0 ord _B0) ? 0xffffffffffffffff : 0x0,   
  94. //r1=(_A1 ord _B1) ? 0xffffffffffffffff : 0x0  
  95. extern __m128d _mm_cmpord_pd(__m128d _A, __m128d _B);  
  96. //返回一个__m128d的寄存器，r0=(_A0 ord _B0) ? 0xffffffffffffffff : 0x0, r1=_A1  
  97. extern __m128d _mm_cmpord_sd(__m128d _A, __m128d _B);  
  98. //返回一个__m128d的寄存器，r0=(_A0 unord _B0) ? 0xffffffffffffffff : 0x0,   
  99. //r1=(_A1 unord _B1) ? 0xffffffffffffffff : 0x0  
  100. extern __m128d _mm_cmpunord_pd(__m128d _A, __m128d _B);  
  101. //返回一个__m128d的寄存器，r0=(_A0 unord _B0) ? 0xffffffffffffffff : 0x0, r1=_A1  
  102. extern __m128d _mm_cmpunord_sd(__m128d _A, __m128d _B);  
  103. //返回一个0或1的整数，r=(_A0 != _B0) ? 0x1 : 0x0, If _A and _B is a NaN, 1 is returned  
  104. extern int _mm_comieq_sd(__m128d _A, __m128d _B);  
  105. //返回一个0或1的整数，r=(_A0 < _B0) ? 0x1 : 0x0, If _A and _B is a NaN, 1 is returned  
  106. extern int _mm_comilt_sd(__m128d _A, __m128d _B);  
  107. //返回一个0或1的整数，r=(_A0 <= _B0) ? 0x1 : 0x0, If _A and _B is a NaN, 1 is returned  
  108. extern int _mm_comile_sd(__m128d _A, __m128d _B);  
  109. //返回一个0或1的整数，r=(_A0 > _B0) ? 0x1 : 0x0, If _A and _B is a NaN, 0 is returned  
  110. extern int _mm_comigt_sd(__m128d _A, __m128d _B);  
  111. //返回一个0或1的整数，r=(_A0 >= _B0) ? 0x1 : 0x0, If _A and _B is a NaN, 0 is returned  
  112. extern int _mm_comige_sd(__m128d _A, __m128d _B);  
  113. //返回一个0或1的整数，r=(_A0 != _B0) ? 0x1 : 0x0, If _A and _B is a NaN, 0 is returned  
  114. extern int _mm_comineq_sd(__m128d _A, __m128d _B);  
  115. //返回一个0或1的整数，r=(_A0 == _B0) ? 0x1 : 0x0, If _A and _B is a NaN, 1 is returned  
  116. extern int _mm_ucomieq_sd(__m128d _A, __m128d _B);  
  117. //返回一个0或1的整数，r=(_A0 < _B0) ? 0x1 : 0x0, If _A and _B is a NaN, 1 is returned  
  118. extern int _mm_ucomilt_sd(__m128d _A, __m128d _B);  
  119. //返回一个0或1的整数，r=(_A0 <= _B0) ? 0x1 : 0x0, If _A and _B is a NaN, 1 is returned  
  120. extern int _mm_ucomile_sd(__m128d _A, __m128d _B);  
  121. //返回一个0或1的整数，r=(_A0 > _B0) ? 0x1 : 0x0, If _A and _B is a NaN, 0 is returned  
  122. extern int _mm_ucomigt_sd(__m128d _A, __m128d _B);  
  123. //返回一个0或1的整数，r=(_A0 >= _B0) ? 0x1 : 0x0, If _A and _B is a NaN, 0 is returned  
  124. extern int _mm_ucomige_sd(__m128d _A, __m128d _B);  
  125. //返回一个0或1的整数，r=(_A0 != _B0) ? 0x1 : 0x0, If _A and _B is a NaN, 0 is returned  
  126. extern int _mm_ucomineq_sd(__m128d _A, __m128d _B);  
  127.   
  128. //Conversion Operations  
  129. //返回一个__m128d的寄存器，r0=(dobule)_A0, r1=(double)_A1  
  130. extern __m128d _mm_cvtepi32_pd(__m128i _A);  
  131. //返回一个__m128i的寄存器，r0=(int)_A0, r1=(int)_A1, r2=0x0, r3=0x0  
  132. extern __m128i _mm_cvtpd_epi32(__m128d _A);  
  133. //返回一个__m128i的寄存器，r0=(int)_A0, r1=(int)_A1, r2=0x0, r3=0x0,using truncate  
  134. extern __m128i _mm_cvttpd_epi32(__m128d _A);  
  135. //返回一个__m128的寄存器，r0=(flaot)_A0, r1=(float)_A1, r2=(float)_A2, r3=(float)_A3  
  136. extern __m128 _mm_cvtepi32_ps(__m128i _A);  
  137. //返回一个__m128i的寄存器，r0=(int)_A0, r1=(int)_A1, r2=(int)_A2, r3=(int)_A3  
  138. extern __m128i _mm_cvtps_epi32(__m128 _A);  
  139. //返回一个__m128i的寄存器，r0=(int)_A0, r1=(int)_A1, r2=(int)_A2, r3=(int)_A3,using truncate  
  140. extern __m128i _mm_cvttps_epi32(__m128 _A);  
  141. //返回一个__m128的寄存器，r0=(flaot)_A0, r1=(float)_A1, r2=0.0, r3=0.0  
  142. extern __m128 _mm_cvtpd_ps(__m128d _A);  
  143. //返回一个__m128d的寄存器，r0=(dobule)_A0, r1=(double)_A1  
  144. extern __m128d _mm_cvtps_pd(__m128 _A);  
  145. //返回一个__m128的寄存器，r0=(float)_B0, r1=_B1, r2=_B2, r3=_B3  
  146. extern __m128 _mm_cvtsd_ss(__m128 _A, __m128d _B);  
  147. //返回一个__m128d的寄存器，r0=(double)_B0, r1=_A1  
  148. extern __m128d _mm_cvtss_sd(__m128d _A, __m128 _B);  
  149. //返回一个32bit整数，r=(int)_A0  
  150. extern int _mm_cvtsd_si32(__m128d _A);  
  151. //返回一个32bit整数，r=(int)_A0,using truncate  
  152. extern int _mm_cvttsd_si32(__m128d _A);  
  153. //返回一个__m128d的寄存器，r0=(double)_B, r1=_A1  
  154. extern __m128d _mm_cvtsi32_sd(__m128d _A, int _B);  
  155. //返回一个__m64的寄存器，r0=(int)_A0, r1=(int)_A1  
  156. extern __m64 _mm_cvtpd_pi32(__m128d _A);  
  157. //返回一个__m64的寄存器，r0=(int)_A0, r1=(int)_A1,using truncate  
  158. extern __m64 _mm_cvttpd_pi32(__m128d _A);  
  159. //返回一个__m128d的寄存器，r0=(dobule)_A0, r1=(double)_A1  
  160. extern __m128d _mm_cvtpi32_pd(__m64 _A);  
  161.   
  162. //Miscellaneous Operations(Floating-Point SSE2 Intrinsics)  
  163. //返回一个__m128d的寄存器，r0=_A1, r1=_B1  
  164. extern __m128d _mm_unpackhi_pd(__m128d _A, __m128d _B);  
  165. //返回一个__m128d的寄存器，r0=_A0, r1=_B0  
  166. extern __m128d _mm_unpacklo_pd(__m128d _A, __m128d _B);  
  167. //返回一个2bit整数，r=sign(_A1) << 1 | sign(_A0)  
  168. extern int _mm_movemask_pd(__m128d _A);  
  169. //返回一个__m128d的寄存器，Selects two specific double-precision,  
  170. // floating-point values from _A and _B, based on the mask _I,  
  171. //The mask must be an immediate  
  172. extern __m128d _mm_shuffle_pd(__m128d _A, __m128d _B, int _I);  
  173.   
  174. //Load Operations(Floating-Point SSE2 Intrinsics)  
  175. //返回一个__m128d的寄存器，r0=_Dp[0], r1=_Dp[1], The address _Dp must be 16-byte aligned  
  176. extern __m128d _mm_load_pd(double const*_Dp);  
  177. //返回一个__m128d的寄存器，r0=*_Dp, r1=*_Dp, The address _Dp does not need  
  178. //to be 16-byte aligned  
  179. extern __m128d _mm_load1_pd(double const*_Dp);  
  180. //返回一个__m128d的寄存器，r0=_Dp[1], r1=_Dp[0], The address _Dp must be 16-byte aligned  
  181. extern __m128d _mm_loadr_pd(double const*_Dp);  
  182. //返回一个__m128d的寄存器，r0=_Dp[0], r1=_Dp[1], The address _Dp does not   
  183. //need to be 16-byte aligned  
  184. extern __m128d _mm_loadu_pd(double const*_Dp);  
  185. //返回一个__m128d的寄存器，r0=*_Dp, r1=0.0, The address _Dp does not   
  186. //need to be 16-byte aligned  
  187. extern __m128d _mm_load_sd(double const*_Dp);  
  188. //返回一个__m128d的寄存器，r0=_A0, r1=*_Dp, The address _Dp does not   
  189. //need to be 16-byte aligned  
  190. extern __m128d _mm_loadh_pd(__m128d _A, double const*_Dp);  
  191. //返回一个__m128d的寄存器，r0=*_Dp, r1=_A1, The address _Dp does not  
  192. //need to be 16-byte aligned  
  193. extern __m128d _mm_loadl_pd(__m128d _A, double const*_Dp);  
  194.   
  195. //Set Operations(Floating-Point SSE2 Intrinsics)  
  196. //返回一个__m128d的寄存器，r0=_W, r1=0.0  
  197. extern __m128d _mm_set_sd(double _W);  
  198. //返回一个__m128d的寄存器，r0=_A, r1=_A  
  199. extern __m128d _mm_set1_pd(double _A);  
  200. //返回一个__m128d的寄存器，r0=_Y, r1=_Z  
  201. extern __m128d _mm_set_pd(double _Z, double _Y);  
  202. //返回一个__m128d的寄存器，r0=_Y, r1=_Z  
  203. extern __m128d _mm_setr_pd(double _Y, double _Z);  
  204. //返回一个__m128d的寄存器，r0=0.0, r1=0.0  
  205. extern __m128d _mm_setzero_pd(void);  
  206. //返回一个__m128d的寄存器，r0=_B0, r1=_A1  
  207. extern __m128d _mm_move_sd(__m128d _A, __m128d _B);  
  208.   
  209. //Store Operations(Floating-Point SSE2 Intrinsics)  
  210. //返回为空，*_Dp=_A0, The address _Dp does not need to be 16-byte aligned  
  211. extern void _mm_store_sd(double *_Dp, __m128d _A);  
  212. //返回为空，_Dp[0]=_A0, _Dp[1]=_A0, The address _Dp must be 16-byte aligned  
  213. extern void _mm_store1_pd(double *_Dp, __m128d _A);  
  214. //返回为空，_Dp[0]=_A0, _Dp[1]=_A1, The address _Dp must be 16-byte aligned  
  215. extern void _mm_store_pd(double *_Dp, __m128d _A);  
  216. //返回为空，_Dp[0]=_A0, _Dp[1]=_A1, The address _Dp does not need to be 16-byte aligned  
  217. extern void _mm_storeu_pd(double *_Dp, __m128d _A);  
  218. //返回为空，_Dp[0]=_A1, _Dp[1]=_A0, The address _Dp must be 16-byte aligned  
  219. extern void _mm_storer_pd(double *_Dp, __m128d _A);  
  220. //返回为空，*_Dp=_A1  
  221. extern void _mm_storeh_pd(double *_Dp, __m128d _A);  
  222. //返回为空，*_Dp=_A0  
  223. extern void _mm_storel_pd(double *_Dp, __m128d _A);  
  224.   
  225. //new convert to float  
  226. //返回一个64bit double类型，r=_A0, Extracts the lower order floating point value  
  227. extern double _mm_cvtsd_f64(__m128d _A);  
  228.   
  229. //Cache Support for Streaming SIMD Extensions 2 Floating-Point Operations  
  230. //返回为空，_Dp[0]=_A0, _Dp[1]=_A1, Stores the data in _A to the address _Dp without  
  231. //polluting caches. The address _Dp must be 16-byte aligned. If the cache line   
  232. //containing address _Dp is already in the cache, the cache will be updated  
  233. extern void _mm_stream_pd(double *_Dp, __m128d _A);  
  234.   
  235. /*------------Integer Intrinsics Using Streaming SIMD Extensions 2-------------*/  
  236. //Arithmetic Operations(Integer SSE2 Intrinsics):add、sub、mul、avg、min、max  
  237. //返回一个__m128i的寄存器，r0=_A0+_B0, r1=_A1+_B1, ... r15=_A15+_B15  
  238. extern __m128i _mm_add_epi8(__m128i _A, __m128i _B);  
  239. //返回一个__m128i的寄存器，将_A和_B中对应位置的16bit有符号或无符号整数分别相加，  
  240. //即ri=_Ai+_Bi(r0=_A0+_B0, r1=_A1+_B1, ... r7=_A7+_B7)  
  241. extern __m128i _mm_add_epi16(__m128i _A, __m128i _B);  
  242. //返回一个__m128i的寄存器，r0=_A0+_B0, r1=_A1+_B1, r2=_A2+_B2, r3=_A3+_B3  
  243. extern __m128i _mm_add_epi32(__m128i _A, __m128i _B);  
  244. //返回一个__m64的寄存器，r=_A+_B  
  245. extern __m64 _mm_add_si64(__m64 _A, __m64 _B);  
  246. //返回一个__m128i的寄存器，r0=_A0+_B0, r1=_A1+_B1  
  247. extern __m128i _mm_add_epi64(__m128i _A, __m128i _B);  
  248. //返回一个__m128i的寄存器，r0=SignedSaturate(_A0+_B0), r1=SignedSaturate(_A1+_B1), ...   
  249. //r15=SignedSaturate(_A15+_B15), saturates  
  250. extern __m128i _mm_adds_epi8(__m128i _A, __m128i _B);  
  251. //返回一个__m128i的寄存器，将_A和_B中对应位置的16bit有符号或无符号整数分别相加，  
  252. //r0=SignedSaturate(_A0+_B0), r1=SignedSaturate(_A1+_B1), ...   
  253. //r7=SignedSaturate(_A7+_B7), 当计算结果溢出时将其置为边界值(saturates)  
  254. extern __m128i _mm_adds_epi16(__m128i _A, __m128i _B);  
  255. //返回一个__m128i的寄存器，r0=UnsignedSaturate(_A0+_B0), r1=UnsignedSaturate(_A1+_B1), ...   
  256. //r15=UnsignedSaturate(_A15+_B15), saturates  
  257. extern __m128i _mm_adds_epu8(__m128i _A, __m128i _B);  
  258. //返回一个__m128i的寄存器，r0=UnsignedSaturate(_A0+_B0), r1=UnsignedSaturate(_A1+_B1), ...   
  259. //r7=UnsignedSaturate(_A7+_B7), saturates  
  260. extern __m128i _mm_adds_epu16(__m128i _A, __m128i _B);  
  261. //返回一个__m128i的寄存器，r0=(_A0+_B0)/2, r1=(_A1+_B1)/2, ... r15=(_A15+_B15)/2, rounds  
  262. extern __m128i _mm_avg_epu8(__m128i _A, __m128i _B);   
  263. //返回一个__m128i的寄存器，将_A和_B中对应位置的16bit无符号整数取平均，  
  264. //即ri=(_Ai+_Bi)/2(r0=(_A0+_B0)/2, r1=(_A1+_B1)/2, ... r7=(_A7+_B7)/2), rounds  
  265. extern __m128i _mm_avg_epu16(__m128i _A, __m128i _B);  
  266. //返回一个__m128i的寄存器，它含有4个有符号或无符号32bit的整数，  
  267. //分别满足：r0=(_A0*_B0)+(_A1*_B1), r1=(_A2*_B2)+(_A3*_B3),   
  268. //r2=(_A4*_B4)+(_A5*_B5), r3=(_A6*_B6)+(_A7*_B7)  
  269. extern __m128i _mm_madd_epi16(__m128i _A, __m128i _B);  
  270. //返回一个__m128i的寄存器，取_A和_B中对应位置的16bit有符号或无符号整数的最大值，  
  271. //即ri=max(_Ai,_Bi) (r0=max(_A0,_B1), r1=max(_A1,_B1), ... r7=max(_A7,_B7))  
  272. extern __m128i _mm_max_epi16(__m128i _A, __m128i _B);  
  273. //返回一个__m128i的寄存器，r0=max(_A0,_B1), r1=max(_A1,_B1), ... r15=max(_A15,_B15)  
  274. extern __m128i _mm_max_epu8(__m128i _A, __m128i _B);  
  275. //返回一个__m128i的寄存器，取_A和_B中对应位置的16bit有符号或无符号整数的最小值，  
  276. //即ri=min(_Ai, _Bi)(r0=min(_A0,_B1), r1=min(_A1,_B1), ... r7=min(_A7,_B7))  
  277. extern __m128i _mm_min_epi16(__m128i _A, __m128i _B);  
  278. //返回一个__m128i的寄存器，r0=min(_A0,_B1), r1=min(_A1,_B1), ... r15=min(_A15,_B15)  
  279. extern __m128i _mm_min_epu8(__m128i _A, __m128i _B);  
  280. //返回一个__m128i的寄存器，它含8个有符号或无符号16bit的整数，分别为_A和_B对应位置的16bit  
  281. //有符号或无符号整数相乘结果的高16bit数据，即ri=(_Ai*_Bi)[31:16](r0=(_A0*_B0)[31:16],   
  282. //r1=(_A1*_B1)[31:16] ... r7=(_A7*_B7)[31:16])  
  283. extern __m128i _mm_mulhi_epi16(__m128i _A, __m128i _B);  
  284. //返回一个__m128i的寄存器，r0=(_A0*_B0)[31:16], r1=(_A1*_B1)[31:16] ... r7=(_A7*_B7)[31:16]  
  285. extern __m128i _mm_mulhi_epu16(__m128i _A, __m128i _B);  
  286. //返回一个__m128i的寄存器，它含8个有符号或无符号16bit的整数，分别为_A和_B对应位置的16bit  
  287. //有符号或无符号整数相乘结果的低16bit数据，即ri=(_Ai*_Bi)[15:0](r0=(_A0*_B0)[15:0],   
  288. //r1=(_A1*_B1)[15:0] ... r7=(_A7*_B7)[15:0])  
  289. extern __m128i _mm_mullo_epi16(__m128i _A, __m128i _B);  
  290. //返回一个__m64的寄存器，r=_A0*_B0  
  291. extern __m64 _mm_mul_su32(__m64 _A, __m64 _B);  
  292. //返回一个__m128i的寄存器，r0=_A0*_B0, r1=_A2*_B2  
  293. extern __m128i _mm_mul_epu32(__m128i _A, __m128i _B);  
  294. //返回一个__m128i的寄存器，r0=abs(_A0-_B0) + abs(_A1-_B1) + ... + abs(_A7-_B7),   
  295. //r1=0x0,r2=0x0, r3=0x0, r4=abs(_A8-_B8) + abs(_A9-_B9) + ... + abs(_A15-_B15),   
  296. //r5=0x0, r6=0x0, r7=0x0  
  297. extern __m128i _mm_sad_epu8(__m128i _A, __m128i _B);  
  298. //返回一个__m128i的寄存器，r0=_A0-_B0, r1=_A1-_B1, ... r15=_A15-_B15  
  299. extern __m128i _mm_sub_epi8(__m128i _A, __m128i _B);  
  300. //返回一个__m128i的寄存器，将_A和_B中对应位置的16bit有符号或无符号整数分别相减，  
  301. //即ri=_Ai-_Bi(r0=_A0-_B0, r1=_A1-_B1, ... r7=_A7-_B7)  
  302. extern __m128i _mm_sub_epi16(__m128i _A, __m128i _B);  
  303. //返回一个__m128i的寄存器，r0=_A0-_B0, r1=_A1-_B1, r2=_A2-_B2, r3=_A3-_B3  
  304. extern __m128i _mm_sub_epi32(__m128i _A, __m128i _B);  
  305. //返回一个__m64的寄存器，r=_A-_B  
  306. extern __m64 _mm_sub_si64(__m64 _A, __m64 _B);  
  307. //返回一个__m128i的寄存器，r0=_A0-_B0, r1=_A1-_B1  
  308. extern __m128i _mm_sub_epi64(__m128i _A, __m128i _B);  
  309. //返回一个__m128i的寄存器，r0=SignedSaturate(_A0-_B0), r1=SignedSaturate(_A1-_B1), ...   
  310. //r15=SignedSaturate(_A15-_B15), saturate  
  311. extern __m128i _mm_subs_epi8(__m128i _A, __m128i _B);  
  312. //返回一个__m128i的寄存器，将_A和_B中对应位置的16bit有符号或无符号整数分别相减，  
  313. //当计算结果溢出时将其置为边界值(saturate), r0=SignedSaturate(_A0-_B0),   
  314. //r1=SignedSaturate(_A1-_B1), ... r7=SignedSaturate(_A7-_B7)  
  315. extern __m128i _mm_subs_epi16(__m128i _A, __m128i _B);  
  316. //返回一个__m128i的寄存器，r0=UnsignedSaturate(_A0-_B0), r1=UnsignedSaturate(_A1-_B1), ...  
  317. //r15=UnsignedSaturate(_A15-_B15), saturate  
  318. extern __m128i _mm_subs_epu8(__m128i _A, __m128i _B);  
  319. //返回一个__m128i的寄存器，r0=UnsignedSaturate(_A0-_B0), r1=UnsignedSaturate(_A1-_B1), ...   
  320. //r15=UnsignedSaturate(_A7-_B7), saturate  
  321. extern __m128i _mm_subs_epu16(__m128i _A, __m128i _B);  
  322.   
  323. //Logical Operations(Integer SSE2 Intrinsics):and、or、xor、andnot  
  324. //返回一个__m128i的寄存器，将寄存器_A和寄存器_B的对应位进行按位与运算, r=_A & _B  
  325. extern __m128i _mm_and_si128(__m128i _A, __m128i _B);  
  326. //返回一个__m128i的寄存器，将寄存器_A每一位取非，然后和寄存器_B的每一位进行按位与运算,  
  327. //r=(~_A) & _B  
  328. extern __m128i _mm_andnot_si128(__m128i _A, __m128i _B);  
  329. //返回一个__m128i的寄存器，将寄存器_A和寄存器_B的对应位进行按位或运算, r=_A | _B  
  330. extern __m128i _mm_or_si128(__m128i _A, __m128i _B);  
  331. //返回一个__m128i的寄存器，将寄存器_A和寄存器_B的对应位进行按位异或运算, r=_A ^ _B  
  332. extern __m128i _mm_xor_si128(__m128i _A, __m128i _B);  
  333.   
  334. //Shift Operations  
  335. //返回一个__m128i的寄存器，r=_A << (_Imm * 8),  _Imm must be an immediate,    
  336. //shifting in zeros  
  337. extern __m128i _mm_slli_si128(__m128i _A, int _Imm);  
  338. //返回一个__m128i的寄存器，将寄存器_A中的8个16bit整数按照_Count进行相同的逻辑左移,  
  339. //r0=_A0 << _Count, r1=_A1 << _Count, ... r7=_A7 << count,  shifting in zeros  
  340. extern __m128i _mm_slli_epi16(__m128i _A, int _Count);  
  341. //返回一个__m128i的寄存器，将寄存器_A中的8个16bit整数按照_Count寄存器中对应位置的整数  
  342. //进行逻辑左移, r0=_A0 << _Count, r1=_A1 << _Count, ... r7=_A7 << count,  shifting in zeros  
  343. extern __m128i _mm_sll_epi16(__m128i _A, __m128i _Count);  
  344. //返回一个__m128i的寄存器，r0=_A0 << _Count, r1=_A1 << _Count, r2=_A2 << count,   
  345. //r3=_A3 << count,  shifting in zeros  
  346. extern __m128i _mm_slli_epi32(__m128i _A, int _Count);  
  347. //返回一个__m128i的寄存器，r0=_A0 << _Count, r1=_A1 << _Count, r2=_A2 << count,   
  348. //r3=_A3 << count,  shifting in zeros  
  349. extern __m128i _mm_sll_epi32(__m128i _A, __m128i _Count);  
  350. //返回一个__m128i的寄存器，r0=_A0 << _Count, r1=_A1 << _Count,  shifting in zeros  
  351. extern __m128i _mm_slli_epi64(__m128i _A, int _Count);  
  352. //返回一个__m128i的寄存器，r0=_A0 << _Count, r1=_A1 << _Count,  shifting in zeros  
  353. extern __m128i _mm_sll_epi64(__m128i _A, __m128i _Count);  
  354. //返回一个__m128i的寄存器，将寄存器_A中的8个16bit整数按照_Count进行相同的算术右移,  
  355. //r0=_A0 >> _Count, r1=_A1 >> _Count, ... r7=_A7 >> count,  shifting in the sign bit  
  356. extern __m128i _mm_srai_epi16(__m128i _A, int _Count);  
  357. //返回一个__m128i的寄存器，将寄存器_A中的8个16bit整数按照_Count寄存器中对应位置的整数进行  
  358. //算术右移,r0=_A0 >> _Count, r1=_A1 >> _Count, ... r7=_A7 >> count,  shifting in the sign bit  
  359. extern __m128i _mm_sra_epi16(__m128i _A, __m128i _Count);  
  360. //返回一个__m128i的寄存器，r0=_A0 >> _Count, r1=_A1 >> _Count, r3=_A3 >> count,   
  361. //r4=_A4 >> count,  shifting in the sign bit  
  362. extern __m128i _mm_srai_epi32(__m128i _A, int _Count);  
  363. //返回一个__m128i的寄存器，r0=_A0 >> _Count, r1=_A1 >> _Count, r3=_A3 >> count,  
  364. //r4=_A4 >> count,  shifting in the sign bit  
  365. extern __m128i _mm_sra_epi32(__m128i _A, __m128i _Count);  
  366. //返回一个__m128i的寄存器，r=srl(_A, _Imm * 8),   _Imm must be an immediate,    
  367. //shifting in zeros  
  368. extern __m128i _mm_srli_si128(__m128i _A, int _Imm);  
  369. //返回一个__m128i的寄存器，将寄存器_A中的8个16bit整数按照_Count进行相同的逻辑右移，  
  370. //移位填充值为0,r0=srl(_A0, _Count), r1=srl(_A1, _Count), ... r7=srl(_A7, _Count),   
  371. //shifting in zeros  
  372. extern __m128i _mm_srli_epi16(__m128i _A, int _Count);  
  373. //返回一个__m128i的寄存器，将寄存器_A中的8个16bit整数按照_Count寄存器中对应位置的整数  
  374. //进行逻辑右移，移位填充值为0, r0=srl(_A0, _Count), r1=srl(_A1, _Count), ...   
  375. //r7=srl(_A7, _Count),  shifting in zeros  
  376. extern __m128i _mm_srl_epi16(__m128i _A, __m128i _Count);  
  377. //返回一个__m128i的寄存器，r0=srl(_A0, _Count), r1=srl(_A1, _Count), r2=srl(_A2, _Count),  
  378. //r3=srl(_A3, _Count),  shifting in zeros  
  379. extern __m128i _mm_srli_epi32(__m128i _A, int _Count);  
  380. //返回一个__m128i的寄存器，r0=srl(_A0, _Count), r1=srl(_A1, _Count), r2=srl(_A2, _Count),  
  381. //r3=srl(_A3, _Count),  shifting in zeros  
  382. extern __m128i _mm_srl_epi32(__m128i _A, __m128i _Count);  
  383. //返回一个__m128i的寄存器，r0=srl(_A0, _Count), r1=srl(_A1, _Count), shifting in zeros  
  384. extern __m128i _mm_srli_epi64(__m128i _A, int _Count);  
  385. //返回一个__m128i的寄存器，r0=srl(_A0, _Count), r1=srl(_A1, _Count), shifting in zeros  
  386. extern __m128i _mm_srl_epi64(__m128i _A, __m128i _Count);  
  387.   
  388. //Comparison Intrinsics(SSE2):==、>、<  
  389. //返回一个__m128i的寄存器，r0=(_A0 == _B0) ? 0xff : 0x00,   
  390. //r1=(_A1 == _B1) ? 0xff : 0x0, ... r15=(_A15 == _B15) ? 0xff : 0x0  
  391. extern __m128i _mm_cmpeq_epi8(__m128i _A, __m128i _B);  
  392. //返回一个__m128i的寄存器，分别比较寄存器_A和寄存器_B对应位置16bit整数是否相等，若相等，  
  393. //该位置返回0xffff，否则返回0x0，即ri=(_Ai==_Bi)?0xffff:0x0(r0=(_A0 == _B0) ? 0xffff : 0x00,   
  394. //r1=(_A1 == _B1) ? 0xffff : 0x0, ... r7=(_A7 == _B7) ? 0xffff : 0x0)  
  395. extern __m128i _mm_cmpeq_epi16(__m128i _A, __m128i _B);  
  396. //返回一个__m128i的寄存器，r0=(_A0 == _B0) ? 0xffffffff : 0x00,   
  397. //r1=(_A1 == _B1) ? 0xffffffff : 0x0,  
  398. //r2=(_A2 == _B2) ? 0xffffffff : 0x0, r3=(_A3 == _B3) ? 0xffffffff : 0x0  
  399. extern __m128i _mm_cmpeq_epi32(__m128i _A, __m128i _B);  
  400. //返回一个__m128i的寄存器，r0=(_A0 > _B0) ? 0xff : 0x00, r1=(_A1 > _B1) ? 0xff : 0x0, ...  
  401. //r15=(_A15 > _B15) ? 0xff : 0x0  
  402. extern __m128i _mm_cmpgt_epi8(__m128i _A, __m128i _B);  
  403. //返回一个__m128i的寄存器，分别比较寄存器_A的每个16bit整数是否大于寄存器_B对应位置16bit的整数，  
  404. //若大于，该位置返回0xffff，否则返回0x0，  
  405. //即ri=(_Ai>_Bi)?0xffff:0x0(r0=(_A0 > _B0) ? 0xffff : 0x00,   
  406. //r1=(_A1 > _B1) ? 0xffff : 0x0, ... r7=(_A7 > _B7) ? 0xffff : 0x0)  
  407. extern __m128i _mm_cmpgt_epi16(__m128i _A, __m128i _B);  
  408. //返回一个__m128i的寄存器，r0=(_A0 > _B0) ? 0xffffffff : 0x00,  
  409. //r1=(_A1 > _B1) ? 0xffffffff : 0x0,  
  410. //r2=(_A2 > _B2) ? 0xffffffff : 0x0, r3=(_A3 > _B3) ? 0xffffffff : 0x0  
  411. extern __m128i _mm_cmpgt_epi32(__m128i _A, __m128i _B);  
  412. //返回一个__m128i的寄存器，r0=(_A0 < _B0) ? 0xff : 0x00, r1=(_A1 < _B1) ? 0xff : 0x0, ...   
  413. //r15=(_A15 < _B15) ? 0xff : 0x0  
  414. extern __m128i _mm_cmplt_epi8(__m128i _A, __m128i _B);  
  415. //返回一个__m128i的寄存器，分别比较寄存器_A的每个16bit整数是否小于寄存器_B对应位置16bit整数，  
  416. //若小于，该位置返回0xffff，否则返回0x0，  
  417. //即ri=(_Ai<_Bi)?0xffff:0x0(r0=(_A0 < _B0) ? 0xffff : 0x00,   
  418. //r1=(_A1 < _B1) ? 0xffff : 0x0, ... r7=(_A7 < _B7) ? 0xffff : 0x0)  
  419. extern __m128i _mm_cmplt_epi16(__m128i _A, __m128i _B);  
  420. //返回一个__m128i的寄存器，r0=(_A0 < _B0) ? 0xffffffff : 0x00,  
  421. //r1=(_A1 < _B1) ? 0xffffffff : 0x0,   
  422. //r2=(_A2 < _B2) ? 0xffffffff : 0x0, r3=(_A3 < _B3) ? 0xffffffff : 0x0  
  423. extern __m128i _mm_cmplt_epi32(__m128i _A, __m128i _B);  
  424.   
  425. //Conversion Intrinsics: int <-----> __m128i  
  426. //返回一个__m128i的寄存器，r0=_A, r1=0x0, r2=0x0, r3=0x0  
  427. extern __m128i _mm_cvtsi32_si128(int _A);  
  428. //返回一个32bit整数，r=_A0  
  429. extern int _mm_cvtsi128_si32(__m128i _A);  
  430.   
  431. //Miscellaneous Operations(Integer SSE2 Intrinsics)  
  432. //返回一个__m128i的寄存器，r0=SignedSaturate(_A0), r1=SignedSaturate(_A1), ...   
  433. //r7=SignedSaturate(_A7), r8=SignedSaturate(_B0), r9=SignedSaturate(_B1), ...   
  434. //r15=SignedSaturate(_B7),  saturate  
  435. extern __m128i _mm_packs_epi16(__m128i _A, __m128i _B);  
  436. //返回一个__m128i的寄存器，r0=SignedSaturate(_A0), r1=SignedSaturate(_A1),   
  437. //r2=SignedSaturate(_A2),r3=SignedSaturate(_A3), r4=SignedSaturate(_B0),   
  438. //r5=SignedSaturate(_B1), r6=SignedSaturate(_B2), r7=SignedSaturate(_B3),  saturate  
  439. extern __m128i _mm_packs_epi32(__m128i _A, __m128i _B);  
  440. //返回一个__m128i的寄存器，r0=UnsignedSaturate(_A0), r1=UnsignedSaturate(_A1), ...   
  441. //r7=UnsignedSaturate(_A7),r8=UnsignedSaturate(_B0), r9=UnsignedSaturate(_B1), ...   
  442. //r15=UnsignedSaturate(_B7),  saturate  
  443. extern __m128i _mm_packus_epi16(__m128i _A, __m128i _B);  
  444. //返回一个16bit整数，根据_Imm从_A中8个16bit数中选取对应编号的数,  
  445. //r=(_Imm == 0) ? _A0 : ((_Imm == 1) ? _A1 : ... (_Imm == 7) ? _A7),   
  446. //_Imm must be an immediate, zero extends  
  447. extern int _mm_extract_epi16(__m128i _A, int _Imm);  
  448. //返回一个__m128i的寄存器，根据_Imm将_A中8个16bit数中对应编号的数替换为_B,  
  449. //r0=(_Imm == 0) ? _B : _A0; r1=(_Imm == 1) : _B : _A1, ... r7=(_Imm == 7) ? _B : _A7  
  450. extern __m128i _mm_insert_epi16(__m128i _A, int _B, int _Imm);  
  451. //返回一个16bit整数，r=(_A15[7] << 15) | (_A14[7] << 14) ... (_A1[7] << 1) | _A0[7],   
  452. //zero extends the upper bits  
  453. extern int _mm_movemask_epi8(__m128i _A);  
  454. //返回一个__m128i的寄存器，它是将_A中128bit数据以32bit为单位重新排列得到的，_Imm为有  
  455. //一个四元组，表示重新排列的顺序。当_A中原本存储的整数为16bit时，这条指令将其两两一组  
  456. //进行排列。例如，_A=(_A0,_A1,_A2,_A3,_A4,_A5,_A6,_A7), _Imm=(2,3,0,1),其中_Ai为16bit整数，  
  457. //_A0为低位，返回结果为(_A2,_A3,_A0,_A1,_A6,_A7,_A4,_A5),  _Imm must be an immediate  
  458. extern __m128i _mm_shuffle_epi32(__m128i _A, int _Imm);  
  459. //返回一个__m128i的寄存器，它是将_A中高64bit数据以16bit为单位重新排列得到的，_Imm为一个四元组，  
  460. //表示重新排列的顺序。_A中低64bit数据顺序不变。例如，_A=(_A0,_A1,_A2,_A3,_A4,_A5,_A6,_A7),   
  461. //_Imm=(2,3,0,1),其中_Ai为16bit整数，_A0为低位，返回结果为(_A0,_A1,_A2,_A3,_A5,_A4,_A7,_A6),   
  462. //_Imm must be an immediate   
  463. extern __m128i _mm_shufflehi_epi16(__m128i _A, int _Imm);  
  464. //返回一个__m128i的寄存器，它是将_A中低64bit数据以16bit为单位重新排列得到的，_Imm为一个四元组，  
  465. //表示重新排列的顺序。_A中高64bit数据顺序不变。例如，_A=(_A0,_A1,_A2,_A3,_A4,_A5,_A6,_A7),  
  466. //_Imm=(2,3,0,1),其中_Ai为16bit整数，_A0为低位，返回结果为(_A1,_A0,_A3,_A2,_A5,_A4,_A7,_A6),     
  467. //_Imm must be an immediate  
  468. extern __m128i _mm_shufflelo_epi16(__m128i _A, int _Imm);  
  469. //返回一个__m128i的寄存器，r0=_A8, r1=_B8, r2=_A9, r3=_B9, ... r14=_A15, r15=_B15  
  470. extern __m128i _mm_unpackhi_epi8(__m128i _A, __m128i _B);  
  471. //返回一个__m128i的寄存器，它将寄存器_A和寄存器_B的高64bit数以16bit为单位交织在一块。  
  472. //例如，_A=(_A0,_A1,_A2,_A3,_A4,_A5,_A6,_A7),_B=(_B0,_B1,_B2,_B3,_B4,_B5,_B6,_B7),  
  473. //其中_Ai,_Bi为16bit整数，_A0,_B0为低位，返回结果为(_A4,_B4,_A5,_B5,_A6,_B6,_A7,_B7),  
  474. //r0=_A4, r1=_B4, r2=_A5, r3=_B5, r4=_A6, r5=_B6, r6=_A7, r7=_B7  
  475. extern __m128i _mm_unpackhi_epi16(__m128i _A, __m128i _B);  
  476. //返回一个__m128i的寄存器，它将寄存器_A和寄存器_B的高64bit数以32bit为单位交织在一块。  
  477. //例如，_A=(_A0,_A1,_A2,_A3,_A4,_A5,_A6,_A7),_B=(_B0,_B1,_B2,_B3,_B4,_B5,_B6,_B7),  
  478. //其中_Ai,_Bi为16bit整数，_A0,_B0为低位，返回结果为(_A4,_A5,_B4,_B5,_A6,_A7,_B6,_B7),  
  479. //r0=_A2, r1=_B2, r2=_A3, r3=_B3  
  480. extern __m128i _mm_unpackhi_epi32(__m128i _A, __m128i _B);  
  481. //返回一个__m128i的寄存器，它将寄存器_A和寄存器_B的高64bit数以64bit为单位交织在一块。  
  482. //例如，_A=(_A0,_A1,_A2,_A3,_A4,_A5,_A6,_A7),_B=(_B0,_B1,_B2,_B3,_B4,_B5,_B6,_B7),  
  483. //其中_Ai,_Bi为16bit整数，_A0,_B0为低位，  
  484. //返回结果为(_A4,_A5,_A6,_A7,_B4,_B5,_B6,_B7), r0=_A1, r1=_B1  
  485. extern __m128i _mm_unpackhi_epi64(__m128i _A, __m128i _B);  
  486. //返回一个__m128i的寄存器，r0=_A0, r1=_B0, r2=_A1, r3=_B1, ... r14=_A7, r15=_B7  
  487. extern __m128i _mm_unpacklo_epi8(__m128i _A, __m128i _B);  
  488. //返回一个__m128i的寄存器，它将寄存器_A和寄存器_B的低64bit数以16bit为单位交织在一块。  
  489. //例如，_A=(_A0,_A1,_A2,_A3,_A4,_A5,_A6,_A7),_B=(_B0,_B1,_B2,_B3,_B4,_B5,_B6,_B7),  
  490. //其中_Ai,_Bi为16bit整数，_A0,_B0为低位，返回结果为(_A0,_B0,_A1,_B1,_A2,_B2,_A3,_B3),  
  491. //r0=_A0, r1=_B0, r2=_A1, r3=_B1, r4=_A2, r5=_B2, r6=_A3, r7=_B3  
  492. extern __m128i _mm_unpacklo_epi16(__m128i _A, __m128i _B);  
  493. //返回一个__m128i的寄存器，它将寄存器_A和寄存器_B的低64bit数以32bit为单位交织在一块。  
  494. //例如，_A=(_A0,_A1,_A2,_A3,_A4,_A5,_A6,_A7),_B=(_B0,_B1,_B2,_B3,_B4,_B5,_B6,_B7),  
  495. //其中_Ai,_Bi为16bit整数，_A0,_B0为低位，返回结果为(_A0,_A1,_B0,_B1,_A2,_A3,_B2,_B3),  
  496. //r0=_A0, r1=_B0, r2=_A1, r3=_B1  
  497. extern __m128i _mm_unpacklo_epi32(__m128i _A, __m128i _B);  
  498. //返回一个__m128i的寄存器，它将寄存器_A和寄存器_B的低64bit数以32bit为单位交织在一块。  
  499. //例如，_A=(_A0,_A1,_A2,_A3,_A4,_A5,_A6,_A7),_B=(_B0,_B1,_B2,_B3,_B4,_B5,_B6,_B7),  
  500. //其中_Ai,_Bi为16bit整数，_A0,_B0为低位，返回结果为(_A0,_A1,_A2,_A3,_B0,_B1,_B2,_B3),   
  501. //ro=_A0, r1=_B0  
  502. extern __m128i _mm_unpacklo_epi64(__m128i _A, __m128i _B);  
  503.   
  504. //Load Operations(Integer SSE2 Intrinsics)  
  505. //返回为一个__m128i的寄存器，它将_P指向的数据读到指定寄存器中，实际使用时，  
  506. //_P一般是通过类型转换得到的, Address _P must be 16-byte aligned  
  507. extern __m128i _mm_load_si128(__m128i const*_P);  
  508. //返回一个__m128i的寄存器，Loads 128-bit value, Address _P does not need be 16-byte aligned  
  509. extern __m128i _mm_loadu_si128(__m128i const*_P);  
  510. //返回一个__m128i的寄存器，r0=*p[63:0], r1=0x0, zeroing the upper 64 bits of the result  
  511. extern __m128i _mm_loadl_epi64(__m128i const*_P);  
  512.   
  513. //Set Operations(Integer SSE2 Intrinsics)  
  514. //返回一个__m128i的寄存器，r0=_Q0, r1=_Q1  
  515. extern __m128i _mm_set_epi64(__m64 _Q1, __m64 _Q0);  
  516. //返回一个__m128i的寄存器，r0=_I0, r1=_I1, r2=_I2, r3=_I3  
  517. extern __m128i _mm_set_epi32(int _I3, int _I2, int _I1, int _I0);  
  518. //返回一个__m128i的寄存器，使用8个具体的short型数据来设置寄存器存放数据,  
  519. //r0=_W0, r1=_W1, ... r7=_W7  
  520. extern __m128i _mm_set_epi16(short _W7, short _W6, short _W5, short _W4,   
  521.                                 short _W3, short _W2, short _W1, short _W0);  
  522. //返回一个__m128i的寄存器，r0=_B0, r1=_B1, ... r15=_B15  
  523. extern __m128i _mm_set_epi8(char _B15, char _B14, char _B13, char _B12, char _B11,   
  524.                 char _B10, char _B9,char _B8, char _B7, char _B6, char _B5, char _B4,   
  525.                 char _B3, char _B2, char _B1, char _B0);  
  526. //返回一个__m128i的寄存器，r0=_Q, r1=_Q  
  527. extern __m128i _mm_set1_epi64(__m64 _Q);  
  528. //返回一个__m128i的寄存器，r0=_I, r1=_I, r2=_I, r3=_I  
  529. extern __m128i _mm_set1_epi32(int _I);  
  530. //返回一个__m128i的寄存器，r0=_W, r1=_W, ... r7=_W  
  531. extern __m128i _mm_set1_epi16(short _W);  
  532. //返回一个__m128i的寄存器，r0=_B, r1=_B, ... r15=_B  
  533. extern __m128i _mm_set1_epi8(char _B);  
  534. //返回一个__m128i的寄存器，r=_Q  
  535. extern __m128i _mm_setl_epi64(__m128i _Q);  
  536. //返回一个__m128i的寄存器，r0=_Q0, r1=_Q1  
  537. extern __m128i _mm_setr_epi64(__m64 _Q0, __m64 _Q1);  
  538. //返回一个__m128i的寄存器，r0=_I0, r1=_I1, r2=_I2, r3=_I3  
  539. extern __m128i _mm_setr_epi32(int _I0, int _I1, int _I2, int _I3);  
  540. //返回一个__m128i的寄存器，r0=_W0, r1=_W1, ... r7=_W7  
  541. extern __m128i _mm_setr_epi16(short _W0, short _W1, short _W2, short _W3,   
  542.                                 short _W4, short _W5, short _W6, short _W7);  
  543. //返回一个__m128i的寄存器，r0=_B15, r1=_B14, ... r15=_B0  
  544. extern __m128i _mm_setr_epi8(char _B15, char _B14, char _B13, char _B12, char _B11,   
  545.     char _B10, char _B9, char _B8, char _B7, char _B6, char _B5, char _B4,    
  546.     char _B3, char _B2, char _B1, char _B0);  
  547. //返回一个__m128i的寄存器，r=0x0  
  548. extern __m128i _mm_setzero_si128(void);  
  549.   
  550. //Store Operations(Integer SSE2 Intrinsics)  
  551. //返回为空，它将寄存器_B中的数据存储到_P指向的地址中，实际使用时，  
  552. //_P一般是通过类型转换得到的, *_P = _B, Address _P must be 16-byte aligned  
  553. extern void _mm_store_si128(__m128i *_P, __m128i _B);  
  554. //返回为空，*_P=_B, Address _P does not need to be 16-byte aligned  
  555. extern void _mm_storeu_si128(__m128i *_P, __m128i _B);  
  556. //返回为空，*_P[63:0] =_Q0, lower 64 bits  
  557. extern void _mm_storel_epi64(__m128i *_P, __m128i _Q);  
  558. //返回为空，if(_N0[7]) _P[0]=_D0, if(_N1[7]) _P[1]=_D1, ... if(_N15[7]) _P[15]=_D15,   
  559. //The high bit of each byte in the selector _N determines whether the corresponding byte   
  560. //in _D will be stored. Address _P does not need to be 16-byte aligned  
  561. extern void _mm_maskmoveu_si128(__m128i _D, __m128i _N, char *_P);  
  562.   
  563. //Integer, moves  
  564. //返回一个__m128i的寄存器，r0=_Q0, r1=0x0, zeroing the upper bits  
  565. extern __m128i _mm_move_epi64(__m128i _Q);  
  566. //返回一个__m128i的寄存器，r0=_Q, r1=0x0, zeroing the upper bits  
  567. extern __m128i _mm_movpi64_epi64(__m64 _Q);  
  568. //返回一个__m64的寄存器，r=_Q0  
  569. extern __m64 _mm_movepi64_pi64(__m128i _Q);  
  570.   
  571. //Cache Support for Steaming SIMD Extensions 2 Integer Operations  
  572. //返回为空，*_P=_A, Stores the data in _A to the address _P without polluting the caches.  
  573. //If the cache line containing address _P is already in the cache, the cache will be updated.   
  574. //Address _P must be 16-byte aligned  
  575. extern void _mm_stream_si128(__m128i *_P, __m128i _A);  
  576. //返回为空，Cache line containing _P is flushed and invalidated from   
  577. //all caches in the coherency domain  
  578. extern void _mm_clflush(void const*_P);  
  579. //返回为空，Guarantees that every load instruction that precedes, in program order, the load   
  580. //fence instruction is globally visible before any load instruction   
  581. //that follows the fence in program order  
  582. extern void _mm_lfence(void);  
  583. //返回为空，Guarantees that every memory access that precedes, in program order,   
  584. //the memory fence instruction is globally visible before any memory instruction   
  585. //that follows the fence in program order  
  586. extern void _mm_mfence(void);  
  587. //返回为空，*_P=_I, Stores the data in _I to the address _P without polluting the caches.   
  588. //If the cache line containing address _P is already in the cache, the cache will be updated  
  589. extern void _mm_stream_si32(int *_P, int _I);  
  590. //返回为空，The execution of the next instruction is delayed an implementation specific   
  591. //amount of time. The instruction does not modify the architectural state. This intrinsic  
  592. //provides especially significant performance gain  
  593. extern void _mm_pause(void);  
  594.   
  595. /*---Support for casting between various SP, DP, INT vector types. Note that these do no  
  596.     conversion of values, they just change the type----*/  
  597. //返回一个__m128的寄存器，Applies a type cast to reinterpret two 64-bit floating   
  598. //point values passed in as a 128-bit parameter as packed 32-bit floating point values  
  599. extern __m128  _mm_castpd_ps(__m128d);  
  600. //返回一个__m128i的寄存器，Applies a type cast to reinterpret two 64-bit  
  601. //floating point values passed in as a 128-bit parameter as packed 32-bit integers  
  602. extern __m128i _mm_castpd_si128(__m128d);  
  603. //返回一个__m128d的寄存器，Applies a type cast to reinterpret four 32-bit floating   
  604. //point values passed in as a 128-bit parameter as packed 64-bit floating point values  
  605. extern __m128d _mm_castps_pd(__m128);  
  606. //返回一个__m128i的寄存器，Applies a type cast to reinterpret four 32-bit floating   
  607. //point values passed in as a 128-bit parameter as packed 32-bit integers  
  608. extern __m128i _mm_castps_si128(__m128);  
  609. //返回一个__m128的寄存器，Applies a type cast to reinterpret four 32-bit integers   
  610. //passed in as a 128-bit parameter as packed 32-bit floating point values  
  611. extern __m128  _mm_castsi128_ps(__m128i);  
  612. //返回一个__m128d的寄存器，Applies a type cast to reinterpret four 32-bit   
  613. //integers passed in as a 128-bit parameter as packed 64-bit floating point values  

  1. extern __m128d _mm_castsi128_pd(__m128i);  

原文地址：https://blog.csdn.net/fengbingchun/article/details/18460199

tercel_zhang
关注
  • 1
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
SSE指令集简记
jmp esp
06-07 2218
SSE？SSE（为Streaming SIMD Extensions的缩写）是由 Intel公司，在1999年推出Pentium III处理器时，同时推出的新指令集。如同其名称所表示的，SSE是一种SIMD指令集。所谓的SIMD是指single instruction, multiple data，也就是一个指令同时对多个资料进行相同的动作。较早的MMX和 AMD的3DNow!也都是SIMD指令集。
SSE指令集入门
wensishuai的专栏
12-26 4962
Intel公司的单指令多数据流式扩展（SSE，Streaming SIMD Extensions）技术能够有效增强CPU浮点运算的能力。Visual Studio .NET 2003提供了对SSE指令集的编程支持，从而允许用户在C++代码中不用编写汇编代码就可直接使用SSE指令的功能。MSDN中有关SSE技术的主题[1]有可能会使不熟悉使用SSE汇编指令编程的初学者感到困惑，但是在阅读MSDN有关
sse 指令集--摘自sse_introduction
阿彪
05-24 610
micheal Flynn根据指令和数据流的概念对计算的系统结构分为四个类型：     SISD: 但指令流单数据流     MISD：多指令流单数据流 ，适用于分类问题     SIMD:单指令流多数据流，相同的指令来处理多组数据，适合并行算法，在语音和图像的处理中应用广泛。     MIMD   sse的指令集： 常用整数指令集：   算数指令；加减乘，平均值和取max,min
SSE2 Intrinsics各函数介绍
架构设计
01-18 800
SIMD相关头文件包括： //#include &lt;ivec.h&gt;//MMX //#include &lt;fvec.h&gt;//SSE(also include ivec.h) //#include &lt;dvec.h&gt;//SSE2(also include fvec.h) #include &lt;mmintrin.h&gt; //MMX #inclu...
汇编 intel SSE指令简介
最新发布
m0_73378754的博客
05-10 582
简介：是一组指令集扩展，用于增强处理器的浮点运算和向量操作能力,可以同时对多个数据元素执行相同的操作，采用8个128位寄存器(XMM0~XMM7),适用于需要高性能并行计算的应用场景，能够通过同时处理多个数据元素来提高计算效率，从而加速各种计算密集型任务的执行。，并将结果存储在目标操作数中。将源操作数中的四个单精度浮点值与目标操作数中的四个单精度浮点值逐元素比较，然后将每个位置上的最大值存储在目标操作数中。将源操作数中的单精度浮点数值与目标操作数中的单精度浮点数值相乘的操作，并将结果存储在目标操作数中。
SSE2的一些常用指令集介绍
小白_努力
03-14 1万+
开门见山，前段时间学习OpenCV的FAST算法，中间有很多SSE2的指令集，深受其惑。下面我把学习过程中学到的一些指令集介绍给大家，希望能对大家有所帮助！ __m128i被称为128bits的整数，对其进行赋值时，可以调用__m128i_mm_set1_epi8或者__m128i_mm_set1_epi816等，前者就是把128bits设置为16个8bits的整数值，后一个例子就是把128bi
在C/C++代码中使用SSE等指令集的指令(3)SSE指令集基础
sinat_22510827的博客
06-21 1440
相关参考：http://edu.gamfe.com/tutor/d/11820.htmlhttp://blog.163.com/chenqneu@126/blog/static/45738484200781392836677/ http://dev.gameres.com/Program/Other/SSEjianjie.htm http://www.vckbase.com/document/viewdoc/?id=322scalar packed （1）Summary：前面了解到了可以在代码中使用intr
xmmintrin.h文件解析
Rana专栏
05-21 7558
xmmintrin.h为SSE 头文件，此头文件里包含MMX头文件，其中__m128的定义为： typedef union __declspec(intrin_type) _CRT_ALIGN(16) __m128 { float m128_f32[4]; unsigned __int64 m128_u64[2]; __int8
SSE指令集实现4*4矩阵快速转置
weixin_39782251的博客
08-11 430
(2) _mm_unpacklo_ / _mm_unpackhi_()：从源XMM寄存器中去除低32（或高32）位数据后，交叉存储在目的寄存器中。如图1所示，4*4矩阵可按照行向量方式划分为4行，后续SSE操作时，以上述的行向量为基本操作单位，数据类型统一为float32。(1) _mm_load_ps() / _mm_store_ps() ：利用XMM寄存器单次获取/存储4个fp32的浮点型数据；图4. _mm_unpacklo_ps()函数操作过程说明。图1. 4*4矩阵分步转置示意（共计两大步）
SSE指令集加速.docx
08-12
在学习指令集加速的过程中，对SSE的相关基础概念以及简单的应用原理进行整理汇总，并配有相应的代码实例，先分享给有需要的同学。
SSE指令集学习笔记（个人记录）
07-13
SSE指令集学习笔记。
SSE-指令集
03-21
SSE指令集
09-20
SE指令集
SSE2指令集_中文
11-17
SSE2命令大全，内容十分详细，中文版，对于要使用SSE2的开发者来说，帮助很大！
C/C++指令集介绍以及优化（主要针对SSE优化）
MIss-Y的博客
01-11 1万+
前言：最近在做一些OpenCV的优化相关的东西，发现OpenCV现在的执行效率很高的原因一部分是来自于底层的优化，比如指令集优化，但是一直没找到比较系统性的关于CPU指令集优化的文章或者是书籍，于是自己打算做一个总结，鉴于水平有限，有不正确的地方还望有大佬指正。 一、CPU指令集优化的概述 1.1 数据并行的两种实现 在计算机体系中，数据并行有两种实现路径： MIMD（Multipl...
Intel 64/x86_64/IA-32/x86处理器 - SIMD指令集 - SSE扩展(6) - 逻辑指令 & 比较指令
一凡stkeke
02-01 2305
SSE Logical Instructions SSE的逻辑指令执行与，或，非，以及与非操作。操作数是组合的单精度浮点数。 指令 描述 ANDPS 格式：xmm1, xmm2/m128 对操作数执行按位“与”操作   指令操作： DEST[31:0] &lt;-- DEST[31:0] B...
指令集简介
热门推荐
贾路飞的博客
07-15 2万+
SIMD（Single Instruction Multiple Data）是单指令多数据技术，目前Intel处理器支持的SIMD技术包括MMX，SSE，AVX。SSE（Stream SIMD Extentions，数据流单指令多数据扩展）是英特尔继MMX（Multi Media eXtension，多媒体扩展指令集）之后推出的新一代CPU指令集。MMX提供了8个64bit的寄存器进行SIMD操作，SSE系列提供了8个128bit的寄存器进行SIMD操作。
SSE2 Intrinsics各函数介绍[转]
weixin_30501857的博客
10-18 212
SIMD相关头文件包括： //#include <ivec.h>//MMX //#include <fvec.h>//SSE(also include ivec.h) //#include <dvec.h>//SSE2(also include fvec.h) #include <mmintrin.h> //MMX #...
SSE2 指令
少年的此间
11-02 4564
SSE2指令集
基于C语言，针对不同CPU指令集的性能优化代码有自动移植工具吗？
09-21
### 回答1： 是的，在 C 语言开发中，有一些工具可以帮助你自动地优化代码，使其能够更好地运行在不同的 CPU 指令集上。 其中一个常用的工具是 Intel C Compiler (ICC)，它能够自动地优化代码以使用特定的 CPU 指令集，提升性能。使用 ICC 编译代码时，你可以通过指定编译选项来指定要优化的 CPU 指令集。 另一个常用的工具是 GNU Compiler Collection (GCC)，它也能够自动优化代码以使用特定的 CPU 指令集。你可以使用 GCC 的 `-march` 和 `-mtune` 选项来指定优化的 CPU 指令集。 需要注意的是，这些工具不能完全解决代码优化的问题，你仍然需要了解各种 CPU 指令集的特性，手动地优化代码。 ### 回答2： 在C语言中，针对不同CPU指令集的性能优化代码没有专门的自动移植工具。由于不同CPU的指令集架构和机器语言不同，需要使用不同的指令和寄存器来进行性能优化。因此，对于特定的CPU架构，需要手动编写和适配相应的代码来实现性能优化。 针对不同CPU指令集的性能优化代码需要针对具体的架构进行优化。对于不同的CPU架构，通常需要使用不同的指令集扩展、寄存器使用方法、内存对齐等来实现最佳性能。例如，针对Intel x86架构的CPU可以使用SSE、AVX等多媒体指令集来加速运算，而针对ARM架构的CPU可以使用NEON指令集来加速计算。 编写针对特定CPU指令集的性能优化代码时，常常需要针对不同的编译器和操作系统进行优化。不同的编译器和操作系统可能对代码生成、寄存器分配和代码调度等有不同的实现方式，需要针对具体的编译器和操作系统进行优化。 总之，由于不同CPU指令集架构的差异和复杂性，针对不同CPU指令集的性能优化代码通常需要手动编写和适配，目前尚无专门的自动移植工具提供此功能。 ### 回答3： 在基于C语言的性能优化中，针对不同CPU指令集可以使用自动移植工具进行优化。这些工具可以根据目标平台的CPU指令集特性，自动调整并生成最优化的代码。以下是一些常见的自动移植工具： 1. GCC（GNU编译器套件）：GCC是一款开源的编译器套件，它支持多种不同的CPU指令集。通过设置GCC的编译选项，比如"-march"和"-mcpu"，可以针对不同的CPU指令集进行优化。 2. Clang：Clang也是一款开源的编译器，它可以根据目标平台自动选择并优化适应的指令集。Clang提供了一些编译选项，比如"-march"和"-mtune"，可以指定优化的目标CPU和微架构。 3. Intel编译器：Intel提供了一款专门用于优化Intel CPU的编译器工具集。该工具集可以根据目标平台的具体特性，自动进行特定指令集的优化，提供最佳的性能表现。 4. LLVM（低级虚拟机）：LLVM是一款开源的编译器基础设施，它支持多种前端语言和后端目标平台。通过使用LLVM，可以根据目标平台生成优化的机器码，实现针对不同CPU指令集的性能优化。 这些工具都提供了一些选项和接口，可以根据目标平台的特性生成优化的代码。开发者可以根据自己的需求选择合适的工具，并根据目标平台的特性进行优化。通过使用这些自动移植工具，可以实现针对不同CPU指令集的性能优化，提高代码的执行效率。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值