1 // RUN: %clang_cc1 %s -triple=x86_64-apple-darwin -target-feature +avx2 -emit-llvm -o - -Werror | FileCheck %s 2 // RUN: %clang_cc1 %s -triple=x86_64-apple-darwin -target-feature +avx2 -fno-signed-char -emit-llvm -o - -Werror | FileCheck %s 3 4 // Don't include mm_malloc.h, it's system specific. 5 #define __MM_MALLOC_H 6 7 #include <x86intrin.h> 8 9 // NOTE: This should match the tests in llvm/test/CodeGen/X86/avx2-intrinsics-fast-isel.ll 10 11 __m256i test_mm256_abs_epi8(__m256i a) { 12 // CHECK-LABEL: test_mm256_abs_epi8 13 // CHECK: call <32 x i8> @llvm.x86.avx2.pabs.b(<32 x i8> %{{.*}}) 14 return _mm256_abs_epi8(a); 15 } 16 17 __m256i test_mm256_abs_epi16(__m256i a) { 18 // CHECK-LABEL: test_mm256_abs_epi16 19 // CHECK: call <16 x i16> @llvm.x86.avx2.pabs.w(<16 x i16> %{{.*}}) 20 return _mm256_abs_epi16(a); 21 } 22 23 __m256i test_mm256_abs_epi32(__m256i a) { 24 // CHECK-LABEL: test_mm256_abs_epi32 25 // CHECK: call <8 x i32> @llvm.x86.avx2.pabs.d(<8 x i32> %{{.*}}) 26 return _mm256_abs_epi32(a); 27 } 28 29 __m256i test_mm256_add_epi8(__m256i a, __m256i b) { 30 // CHECK-LABEL: test_mm256_add_epi8 31 // CHECK: add <32 x i8> 32 return _mm256_add_epi8(a, b); 33 } 34 35 __m256i test_mm256_add_epi16(__m256i a, __m256i b) { 36 // CHECK-LABEL: test_mm256_add_epi16 37 // CHECK: add <16 x i16> 38 return _mm256_add_epi16(a, b); 39 } 40 41 __m256i test_mm256_add_epi32(__m256i a, __m256i b) { 42 // CHECK-LABEL: test_mm256_add_epi32 43 // CHECK: add <8 x i32> 44 return _mm256_add_epi32(a, b); 45 } 46 47 __m256i test_mm256_add_epi64(__m256i a, __m256i b) { 48 // CHECK-LABEL: test_mm256_add_epi64 49 // CHECK: add <4 x i64> 50 return _mm256_add_epi64(a, b); 51 } 52 53 __m256i test_mm256_adds_epi8(__m256i a, __m256i b) { 54 // CHECK-LABEL: test_mm256_adds_epi8 55 // CHECK: call <32 x i8> @llvm.x86.avx2.padds.b(<32 x i8> %{{.*}}, <32 x i8> %{{.*}}) 56 return _mm256_adds_epi8(a, b); 57 } 58 59 __m256i test_mm256_adds_epi16(__m256i a, __m256i b) { 60 // CHECK-LABEL: test_mm256_adds_epi16 61 // CHECK: call <16 x i16> @llvm.x86.avx2.padds.w(<16 x i16> %{{.*}}, <16 x i16> %{{.*}}) 62 return _mm256_adds_epi16(a, b); 63 } 64 65 __m256i test_mm256_adds_epu8(__m256i a, __m256i b) { 66 // CHECK-LABEL: test_mm256_adds_epu8 67 // CHECK: call <32 x i8> @llvm.x86.avx2.paddus.b(<32 x i8> %{{.*}}, <32 x i8> %{{.*}}) 68 return _mm256_adds_epu8(a, b); 69 } 70 71 __m256i test_mm256_adds_epu16(__m256i a, __m256i b) { 72 // CHECK-LABEL: test_mm256_adds_epu16 73 // CHECK: call <16 x i16> @llvm.x86.avx2.paddus.w(<16 x i16> %{{.*}}, <16 x i16> %{{.*}}) 74 return _mm256_adds_epu16(a, b); 75 } 76 77 __m256i test_mm256_alignr_epi8(__m256i a, __m256i b) { 78 // CHECK-LABEL: test_mm256_alignr_epi8 79 // CHECK: shufflevector <32 x i8> %{{.*}}, <32 x i8> %{{.*}}, <32 x i32> <i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 8, i32 9, i32 10, i32 11, i32 12, i32 13, i32 14, i32 15, i32 32, i32 33, i32 18, i32 19, i32 20, i32 21, i32 22, i32 23, i32 24, i32 25, i32 26, i32 27, i32 28, i32 29, i32 30, i32 31, i32 48, i32 49> 80 return _mm256_alignr_epi8(a, b, 2); 81 } 82 83 __m256i test2_mm256_alignr_epi8(__m256i a, __m256i b) { 84 // CHECK-LABEL: test2_mm256_alignr_epi8 85 // CHECK: shufflevector <32 x i8> %{{.*}}, <32 x i8> zeroinitializer, <32 x i32> <i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 8, i32 9, i32 10, i32 11, i32 12, i32 13, i32 14, i32 15, i32 32, i32 17, i32 18, i32 19, i32 20, i32 21, i32 22, i32 23, i32 24, i32 25, i32 26, i32 27, i32 28, i32 29, i32 30, i32 31, i32 48> 86 return _mm256_alignr_epi8(a, b, 17); 87 } 88 89 __m256i test_mm256_and_si256(__m256i a, __m256i b) { 90 // CHECK-LABEL: test_mm256_and_si256 91 // CHECK: and <4 x i64> 92 return _mm256_and_si256(a, b); 93 } 94 95 __m256i test_mm256_andnot_si256(__m256i a, __m256i b) { 96 // CHECK-LABEL: test_mm256_andnot_si256 97 // CHECK: xor <4 x i64> 98 // CHECK: and <4 x i64> 99 return _mm256_andnot_si256(a, b); 100 } 101 102 __m256i test_mm256_avg_epu8(__m256i a, __m256i b) { 103 // CHECK-LABEL: test_mm256_avg_epu8 104 // CHECK: call <32 x i8> @llvm.x86.avx2.pavg.b(<32 x i8> %{{.*}}, <32 x i8> %{{.*}}) 105 return _mm256_avg_epu8(a, b); 106 } 107 108 __m256i test_mm256_avg_epu16(__m256i a, __m256i b) { 109 // CHECK-LABEL: test_mm256_avg_epu16 110 // CHECK: call <16 x i16> @llvm.x86.avx2.pavg.w(<16 x i16> %{{.*}}, <16 x i16> %{{.*}}) 111 return _mm256_avg_epu16(a, b); 112 } 113 114 // FIXME: We should also lower the __builtin_ia32_pblendw128 (and similar) 115 // functions to this IR. In the future we could delete the corresponding 116 // intrinsic in LLVM if it's not being used anymore. 117 __m256i test_mm256_blend_epi16(__m256i a, __m256i b) { 118 // CHECK-LABEL: test_mm256_blend_epi16 119 // CHECK-NOT: @llvm.x86.avx2.pblendw 120 // CHECK: shufflevector <16 x i16> %{{.*}}, <16 x i16> %{{.*}}, <16 x i32> <i32 0, i32 17, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 8, i32 25, i32 10, i32 11, i32 12, i32 13, i32 14, i32 15> 121 return _mm256_blend_epi16(a, b, 2); 122 } 123 124 __m128i test_mm_blend_epi32(__m128i a, __m128i b) { 125 // CHECK-LABEL: test_mm_blend_epi32 126 // CHECK-NOT: @llvm.x86.avx2.pblendd.128 127 // CHECK: shufflevector <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> <i32 4, i32 1, i32 6, i32 3> 128 return _mm_blend_epi32(a, b, 0x35); 129 } 130 131 __m256i test_mm256_blend_epi32(__m256i a, __m256i b) { 132 // CHECK-LABEL: test_mm256_blend_epi32 133 // CHECK-NOT: @llvm.x86.avx2.pblendd.256 134 // CHECK: shufflevector <8 x i32> %{{.*}}, <8 x i32> %{{.*}}, <8 x i32> <i32 8, i32 1, i32 10, i32 3, i32 12, i32 13, i32 6, i32 7> 135 return _mm256_blend_epi32(a, b, 0x35); 136 } 137 138 __m256i test_mm256_blendv_epi8(__m256i a, __m256i b, __m256i m) { 139 // CHECK-LABEL: test_mm256_blendv_epi8 140 // CHECK: call <32 x i8> @llvm.x86.avx2.pblendvb(<32 x i8> %{{.*}}, <32 x i8> %{{.*}}, <32 x i8> %{{.*}}) 141 return _mm256_blendv_epi8(a, b, m); 142 } 143 144 __m128i test_mm_broadcastb_epi8(__m128i a) { 145 // CHECK-LABEL: test_mm_broadcastb_epi8 146 // CHECK-NOT: @llvm.x86.avx2.pbroadcastb.128 147 // CHECK: shufflevector <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i32> zeroinitializer 148 return _mm_broadcastb_epi8(a); 149 } 150 151 __m256i test_mm256_broadcastb_epi8(__m128i a) { 152 // CHECK-LABEL: test_mm256_broadcastb_epi8 153 // CHECK-NOT: @llvm.x86.avx2.pbroadcastb.256 154 // CHECK: shufflevector <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <32 x i32> zeroinitializer 155 return _mm256_broadcastb_epi8(a); 156 } 157 158 __m128i test_mm_broadcastd_epi32(__m128i a) { 159 // CHECK-LABEL: test_mm_broadcastd_epi32 160 // CHECK-NOT: @llvm.x86.avx2.pbroadcastd.128 161 // CHECK: shufflevector <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> zeroinitializer 162 return _mm_broadcastd_epi32(a); 163 } 164 165 __m256i test_mm256_broadcastd_epi32(__m128i a) { 166 // CHECK-LABEL: test_mm256_broadcastd_epi32 167 // CHECK-NOT: @llvm.x86.avx2.pbroadcastd.256 168 // CHECK: shufflevector <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <8 x i32> zeroinitializer 169 return _mm256_broadcastd_epi32(a); 170 } 171 172 __m128i test_mm_broadcastq_epi64(__m128i a) { 173 // CHECK-LABEL: test_mm_broadcastq_epi64 174 // CHECK-NOT: @llvm.x86.avx2.pbroadcastq.128 175 // CHECK: shufflevector <2 x i64> %{{.*}}, <2 x i64> %{{.*}}, <2 x i32> zeroinitializer 176 return _mm_broadcastq_epi64(a); 177 } 178 179 __m256i test_mm256_broadcastq_epi64(__m128i a) { 180 // CHECK-LABEL: test_mm256_broadcastq_epi64 181 // CHECK-NOT: @llvm.x86.avx2.pbroadcastq.256 182 // CHECK: shufflevector <2 x i64> %{{.*}}, <2 x i64> %{{.*}}, <4 x i32> zeroinitializer 183 return _mm256_broadcastq_epi64(a); 184 } 185 186 __m128d test_mm_broadcastsd_pd(__m128d a) { 187 // CHECK-LABEL: test_mm_broadcastsd_pd 188 // CHECK: shufflevector <2 x double> %{{.*}}, <2 x double> %{{.*}}, <2 x i32> zeroinitializer 189 return _mm_broadcastsd_pd(a); 190 } 191 192 __m256d test_mm256_broadcastsd_pd(__m128d a) { 193 // CHECK-LABEL: test_mm256_broadcastsd_pd 194 // CHECK-NOT: @llvm.x86.avx2.vbroadcast.sd.pd.256 195 // CHECK: shufflevector <2 x double> %{{.*}}, <2 x double> %{{.*}}, <4 x i32> zeroinitializer 196 return _mm256_broadcastsd_pd(a); 197 } 198 199 __m256i test_mm256_broadcastsi128_si256(__m128i a) { 200 // CHECK-LABEL: test_mm256_broadcastsi128_si256 201 // CHECK: shufflevector <2 x i64> %{{.*}}, <2 x i64> %{{.*}}, <4 x i32> <i32 0, i32 1, i32 0, i32 1> 202 return _mm256_broadcastsi128_si256(a); 203 } 204 205 __m128 test_mm_broadcastss_ps(__m128 a) { 206 // CHECK-LABEL: test_mm_broadcastss_ps 207 // CHECK-NOT: @llvm.x86.avx2.vbroadcast.ss.ps 208 // CHECK: shufflevector <4 x float> %{{.*}}, <4 x float> %{{.*}}, <4 x i32> zeroinitializer 209 return _mm_broadcastss_ps(a); 210 } 211 212 __m256 test_mm256_broadcastss_ps(__m128 a) { 213 // CHECK-LABEL: test_mm256_broadcastss_ps 214 // CHECK-NOT: @llvm.x86.avx2.vbroadcast.ss.ps.256 215 // CHECK: shufflevector <4 x float> %{{.*}}, <4 x float> %{{.*}}, <8 x i32> zeroinitializer 216 return _mm256_broadcastss_ps(a); 217 } 218 219 __m128i test_mm_broadcastw_epi16(__m128i a) { 220 // CHECK-LABEL: test_mm_broadcastw_epi16 221 // CHECK-NOT: @llvm.x86.avx2.pbroadcastw.128 222 // CHECK: shufflevector <8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <8 x i32> zeroinitializer 223 return _mm_broadcastw_epi16(a); 224 } 225 226 __m256i test_mm256_broadcastw_epi16(__m128i a) { 227 // CHECK-LABEL: test_mm256_broadcastw_epi16 228 // CHECK-NOT: @llvm.x86.avx2.pbroadcastw.256 229 // CHECK: shufflevector <8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <16 x i32> zeroinitializer 230 return _mm256_broadcastw_epi16(a); 231 } 232 233 __m256i test_mm256_bslli_epi128(__m256i a) { 234 // CHECK-LABEL: test_mm256_bslli_epi128 235 // CHECK: shufflevector <32 x i8> %{{.*}}, <32 x i8> %{{.*}}, <32 x i32> <i32 13, i32 14, i32 15, i32 32, i32 33, i32 34, i32 35, i32 36, i32 37, i32 38, i32 39, i32 40, i32 41, i32 42, i32 43, i32 44, i32 29, i32 30, i32 31, i32 48, i32 49, i32 50, i32 51, i32 52, i32 53, i32 54, i32 55, i32 56, i32 57, i32 58, i32 59, i32 60> 236 return _mm256_bslli_epi128(a, 3); 237 } 238 239 __m256i test_mm256_bsrli_epi128(__m256i a) { 240 // CHECK-LABEL: test_mm256_bsrli_epi128 241 // CHECK: shufflevector <32 x i8> %{{.*}}, <32 x i8> %{{.*}}, <32 x i32> <i32 3, i32 4, i32 5, i32 6, i32 7, i32 8, i32 9, i32 10, i32 11, i32 12, i32 13, i32 14, i32 15, i32 32, i32 33, i32 34, i32 19, i32 20, i32 21, i32 22, i32 23, i32 24, i32 25, i32 26, i32 27, i32 28, i32 29, i32 30, i32 31, i32 48, i32 49, i32 50> 242 return _mm256_bsrli_epi128(a, 3); 243 } 244 245 __m256i test_mm256_cmpeq_epi8(__m256i a, __m256i b) { 246 // CHECK-LABEL: test_mm256_cmpeq_epi8 247 // CHECK: icmp eq <32 x i8> 248 return _mm256_cmpeq_epi8(a, b); 249 } 250 251 __m256i test_mm256_cmpeq_epi16(__m256i a, __m256i b) { 252 // CHECK-LABEL: test_mm256_cmpeq_epi16 253 // CHECK: icmp eq <16 x i16> 254 return _mm256_cmpeq_epi16(a, b); 255 } 256 257 __m256i test_mm256_cmpeq_epi32(__m256i a, __m256i b) { 258 // CHECK-LABEL: test_mm256_cmpeq_epi32 259 // CHECK: icmp eq <8 x i32> 260 return _mm256_cmpeq_epi32(a, b); 261 } 262 263 __m256i test_mm256_cmpeq_epi64(__m256i a, __m256i b) { 264 // CHECK-LABEL: test_mm256_cmpeq_epi64 265 // CHECK: icmp eq <4 x i64> 266 return _mm256_cmpeq_epi64(a, b); 267 } 268 269 __m256i test_mm256_cmpgt_epi8(__m256i a, __m256i b) { 270 // CHECK-LABEL: test_mm256_cmpgt_epi8 271 // CHECK: icmp sgt <32 x i8> 272 return _mm256_cmpgt_epi8(a, b); 273 } 274 275 __m256i test_mm256_cmpgt_epi16(__m256i a, __m256i b) { 276 // CHECK-LABEL: test_mm256_cmpgt_epi16 277 // CHECK: icmp sgt <16 x i16> 278 return _mm256_cmpgt_epi16(a, b); 279 } 280 281 __m256i test_mm256_cmpgt_epi32(__m256i a, __m256i b) { 282 // CHECK-LABEL: test_mm256_cmpgt_epi32 283 // CHECK: icmp sgt <8 x i32> 284 return _mm256_cmpgt_epi32(a, b); 285 } 286 287 __m256i test_mm256_cmpgt_epi64(__m256i a, __m256i b) { 288 // CHECK-LABEL: test_mm256_cmpgt_epi64 289 // CHECK: icmp sgt <4 x i64> 290 return _mm256_cmpgt_epi64(a, b); 291 } 292 293 __m256i test_mm256_cvtepi8_epi16(__m128i a) { 294 // CHECK-LABEL: test_mm256_cvtepi8_epi16 295 // CHECK: sext <16 x i8> %{{.*}} to <16 x i16> 296 return _mm256_cvtepi8_epi16(a); 297 } 298 299 __m256i test_mm256_cvtepi8_epi32(__m128i a) { 300 // CHECK-LABEL: test_mm256_cvtepi8_epi32 301 // CHECK: shufflevector <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7> 302 // CHECK: sext <8 x i8> %{{.*}} to <8 x i32> 303 return _mm256_cvtepi8_epi32(a); 304 } 305 306 __m256i test_mm256_cvtepi8_epi64(__m128i a) { 307 // CHECK-LABEL: test_mm256_cvtepi8_epi64 308 // CHECK: shufflevector <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <4 x i32> <i32 0, i32 1, i32 2, i32 3> 309 // CHECK: sext <4 x i8> %{{.*}} to <4 x i64> 310 return _mm256_cvtepi8_epi64(a); 311 } 312 313 __m256i test_mm256_cvtepi16_epi32(__m128i a) { 314 // CHECK-LABEL: test_mm256_cvtepi16_epi32 315 // CHECK: sext <8 x i16> %{{.*}} to <8 x i32> 316 return _mm256_cvtepi16_epi32(a); 317 } 318 319 __m256i test_mm256_cvtepi16_epi64(__m128i a) { 320 // CHECK-LABEL: test_mm256_cvtepi16_epi64 321 // CHECK: shufflevector <8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <4 x i32> <i32 0, i32 1, i32 2, i32 3> 322 // CHECK: sext <4 x i16> %{{.*}} to <4 x i64> 323 return _mm256_cvtepi16_epi64(a); 324 } 325 326 __m256i test_mm256_cvtepi32_epi64(__m128i a) { 327 // CHECK-LABEL: test_mm256_cvtepi32_epi64 328 // CHECK: sext <4 x i32> %{{.*}} to <4 x i64> 329 return _mm256_cvtepi32_epi64(a); 330 } 331 332 __m256i test_mm256_cvtepu8_epi16(__m128i a) { 333 // CHECK-LABEL: test_mm256_cvtepu8_epi16 334 // CHECK: zext <16 x i8> %{{.*}} to <16 x i16> 335 return _mm256_cvtepu8_epi16(a); 336 } 337 338 __m256i test_mm256_cvtepu8_epi32(__m128i a) { 339 // CHECK-LABEL: test_mm256_cvtepu8_epi32 340 // CHECK: shufflevector <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7> 341 // CHECK: zext <8 x i8> %{{.*}} to <8 x i32> 342 return _mm256_cvtepu8_epi32(a); 343 } 344 345 __m256i test_mm256_cvtepu8_epi64(__m128i a) { 346 // CHECK-LABEL: test_mm256_cvtepu8_epi64 347 // CHECK: shufflevector <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <4 x i32> <i32 0, i32 1, i32 2, i32 3> 348 // CHECK: zext <4 x i8> %{{.*}} to <4 x i64> 349 return _mm256_cvtepu8_epi64(a); 350 } 351 352 __m256i test_mm256_cvtepu16_epi32(__m128i a) { 353 // CHECK-LABEL: test_mm256_cvtepu16_epi32 354 // CHECK: zext <8 x i16> {{.*}} to <8 x i32> 355 return _mm256_cvtepu16_epi32(a); 356 } 357 358 __m256i test_mm256_cvtepu16_epi64(__m128i a) { 359 // CHECK-LABEL: test_mm256_cvtepu16_epi64 360 // CHECK: shufflevector <8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <4 x i32> <i32 0, i32 1, i32 2, i32 3> 361 // CHECK: zext <4 x i16> %{{.*}} to <4 x i64> 362 return _mm256_cvtepu16_epi64(a); 363 } 364 365 __m256i test_mm256_cvtepu32_epi64(__m128i a) { 366 // CHECK-LABEL: test_mm256_cvtepu32_epi64 367 // CHECK: zext <4 x i32> %{{.*}} to <4 x i64> 368 return _mm256_cvtepu32_epi64(a); 369 } 370 371 __m128i test0_mm256_extracti128_si256_0(__m256i a) { 372 // CHECK-LABEL: test0_mm256_extracti128_si256 373 // CHECK: shufflevector <4 x i64> %{{.*}}, <4 x i64> undef, <2 x i32> <i32 0, i32 1> 374 return _mm256_extracti128_si256(a, 0); 375 } 376 377 __m128i test1_mm256_extracti128_si256_1(__m256i a) { 378 // CHECK-LABEL: test1_mm256_extracti128_si256 379 // CHECK: shufflevector <4 x i64> %{{.*}}, <4 x i64> undef, <2 x i32> <i32 2, i32 3> 380 return _mm256_extracti128_si256(a, 1); 381 } 382 383 // Immediate should be truncated to one bit. 384 __m128i test2_mm256_extracti128_si256(__m256i a) { 385 // CHECK-LABEL: test2_mm256_extracti128_si256 386 // CHECK: shufflevector <4 x i64> %{{.*}}, <4 x i64> undef, <2 x i32> <i32 0, i32 1> 387 return _mm256_extracti128_si256(a, 2); 388 } 389 390 __m256i test_mm256_hadd_epi16(__m256i a, __m256i b) { 391 // CHECK-LABEL: test_mm256_hadd_epi16 392 // CHECK: call <16 x i16> @llvm.x86.avx2.phadd.w(<16 x i16> %{{.*}}, <16 x i16> %{{.*}}) 393 return _mm256_hadd_epi16(a, b); 394 } 395 396 __m256i test_mm256_hadd_epi32(__m256i a, __m256i b) { 397 // CHECK-LABEL: test_mm256_hadd_epi32 398 // CHECK: call <8 x i32> @llvm.x86.avx2.phadd.d(<8 x i32> %{{.*}}, <8 x i32> %{{.*}}) 399 return _mm256_hadd_epi32(a, b); 400 } 401 402 __m256i test_mm256_hadds_epi16(__m256i a, __m256i b) { 403 // CHECK-LABEL: test_mm256_hadds_epi16 404 // CHECK:call <16 x i16> @llvm.x86.avx2.phadd.sw(<16 x i16> %{{.*}}, <16 x i16> %{{.*}}) 405 return _mm256_hadds_epi16(a, b); 406 } 407 408 __m256i test_mm256_hsub_epi16(__m256i a, __m256i b) { 409 // CHECK-LABEL: test_mm256_hsub_epi16 410 // CHECK: call <16 x i16> @llvm.x86.avx2.phsub.w(<16 x i16> %{{.*}}, <16 x i16> %{{.*}}) 411 return _mm256_hsub_epi16(a, b); 412 } 413 414 __m256i test_mm256_hsub_epi32(__m256i a, __m256i b) { 415 // CHECK-LABEL: test_mm256_hsub_epi32 416 // CHECK: call <8 x i32> @llvm.x86.avx2.phsub.d(<8 x i32> %{{.*}}, <8 x i32> %{{.*}}) 417 return _mm256_hsub_epi32(a, b); 418 } 419 420 __m256i test_mm256_hsubs_epi16(__m256i a, __m256i b) { 421 // CHECK-LABEL: test_mm256_hsubs_epi16 422 // CHECK:call <16 x i16> @llvm.x86.avx2.phsub.sw(<16 x i16> %{{.*}}, <16 x i16> %{{.*}}) 423 return _mm256_hsubs_epi16(a, b); 424 } 425 426 __m128i test_mm_i32gather_epi32(int const *b, __m128i c) { 427 // CHECK-LABEL: test_mm_i32gather_epi32 428 // CHECK: call <4 x i32> @llvm.x86.avx2.gather.d.d(<4 x i32> %{{.*}}, i8* %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i8 2) 429 return _mm_i32gather_epi32(b, c, 2); 430 } 431 432 __m128i test_mm_mask_i32gather_epi32(__m128i a, int const *b, __m128i c, __m128i d) { 433 // CHECK-LABEL: test_mm_mask_i32gather_epi32 434 // CHECK: call <4 x i32> @llvm.x86.avx2.gather.d.d(<4 x i32> %{{.*}}, i8* %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i8 2) 435 return _mm_mask_i32gather_epi32(a, b, c, d, 2); 436 } 437 438 __m256i test_mm256_i32gather_epi32(int const *b, __m256i c) { 439 // CHECK-LABEL: test_mm256_i32gather_epi32 440 // CHECK: call <8 x i32> @llvm.x86.avx2.gather.d.d.256(<8 x i32> %{{.*}}, i8* %{{.*}}, <8 x i32> %{{.*}}, <8 x i32> %{{.*}}, i8 2) 441 return _mm256_i32gather_epi32(b, c, 2); 442 } 443 444 __m256i test_mm256_mask_i32gather_epi32(__m256i a, int const *b, __m256i c, __m256i d) { 445 // CHECK-LABEL: test_mm256_mask_i32gather_epi32 446 // CHECK: call <8 x i32> @llvm.x86.avx2.gather.d.d.256(<8 x i32> %{{.*}}, i8* %{{.*}}, <8 x i32> %{{.*}}, <8 x i32> %{{.*}}, i8 2) 447 return _mm256_mask_i32gather_epi32(a, b, c, d, 2); 448 } 449 450 __m128i test_mm_i32gather_epi64(long long const *b, __m128i c) { 451 // CHECK-LABEL: test_mm_i32gather_epi64 452 // CHECK: call <2 x i64> @llvm.x86.avx2.gather.d.q(<2 x i64> undef, i8* %{{.*}}, <4 x i32> %{{.*}}, <2 x i64> %{{.*}}, i8 2) 453 return _mm_i32gather_epi64(b, c, 2); 454 } 455 456 __m128i test_mm_mask_i32gather_epi64(__m128i a, long long const *b, __m128i c, __m128i d) { 457 // CHECK-LABEL: test_mm_mask_i32gather_epi64 458 // CHECK: call <2 x i64> @llvm.x86.avx2.gather.d.q(<2 x i64> %{{.*}}, i8* %{{.*}}, <4 x i32> %{{.*}}, <2 x i64> %{{.*}}, i8 2) 459 return _mm_mask_i32gather_epi64(a, b, c, d, 2); 460 } 461 462 __m256i test_mm256_i32gather_epi64(long long const *b, __m128i c) { 463 // CHECK-LABEL: test_mm256_i32gather_epi64 464 // CHECK: call <4 x i64> @llvm.x86.avx2.gather.d.q.256(<4 x i64> undef, i8* %{{.*}}, <4 x i32> %{{.*}}, <4 x i64> %{{.*}}, i8 2) 465 return _mm256_i32gather_epi64(b, c, 2); 466 } 467 468 __m256i test_mm256_mask_i32gather_epi64(__m256i a, long long const *b, __m128i c, __m256i d) { 469 // CHECK-LABEL: test_mm256_mask_i32gather_epi64 470 // CHECK: call <4 x i64> @llvm.x86.avx2.gather.d.q.256(<4 x i64> %{{.*}}, i8* %{{.*}}, <4 x i32> %{{.*}}, <4 x i64> %{{.*}}, i8 2) 471 return _mm256_mask_i32gather_epi64(a, b, c, d, 2); 472 } 473 474 __m128d test_mm_i32gather_pd(double const *b, __m128i c) { 475 // CHECK-LABEL: test_mm_i32gather_pd 476 // CHECK: [[CMP:%.*]] = fcmp oeq <2 x double> 477 // CHECK-NEXT: [[SEXT:%.*]] = sext <2 x i1> [[CMP]] to <2 x i64> 478 // CHECK-NEXT: [[BC:%.*]] = bitcast <2 x i64> [[SEXT]] to <2 x double> 479 // CHECK: call <2 x double> @llvm.x86.avx2.gather.d.pd(<2 x double> undef, i8* %{{.*}}, <4 x i32> %{{.*}}, <2 x double> %{{.*}}, i8 2) 480 return _mm_i32gather_pd(b, c, 2); 481 } 482 483 __m128d test_mm_mask_i32gather_pd(__m128d a, double const *b, __m128i c, __m128d d) { 484 // CHECK-LABEL: test_mm_mask_i32gather_pd 485 // CHECK: call <2 x double> @llvm.x86.avx2.gather.d.pd(<2 x double> %{{.*}}, i8* %{{.*}}, <4 x i32> %{{.*}}, <2 x double> %{{.*}}, i8 2) 486 return _mm_mask_i32gather_pd(a, b, c, d, 2); 487 } 488 489 __m256d test_mm256_i32gather_pd(double const *b, __m128i c) { 490 // CHECK-LABEL: test_mm256_i32gather_pd 491 // CHECK: [[CMP:%.*]] = fcmp oeq <4 x double> 492 // CHECK-NEXT: [[SEXT:%.*]] = sext <4 x i1> [[CMP]] to <4 x i64> 493 // CHECK-NEXT: [[BC:%.*]] = bitcast <4 x i64> [[SEXT]] to <4 x double> 494 // CHECK: call <4 x double> @llvm.x86.avx2.gather.d.pd.256(<4 x double> undef, i8* %{{.*}}, <4 x i32> %{{.*}}, <4 x double> %{{.*}}, i8 2) 495 return _mm256_i32gather_pd(b, c, 2); 496 } 497 498 __m256d test_mm256_mask_i32gather_pd(__m256d a, double const *b, __m128i c, __m256d d) { 499 // CHECK-LABEL: test_mm256_mask_i32gather_pd 500 // CHECK: call <4 x double> @llvm.x86.avx2.gather.d.pd.256(<4 x double> %{{.*}}, i8* %{{.*}}, <4 x i32> %{{.*}}, <4 x double> %{{.*}}, i8 2) 501 return _mm256_mask_i32gather_pd(a, b, c, d, 2); 502 } 503 504 __m128 test_mm_i32gather_ps(float const *b, __m128i c) { 505 // CHECK-LABEL: test_mm_i32gather_ps 506 // CHECK: [[CMP:%.*]] = fcmp oeq <4 x float> 507 // CHECK-NEXT: [[SEXT:%.*]] = sext <4 x i1> [[CMP]] to <4 x i32> 508 // CHECK-NEXT: [[BC:%.*]] = bitcast <4 x i32> [[SEXT]] to <4 x float> 509 // CHECK: call <4 x float> @llvm.x86.avx2.gather.d.ps(<4 x float> undef, i8* %{{.*}}, <4 x i32> %{{.*}}, <4 x float> %{{.*}}, i8 2) 510 return _mm_i32gather_ps(b, c, 2); 511 } 512 513 __m128 test_mm_mask_i32gather_ps(__m128 a, float const *b, __m128i c, __m128 d) { 514 // CHECK-LABEL: test_mm_mask_i32gather_ps 515 // CHECK: call <4 x float> @llvm.x86.avx2.gather.d.ps(<4 x float> %{{.*}}, i8* %{{.*}}, <4 x i32> %{{.*}}, <4 x float> %{{.*}}, i8 2) 516 return _mm_mask_i32gather_ps(a, b, c, d, 2); 517 } 518 519 __m256 test_mm256_i32gather_ps(float const *b, __m256i c) { 520 // CHECK-LABEL: test_mm256_i32gather_ps 521 // CHECK: [[CMP:%.*]] = fcmp oeq <8 x float> 522 // CHECK-NEXT: [[SEXT:%.*]] = sext <8 x i1> [[CMP]] to <8 x i32> 523 // CHECK-NEXT: [[BC:%.*]] = bitcast <8 x i32> [[SEXT]] to <8 x float> 524 // CHECK: call <8 x float> @llvm.x86.avx2.gather.d.ps.256(<8 x float> undef, i8* %{{.*}}, <8 x i32> %{{.*}}, <8 x float> %{{.*}}, i8 2) 525 return _mm256_i32gather_ps(b, c, 2); 526 } 527 528 __m256 test_mm256_mask_i32gather_ps(__m256 a, float const *b, __m256i c, __m256 d) { 529 // CHECK-LABEL: test_mm256_mask_i32gather_ps 530 // CHECK: call <8 x float> @llvm.x86.avx2.gather.d.ps.256(<8 x float> %{{.*}}, i8* %{{.*}}, <8 x i32> %{{.*}}, <8 x float> %{{.*}}, i8 2) 531 return _mm256_mask_i32gather_ps(a, b, c, d, 2); 532 } 533 534 __m128i test_mm_i64gather_epi32(int const *b, __m128i c) { 535 // CHECK-LABEL: test_mm_i64gather_epi32 536 // CHECK: call <4 x i32> @llvm.x86.avx2.gather.q.d(<4 x i32> %{{.*}}, i8* %{{.*}}, <2 x i64> %{{.*}}, <4 x i32> %{{.*}}, i8 2) 537 return _mm_i64gather_epi32(b, c, 2); 538 } 539 540 __m128i test_mm_mask_i64gather_epi32(__m128i a, int const *b, __m128i c, __m128i d) { 541 // CHECK-LABEL: test_mm_mask_i64gather_epi32 542 // CHECK: call <4 x i32> @llvm.x86.avx2.gather.q.d(<4 x i32> %{{.*}}, i8* %{{.*}}, <2 x i64> %{{.*}}, <4 x i32> %{{.*}}, i8 2) 543 return _mm_mask_i64gather_epi32(a, b, c, d, 2); 544 } 545 546 __m128i test_mm256_i64gather_epi32(int const *b, __m256i c) { 547 // CHECK-LABEL: test_mm256_i64gather_epi32 548 // CHECK: call <4 x i32> @llvm.x86.avx2.gather.q.d.256(<4 x i32> %{{.*}}, i8* %{{.*}}, <4 x i64> %{{.*}}, <4 x i32> %{{.*}}, i8 2) 549 return _mm256_i64gather_epi32(b, c, 2); 550 } 551 552 __m128i test_mm256_mask_i64gather_epi32(__m128i a, int const *b, __m256i c, __m128i d) { 553 // CHECK-LABEL: test_mm256_mask_i64gather_epi32 554 // CHECK: call <4 x i32> @llvm.x86.avx2.gather.q.d.256(<4 x i32> %{{.*}}, i8* %{{.*}}, <4 x i64> %{{.*}}, <4 x i32> %{{.*}}, i8 2) 555 return _mm256_mask_i64gather_epi32(a, b, c, d, 2); 556 } 557 558 __m128i test_mm_i64gather_epi64(long long const *b, __m128i c) { 559 // CHECK-LABEL: test_mm_i64gather_epi64 560 // CHECK: call <2 x i64> @llvm.x86.avx2.gather.q.q(<2 x i64> undef, i8* %{{.*}}, <2 x i64> %{{.*}}, <2 x i64> %{{.*}}, i8 2) 561 return _mm_i64gather_epi64(b, c, 2); 562 } 563 564 __m128i test_mm_mask_i64gather_epi64(__m128i a, long long const *b, __m128i c, __m128i d) { 565 // CHECK-LABEL: test_mm_mask_i64gather_epi64 566 // CHECK: call <2 x i64> @llvm.x86.avx2.gather.q.q(<2 x i64> %{{.*}}, i8* %{{.*}}, <2 x i64> %{{.*}}, <2 x i64> %{{.*}}, i8 2) 567 return _mm_mask_i64gather_epi64(a, b, c, d, 2); 568 } 569 570 __m256i test_mm256_i64gather_epi64(long long const *b, __m256i c) { 571 // CHECK-LABEL: test_mm256_i64gather_epi64 572 // CHECK: call <4 x i64> @llvm.x86.avx2.gather.q.q.256(<4 x i64> undef, i8* %{{.*}}, <4 x i64> %{{.*}}, <4 x i64> %{{.*}}, i8 2) 573 return _mm256_i64gather_epi64(b, c, 2); 574 } 575 576 __m256i test_mm256_mask_i64gather_epi64(__m256i a, long long const *b, __m256i c, __m256i d) { 577 // CHECK-LABEL: test_mm256_mask_i64gather_epi64 578 // CHECK: call <4 x i64> @llvm.x86.avx2.gather.q.q.256(<4 x i64> %{{.*}}, i8* %{{.*}}, <4 x i64> %{{.*}}, <4 x i64> %{{.*}}, i8 2) 579 return _mm256_mask_i64gather_epi64(a, b, c, d, 2); 580 } 581 582 __m128d test_mm_i64gather_pd(double const *b, __m128i c) { 583 // CHECK-LABEL: test_mm_i64gather_pd 584 // CHECK: [[CMP:%.*]] = fcmp oeq <2 x double> 585 // CHECK-NEXT: [[SEXT:%.*]] = sext <2 x i1> [[CMP]] to <2 x i64> 586 // CHECK-NEXT: [[BC:%.*]] = bitcast <2 x i64> [[SEXT]] to <2 x double> 587 // CHECK: call <2 x double> @llvm.x86.avx2.gather.q.pd(<2 x double> undef, i8* %{{.*}}, <2 x i64> %{{.*}}, <2 x double> %{{.*}}, i8 2) 588 return _mm_i64gather_pd(b, c, 2); 589 } 590 591 __m128d test_mm_mask_i64gather_pd(__m128d a, double const *b, __m128i c, __m128d d) { 592 // CHECK-LABEL: test_mm_mask_i64gather_pd 593 // CHECK: call <2 x double> @llvm.x86.avx2.gather.q.pd(<2 x double> %{{.*}}, i8* %{{.*}}, <2 x i64> %{{.*}}, <2 x double> %{{.*}}, i8 2) 594 return _mm_mask_i64gather_pd(a, b, c, d, 2); 595 } 596 597 __m256d test_mm256_i64gather_pd(double const *b, __m256i c) { 598 // CHECK-LABEL: test_mm256_i64gather_pd 599 // CHECK: [[CMP:%.*]] = fcmp oeq <4 x double> 600 // CHECK-NEXT: [[SEXT:%.*]] = sext <4 x i1> [[CMP]] to <4 x i64> 601 // CHECK-NEXT: [[BC:%.*]] = bitcast <4 x i64> [[SEXT]] to <4 x double> 602 // CHECK: call <4 x double> @llvm.x86.avx2.gather.q.pd.256(<4 x double> undef, i8* %{{.*}}, <4 x i64> %{{.*}}, <4 x double> %{{.*}}, i8 2) 603 return _mm256_i64gather_pd(b, c, 2); 604 } 605 606 __m256d test_mm256_mask_i64gather_pd(__m256d a, double const *b, __m256i c, __m256d d) { 607 // CHECK-LABEL: test_mm256_mask_i64gather_pd 608 // CHECK: call <4 x double> @llvm.x86.avx2.gather.q.pd.256(<4 x double> %{{.*}}, i8* %{{.*}}, <4 x i64> %{{.*}}, <4 x double> %{{.*}}, i8 2) 609 return _mm256_mask_i64gather_pd(a, b, c, d, 2); 610 } 611 612 __m128 test_mm_i64gather_ps(float const *b, __m128i c) { 613 // CHECK-LABEL: test_mm_i64gather_ps 614 // CHECK: [[CMP:%.*]] = fcmp oeq <4 x float> 615 // CHECK-NEXT: [[SEXT:%.*]] = sext <4 x i1> [[CMP]] to <4 x i32> 616 // CHECK-NEXT: [[BC:%.*]] = bitcast <4 x i32> [[SEXT]] to <4 x float> 617 // CHECK: call <4 x float> @llvm.x86.avx2.gather.q.ps(<4 x float> undef, i8* %{{.*}}, <2 x i64> %{{.*}}, <4 x float> %{{.*}}, i8 2) 618 return _mm_i64gather_ps(b, c, 2); 619 } 620 621 __m128 test_mm_mask_i64gather_ps(__m128 a, float const *b, __m128i c, __m128 d) { 622 // CHECK-LABEL: test_mm_mask_i64gather_ps 623 // CHECK: call <4 x float> @llvm.x86.avx2.gather.q.ps(<4 x float> %{{.*}}, i8* %{{.*}}, <2 x i64> %{{.*}}, <4 x float> %{{.*}}, i8 2) 624 return _mm_mask_i64gather_ps(a, b, c, d, 2); 625 } 626 627 __m128 test_mm256_i64gather_ps(float const *b, __m256i c) { 628 // CHECK-LABEL: test_mm256_i64gather_ps 629 // CHECK: [[CMP:%.*]] = fcmp oeq <4 x float> 630 // CHECK-NEXT: [[SEXT:%.*]] = sext <4 x i1> [[CMP]] to <4 x i32> 631 // CHECK-NEXT: [[BC:%.*]] = bitcast <4 x i32> [[SEXT]] to <4 x float> 632 // CHECK: call <4 x float> @llvm.x86.avx2.gather.q.ps.256(<4 x float> undef, i8* %{{.*}}, <4 x i64> %{{.*}}, <4 x float> %{{.*}}, i8 2) 633 return _mm256_i64gather_ps(b, c, 2); 634 } 635 636 __m128 test_mm256_mask_i64gather_ps(__m128 a, float const *b, __m256i c, __m128 d) { 637 // CHECK-LABEL: test_mm256_mask_i64gather_ps 638 // CHECK: call <4 x float> @llvm.x86.avx2.gather.q.ps.256(<4 x float> %{{.*}}, i8* %{{.*}}, <4 x i64> %{{.*}}, <4 x float> %{{.*}}, i8 2) 639 return _mm256_mask_i64gather_ps(a, b, c, d, 2); 640 } 641 642 __m256i test0_mm256_inserti128_si256(__m256i a, __m128i b) { 643 // CHECK-LABEL: test0_mm256_inserti128_si256 644 // CHECK: shufflevector <2 x i64> %{{.*}}, <2 x i64> %{{.*}}, <4 x i32> <i32 0, i32 1, i32 undef, i32 undef> 645 // CHECK: shufflevector <4 x i64> %{{.*}}, <4 x i64> %{{.*}}, <4 x i32> <i32 4, i32 5, i32 2, i32 3> 646 return _mm256_inserti128_si256(a, b, 0); 647 } 648 649 __m256i test1_mm256_inserti128_si256(__m256i a, __m128i b) { 650 // CHECK-LABEL: test1_mm256_inserti128_si256 651 // CHECK: shufflevector <2 x i64> %{{.*}}, <2 x i64> %{{.*}}, <4 x i32> <i32 0, i32 1, i32 undef, i32 undef> 652 // CHECK: shufflevector <4 x i64> %{{.*}}, <4 x i64> %{{.*}}, <4 x i32> <i32 0, i32 1, i32 4, i32 5> 653 return _mm256_inserti128_si256(a, b, 1); 654 } 655 656 // Immediate should be truncated to one bit. 657 __m256i test2_mm256_inserti128_si256(__m256i a, __m128i b) { 658 // CHECK-LABEL: test2_mm256_inserti128_si256 659 // CHECK: shufflevector <2 x i64> %{{.*}}, <2 x i64> %{{.*}}, <4 x i32> <i32 0, i32 1, i32 undef, i32 undef> 660 // CHECK: shufflevector <4 x i64> %{{.*}}, <4 x i64> %{{.*}}, <4 x i32> <i32 4, i32 5, i32 2, i32 3> 661 return _mm256_inserti128_si256(a, b, 2); 662 } 663 664 __m256i test_mm256_madd_epi16(__m256i a, __m256i b) { 665 // CHECK-LABEL: test_mm256_madd_epi16 666 // CHECK: call <8 x i32> @llvm.x86.avx2.pmadd.wd(<16 x i16> %{{.*}}, <16 x i16> %{{.*}}) 667 return _mm256_madd_epi16(a, b); 668 } 669 670 __m256i test_mm256_maddubs_epi16(__m256i a, __m256i b) { 671 // CHECK-LABEL: test_mm256_maddubs_epi16 672 // CHECK: call <16 x i16> @llvm.x86.avx2.pmadd.ub.sw(<32 x i8> %{{.*}}, <32 x i8> %{{.*}}) 673 return _mm256_maddubs_epi16(a, b); 674 } 675 676 __m128i test_mm_maskload_epi32(int const *a, __m128i m) { 677 // CHECK-LABEL: test_mm_maskload_epi32 678 // CHECK: call <4 x i32> @llvm.x86.avx2.maskload.d(i8* %{{.*}}, <4 x i32> %{{.*}}) 679 return _mm_maskload_epi32(a, m); 680 } 681 682 __m256i test_mm256_maskload_epi32(int const *a, __m256i m) { 683 // CHECK-LABEL: test_mm256_maskload_epi32 684 // CHECK: call <8 x i32> @llvm.x86.avx2.maskload.d.256(i8* %{{.*}}, <8 x i32> %{{.*}}) 685 return _mm256_maskload_epi32(a, m); 686 } 687 688 __m128i test_mm_maskload_epi64(long long const *a, __m128i m) { 689 // CHECK-LABEL: test_mm_maskload_epi64 690 // CHECK: call <2 x i64> @llvm.x86.avx2.maskload.q(i8* %{{.*}}, <2 x i64> %{{.*}}) 691 return _mm_maskload_epi64(a, m); 692 } 693 694 __m256i test_mm256_maskload_epi64(long long const *a, __m256i m) { 695 // CHECK-LABEL: test_mm256_maskload_epi64 696 // CHECK: call <4 x i64> @llvm.x86.avx2.maskload.q.256(i8* %{{.*}}, <4 x i64> %{{.*}}) 697 return _mm256_maskload_epi64(a, m); 698 } 699 700 void test_mm_maskstore_epi32(int *a, __m128i m, __m128i b) { 701 // CHECK-LABEL: test_mm_maskstore_epi32 702 // CHECK: call void @llvm.x86.avx2.maskstore.d(i8* %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 703 _mm_maskstore_epi32(a, m, b); 704 } 705 706 void test_mm256_maskstore_epi32(int *a, __m256i m, __m256i b) { 707 // CHECK-LABEL: test_mm256_maskstore_epi32 708 // CHECK: call void @llvm.x86.avx2.maskstore.d.256(i8* %{{.*}}, <8 x i32> %{{.*}}, <8 x i32> %{{.*}}) 709 _mm256_maskstore_epi32(a, m, b); 710 } 711 712 void test_mm_maskstore_epi64(long long *a, __m128i m, __m128i b) { 713 // CHECK-LABEL: test_mm_maskstore_epi64 714 // CHECK: call void @llvm.x86.avx2.maskstore.q(i8* %{{.*}}, <2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 715 _mm_maskstore_epi64(a, m, b); 716 } 717 718 void test_mm256_maskstore_epi64(long long *a, __m256i m, __m256i b) { 719 // CHECK-LABEL: test_mm256_maskstore_epi64 720 // CHECK: call void @llvm.x86.avx2.maskstore.q.256(i8* %{{.*}}, <4 x i64> %{{.*}}, <4 x i64> %{{.*}}) 721 _mm256_maskstore_epi64(a, m, b); 722 } 723 724 __m256i test_mm256_max_epi8(__m256i a, __m256i b) { 725 // CHECK-LABEL: test_mm256_max_epi8 726 // CHECK: [[CMP:%.*]] = icmp sgt <32 x i8> [[X:%.*]], [[Y:%.*]] 727 // CHECK-NEXT: select <32 x i1> [[CMP]], <32 x i8> [[X]], <32 x i8> [[Y]] 728 return _mm256_max_epi8(a, b); 729 } 730 731 __m256i test_mm256_max_epi16(__m256i a, __m256i b) { 732 // CHECK-LABEL: test_mm256_max_epi16 733 // CHECK: [[CMP:%.*]] = icmp sgt <16 x i16> [[X:%.*]], [[Y:%.*]] 734 // CHECK-NEXT: select <16 x i1> [[CMP]], <16 x i16> [[X]], <16 x i16> [[Y]] 735 return _mm256_max_epi16(a, b); 736 } 737 738 __m256i test_mm256_max_epi32(__m256i a, __m256i b) { 739 // CHECK-LABEL: test_mm256_max_epi32 740 // CHECK: [[CMP:%.*]] = icmp sgt <8 x i32> [[X:%.*]], [[Y:%.*]] 741 // CHECK-NEXT: select <8 x i1> [[CMP]], <8 x i32> [[X]], <8 x i32> [[Y]] 742 return _mm256_max_epi32(a, b); 743 } 744 745 __m256i test_mm256_max_epu8(__m256i a, __m256i b) { 746 // CHECK-LABEL: test_mm256_max_epu8 747 // CHECK: [[CMP:%.*]] = icmp ugt <32 x i8> [[X:%.*]], [[Y:%.*]] 748 // CHECK-NEXT: select <32 x i1> [[CMP]], <32 x i8> [[X]], <32 x i8> [[Y]] 749 return _mm256_max_epu8(a, b); 750 } 751 752 __m256i test_mm256_max_epu16(__m256i a, __m256i b) { 753 // CHECK-LABEL: test_mm256_max_epu16 754 // CHECK: [[CMP:%.*]] = icmp ugt <16 x i16> [[X:%.*]], [[Y:%.*]] 755 // CHECK-NEXT: select <16 x i1> [[CMP]], <16 x i16> [[X]], <16 x i16> [[Y]] 756 return _mm256_max_epu16(a, b); 757 } 758 759 __m256i test_mm256_max_epu32(__m256i a, __m256i b) { 760 // CHECK-LABEL: test_mm256_max_epu32 761 // CHECK: [[CMP:%.*]] = icmp ugt <8 x i32> [[X:%.*]], [[Y:%.*]] 762 // CHECK-NEXT: select <8 x i1> [[CMP]], <8 x i32> [[X]], <8 x i32> [[Y]] 763 return _mm256_max_epu32(a, b); 764 } 765 766 __m256i test_mm256_min_epi8(__m256i a, __m256i b) { 767 // CHECK-LABEL: test_mm256_min_epi8 768 // CHECK: [[CMP:%.*]] = icmp slt <32 x i8> [[X:%.*]], [[Y:%.*]] 769 // CHECK-NEXT: select <32 x i1> [[CMP]], <32 x i8> [[X]], <32 x i8> [[Y]] 770 return _mm256_min_epi8(a, b); 771 } 772 773 __m256i test_mm256_min_epi16(__m256i a, __m256i b) { 774 // CHECK-LABEL: test_mm256_min_epi16 775 // CHECK: [[CMP:%.*]] = icmp slt <16 x i16> [[X:%.*]], [[Y:%.*]] 776 // CHECK-NEXT: select <16 x i1> [[CMP]], <16 x i16> [[X]], <16 x i16> [[Y]] 777 return _mm256_min_epi16(a, b); 778 } 779 780 __m256i test_mm256_min_epi32(__m256i a, __m256i b) { 781 // CHECK-LABEL: test_mm256_min_epi32 782 // CHECK: [[CMP:%.*]] = icmp slt <8 x i32> [[X:%.*]], [[Y:%.*]] 783 // CHECK-NEXT: select <8 x i1> [[CMP]], <8 x i32> [[X]], <8 x i32> [[Y]] 784 return _mm256_min_epi32(a, b); 785 } 786 787 __m256i test_mm256_min_epu8(__m256i a, __m256i b) { 788 // CHECK-LABEL: test_mm256_min_epu8 789 // CHECK: [[CMP:%.*]] = icmp ult <32 x i8> [[X:%.*]], [[Y:%.*]] 790 // CHECK-NEXT: select <32 x i1> [[CMP]], <32 x i8> [[X]], <32 x i8> [[Y]] 791 return _mm256_min_epu8(a, b); 792 } 793 794 __m256i test_mm256_min_epu16(__m256i a, __m256i b) { 795 // CHECK-LABEL: test_mm256_min_epu16 796 // CHECK: [[CMP:%.*]] = icmp ult <16 x i16> [[X:%.*]], [[Y:%.*]] 797 // CHECK-NEXT: select <16 x i1> [[CMP]], <16 x i16> [[X]], <16 x i16> [[Y]] 798 return _mm256_min_epu16(a, b); 799 } 800 801 __m256i test_mm256_min_epu32(__m256i a, __m256i b) { 802 // CHECK-LABEL: test_mm256_min_epu32 803 // CHECK: [[CMP:%.*]] = icmp ult <8 x i32> [[X:%.*]], [[Y:%.*]] 804 // CHECK-NEXT: select <8 x i1> [[CMP]], <8 x i32> [[X]], <8 x i32> [[Y]] 805 return _mm256_min_epu32(a, b); 806 } 807 808 int test_mm256_movemask_epi8(__m256i a) { 809 // CHECK-LABEL: test_mm256_movemask_epi8 810 // CHECK: call i32 @llvm.x86.avx2.pmovmskb(<32 x i8> %{{.*}}) 811 return _mm256_movemask_epi8(a); 812 } 813 814 __m256i test_mm256_mpsadbw_epu8(__m256i x, __m256i y) { 815 // CHECK-LABEL: test_mm256_mpsadbw_epu8 816 // CHECK: call <16 x i16> @llvm.x86.avx2.mpsadbw(<32 x i8> %{{.*}}, <32 x i8> %{{.*}}, i8 3) 817 return _mm256_mpsadbw_epu8(x, y, 3); 818 } 819 820 __m256i test_mm256_mul_epi32(__m256i a, __m256i b) { 821 // CHECK-LABEL: test_mm256_mul_epi32 822 // CHECK: call <4 x i64> @llvm.x86.avx2.pmul.dq(<8 x i32> %{{.*}}, <8 x i32> %{{.*}}) 823 return _mm256_mul_epi32(a, b); 824 } 825 826 __m256i test_mm256_mul_epu32(__m256i a, __m256i b) { 827 // CHECK-LABEL: test_mm256_mul_epu32 828 // CHECK: call <4 x i64> @llvm.x86.avx2.pmulu.dq(<8 x i32> %{{.*}}, <8 x i32> %{{.*}}) 829 return _mm256_mul_epu32(a, b); 830 } 831 832 __m256i test_mm256_mulhi_epu16(__m256i a, __m256i b) { 833 // CHECK-LABEL: test_mm256_mulhi_epu16 834 // CHECK: call <16 x i16> @llvm.x86.avx2.pmulhu.w(<16 x i16> %{{.*}}, <16 x i16> %{{.*}}) 835 return _mm256_mulhi_epu16(a, b); 836 } 837 838 __m256i test_mm256_mulhi_epi16(__m256i a, __m256i b) { 839 // CHECK-LABEL: test_mm256_mulhi_epi16 840 // CHECK: call <16 x i16> @llvm.x86.avx2.pmulh.w(<16 x i16> %{{.*}}, <16 x i16> %{{.*}}) 841 return _mm256_mulhi_epi16(a, b); 842 } 843 844 __m256i test_mm256_mulhrs_epi16(__m256i a, __m256i b) { 845 // CHECK-LABEL: test_mm256_mulhrs_epi16 846 // CHECK: call <16 x i16> @llvm.x86.avx2.pmul.hr.sw(<16 x i16> %{{.*}}, <16 x i16> %{{.*}}) 847 return _mm256_mulhrs_epi16(a, b); 848 } 849 850 __m256i test_mm256_mullo_epi16(__m256i a, __m256i b) { 851 // CHECK-LABEL: test_mm256_mullo_epi16 852 // CHECK: mul <16 x i16> 853 return _mm256_mullo_epi16(a, b); 854 } 855 856 __m256i test_mm256_mullo_epi32(__m256i a, __m256i b) { 857 // CHECK-LABEL: test_mm256_mullo_epi32 858 // CHECK: mul <8 x i32> 859 return _mm256_mullo_epi32(a, b); 860 } 861 862 __m256i test_mm256_or_si256(__m256i a, __m256i b) { 863 // CHECK-LABEL: test_mm256_or_si256 864 // CHECK: or <4 x i64> 865 return _mm256_or_si256(a, b); 866 } 867 868 __m256i test_mm256_packs_epi16(__m256i a, __m256i b) { 869 // CHECK-LABEL: test_mm256_packs_epi16 870 // CHECK: call <32 x i8> @llvm.x86.avx2.packsswb(<16 x i16> %{{.*}}, <16 x i16> %{{.*}}) 871 return _mm256_packs_epi16(a, b); 872 } 873 874 __m256i test_mm256_packs_epi32(__m256i a, __m256i b) { 875 // CHECK-LABEL: test_mm256_packs_epi32 876 // CHECK: call <16 x i16> @llvm.x86.avx2.packssdw(<8 x i32> %{{.*}}, <8 x i32> %{{.*}}) 877 return _mm256_packs_epi32(a, b); 878 } 879 880 __m256i test_mm256_packs_epu16(__m256i a, __m256i b) { 881 // CHECK-LABEL: test_mm256_packs_epu16 882 // CHECK: call <32 x i8> @llvm.x86.avx2.packuswb(<16 x i16> %{{.*}}, <16 x i16> %{{.*}}) 883 return _mm256_packus_epi16(a, b); 884 } 885 886 __m256i test_mm256_packs_epu32(__m256i a, __m256i b) { 887 // CHECK-LABEL: test_mm256_packs_epu32 888 // CHECK: call <16 x i16> @llvm.x86.avx2.packusdw(<8 x i32> %{{.*}}, <8 x i32> %{{.*}}) 889 return _mm256_packus_epi32(a, b); 890 } 891 892 __m256i test_mm256_permute2x128_si256(__m256i a, __m256i b) { 893 // CHECK-LABEL: test_mm256_permute2x128_si256 894 // CHECK: call <4 x i64> @llvm.x86.avx2.vperm2i128(<4 x i64> %{{.*}}, <4 x i64> %{{.*}}, i8 49) 895 return _mm256_permute2x128_si256(a, b, 0x31); 896 } 897 898 __m256i test_mm256_permute4x64_epi64(__m256i a) { 899 // CHECK-LABEL: test_mm256_permute4x64_epi64 900 // CHECK: shufflevector <4 x i64> %{{.*}}, <4 x i64> undef, <4 x i32> <i32 3, i32 0, i32 2, i32 0> 901 return _mm256_permute4x64_epi64(a, 35); 902 } 903 904 __m256d test_mm256_permute4x64_pd(__m256d a) { 905 // CHECK-LABEL: test_mm256_permute4x64_pd 906 // CHECK: shufflevector <4 x double> %{{.*}}, <4 x double> undef, <4 x i32> <i32 1, i32 2, i32 1, i32 0> 907 return _mm256_permute4x64_pd(a, 25); 908 } 909 910 __m256i test_mm256_permutevar8x32_epi32(__m256i a, __m256i b) { 911 // CHECK-LABEL: test_mm256_permutevar8x32_epi32 912 // CHECK: call <8 x i32> @llvm.x86.avx2.permd(<8 x i32> %{{.*}}, <8 x i32> %{{.*}}) 913 return _mm256_permutevar8x32_epi32(a, b); 914 } 915 916 __m256 test_mm256_permutevar8x32_ps(__m256 a, __m256i b) { 917 // CHECK-LABEL: test_mm256_permutevar8x32_ps 918 // CHECK: call <8 x float> @llvm.x86.avx2.permps(<8 x float> %{{.*}}, <8 x i32> %{{.*}}) 919 return _mm256_permutevar8x32_ps(a, b); 920 } 921 922 __m256i test_mm256_sad_epu8(__m256i x, __m256i y) { 923 // CHECK-LABEL: test_mm256_sad_epu8 924 // CHECK: call <4 x i64> @llvm.x86.avx2.psad.bw(<32 x i8> %{{.*}}, <32 x i8> %{{.*}}) 925 return _mm256_sad_epu8(x, y); 926 } 927 928 __m256i test_mm256_shuffle_epi8(__m256i a, __m256i b) { 929 // CHECK-LABEL: test_mm256_shuffle_epi8 930 // CHECK: call <32 x i8> @llvm.x86.avx2.pshuf.b(<32 x i8> %{{.*}}, <32 x i8> %{{.*}}) 931 return _mm256_shuffle_epi8(a, b); 932 } 933 934 __m256i test_mm256_shuffle_epi32(__m256i a) { 935 // CHECK-LABEL: test_mm256_shuffle_epi32 936 // CHECK: shufflevector <8 x i32> %{{.*}}, <8 x i32> %{{.*}}, <8 x i32> <i32 3, i32 3, i32 0, i32 0, i32 7, i32 7, i32 4, i32 4> 937 return _mm256_shuffle_epi32(a, 15); 938 } 939 940 __m256i test_mm256_shufflehi_epi16(__m256i a) { 941 // CHECK-LABEL: test_mm256_shufflehi_epi16 942 // CHECK: shufflevector <16 x i16> %{{.*}}, <16 x i16> %{{.*}}, <16 x i32> <i32 0, i32 1, i32 2, i32 3, i32 7, i32 6, i32 6, i32 5, i32 8, i32 9, i32 10, i32 11, i32 15, i32 14, i32 14, i32 13> 943 return _mm256_shufflehi_epi16(a, 107); 944 } 945 946 __m256i test_mm256_shufflelo_epi16(__m256i a) { 947 // CHECK-LABEL: test_mm256_shufflelo_epi16 948 // CHECK: shufflevector <16 x i16> %{{.*}}, <16 x i16> %{{.*}}, <16 x i32> <i32 3, i32 0, i32 1, i32 1, i32 4, i32 5, i32 6, i32 7, i32 11, i32 8, i32 9, i32 9, i32 12, i32 13, i32 14, i32 15> 949 return _mm256_shufflelo_epi16(a, 83); 950 } 951 952 __m256i test_mm256_sign_epi8(__m256i a, __m256i b) { 953 // CHECK-LABEL: test_mm256_sign_epi8 954 // CHECK: call <32 x i8> @llvm.x86.avx2.psign.b(<32 x i8> %{{.*}}, <32 x i8> %{{.*}}) 955 return _mm256_sign_epi8(a, b); 956 } 957 958 __m256i test_mm256_sign_epi16(__m256i a, __m256i b) { 959 // CHECK-LABEL: test_mm256_sign_epi16 960 // CHECK: call <16 x i16> @llvm.x86.avx2.psign.w(<16 x i16> %{{.*}}, <16 x i16> %{{.*}}) 961 return _mm256_sign_epi16(a, b); 962 } 963 964 __m256i test_mm256_sign_epi32(__m256i a, __m256i b) { 965 // CHECK-LABEL: test_mm256_sign_epi32 966 // CHECK: call <8 x i32> @llvm.x86.avx2.psign.d(<8 x i32> %{{.*}}, <8 x i32> %{{.*}}) 967 return _mm256_sign_epi32(a, b); 968 } 969 970 __m256i test_mm256_slli_epi16(__m256i a) { 971 // CHECK-LABEL: test_mm256_slli_epi16 972 // CHECK: call <16 x i16> @llvm.x86.avx2.pslli.w(<16 x i16> %{{.*}}, i32 %{{.*}}) 973 return _mm256_slli_epi16(a, 3); 974 } 975 976 __m256i test_mm256_slli_epi32(__m256i a) { 977 // CHECK-LABEL: test_mm256_slli_epi32 978 // CHECK: call <8 x i32> @llvm.x86.avx2.pslli.d(<8 x i32> %{{.*}}, i32 %{{.*}}) 979 return _mm256_slli_epi32(a, 3); 980 } 981 982 __m256i test_mm256_slli_epi64(__m256i a) { 983 // CHECK-LABEL: test_mm256_slli_epi64 984 // CHECK: call <4 x i64> @llvm.x86.avx2.pslli.q(<4 x i64> %{{.*}}, i32 %{{.*}}) 985 return _mm256_slli_epi64(a, 3); 986 } 987 988 __m256i test_mm256_slli_si256(__m256i a) { 989 // CHECK-LABEL: test_mm256_slli_si256 990 // CHECK: shufflevector <32 x i8> %{{.*}}, <32 x i8> %{{.*}}, <32 x i32> <i32 13, i32 14, i32 15, i32 32, i32 33, i32 34, i32 35, i32 36, i32 37, i32 38, i32 39, i32 40, i32 41, i32 42, i32 43, i32 44, i32 29, i32 30, i32 31, i32 48, i32 49, i32 50, i32 51, i32 52, i32 53, i32 54, i32 55, i32 56, i32 57, i32 58, i32 59, i32 60> 991 return _mm256_slli_si256(a, 3); 992 } 993 994 __m128i test_mm_sllv_epi32(__m128i a, __m128i b) { 995 // CHECK-LABEL: test_mm_sllv_epi32 996 // CHECK: call <4 x i32> @llvm.x86.avx2.psllv.d(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 997 return _mm_sllv_epi32(a, b); 998 } 999 1000 __m256i test_mm256_sllv_epi32(__m256i a, __m256i b) { 1001 // CHECK-LABEL: test_mm256_sllv_epi32 1002 // CHECK: call <8 x i32> @llvm.x86.avx2.psllv.d.256(<8 x i32> %{{.*}}, <8 x i32> %{{.*}}) 1003 return _mm256_sllv_epi32(a, b); 1004 } 1005 1006 __m128i test_mm_sllv_epi64(__m128i a, __m128i b) { 1007 // CHECK-LABEL: test_mm_sllv_epi64 1008 // CHECK: call <2 x i64> @llvm.x86.avx2.psllv.q(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 1009 return _mm_sllv_epi64(a, b); 1010 } 1011 1012 __m256i test_mm256_sllv_epi64(__m256i a, __m256i b) { 1013 // CHECK-LABEL: test_mm256_sllv_epi64 1014 // CHECK: call <4 x i64> @llvm.x86.avx2.psllv.q.256(<4 x i64> %{{.*}}, <4 x i64> %{{.*}}) 1015 return _mm256_sllv_epi64(a, b); 1016 } 1017 1018 __m256i test_mm256_sra_epi16(__m256i a, __m128i b) { 1019 // CHECK-LABEL: test_mm256_sra_epi16 1020 // CHECK: call <16 x i16> @llvm.x86.avx2.psra.w(<16 x i16> %{{.*}}, <8 x i16> %{{.*}}) 1021 return _mm256_sra_epi16(a, b); 1022 } 1023 1024 __m256i test_mm256_sra_epi32(__m256i a, __m128i b) { 1025 // CHECK-LABEL: test_mm256_sra_epi32 1026 // CHECK: call <8 x i32> @llvm.x86.avx2.psra.d(<8 x i32> %{{.*}}, <4 x i32> %{{.*}}) 1027 return _mm256_sra_epi32(a, b); 1028 } 1029 1030 __m256i test_mm256_srai_epi16(__m256i a) { 1031 // CHECK-LABEL: test_mm256_srai_epi16 1032 // CHECK: call <16 x i16> @llvm.x86.avx2.psrai.w(<16 x i16> %{{.*}}, i32 %{{.*}}) 1033 return _mm256_srai_epi16(a, 3); 1034 } 1035 1036 __m256i test_mm256_srai_epi32(__m256i a) { 1037 // CHECK-LABEL: test_mm256_srai_epi32 1038 // CHECK: call <8 x i32> @llvm.x86.avx2.psrai.d(<8 x i32> %{{.*}}, i32 %{{.*}}) 1039 return _mm256_srai_epi32(a, 3); 1040 } 1041 1042 __m128i test_mm_srav_epi32(__m128i a, __m128i b) { 1043 // CHECK-LABEL: test_mm_srav_epi32 1044 // CHECK: call <4 x i32> @llvm.x86.avx2.psrav.d(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 1045 return _mm_srav_epi32(a, b); 1046 } 1047 1048 __m256i test_mm256_srav_epi32(__m256i a, __m256i b) { 1049 // CHECK-LABEL: test_mm256_srav_epi32 1050 // CHECK: call <8 x i32> @llvm.x86.avx2.psrav.d.256(<8 x i32> %{{.*}}, <8 x i32> %{{.*}}) 1051 return _mm256_srav_epi32(a, b); 1052 } 1053 1054 __m256i test_mm256_srl_epi16(__m256i a, __m128i b) { 1055 // CHECK-LABEL: test_mm256_srl_epi16 1056 // CHECK: call <16 x i16> @llvm.x86.avx2.psrl.w(<16 x i16> %{{.*}}, <8 x i16> %{{.*}}) 1057 return _mm256_srl_epi16(a, b); 1058 } 1059 1060 __m256i test_mm256_srl_epi32(__m256i a, __m128i b) { 1061 // CHECK-LABEL: test_mm256_srl_epi32 1062 // CHECK:call <8 x i32> @llvm.x86.avx2.psrl.d(<8 x i32> %{{.*}}, <4 x i32> %{{.*}}) 1063 return _mm256_srl_epi32(a, b); 1064 } 1065 1066 __m256i test_mm256_srl_epi64(__m256i a, __m128i b) { 1067 // CHECK-LABEL: test_mm256_srl_epi64 1068 // CHECK: call <4 x i64> @llvm.x86.avx2.psrl.q(<4 x i64> %{{.*}}, <2 x i64> %{{.*}}) 1069 return _mm256_srl_epi64(a, b); 1070 } 1071 1072 __m256i test_mm256_srli_epi16(__m256i a) { 1073 // CHECK-LABEL: test_mm256_srli_epi16 1074 // CHECK: call <16 x i16> @llvm.x86.avx2.psrli.w(<16 x i16> %{{.*}}, i32 %{{.*}}) 1075 return _mm256_srli_epi16(a, 3); 1076 } 1077 1078 __m256i test_mm256_srli_epi32(__m256i a) { 1079 // CHECK-LABEL: test_mm256_srli_epi32 1080 // CHECK: call <8 x i32> @llvm.x86.avx2.psrli.d(<8 x i32> %{{.*}}, i32 %{{.*}}) 1081 return _mm256_srli_epi32(a, 3); 1082 } 1083 1084 __m256i test_mm256_srli_epi64(__m256i a) { 1085 // CHECK-LABEL: test_mm256_srli_epi64 1086 // CHECK: call <4 x i64> @llvm.x86.avx2.psrli.q(<4 x i64> %{{.*}}, i32 %{{.*}}) 1087 return _mm256_srli_epi64(a, 3); 1088 } 1089 1090 __m256i test_mm256_srli_si256(__m256i a) { 1091 // CHECK-LABEL: test_mm256_srli_si256 1092 // CHECK: shufflevector <32 x i8> %{{.*}}, <32 x i8> %{{.*}}, <32 x i32> <i32 3, i32 4, i32 5, i32 6, i32 7, i32 8, i32 9, i32 10, i32 11, i32 12, i32 13, i32 14, i32 15, i32 32, i32 33, i32 34, i32 19, i32 20, i32 21, i32 22, i32 23, i32 24, i32 25, i32 26, i32 27, i32 28, i32 29, i32 30, i32 31, i32 48, i32 49, i32 50> 1093 return _mm256_srli_si256(a, 3); 1094 } 1095 1096 __m128i test_mm_srlv_epi32(__m128i a, __m128i b) { 1097 // CHECK-LABEL: test_mm_srlv_epi32 1098 // CHECK: call <4 x i32> @llvm.x86.avx2.psrlv.d(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) 1099 return _mm_srlv_epi32(a, b); 1100 } 1101 1102 __m256i test_mm256_srlv_epi32(__m256i a, __m256i b) { 1103 // CHECK-LABEL: test_mm256_srlv_epi32 1104 // CHECK: call <8 x i32> @llvm.x86.avx2.psrlv.d.256(<8 x i32> %{{.*}}, <8 x i32> %{{.*}}) 1105 return _mm256_srlv_epi32(a, b); 1106 } 1107 1108 __m128i test_mm_srlv_epi64(__m128i a, __m128i b) { 1109 // CHECK-LABEL: test_mm_srlv_epi64 1110 // CHECK: call <2 x i64> @llvm.x86.avx2.psrlv.q(<2 x i64> %{{.*}}, <2 x i64> %{{.*}}) 1111 return _mm_srlv_epi64(a, b); 1112 } 1113 1114 __m256i test_mm256_srlv_epi64(__m256i a, __m256i b) { 1115 // CHECK-LABEL: test_mm256_srlv_epi64 1116 // CHECK: call <4 x i64> @llvm.x86.avx2.psrlv.q.256(<4 x i64> %{{.*}}, <4 x i64> %{{.*}}) 1117 return _mm256_srlv_epi64(a, b); 1118 } 1119 1120 __m256i test_mm256_stream_load_si256(__m256i const *a) { 1121 // CHECK-LABEL: test_mm256_stream_load_si256 1122 // CHECK: call <4 x i64> @llvm.x86.avx2.movntdqa(i8* %{{.*}}) 1123 return _mm256_stream_load_si256(a); 1124 } 1125 1126 __m256i test_mm256_sub_epi8(__m256i a, __m256i b) { 1127 // CHECK-LABEL: test_mm256_sub_epi8 1128 // CHECK: sub <32 x i8> 1129 return _mm256_sub_epi8(a, b); 1130 } 1131 1132 __m256i test_mm256_sub_epi16(__m256i a, __m256i b) { 1133 // CHECK-LABEL: test_mm256_sub_epi16 1134 // CHECK: sub <16 x i16> 1135 return _mm256_sub_epi16(a, b); 1136 } 1137 1138 __m256i test_mm256_sub_epi32(__m256i a, __m256i b) { 1139 // CHECK-LABEL: test_mm256_sub_epi32 1140 // CHECK: sub <8 x i32> 1141 return _mm256_sub_epi32(a, b); 1142 } 1143 1144 __m256i test_mm256_sub_epi64(__m256i a, __m256i b) { 1145 // CHECK-LABEL: test_mm256_sub_epi64 1146 // CHECK: sub <4 x i64> 1147 return _mm256_sub_epi64(a, b); 1148 } 1149 1150 __m256i test_mm256_subs_epi8(__m256i a, __m256i b) { 1151 // CHECK-LABEL: test_mm256_subs_epi8 1152 // CHECK: call <32 x i8> @llvm.x86.avx2.psubs.b(<32 x i8> %{{.*}}, <32 x i8> %{{.*}}) 1153 return _mm256_subs_epi8(a, b); 1154 } 1155 1156 __m256i test_mm256_subs_epi16(__m256i a, __m256i b) { 1157 // CHECK-LABEL: test_mm256_subs_epi16 1158 // CHECK: call <16 x i16> @llvm.x86.avx2.psubs.w(<16 x i16> %{{.*}}, <16 x i16> %{{.*}}) 1159 return _mm256_subs_epi16(a, b); 1160 } 1161 1162 __m256i test_mm256_subs_epu8(__m256i a, __m256i b) { 1163 // CHECK-LABEL: test_mm256_subs_epu8 1164 // CHECK: call <32 x i8> @llvm.x86.avx2.psubus.b(<32 x i8> %{{.*}}, <32 x i8> %{{.*}}) 1165 return _mm256_subs_epu8(a, b); 1166 } 1167 1168 __m256i test_mm256_subs_epu16(__m256i a, __m256i b) { 1169 // CHECK-LABEL: test_mm256_subs_epu16 1170 // CHECK: call <16 x i16> @llvm.x86.avx2.psubus.w(<16 x i16> %{{.*}}, <16 x i16> %{{.*}}) 1171 return _mm256_subs_epu16(a, b); 1172 } 1173 1174 __m256i test_mm256_unpackhi_epi8(__m256i a, __m256i b) { 1175 // CHECK-LABEL: test_mm256_unpackhi_epi8 1176 // CHECK: shufflevector <32 x i8> %{{.*}}, <32 x i8> %{{.*}}, <32 x i32> <i32 8, i32 40, i32 9, i32 41, i32 10, i32 42, i32 11, i32 43, i32 12, i32 44, i32 13, i32 45, i32 14, i32 46, i32 15, i32 47, i32 24, i32 56, i32 25, i32 57, i32 26, i32 58, i32 27, i32 59, i32 28, i32 60, i32 29, i32 61, i32 30, i32 62, i32 31, i32 63> 1177 return _mm256_unpackhi_epi8(a, b); 1178 } 1179 1180 __m256i test_mm256_unpackhi_epi16(__m256i a, __m256i b) { 1181 // CHECK-LABEL: test_mm256_unpackhi_epi16 1182 // CHECK: shufflevector <16 x i16> %{{.*}}, <16 x i16> %{{.*}}, <16 x i32> <i32 4, i32 20, i32 5, i32 21, i32 6, i32 22, i32 7, i32 23, i32 12, i32 28, i32 13, i32 29, i32 14, i32 30, i32 15, i32 31> 1183 return _mm256_unpackhi_epi16(a, b); 1184 } 1185 1186 __m256i test_mm256_unpackhi_epi32(__m256i a, __m256i b) { 1187 // CHECK-LABEL: test_mm256_unpackhi_epi32 1188 // CHECK: shufflevector <8 x i32> %{{.*}}, <8 x i32> %{{.*}}, <8 x i32> <i32 2, i32 10, i32 3, i32 11, i32 6, i32 14, i32 7, i32 15> 1189 return _mm256_unpackhi_epi32(a, b); 1190 } 1191 1192 __m256i test_mm256_unpackhi_epi64(__m256i a, __m256i b) { 1193 // CHECK-LABEL: test_mm256_unpackhi_epi64 1194 // CHECK: shufflevector <4 x i64> %{{.*}}, <4 x i64> %{{.*}}, <4 x i32> <i32 1, i32 5, i32 3, i32 7> 1195 return _mm256_unpackhi_epi64(a, b); 1196 } 1197 1198 __m256i test_mm256_unpacklo_epi8(__m256i a, __m256i b) { 1199 // CHECK-LABEL: test_mm256_unpacklo_epi8 1200 // CHECK: shufflevector <32 x i8> %{{.*}}, <32 x i8> %{{.*}}, <32 x i32> <i32 0, i32 32, i32 1, i32 33, i32 2, i32 34, i32 3, i32 35, i32 4, i32 36, i32 5, i32 37, i32 6, i32 38, i32 7, i32 39, i32 16, i32 48, i32 17, i32 49, i32 18, i32 50, i32 19, i32 51, i32 20, i32 52, i32 21, i32 53, i32 22, i32 54, i32 23, i32 55> 1201 return _mm256_unpacklo_epi8(a, b); 1202 } 1203 1204 __m256i test_mm256_unpacklo_epi16(__m256i a, __m256i b) { 1205 // CHECK-LABEL: test_mm256_unpacklo_epi16 1206 // CHECK: shufflevector <16 x i16> %{{.*}}, <16 x i16> %{{.*}}, <16 x i32> <i32 0, i32 16, i32 1, i32 17, i32 2, i32 18, i32 3, i32 19, i32 8, i32 24, i32 9, i32 25, i32 10, i32 26, i32 11, i32 27> 1207 return _mm256_unpacklo_epi16(a, b); 1208 } 1209 1210 __m256i test_mm256_unpacklo_epi32(__m256i a, __m256i b) { 1211 // CHECK-LABEL: test_mm256_unpacklo_epi32 1212 // CHECK: shufflevector <8 x i32> %{{.*}}, <8 x i32> %{{.*}}, <8 x i32> <i32 0, i32 8, i32 1, i32 9, i32 4, i32 12, i32 5, i32 13> 1213 return _mm256_unpacklo_epi32(a, b); 1214 } 1215 1216 __m256i test_mm256_unpacklo_epi64(__m256i a, __m256i b) { 1217 // CHECK-LABEL: test_mm256_unpacklo_epi64 1218 // CHECK: shufflevector <4 x i64> %{{.*}}, <4 x i64> %{{.*}}, <4 x i32> <i32 0, i32 4, i32 2, i32 6> 1219 return _mm256_unpacklo_epi64(a, b); 1220 } 1221 1222 __m256i test_mm256_xor_si256(__m256i a, __m256i b) { 1223 // CHECK-LABEL: test_mm256_xor_si256 1224 // CHECK: xor <4 x i64> 1225 return _mm256_xor_si256(a, b); 1226 } 1227
