Home | History | Annotate | Download | only in CodeGen
      1 // RUN: %clang_cc1 %s -triple=x86_64-apple-darwin -target-feature +avx -emit-llvm -o - -Werror | FileCheck %s
      2 // RUN: %clang_cc1 %s -triple=x86_64-apple-darwin -target-feature +avx -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/sse-intrinsics-fast-isel.ll
     10 
     11 __m256d test_mm256_add_pd(__m256d A, __m256d B) {
     12   // CHECK-LABEL: test_mm256_add_pd
     13   // CHECK: fadd <4 x double>
     14   return _mm256_add_pd(A, B);
     15 }
     16 
     17 __m256 test_mm256_add_ps(__m256 A, __m256 B) {
     18   // CHECK-LABEL: test_mm256_add_ps
     19   // CHECK: fadd <8 x float>
     20   return _mm256_add_ps(A, B);
     21 }
     22 
     23 __m256d test_mm256_addsub_pd(__m256d A, __m256d B) {
     24   // CHECK-LABEL: test_mm256_addsub_pd
     25   // CHECK: call <4 x double> @llvm.x86.avx.addsub.pd.256(<4 x double> %{{.*}}, <4 x double> %{{.*}})
     26   return _mm256_addsub_pd(A, B);
     27 }
     28 
     29 __m256 test_mm256_addsub_ps(__m256 A, __m256 B) {
     30   // CHECK-LABEL: test_mm256_addsub_ps
     31   // CHECK: call <8 x float> @llvm.x86.avx.addsub.ps.256(<8 x float> %{{.*}}, <8 x float> %{{.*}})
     32   return _mm256_addsub_ps(A, B);
     33 }
     34 
     35 __m256d test_mm256_and_pd(__m256d A, __m256d B) {
     36   // CHECK-LABEL: test_mm256_and_pd
     37   // CHECK: and <4 x i64>
     38   return _mm256_and_pd(A, B);
     39 }
     40 
     41 __m256 test_mm256_and_ps(__m256 A, __m256 B) {
     42   // CHECK-LABEL: test_mm256_and_ps
     43   // CHECK: and <8 x i32>
     44   return _mm256_and_ps(A, B);
     45 }
     46 
     47 __m256d test_mm256_andnot_pd(__m256d A, __m256d B) {
     48   // CHECK-LABEL: test_mm256_andnot_pd
     49   // CHECK: xor <4 x i64> %{{.*}}, <i64 -1, i64 -1, i64 -1, i64 -1>
     50   // CHECK: and <4 x i64>
     51   return _mm256_andnot_pd(A, B);
     52 }
     53 
     54 __m256 test_mm256_andnot_ps(__m256 A, __m256 B) {
     55   // CHECK-LABEL: test_mm256_andnot_ps
     56   // CHECK: xor <8 x i32> %{{.*}}, <i32 -1, i32 -1, i32 -1, i32 -1, i32 -1, i32 -1, i32 -1, i32 -1>
     57   // CHECK: and <8 x i32>
     58   return _mm256_andnot_ps(A, B);
     59 }
     60 
     61 __m256d test_mm256_blend_pd(__m256d A, __m256d B) {
     62   // CHECK-LABEL: test_mm256_blend_pd
     63   // CHECK: shufflevector <4 x double> %{{.*}}, <4 x double> %{{.*}}, <4 x i32> <i32 4, i32 1, i32 6, i32 3>
     64   return _mm256_blend_pd(A, B, 0x35);
     65 }
     66 
     67 __m256 test_mm256_blend_ps(__m256 A, __m256 B) {
     68   // CHECK-LABEL: test_mm256_blend_ps
     69   // CHECK: shufflevector <8 x float> %{{.*}}, <8 x float> %{{.*}}, <8 x i32> <i32 8, i32 1, i32 10, i32 3, i32 12, i32 13, i32 6, i32 7>
     70   return _mm256_blend_ps(A, B, 0x35);
     71 }
     72 
     73 __m256d test_mm256_blendv_pd(__m256d V1, __m256d V2, __m256d V3) {
     74   // CHECK-LABEL: test_mm256_blendv_pd
     75   // CHECK: call <4 x double> @llvm.x86.avx.blendv.pd.256(<4 x double> %{{.*}}, <4 x double> %{{.*}}, <4 x double> %{{.*}})
     76   return _mm256_blendv_pd(V1, V2, V3);
     77 }
     78 
     79 __m256 test_mm256_blendv_ps(__m256 V1, __m256 V2, __m256 V3) {
     80   // CHECK-LABEL: test_mm256_blendv_ps
     81   // CHECK: call <8 x float> @llvm.x86.avx.blendv.ps.256(<8 x float> %{{.*}}, <8 x float> %{{.*}}, <8 x float> %{{.*}})
     82   return _mm256_blendv_ps(V1, V2, V3);
     83 }
     84 
     85 __m256d test_mm256_broadcast_pd(__m128d* A) {
     86   // CHECK-LABEL: test_mm256_broadcast_pd
     87   // CHECK: call <4 x double> @llvm.x86.avx.vbroadcastf128.pd.256(i8* %{{.*}})
     88   return _mm256_broadcast_pd(A);
     89 }
     90 
     91 __m256 test_mm256_broadcast_ps(__m128* A) {
     92   // CHECK-LABEL: test_mm256_broadcast_ps
     93   // CHECK: call <8 x float> @llvm.x86.avx.vbroadcastf128.ps.256(i8* %{{.*}})
     94   return _mm256_broadcast_ps(A);
     95 }
     96 
     97 __m256d test_mm256_broadcast_sd(double* A) {
     98   // CHECK-LABEL: test_mm256_broadcast_sd
     99   // CHECK: load double, double* %{{.*}}
    100   // CHECK: insertelement <4 x double> undef, double %{{.*}}, i32 0
    101   // CHECK: insertelement <4 x double> %{{.*}}, double %{{.*}}, i32 1
    102   // CHECK: insertelement <4 x double> %{{.*}}, double %{{.*}}, i32 2
    103   // CHECK: insertelement <4 x double> %{{.*}}, double %{{.*}}, i32 3
    104   return _mm256_broadcast_sd(A);
    105 }
    106 
    107 __m128d test_mm_broadcast_ss(float* A) {
    108   // CHECK-LABEL: test_mm_broadcast_ss
    109   // CHECK: load float, float* %{{.*}}
    110   // CHECK: insertelement <4 x float> undef, float %{{.*}}, i32 0
    111   // CHECK: insertelement <4 x float> %{{.*}}, float %{{.*}}, i32 1
    112   // CHECK: insertelement <4 x float> %{{.*}}, float %{{.*}}, i32 2
    113   // CHECK: insertelement <4 x float> %{{.*}}, float %{{.*}}, i32 3
    114   return _mm_broadcast_ss(A);
    115 }
    116 
    117 __m256d test_mm256_broadcast_ss(float* A) {
    118   // CHECK-LABEL: test_mm256_broadcast_ss
    119   // CHECK: load float, float* %{{.*}}
    120   // CHECK: insertelement <8 x float> undef, float %{{.*}}, i32 0
    121   // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 1
    122   // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 2
    123   // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 3
    124   // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 4
    125   // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 5
    126   // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 6
    127   // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 7
    128   return _mm256_broadcast_ss(A);
    129 }
    130 
    131 __m256 test_mm256_castpd_ps(__m256d A) {
    132   // CHECK-LABEL: test_mm256_castpd_ps
    133   // CHECK: bitcast <4 x double> %{{.*}} to <8 x float>
    134   return _mm256_castpd_ps(A);
    135 }
    136 
    137 __m256i test_mm256_castpd_si256(__m256d A) {
    138   // CHECK-LABEL: test_mm256_castpd_si256
    139   // CHECK: bitcast <4 x double> %{{.*}} to <4 x i64>
    140   return _mm256_castpd_si256(A);
    141 }
    142 
    143 __m256d test_mm256_castpd128_pd256(__m128d A) {
    144   // CHECK-LABEL: test_mm256_castpd128_pd256
    145   // CHECK: shufflevector <2 x double> %{{.*}}, <2 x double> %{{.*}}, <4 x i32> <i32 0, i32 1, i32 undef, i32 undef>
    146   return _mm256_castpd128_pd256(A);
    147 }
    148 
    149 __m128d test_mm256_castpd256_pd128(__m256d A) {
    150   // CHECK-LABEL: test_mm256_castpd256_pd128
    151   // CHECK: shufflevector <4 x double> %{{.*}}, <4 x double> %{{.*}}, <2 x i32> <i32 0, i32 1>
    152   return _mm256_castpd256_pd128(A);
    153 }
    154 
    155 __m256d test_mm256_castps_pd(__m256 A) {
    156   // CHECK-LABEL: test_mm256_castps_pd
    157   // CHECK: bitcast <8 x float> %{{.*}} to <4 x double>
    158   return _mm256_castps_pd(A);
    159 }
    160 
    161 __m256i test_mm256_castps_si256(__m256 A) {
    162   // CHECK-LABEL: test_mm256_castps_si256
    163   // CHECK: bitcast <8 x float> %{{.*}} to <4 x i64>
    164   return _mm256_castps_si256(A);
    165 }
    166 
    167 __m256 test_mm256_castps128_ps256(__m128 A) {
    168   // CHECK-LABEL: test_mm256_castps128_ps256
    169   // CHECK: shufflevector <4 x float> %{{.*}}, <4 x float> %{{.*}}, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 undef, i32 undef, i32 undef, i32 undef>
    170   return _mm256_castps128_ps256(A);
    171 }
    172 
    173 __m128 test_mm256_castps256_ps128(__m256 A) {
    174   // CHECK-LABEL: test_mm256_castps256_ps128
    175   // CHECK: shufflevector <8 x float> %{{.*}}, <8 x float> %{{.*}}, <4 x i32> <i32 0, i32 1, i32 2, i32 3>
    176   return _mm256_castps256_ps128(A);
    177 }
    178 
    179 __m256i test_mm256_castsi128_si256(__m128i A) {
    180   // CHECK-LABEL: test_mm256_castsi128_si256
    181   // CHECK: shufflevector <2 x i64> %{{.*}}, <2 x i64> %{{.*}}, <4 x i32> <i32 0, i32 1, i32 undef, i32 undef>
    182   return _mm256_castsi128_si256(A);
    183 }
    184 
    185 __m256d test_mm256_castsi256_pd(__m256i A) {
    186   // CHECK-LABEL: test_mm256_castsi256_pd
    187   // CHECK: bitcast <4 x i64> %{{.*}} to <4 x double>
    188   return _mm256_castsi256_pd(A);
    189 }
    190 
    191 __m256 test_mm256_castsi256_ps(__m256i A) {
    192   // CHECK-LABEL: test_mm256_castsi256_ps
    193   // CHECK: bitcast <4 x i64> %{{.*}} to <8 x float>
    194   return _mm256_castsi256_ps(A);
    195 }
    196 
    197 __m128i test_mm256_castsi256_si128(__m256i A) {
    198   // CHECK-LABEL: test_mm256_castsi256_si128
    199   // CHECK: shufflevector <4 x i64> %{{.*}}, <4 x i64> %{{.*}}, <2 x i32> <i32 0, i32 1>
    200   return _mm256_castsi256_si128(A);
    201 }
    202 
    203 __m256d test_mm256_ceil_pd(__m256d x) {
    204   // CHECK-LABEL: test_mm256_ceil_pd
    205   // CHECK: call <4 x double> @llvm.x86.avx.round.pd.256(<4 x double> %{{.*}}, i32 2)
    206   return _mm256_ceil_pd(x);
    207 }
    208 
    209 __m256 test_mm_ceil_ps(__m256 x) {
    210   // CHECK-LABEL: test_mm_ceil_ps
    211   // CHECK: call <8 x float> @llvm.x86.avx.round.ps.256(<8 x float> %{{.*}}, i32 2)
    212   return _mm256_ceil_ps(x);
    213 }
    214 
    215 __m128d test_mm_cmp_pd(__m128d A, __m128d B) {
    216   // CHECK-LABEL: test_mm_cmp_pd
    217   // CHECK: call <2 x double> @llvm.x86.sse2.cmp.pd(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i8 13)
    218   return _mm_cmp_pd(A, B, _CMP_GE_OS);
    219 }
    220 
    221 __m256d test_mm256_cmp_pd(__m256d A, __m256d B) {
    222   // CHECK-LABEL: test_mm256_cmp_pd
    223   // CHECK: call <4 x double> @llvm.x86.avx.cmp.pd.256(<4 x double> %{{.*}}, <4 x double> %{{.*}}, i8 13)
    224   return _mm256_cmp_pd(A, B, _CMP_GE_OS);
    225 }
    226 
    227 __m128 test_mm_cmp_ps(__m128 A, __m128 B) {
    228   // CHECK-LABEL: test_mm_cmp_ps
    229   // CHECK: call <4 x float> @llvm.x86.sse.cmp.ps(<4 x float> %{{.*}}, <4 x float> %{{.*}}, i8 13)
    230   return _mm_cmp_ps(A, B, _CMP_GE_OS);
    231 }
    232 
    233 __m256 test_mm256_cmp_ps(__m256d A, __m256d B) {
    234   // CHECK-LABEL: test_mm256_cmp_ps
    235   // CHECK: call <8 x float> @llvm.x86.avx.cmp.ps.256(<8 x float> %{{.*}}, <8 x float> %{{.*}}, i8 13)
    236   return _mm256_cmp_ps(A, B, _CMP_GE_OS);
    237 }
    238 
    239 __m128d test_mm_cmp_sd(__m128d A, __m128d B) {
    240   // CHECK-LABEL: test_mm_cmp_sd
    241   // CHECK: call <2 x double> @llvm.x86.sse2.cmp.sd(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i8 13)
    242   return _mm_cmp_sd(A, B, _CMP_GE_OS);
    243 }
    244 
    245 __m128 test_mm_cmp_ss(__m128 A, __m128 B) {
    246   // CHECK-LABEL: test_mm_cmp_ss
    247   // CHECK: call <4 x float> @llvm.x86.sse.cmp.ss(<4 x float> %{{.*}}, <4 x float> %{{.*}}, i8 13)
    248   return _mm_cmp_ss(A, B, _CMP_GE_OS);
    249 }
    250 
    251 __m256d test_mm256_cvtepi32_pd(__m128i A) {
    252   // CHECK-LABEL: test_mm256_cvtepi32_pd
    253   // CHECK: sitofp <4 x i32> %{{.*}} to <4 x double>
    254   return _mm256_cvtepi32_pd(A);
    255 }
    256 
    257 __m256 test_mm256_cvtepi32_ps(__m256i A) {
    258   // CHECK-LABEL: test_mm256_cvtepi32_ps
    259   // CHECK: call <8 x float> @llvm.x86.avx.cvtdq2.ps.256(<8 x i32> %{{.*}})
    260   return _mm256_cvtepi32_ps(A);
    261 }
    262 
    263 __m128i test_mm256_cvtpd_epi32(__m256d A) {
    264   // CHECK-LABEL: test_mm256_cvtpd_epi32
    265   // CHECK: call <4 x i32> @llvm.x86.avx.cvt.pd2dq.256(<4 x double> %{{.*}})
    266   return _mm256_cvtpd_epi32(A);
    267 }
    268 
    269 __m128 test_mm256_cvtpd_ps(__m256d A) {
    270   // CHECK-LABEL: test_mm256_cvtpd_ps
    271   // CHECK: call <4 x float> @llvm.x86.avx.cvt.pd2.ps.256(<4 x double> %{{.*}})
    272   return _mm256_cvtpd_ps(A);
    273 }
    274 
    275 __m256i test_mm256_cvtps_epi32(__m256 A) {
    276   // CHECK-LABEL: test_mm256_cvtps_epi32
    277   // CHECK: call <8 x i32> @llvm.x86.avx.cvt.ps2dq.256(<8 x float> %{{.*}})
    278   return _mm256_cvtps_epi32(A);
    279 }
    280 
    281 __m256d test_mm256_cvtps_pd(__m128 A) {
    282   // CHECK-LABEL: test_mm256_cvtps_pd
    283   // CHECK: fpext <4 x float> %{{.*}} to <4 x double>
    284   return _mm256_cvtps_pd(A);
    285 }
    286 
    287 __m128i test_mm256_cvttpd_epi32(__m256d A) {
    288   // CHECK-LABEL: test_mm256_cvttpd_epi32
    289   // CHECK: fptosi <4 x double> %{{.*}} to <4 x i32>
    290   return _mm256_cvttpd_epi32(A);
    291 }
    292 
    293 __m256i test_mm256_cvttps_epi32(__m256 A) {
    294   // CHECK-LABEL: test_mm256_cvttps_epi32
    295   // CHECK: fptosi <8 x float> %{{.*}} to <8 x i32>
    296   return _mm256_cvttps_epi32(A);
    297 }
    298 
    299 __m256d test_mm256_div_pd(__m256d A, __m256d B) {
    300   // CHECK-LABEL: test_mm256_div_pd
    301   // CHECK: fdiv <4 x double>
    302   return _mm256_div_pd(A, B);
    303 }
    304 
    305 __m256 test_mm256_div_ps(__m256 A, __m256 B) {
    306   // CHECK-LABEL: test_mm256_div_ps
    307   // CHECK: fdiv <8 x float>
    308   return _mm256_div_ps(A, B);
    309 }
    310 
    311 __m256 test_mm256_dp_ps(__m256 A, __m256 B) {
    312   // CHECK-LABEL: test_mm256_dp_ps
    313   // CHECK: call <8 x float> @llvm.x86.avx.dp.ps.256(<8 x float> {{.*}}, <8 x float> {{.*}}, i8 7)
    314   return _mm256_dp_ps(A, B, 7);
    315 }
    316 
    317 int test_mm256_extract_epi8(__m256i A) {
    318   // CHECK-LABEL: test_mm256_extract_epi8
    319   // CHECK: and i32 %{{.*}}, 31
    320   // CHECK: extractelement <32 x i8> %{{.*}}, i32 %{{.*}}
    321   // CHECK: zext i8 %{{.*}} to i32
    322   return _mm256_extract_epi8(A, 32);
    323 }
    324 
    325 int test_mm256_extract_epi16(__m256i A) {
    326   // CHECK-LABEL: test_mm256_extract_epi16
    327   // CHECK: and i32 %{{.*}}, 15
    328   // CHECK: extractelement <16 x i16> %{{.*}}, i32 %{{.*}}
    329   // CHECK: zext i16 %{{.*}} to i32
    330   return _mm256_extract_epi16(A, 16);
    331 }
    332 
    333 int test_mm256_extract_epi32(__m256i A) {
    334   // CHECK-LABEL: test_mm256_extract_epi32
    335   // CHECK: and i32 %{{.*}}, 7
    336   // CHECK: extractelement <8 x i32> %{{.*}}, i32 %{{.*}}
    337   return _mm256_extract_epi32(A, 8);
    338 }
    339 
    340 long long test_mm256_extract_epi64(__m256i A) {
    341   // CHECK-LABEL: test_mm256_extract_epi64
    342   // CHECK: and i32 %{{.*}}, 3
    343   // CHECK: extractelement <4 x i64> %{{.*}}, i32 %{{.*}}
    344   return _mm256_extract_epi64(A, 5);
    345 }
    346 
    347 __m128d test_mm256_extractf128_pd(__m256d A) {
    348   // CHECK-LABEL: test_mm256_extractf128_pd
    349   // CHECK: shufflevector <4 x double> %{{.*}}, <4 x double> undef, <2 x i32> <i32 2, i32 3>
    350   return _mm256_extractf128_pd(A, 1);
    351 }
    352 
    353 __m128 test_mm256_extractf128_ps(__m256 A) {
    354   // CHECK-LABEL: test_mm256_extractf128_ps
    355   // CHECK: shufflevector <8 x float> %{{.*}}, <8 x float> undef, <4 x i32> <i32 4, i32 5, i32 6, i32 7>
    356   return _mm256_extractf128_ps(A, 1);
    357 }
    358 
    359 __m128i test_mm256_extractf128_si256(__m256i A) {
    360   // CHECK-LABEL: test_mm256_extractf128_si256
    361   // CHECK: shufflevector <4 x i64> %{{.*}}, <4 x i64> undef, <2 x i32> <i32 2, i32 3>
    362   return _mm256_extractf128_si256(A, 1);
    363 }
    364 
    365 __m256d test_mm256_floor_pd(__m256d x) {
    366   // CHECK-LABEL: test_mm256_floor_pd
    367   // CHECK: call <4 x double> @llvm.x86.avx.round.pd.256(<4 x double> %{{.*}}, i32 1)
    368   return _mm256_floor_pd(x);
    369 }
    370 
    371 __m256 test_mm_floor_ps(__m256 x) {
    372   // CHECK-LABEL: test_mm_floor_ps
    373   // CHECK: call <8 x float> @llvm.x86.avx.round.ps.256(<8 x float> %{{.*}}, i32 1)
    374   return _mm256_floor_ps(x);
    375 }
    376 
    377 __m256d test_mm256_hadd_pd(__m256d A, __m256d B) {
    378   // CHECK-LABEL: test_mm256_hadd_pd
    379   // CHECK: call <4 x double> @llvm.x86.avx.hadd.pd.256(<4 x double> %{{.*}}, <4 x double> %{{.*}})
    380   return _mm256_hadd_pd(A, B);
    381 }
    382 
    383 __m256 test_mm256_hadd_ps(__m256 A, __m256 B) {
    384   // CHECK-LABEL: test_mm256_hadd_ps
    385   // CHECK: call <8 x float> @llvm.x86.avx.hadd.ps.256(<8 x float> %{{.*}}, <8 x float> %{{.*}})
    386   return _mm256_hadd_ps(A, B);
    387 }
    388 
    389 __m256d test_mm256_hsub_pd(__m256d A, __m256d B) {
    390   // CHECK-LABEL: test_mm256_hsub_pd
    391   // CHECK: call <4 x double> @llvm.x86.avx.hsub.pd.256(<4 x double> %{{.*}}, <4 x double> %{{.*}})
    392   return _mm256_hsub_pd(A, B);
    393 }
    394 
    395 __m256 test_mm256_hsub_ps(__m256 A, __m256 B) {
    396   // CHECK-LABEL: test_mm256_hsub_ps
    397   // CHECK: call <8 x float> @llvm.x86.avx.hsub.ps.256(<8 x float> %{{.*}}, <8 x float> %{{.*}})
    398   return _mm256_hsub_ps(A, B);
    399 }
    400 
    401 __m256i test_mm256_insert_epi8(__m256i x, char b) {
    402   // CHECK-LABEL: test_mm256_insert_epi8
    403   // CHECK: and i32 %{{.*}}, 31
    404   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 %{{.*}}
    405   return _mm256_insert_epi8(x, b, 17);
    406 }
    407 
    408 __m256i test_mm256_insert_epi16(__m256i x, int b) {
    409   // CHECK-LABEL: test_mm256_insert_epi16
    410   // CHECK: and i32 %{{.*}}, 15
    411   // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 %{{.*}}
    412   return _mm256_insert_epi16(x, b, 4);
    413 }
    414 
    415 __m256i test_mm256_insert_epi32(__m256i x, int b) {
    416   // CHECK-LABEL: test_mm256_insert_epi32
    417   // CHECK: and i32 %{{.*}}, 7
    418   // CHECK: insertelement <8 x i32> %{{.*}}, i32 %{{.*}}, i32 %{{.*}}
    419   return _mm256_insert_epi32(x, b, 5);
    420 }
    421 
    422 __m256i test_mm256_insert_epi64(__m256i x, long long b) {
    423   // CHECK-LABEL: test_mm256_insert_epi64
    424   // CHECK: and i32 %{{.*}}, 3
    425   // CHECK: insertelement <4 x i64> %{{.*}}, i64 %{{.*}}, i32 %{{.*}}
    426   return _mm256_insert_epi64(x, b, 2);
    427 }
    428 
    429 __m256d test_mm256_insertf128_pd(__m256d A, __m128d B) {
    430   // CHECK-LABEL: test_mm256_insertf128_pd
    431   // CHECK: shufflevector <2 x double> %{{.*}}, <2 x double> %{{.*}}, <4 x i32> <i32 0, i32 1, i32 undef, i32 undef>
    432   // CHECK: shufflevector <4 x double> %{{.*}}, <4 x double> %{{.*}}, <4 x i32> <i32 4, i32 5, i32 2, i32 3>
    433   return _mm256_insertf128_pd(A, B, 0);
    434 }
    435 
    436 __m256 test_mm256_insertf128_ps(__m256 A, __m128 B) {
    437   // CHECK-LABEL: test_mm256_insertf128_ps
    438   // CHECK: shufflevector <4 x float> %{{.*}}, <4 x float> %{{.*}}, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 undef, i32 undef, i32 undef, i32 undef>
    439   // CHECK: shufflevector <8 x float> %{{.*}}, <8 x float> %{{.*}}, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 8, i32 9, i32 10, i32 11>
    440   return _mm256_insertf128_ps(A, B, 1);
    441 }
    442 
    443 __m256i test_mm256_insertf128_si256(__m256i A, __m128i B) {
    444   // CHECK-LABEL: test_mm256_insertf128_si256
    445   // CHECK: shufflevector <2 x i64> %{{.*}}, <2 x i64> %{{.*}}, <4 x i32> <i32 0, i32 1, i32 undef, i32 undef>
    446   // CHECK: shufflevector <4 x i64> %{{.*}}, <4 x i64> %{{.*}}, <4 x i32> <i32 4, i32 5, i32 2, i32 3>
    447   return _mm256_insertf128_si256(A, B, 0);
    448 }
    449 
    450 __m256i test_mm256_lddqu_si256(__m256i* A) {
    451   // CHECK-LABEL: test_mm256_lddqu_si256
    452   // CHECK: call <32 x i8> @llvm.x86.avx.ldu.dq.256(i8* %{{.*}})
    453   return _mm256_lddqu_si256(A);
    454 }
    455 
    456 __m256d test_mm256_load_pd(double* A) {
    457   // CHECK-LABEL: test_mm256_load_pd
    458   // CHECK: load <4 x double>, <4 x double>* %{{.*}}, align 32
    459   return _mm256_load_pd(A);
    460 }
    461 
    462 __m256 test_mm256_load_ps(float* A) {
    463   // CHECK-LABEL: test_mm256_load_ps
    464   // CHECK: load <8 x float>, <8 x float>* %{{.*}}, align 32
    465   return _mm256_load_ps(A);
    466 }
    467 
    468 __m256i test_mm256_load_si256(__m256i* A) {
    469   // CHECK-LABEL: test_mm256_load_si256
    470   // CHECK: load <4 x i64>, <4 x i64>* %{{.*}}, align 32
    471   return _mm256_load_si256(A);
    472 }
    473 
    474 __m256d test_mm256_loadu_pd(double* A) {
    475   // CHECK-LABEL: test_mm256_loadu_pd
    476   // CHECK: load <4 x double>, <4 x double>* %{{.*}}, align 1{{$}}
    477   return _mm256_loadu_pd(A);
    478 }
    479 
    480 __m256 test_mm256_loadu_ps(float* A) {
    481   // CHECK-LABEL: test_mm256_loadu_ps
    482   // CHECK: load <8 x float>, <8 x float>* %{{.*}}, align 1{{$}}
    483   return _mm256_loadu_ps(A);
    484 }
    485 
    486 __m256i test_mm256_loadu_si256(__m256i* A) {
    487   // CHECK-LABEL: test_mm256_loadu_si256
    488   // CHECK: load <4 x i64>, <4 x i64>* %{{.+}}, align 1{{$}}
    489   return _mm256_loadu_si256(A);
    490 }
    491 
    492 __m256 test_mm256_loadu2_m128(float* A, float* B) {
    493   // CHECK-LABEL: test_mm256_loadu2_m128
    494   // CHECK: load <4 x float>, <4 x float>* %{{.*}}, align 1{{$}}
    495   // CHECK: shufflevector <4 x float> %{{.*}}, <4 x float> %{{.*}}, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 undef, i32 undef, i32 undef, i32 undef>
    496   // CHECK: load <4 x float>, <4 x float>* %{{.*}}, align 1{{$}}
    497   // CHECK: shufflevector <4 x float> %{{.*}}, <4 x float> %{{.*}}, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 undef, i32 undef, i32 undef, i32 undef>
    498   // CHECK: shufflevector <8 x float> %{{.*}}, <8 x float> %{{.*}}, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 8, i32 9, i32 10, i32 11>
    499   return _mm256_loadu2_m128(A, B);
    500 }
    501 
    502 __m256d test_mm256_loadu2_m128d(double* A, double* B) {
    503   // CHECK-LABEL: test_mm256_loadu2_m128d
    504   // CHECK: load <2 x double>, <2 x double>* %{{.*}}, align 1{{$}}
    505   // CHECK: shufflevector <2 x double> %{{.*}}, <2 x double> %{{.*}}, <4 x i32> <i32 0, i32 1, i32 undef, i32 undef>
    506   // CHECK: load <2 x double>, <2 x double>* %{{.*}}, align 1{{$}}
    507   // CHECK: shufflevector <2 x double> %{{.*}}, <2 x double> %{{.*}}, <4 x i32> <i32 0, i32 1, i32 undef, i32 undef>
    508   // CHECK: shufflevector <4 x double> %{{.*}}, <4 x double> %{{.*}}, <4 x i32> <i32 0, i32 1, i32 4, i32 5>
    509   return _mm256_loadu2_m128d(A, B);
    510 }
    511 
    512 __m256i test_mm256_loadu2_m128i(__m128i* A, __m128i* B) {
    513   // CHECK-LABEL: test_mm256_loadu2_m128i
    514   // CHECK: load <2 x i64>, <2 x i64>* %{{.*}}, align 1{{$}}
    515   // CHECK: shufflevector <2 x i64> %{{.*}}, <2 x i64> %{{.*}}, <4 x i32> <i32 0, i32 1, i32 undef, i32 undef>
    516   // CHECK: load <2 x i64>, <2 x i64>* %{{.*}}, align 1{{$}}
    517   // CHECK: shufflevector <2 x i64> %{{.*}}, <2 x i64> %{{.*}}, <4 x i32> <i32 0, i32 1, i32 undef, i32 undef>
    518   // CHECK: shufflevector <4 x i64> %{{.*}}, <4 x i64> %{{.*}}, <4 x i32> <i32 0, i32 1, i32 4, i32 5>
    519   return _mm256_loadu2_m128i(A, B);
    520 }
    521 
    522 __m128d test_mm_maskload_pd(double* A, __m128i B) {
    523   // CHECK-LABEL: test_mm_maskload_pd
    524   // CHECK: call <2 x double> @llvm.x86.avx.maskload.pd(i8* %{{.*}}, <2 x i64> %{{.*}})
    525   return _mm_maskload_pd(A, B);
    526 }
    527 
    528 __m256d test_mm256_maskload_pd(double* A, __m256i B) {
    529   // CHECK-LABEL: test_mm256_maskload_pd
    530   // CHECK: call <4 x double> @llvm.x86.avx.maskload.pd.256(i8* %{{.*}}, <4 x i64> %{{.*}})
    531   return _mm256_maskload_pd(A, B);
    532 }
    533 
    534 __m128 test_mm_maskload_ps(float* A, __m128i B) {
    535   // CHECK-LABEL: test_mm_maskload_ps
    536   // CHECK: call <4 x float> @llvm.x86.avx.maskload.ps(i8* %{{.*}}, <4 x i32> %{{.*}})
    537   return _mm_maskload_ps(A, B);
    538 }
    539 
    540 __m256d test_mm256_maskload_ps(float* A, __m256i B) {
    541   // CHECK-LABEL: test_mm256_maskload_ps
    542   // CHECK: call <8 x float> @llvm.x86.avx.maskload.ps.256(i8* %{{.*}}, <8 x i32> %{{.*}})
    543   return _mm256_maskload_ps(A, B);
    544 }
    545 
    546 void test_mm_maskstore_pd(double* A, __m128i B, __m128d C) {
    547   // CHECK-LABEL: test_mm_maskstore_pd
    548   // CHECK: call void @llvm.x86.avx.maskstore.pd(i8* %{{.*}}, <2 x i64> %{{.*}}, <2 x double> %{{.*}})
    549   _mm_maskstore_pd(A, B, C);
    550 }
    551 
    552 void test_mm256_maskstore_pd(double* A, __m256i B, __m256d C) {
    553   // CHECK-LABEL: test_mm256_maskstore_pd
    554   // CHECK: call void @llvm.x86.avx.maskstore.pd.256(i8* %{{.*}}, <4 x i64> %{{.*}}, <4 x double> %{{.*}})
    555   _mm256_maskstore_pd(A, B, C);
    556 }
    557 
    558 void test_mm_maskstore_ps(float* A, __m128i B, __m128 C) {
    559   // CHECK-LABEL: test_mm_maskstore_ps
    560   // CHECK: call void @llvm.x86.avx.maskstore.ps(i8* %{{.*}}, <4 x i32> %{{.*}}, <4 x float> %{{.*}})
    561   _mm_maskstore_ps(A, B, C);
    562 }
    563 
    564 void test_mm256_maskstore_ps(float* A, __m256i B, __m256 C) {
    565   // CHECK-LABEL: test_mm256_maskstore_ps
    566   // CHECK: call void @llvm.x86.avx.maskstore.ps.256(i8* %{{.*}}, <8 x i32> %{{.*}}, <8 x float> %{{.*}})
    567   _mm256_maskstore_ps(A, B, C);
    568 }
    569 
    570 __m256d test_mm256_max_pd(__m256d A, __m256d B) {
    571   // CHECK-LABEL: test_mm256_max_pd
    572   // CHECK: call <4 x double> @llvm.x86.avx.max.pd.256(<4 x double> %{{.*}}, <4 x double> %{{.*}})
    573   return _mm256_max_pd(A, B);
    574 }
    575 
    576 __m256 test_mm256_max_ps(__m256 A, __m256 B) {
    577   // CHECK-LABEL: test_mm256_max_ps
    578   // CHECK: call <8 x float> @llvm.x86.avx.max.ps.256(<8 x float> %{{.*}}, <8 x float> %{{.*}})
    579   return _mm256_max_ps(A, B);
    580 }
    581 
    582 __m256d test_mm256_min_pd(__m256d A, __m256d B) {
    583   // CHECK-LABEL: test_mm256_min_pd
    584   // CHECK: call <4 x double> @llvm.x86.avx.min.pd.256(<4 x double> %{{.*}}, <4 x double> %{{.*}})
    585   return _mm256_min_pd(A, B);
    586 }
    587 
    588 __m256 test_mm256_min_ps(__m256 A, __m256 B) {
    589   // CHECK-LABEL: test_mm256_min_ps
    590   // CHECK: call <8 x float> @llvm.x86.avx.min.ps.256(<8 x float> %{{.*}}, <8 x float> %{{.*}})
    591   return _mm256_min_ps(A, B);
    592 }
    593 
    594 __m256d test_mm256_movedup_pd(__m256d A) {
    595   // CHECK-LABEL: test_mm256_movedup_pd
    596   // CHECK: shufflevector <4 x double> %{{.*}}, <4 x double> %{{.*}}, <4 x i32> <i32 0, i32 0, i32 2, i32 2>
    597   return _mm256_movedup_pd(A);
    598 }
    599 
    600 __m256 test_mm256_movehdup_ps(__m256 A) {
    601   // CHECK-LABEL: test_mm256_movehdup_ps
    602   // CHECK: shufflevector <8 x float> %{{.*}}, <8 x float> %{{.*}}, <8 x i32> <i32 1, i32 1, i32 3, i32 3, i32 5, i32 5, i32 7, i32 7>
    603   return _mm256_movehdup_ps(A);
    604 }
    605 
    606 __m256 test_mm256_moveldup_ps(__m256 A) {
    607   // CHECK-LABEL: test_mm256_moveldup_ps
    608   // CHECK: shufflevector <8 x float> %{{.*}}, <8 x float> %{{.*}}, <8 x i32> <i32 0, i32 0, i32 2, i32 2, i32 4, i32 4, i32 6, i32 6>
    609   return _mm256_moveldup_ps(A);
    610 }
    611 
    612 int test_mm256_movemask_pd(__m256d A) {
    613   // CHECK-LABEL: test_mm256_movemask_pd
    614   // CHECK: call i32 @llvm.x86.avx.movmsk.pd.256(<4 x double> %{{.*}})
    615   return _mm256_movemask_pd(A);
    616 }
    617 
    618 int test_mm256_movemask_ps(__m256 A) {
    619   // CHECK-LABEL: test_mm256_movemask_ps
    620   // CHECK: call i32 @llvm.x86.avx.movmsk.ps.256(<8 x float> %{{.*}})
    621   return _mm256_movemask_ps(A);
    622 }
    623 
    624 __m256d test_mm256_mul_pd(__m256d A, __m256d B) {
    625   // CHECK-LABEL: test_mm256_mul_pd
    626   // CHECK: fmul <4 x double>
    627   return _mm256_mul_pd(A, B);
    628 }
    629 
    630 __m256 test_mm256_mul_ps(__m256 A, __m256 B) {
    631   // CHECK-LABEL: test_mm256_mul_ps
    632   // CHECK: fmul <8 x float>
    633   return _mm256_mul_ps(A, B);
    634 }
    635 
    636 __m256d test_mm256_or_pd(__m256d A, __m256d B) {
    637   // CHECK-LABEL: test_mm256_or_pd
    638   // CHECK: or <4 x i64>
    639   return _mm256_or_pd(A, B);
    640 }
    641 
    642 __m256 test_mm256_or_ps(__m256 A, __m256 B) {
    643   // CHECK-LABEL: test_mm256_or_ps
    644   // CHECK: or <8 x i32>
    645   return _mm256_or_ps(A, B);
    646 }
    647 
    648 __m128d test_mm_permute_pd(__m128d A) {
    649   // CHECK-LABEL: test_mm_permute_pd
    650   // CHECK: shufflevector <2 x double> %{{.*}}, <2 x double> undef, <2 x i32> <i32 1, i32 0>
    651   return _mm_permute_pd(A, 1);
    652 }
    653 
    654 __m256d test_mm256_permute_pd(__m256d A) {
    655   // CHECK-LABEL: test_mm256_permute_pd
    656   // CHECK: shufflevector <4 x double> %{{.*}}, <4 x double> undef, <4 x i32> <i32 1, i32 0, i32 3, i32 2>
    657   return _mm256_permute_pd(A, 5);
    658 }
    659 
    660 __m128 test_mm_permute_ps(__m128 A) {
    661   // CHECK-LABEL: test_mm_permute_ps
    662   // CHECK: shufflevector <4 x float> %{{.*}}, <4 x float> undef, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
    663   return _mm_permute_ps(A, 0x1b);
    664 }
    665 
    666 // Test case for PR12401
    667 __m128 test2_mm_permute_ps(__m128 a) {
    668   // CHECK-LABEL: test2_mm_permute_ps
    669   // CHECK: shufflevector <4 x float> %{{.*}}, <4 x float> undef, <4 x i32> <i32 2, i32 1, i32 2, i32 3>
    670   return _mm_permute_ps(a, 0xe6);
    671 }
    672 
    673 __m256 test_mm256_permute_ps(__m256 A) {
    674   // CHECK-LABEL: test_mm256_permute_ps
    675   // CHECK: shufflevector <8 x float> %{{.*}}, <8 x float> undef, <8 x i32> <i32 3, i32 2, i32 1, i32 0, i32 7, i32 6, i32 5, i32 4>
    676   return _mm256_permute_ps(A, 0x1b);
    677 }
    678 
    679 __m256d test_mm256_permute2f128_pd(__m256d A, __m256d B) {
    680   // CHECK-LABEL: test_mm256_permute2f128_pd
    681   // CHECK: call <4 x double> @llvm.x86.avx.vperm2f128.pd.256(<4 x double> %{{.*}}, <4 x double> %{{.*}}, i8 49)
    682   return _mm256_permute2f128_pd(A, B, 0x31);
    683 }
    684 
    685 __m256 test_mm256_permute2f128_ps(__m256 A, __m256 B) {
    686   // CHECK-LABEL: test_mm256_permute2f128_ps
    687   // CHECK: call <8 x float> @llvm.x86.avx.vperm2f128.ps.256(<8 x float> %{{.*}}, <8 x float> %{{.*}}, i8 19)
    688   return _mm256_permute2f128_ps(A, B, 0x13);
    689 }
    690 
    691 __m256i test_mm256_permute2f128_si256(__m256i A, __m256i B) {
    692   // CHECK-LABEL: test_mm256_permute2f128_si256
    693   // CHECK: call <8 x i32> @llvm.x86.avx.vperm2f128.si.256(<8 x i32> %{{.*}}, <8 x i32> %{{.*}}, i8 32)
    694   return _mm256_permute2f128_si256(A, B, 0x20);
    695 }
    696 
    697 __m128d test_mm_permutevar_pd(__m128d A, __m128i B) {
    698   // CHECK-LABEL: test_mm_permutevar_pd
    699   // CHECK: call <2 x double> @llvm.x86.avx.vpermilvar.pd(<2 x double> %{{.*}}, <2 x i64> %{{.*}})
    700   return _mm_permutevar_pd(A, B);
    701 }
    702 
    703 __m256d test_mm256_permutevar_pd(__m256d A, __m256i B) {
    704   // CHECK-LABEL: test_mm256_permutevar_pd
    705   // CHECK: call <4 x double> @llvm.x86.avx.vpermilvar.pd.256(<4 x double> %{{.*}}, <4 x i64> %{{.*}})
    706   return _mm256_permutevar_pd(A, B);
    707 }
    708 
    709 __m128 test_mm_permutevar_ps(__m128 A, __m128i B) {
    710   // CHECK-LABEL: test_mm_permutevar_ps
    711   // CHECK: call <4 x float> @llvm.x86.avx.vpermilvar.ps(<4 x float> %{{.*}}, <4 x i32> %{{.*}})
    712   return _mm_permutevar_ps(A, B);
    713 }
    714 
    715 __m256 test_mm256_permutevar_ps(__m256 A, __m256i B) {
    716   // CHECK-LABEL: test_mm256_permutevar_ps
    717   // CHECK: call <8 x float> @llvm.x86.avx.vpermilvar.ps.256(<8 x float> %{{.*}}, <8 x i32> %{{.*}})
    718   return _mm256_permutevar_ps(A, B);
    719 }
    720 
    721 __m256 test_mm256_rcp_ps(__m256 A) {
    722   // CHECK-LABEL: test_mm256_rcp_ps
    723   // CHECK: call <8 x float> @llvm.x86.avx.rcp.ps.256(<8 x float> %{{.*}})
    724   return _mm256_rcp_ps(A);
    725 }
    726 
    727 __m256d test_mm256_round_pd(__m256d x) {
    728   // CHECK-LABEL: test_mm256_round_pd
    729   // CHECK: call <4 x double> @llvm.x86.avx.round.pd.256(<4 x double> %{{.*}}, i32 4)
    730   return _mm256_round_pd(x, 4);
    731 }
    732 
    733 __m256 test_mm256_round_ps(__m256 x) {
    734   // CHECK-LABEL: test_mm256_round_ps
    735   // CHECK: call <8 x float> @llvm.x86.avx.round.ps.256(<8 x float> %{{.*}}, i32 4)
    736   return _mm256_round_ps(x, 4);
    737 }
    738 
    739 __m256 test_mm256_rsqrt_ps(__m256 A) {
    740   // CHECK-LABEL: test_mm256_rsqrt_ps
    741   // CHECK: call <8 x float> @llvm.x86.avx.rsqrt.ps.256(<8 x float> %{{.*}})
    742   return _mm256_rsqrt_ps(A);
    743 }
    744 
    745 __m256i test_mm256_set_epi8(char A0, char A1, char A2, char A3, char A4, char A5, char A6, char A7,
    746                             char A8, char A9, char A10, char A11, char A12, char A13, char A14, char A15,
    747                             char A16, char A17, char A18, char A19, char A20, char A21, char A22, char A23,
    748                             char A24, char A25, char A26, char A27, char A28, char A29, char A30, char A31) {
    749   // CHECK-LABEL: test_mm256_set_epi8
    750   // CHECK: insertelement <32 x i8> undef, i8 %{{.*}}, i32 0
    751   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 1
    752   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 2
    753   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 3
    754   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 4
    755   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 5
    756   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 6
    757   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 7
    758   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 8
    759   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 9
    760   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 10
    761   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 11
    762   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 12
    763   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 13
    764   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 14
    765   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 15
    766   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 16
    767   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 17
    768   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 18
    769   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 19
    770   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 20
    771   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 21
    772   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 22
    773   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 23
    774   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 24
    775   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 25
    776   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 26
    777   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 27
    778   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 28
    779   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 29
    780   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 30
    781   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 31
    782   return _mm256_set_epi8(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31);
    783 }
    784 
    785 __m256i test_mm256_set_epi16(short A0, short A1, short A2, short A3, short A4, short A5, short A6, short A7,
    786                              short A8, short A9, short A10, short A11, short A12, short A13, short A14, short A15) {
    787   // CHECK-LABEL: test_mm256_set_epi16
    788   // CHECK: insertelement <16 x i16> undef, i16 %{{.*}}, i32 0
    789   // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 1
    790   // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 2
    791   // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 3
    792   // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 4
    793   // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 5
    794   // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 6
    795   // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 7
    796   // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 8
    797   // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 9
    798   // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 10
    799   // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 11
    800   // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 12
    801   // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 13
    802   // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 14
    803   // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 15
    804   return _mm256_set_epi16(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15);
    805 }
    806 
    807 __m256i test_mm256_set_epi32(int A0, int A1, int A2, int A3, int A4, int A5, int A6, int A7) {
    808   // CHECK-LABEL: test_mm256_set_epi32
    809   // CHECK: insertelement <8 x i32> undef, i32 %{{.*}}, i32 0
    810   // CHECK: insertelement <8 x i32> %{{.*}}, i32 %{{.*}}, i32 1
    811   // CHECK: insertelement <8 x i32> %{{.*}}, i32 %{{.*}}, i32 2
    812   // CHECK: insertelement <8 x i32> %{{.*}}, i32 %{{.*}}, i32 3
    813   // CHECK: insertelement <8 x i32> %{{.*}}, i32 %{{.*}}, i32 4
    814   // CHECK: insertelement <8 x i32> %{{.*}}, i32 %{{.*}}, i32 5
    815   // CHECK: insertelement <8 x i32> %{{.*}}, i32 %{{.*}}, i32 6
    816   // CHECK: insertelement <8 x i32> %{{.*}}, i32 %{{.*}}, i32 7
    817   return _mm256_set_epi32(A0, A1, A2, A3, A4, A5, A6, A7);
    818 }
    819 
    820 __m256i test_mm256_set_epi64x(long long A0, long long A1, long long A2, long long A3) {
    821   // CHECK-LABEL: test_mm256_set_epi64x
    822   // CHECK: insertelement <4 x i64> undef, i64 %{{.*}}, i32 0
    823   // CHECK: insertelement <4 x i64> %{{.*}}, i64 %{{.*}}, i32 1
    824   // CHECK: insertelement <4 x i64> %{{.*}}, i64 %{{.*}}, i32 2
    825   // CHECK: insertelement <4 x i64> %{{.*}}, i64 %{{.*}}, i32 3
    826   return _mm256_set_epi64x(A0, A1, A2, A3);
    827 }
    828 
    829 __m256 test_mm256_set_m128(__m128 A, __m128 B) {
    830   // CHECK-LABEL: test_mm256_set_m128
    831   // CHECK: shufflevector <4 x float> %{{.*}}, <4 x float> %{{.*}}, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7>
    832   return _mm256_set_m128(A, B);
    833 }
    834 
    835 __m256d test_mm256_set_m128d(__m128d A, __m128d B) {
    836   // CHECK-LABEL: test_mm256_set_m128d
    837   // CHECK: shufflevector <4 x float> %{{.*}}, <4 x float> %{{.*}}, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7>
    838   return _mm256_set_m128d(A, B);
    839 }
    840 
    841 __m256i test_mm256_set_m128i(__m128i A, __m128i B) {
    842   // CHECK-LABEL: test_mm256_set_m128i
    843   // CHECK: shufflevector <4 x float> %{{.*}}, <4 x float> %{{.*}}, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7>
    844   return _mm256_set_m128i(A, B);
    845 }
    846 
    847 __m256d test_mm256_set_pd(double A0, double A1, double A2, double A3) {
    848   // CHECK-LABEL: test_mm256_set_pd
    849   // CHECK: insertelement <4 x double> undef, double %{{.*}}, i32 0
    850   // CHECK: insertelement <4 x double> %{{.*}}, double %{{.*}}, i32 1
    851   // CHECK: insertelement <4 x double> %{{.*}}, double %{{.*}}, i32 2
    852   // CHECK: insertelement <4 x double> %{{.*}}, double %{{.*}}, i32 3
    853   return _mm256_set_pd(A0, A1, A2, A3);
    854 }
    855 
    856 __m256 test_mm256_set_ps(float A0, float A1, float A2, float A3, float A4, float A5, float A6, float A7) {
    857   // CHECK-LABEL: test_mm256_set_ps
    858   // CHECK: insertelement <8 x float> undef, float %{{.*}}, i32 0
    859   // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 1
    860   // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 2
    861   // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 3
    862   // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 4
    863   // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 5
    864   // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 6
    865   // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 7
    866   return _mm256_set_ps(A0, A1, A2, A3, A4, A5, A6, A7);
    867 }
    868 
    869 __m256i test_mm256_set1_epi8(char A) {
    870   // CHECK-LABEL: test_mm256_set1_epi8
    871   // CHECK: insertelement <32 x i8> undef, i8 %{{.*}}, i32 0
    872   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 1
    873   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 2
    874   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 3
    875   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 4
    876   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 5
    877   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 6
    878   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 7
    879   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 8
    880   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 9
    881   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 10
    882   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 11
    883   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 12
    884   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 13
    885   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 14
    886   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 15
    887   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 16
    888   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 17
    889   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 18
    890   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 19
    891   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 20
    892   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 21
    893   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 22
    894   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 23
    895   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 24
    896   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 25
    897   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 26
    898   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 27
    899   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 28
    900   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 29
    901   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 30
    902   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 31
    903   return _mm256_set1_epi8(A);
    904 }
    905 
    906 __m256i test_mm256_set1_epi16(short A) {
    907   // CHECK-LABEL: test_mm256_set1_epi16
    908   // CHECK: insertelement <16 x i16> undef, i16 %{{.*}}, i32 0
    909   // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 1
    910   // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 2
    911   // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 3
    912   // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 4
    913   // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 5
    914   // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 6
    915   // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 7
    916   // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 8
    917   // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 9
    918   // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 10
    919   // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 11
    920   // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 12
    921   // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 13
    922   // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 14
    923   // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 15
    924   return _mm256_set1_epi16(A);
    925 }
    926 
    927 __m256i test_mm256_set1_epi32(int A) {
    928   // CHECK-LABEL: test_mm256_set1_epi32
    929   // CHECK: insertelement <8 x i32> undef, i32 %{{.*}}, i32 0
    930   // CHECK: insertelement <8 x i32> %{{.*}}, i32 %{{.*}}, i32 1
    931   // CHECK: insertelement <8 x i32> %{{.*}}, i32 %{{.*}}, i32 2
    932   // CHECK: insertelement <8 x i32> %{{.*}}, i32 %{{.*}}, i32 3
    933   // CHECK: insertelement <8 x i32> %{{.*}}, i32 %{{.*}}, i32 4
    934   // CHECK: insertelement <8 x i32> %{{.*}}, i32 %{{.*}}, i32 5
    935   // CHECK: insertelement <8 x i32> %{{.*}}, i32 %{{.*}}, i32 6
    936   // CHECK: insertelement <8 x i32> %{{.*}}, i32 %{{.*}}, i32 7
    937   return _mm256_set1_epi32(A);
    938 }
    939 
    940 __m256i test_mm256_set1_epi64x(long long A) {
    941   // CHECK-LABEL: test_mm256_set1_epi64x
    942   // CHECK: insertelement <4 x i64> undef, i64 %{{.*}}, i32 0
    943   // CHECK: insertelement <4 x i64> %{{.*}}, i64 %{{.*}}, i32 1
    944   // CHECK: insertelement <4 x i64> %{{.*}}, i64 %{{.*}}, i32 2
    945   // CHECK: insertelement <4 x i64> %{{.*}}, i64 %{{.*}}, i32 3
    946   return _mm256_set1_epi64x(A);
    947 }
    948 
    949 __m256d test_mm256_set1_pd(double A) {
    950   // CHECK-LABEL: test_mm256_set1_pd
    951   // CHECK: insertelement <4 x double> undef, double %{{.*}}, i32 0
    952   // CHECK: insertelement <4 x double> %{{.*}}, double %{{.*}}, i32 1
    953   // CHECK: insertelement <4 x double> %{{.*}}, double %{{.*}}, i32 2
    954   // CHECK: insertelement <4 x double> %{{.*}}, double %{{.*}}, i32 3
    955   return _mm256_set1_pd(A);
    956 }
    957 
    958 __m256 test_mm256_set1_ps(float A) {
    959   // CHECK-LABEL: test_mm256_set1_ps
    960   // CHECK: insertelement <8 x float> undef, float %{{.*}}, i32 0
    961   // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 1
    962   // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 2
    963   // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 3
    964   // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 4
    965   // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 5
    966   // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 6
    967   // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 7
    968   return _mm256_set1_ps(A);
    969 }
    970 
    971 __m256i test_mm256_setr_epi8(char A0, char A1, char A2, char A3, char A4, char A5, char A6, char A7,
    972                              char A8, char A9, char A10, char A11, char A12, char A13, char A14, char A15,
    973                              char A16, char A17, char A18, char A19, char A20, char A21, char A22, char A23,
    974                              char A24, char A25, char A26, char A27, char A28, char A29, char A30, char A31) {
    975   // CHECK-LABEL: test_mm256_setr_epi8
    976   // CHECK: insertelement <32 x i8> undef, i8 %{{.*}}, i32 0
    977   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 1
    978   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 2
    979   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 3
    980   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 4
    981   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 5
    982   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 6
    983   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 7
    984   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 8
    985   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 9
    986   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 10
    987   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 11
    988   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 12
    989   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 13
    990   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 14
    991   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 15
    992   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 16
    993   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 17
    994   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 18
    995   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 19
    996   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 20
    997   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 21
    998   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 22
    999   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 23
   1000   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 24
   1001   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 25
   1002   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 26
   1003   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 27
   1004   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 28
   1005   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 29
   1006   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 30
   1007   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 31
   1008   return _mm256_setr_epi8(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31);
   1009 }
   1010 
   1011 __m256i test_mm256_setr_epi16(short A0, short A1, short A2, short A3, short A4, short A5, short A6, short A7,
   1012                               short A8, short A9, short A10, short A11, short A12, short A13, short A14, short A15) {
   1013   // CHECK-LABEL: test_mm256_setr_epi16
   1014   // CHECK: insertelement <16 x i16> undef, i16 %{{.*}}, i32 0
   1015   // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 1
   1016   // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 2
   1017   // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 3
   1018   // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 4
   1019   // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 5
   1020   // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 6
   1021   // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 7
   1022   // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 8
   1023   // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 9
   1024   // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 10
   1025   // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 11
   1026   // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 12
   1027   // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 13
   1028   // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 14
   1029   // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 15
   1030   return _mm256_setr_epi16(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15);
   1031 }
   1032 
   1033 __m256i test_mm256_setr_epi32(int A0, int A1, int A2, int A3, int A4, int A5, int A6, int A7) {
   1034   // CHECK-LABEL: test_mm256_setr_epi32
   1035   // CHECK: insertelement <8 x i32> undef, i32 %{{.*}}, i32 0
   1036   // CHECK: insertelement <8 x i32> %{{.*}}, i32 %{{.*}}, i32 1
   1037   // CHECK: insertelement <8 x i32> %{{.*}}, i32 %{{.*}}, i32 2
   1038   // CHECK: insertelement <8 x i32> %{{.*}}, i32 %{{.*}}, i32 3
   1039   // CHECK: insertelement <8 x i32> %{{.*}}, i32 %{{.*}}, i32 4
   1040   // CHECK: insertelement <8 x i32> %{{.*}}, i32 %{{.*}}, i32 5
   1041   // CHECK: insertelement <8 x i32> %{{.*}}, i32 %{{.*}}, i32 6
   1042   // CHECK: insertelement <8 x i32> %{{.*}}, i32 %{{.*}}, i32 7
   1043   return _mm256_setr_epi32(A0, A1, A2, A3, A4, A5, A6, A7);
   1044 }
   1045 
   1046 __m256i test_mm256_setr_epi64x(long long A0, long long A1, long long A2, long long A3) {
   1047   // CHECK-LABEL: test_mm256_setr_epi64x
   1048   // CHECK: insertelement <4 x i64> undef, i64 %{{.*}}, i32 0
   1049   // CHECK: insertelement <4 x i64> %{{.*}}, i64 %{{.*}}, i32 1
   1050   // CHECK: insertelement <4 x i64> %{{.*}}, i64 %{{.*}}, i32 2
   1051   // CHECK: insertelement <4 x i64> %{{.*}}, i64 %{{.*}}, i32 3
   1052   return _mm256_setr_epi64x(A0, A1, A2, A3);
   1053 }
   1054 
   1055 __m256 test_mm256_setr_m128(__m128 A, __m128 B) {
   1056   // CHECK-LABEL: test_mm256_setr_m128
   1057   // CHECK: shufflevector <4 x float> %{{.*}}, <4 x float> %{{.*}}, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7>
   1058   return _mm256_setr_m128(A, B);
   1059 }
   1060 
   1061 __m256d test_mm256_setr_m128d(__m128d A, __m128d B) {
   1062   // CHECK-LABEL: test_mm256_setr_m128d
   1063   // CHECK: shufflevector <4 x float> %{{.*}}, <4 x float> %{{.*}}, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7>
   1064   return _mm256_setr_m128d(A, B);
   1065 }
   1066 
   1067 __m256i test_mm256_setr_m128i(__m128i A, __m128i B) {
   1068   // CHECK-LABEL: test_mm256_setr_m128i
   1069   // CHECK: shufflevector <4 x float> %{{.*}}, <4 x float> %{{.*}}, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7>
   1070   return _mm256_setr_m128i(A, B);
   1071 }
   1072 
   1073 __m256d test_mm256_setr_pd(double A0, double A1, double A2, double A3) {
   1074   // CHECK-LABEL: test_mm256_setr_pd
   1075   // CHECK: insertelement <4 x double> undef, double %{{.*}}, i32 0
   1076   // CHECK: insertelement <4 x double> %{{.*}}, double %{{.*}}, i32 1
   1077   // CHECK: insertelement <4 x double> %{{.*}}, double %{{.*}}, i32 2
   1078   // CHECK: insertelement <4 x double> %{{.*}}, double %{{.*}}, i32 3
   1079   return _mm256_setr_pd(A0, A1, A2, A3);
   1080 }
   1081 
   1082 __m256 test_mm256_setr_ps(float A0, float A1, float A2, float A3, float A4, float A5, float A6, float A7) {
   1083   // CHECK-LABEL: test_mm256_setr_ps
   1084   // CHECK: insertelement <8 x float> undef, float %{{.*}}, i32 0
   1085   // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 1
   1086   // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 2
   1087   // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 3
   1088   // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 4
   1089   // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 5
   1090   // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 6
   1091   // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 7
   1092   return _mm256_setr_ps(A0, A1, A2, A3, A4, A5, A6, A7);
   1093 }
   1094 
   1095 __m256d test_mm256_setzero_pd() {
   1096   // CHECK-LABEL: test_mm256_setzero_pd
   1097   // CHECK: store <4 x double> zeroinitializer
   1098   return _mm256_setzero_pd();
   1099 }
   1100 
   1101 __m256 test_mm256_setzero_ps() {
   1102   // CHECK-LABEL: test_mm256_setzero_ps
   1103   // CHECK: store <8 x float> zeroinitializer
   1104   return _mm256_setzero_ps();
   1105 }
   1106 
   1107 __m256i test_mm256_setzero_si256() {
   1108   // CHECK-LABEL: test_mm256_setzero_si256
   1109   // CHECK: store <4 x i64> zeroinitializer
   1110   return _mm256_setzero_si256();
   1111 }
   1112 
   1113 __m256d test_mm256_shuffle_pd(__m256d A, __m256d B) {
   1114   // CHECK-LABEL: test_mm256_shuffle_pd
   1115   // CHECK: shufflevector <4 x double> %{{.*}}, <4 x double> %{{.*}}, <4 x i32> <i32 0, i32 4, i32 2, i32 6>
   1116   return _mm256_shuffle_pd(A, B, 0);
   1117 }
   1118 
   1119 __m256 test_mm256_shuffle_ps(__m256 A, __m256 B) {
   1120   // CHECK-LABEL: test_mm256_shuffle_ps
   1121   // CHECK: shufflevector <8 x float> %{{.*}}, <8 x float> %{{.*}}, <8 x i32> <i32 0, i32 0, i32 8, i32 8, i32 4, i32 4, i32 12, i32 12>
   1122   return _mm256_shuffle_ps(A, B, 0);
   1123 }
   1124 
   1125 __m256d test_mm256_sqrt_pd(__m256d A) {
   1126   // CHECK-LABEL: test_mm256_sqrt_pd
   1127   // CHECK: call <4 x double> @llvm.x86.avx.sqrt.pd.256(<4 x double> %{{.*}})
   1128   return _mm256_sqrt_pd(A);
   1129 }
   1130 
   1131 __m256 test_mm256_sqrt_ps(__m256 A) {
   1132   // CHECK-LABEL: test_mm256_sqrt_ps
   1133   // CHECK: call <8 x float> @llvm.x86.avx.sqrt.ps.256(<8 x float> %{{.*}})
   1134   return _mm256_sqrt_ps(A);
   1135 }
   1136 
   1137 void test_mm256_store_pd(double* A, __m256d B) {
   1138   // CHECK-LABEL: test_mm256_store_pd
   1139   // CHECK: store <4 x double> %{{.*}}, <4 x double>* %{{.*}}, align 32
   1140   _mm256_store_pd(A, B);
   1141 }
   1142 
   1143 void test_mm256_store_ps(float* A, __m256 B) {
   1144   // CHECK-LABEL: test_mm256_store_ps
   1145   // CHECK: store <8 x float> %{{.*}}, <8 x float>* %{{.*}}, align 32
   1146   _mm256_store_ps(A, B);
   1147 }
   1148 
   1149 void test_mm256_store_si256(__m256i* A, __m256i B) {
   1150   // CHECK-LABEL: test_mm256_store_si256
   1151   // CHECK: store <4 x i64> %{{.*}}, <4 x i64>* %{{.*}}, align 32
   1152   _mm256_store_si256(A, B);
   1153 }
   1154 
   1155 void test_mm256_storeu_pd(double* A, __m256d B) {
   1156   // CHECK-LABEL: test_mm256_storeu_pd
   1157   // CHECK:   store <4 x double> %{{.*}}, <4 x double>* %{{.*}}, align 1{{$}}
   1158   // CHECK-NEXT: ret void
   1159   _mm256_storeu_pd(A, B);
   1160 }
   1161 
   1162 void test_mm256_storeu_ps(float* A, __m256 B) {
   1163   // CHECK-LABEL: test_mm256_storeu_ps
   1164   // CHECK: store <8 x float> %{{.*}}, <8 x float>* %{{.*}}, align 1{{$}}
   1165   // CHECk-NEXT: ret void
   1166   _mm256_storeu_ps(A, B);
   1167 }
   1168 
   1169 void test_mm256_storeu_si256(__m256i* A, __m256i B) {
   1170   // CHECK-LABEL: test_mm256_storeu_si256
   1171   // CHECK: store <4 x i64> %{{.*}}, <4 x i64>* %{{.*}}, align 1{{$}}
   1172   // CHECk-NEXT: ret void
   1173   _mm256_storeu_si256(A, B);
   1174 }
   1175 
   1176 void test_mm256_storeu2_m128(float* A, float* B, __m256 C) {
   1177   // CHECK-LABEL: test_mm256_storeu2_m128
   1178   // CHECK: shufflevector <8 x float> %{{.*}}, <8 x float> %{{.*}}, <4 x i32> <i32 0, i32 1, i32 2, i32 3>
   1179   // CHECK: store <4 x float> %{{.*}}, <4 x float>* %{{.*}}, align 1{{$}}
   1180   // CHECK: shufflevector <8 x float> %{{.*}}, <8 x float> undef, <4 x i32> <i32 4, i32 5, i32 6, i32 7>
   1181   // CHECK: store <4 x float> %{{.*}}, <4 x float>* %{{.*}}, align 1{{$}}
   1182   _mm256_storeu2_m128(A, B, C);
   1183 }
   1184 
   1185 void test_mm256_storeu2_m128d(double* A, double* B, __m256d C) {
   1186   // CHECK-LABEL: test_mm256_storeu2_m128d
   1187   // CHECK: shufflevector <4 x double> %{{.*}}, <4 x double> %{{.*}}, <2 x i32> <i32 0, i32 1>
   1188   // CHECK: store <2 x double> %{{.*}}, <2 x double>* %{{.*}}, align 1{{$}}
   1189   // CHECK: shufflevector <4 x double> %{{.*}}, <4 x double> undef, <2 x i32> <i32 2, i32 3>
   1190   // CHECK: store <2 x double> %{{.*}}, <2 x double>* %{{.*}}, align 1{{$}}
   1191   _mm256_storeu2_m128d(A, B, C);
   1192 }
   1193 
   1194 void test_mm256_storeu2_m128i(__m128i* A, __m128i* B, __m256i C) {
   1195   // CHECK-LABEL: test_mm256_storeu2_m128i
   1196   // CHECK: shufflevector <4 x i64> %{{.*}}, <4 x i64> %{{.*}}, <2 x i32> <i32 0, i32 1>
   1197   // CHECK: store <2 x i64> %{{.*}}, <2 x i64>* %{{.*}}, align 1{{$}}
   1198   // CHECK: shufflevector <4 x i64> %{{.*}}, <4 x i64> undef, <2 x i32> <i32 2, i32 3>
   1199   // CHECK: store <2 x i64> %{{.*}}, <2 x i64>* %{{.*}}, align 1{{$}}
   1200   _mm256_storeu2_m128i(A, B, C);
   1201 }
   1202 
   1203 void test_mm256_stream_pd(double* A, __m256d B) {
   1204   // CHECK-LABEL: test_mm256_stream_pd
   1205   // CHECK: store <4 x double> %{{.*}}, <4 x double>* %{{.*}}, align 32, !nontemporal
   1206   _mm256_stream_pd(A, B);
   1207 }
   1208 
   1209 void test_mm256_stream_ps(float* A, __m256 B) {
   1210   // CHECK-LABEL: test_mm256_stream_ps
   1211   // CHECK: store <8 x float> %{{.*}}, <8 x float>* %{{.*}}, align 32, !nontemporal
   1212   _mm256_stream_ps(A, B);
   1213 }
   1214 
   1215 void test_mm256_stream_si256(__m256i* A, __m256i B) {
   1216   // CHECK-LABEL: test_mm256_stream_si256
   1217   // CHECK: store <4 x i64> %{{.*}}, <4 x i64>* %{{.*}}, align 32, !nontemporal
   1218   _mm256_stream_si256(A, B);
   1219 }
   1220 
   1221 __m256d test_mm256_sub_pd(__m256d A, __m256d B) {
   1222   // CHECK-LABEL: test_mm256_sub_pd
   1223   // CHECK: fsub <4 x double>
   1224   return _mm256_sub_pd(A, B);
   1225 }
   1226 
   1227 __m256 test_mm256_sub_ps(__m256 A, __m256 B) {
   1228   // CHECK-LABEL: test_mm256_sub_ps
   1229   // CHECK: fsub <8 x float>
   1230   return _mm256_sub_ps(A, B);
   1231 }
   1232 
   1233 int test_mm_testc_pd(__m128d A, __m128d B) {
   1234   // CHECK-LABEL: test_mm_testc_pd
   1235   // CHECK: call i32 @llvm.x86.avx.vtestc.pd(<2 x double> %{{.*}}, <2 x double> %{{.*}})
   1236   return _mm_testc_pd(A, B);
   1237 }
   1238 
   1239 int test_mm256_testc_pd(__m256d A, __m256d B) {
   1240   // CHECK-LABEL: test_mm256_testc_pd
   1241   // CHECK: call i32 @llvm.x86.avx.vtestc.pd.256(<4 x double> %{{.*}}, <4 x double> %{{.*}})
   1242   return _mm256_testc_pd(A, B);
   1243 }
   1244 
   1245 int test_mm_testc_ps(__m128 A, __m128 B) {
   1246   // CHECK-LABEL: test_mm_testc_ps
   1247   // CHECK: call i32 @llvm.x86.avx.vtestc.ps(<4 x float> %{{.*}}, <4 x float> %{{.*}})
   1248   return _mm_testc_ps(A, B);
   1249 }
   1250 
   1251 int test_mm256_testc_ps(__m256 A, __m256 B) {
   1252   // CHECK-LABEL: test_mm256_testc_ps
   1253   // CHECK: call i32 @llvm.x86.avx.vtestc.ps.256(<8 x float> %{{.*}}, <8 x float> %{{.*}})
   1254   return _mm256_testc_ps(A, B);
   1255 }
   1256 
   1257 int test_mm256_testc_si256(__m256 A, __m256 B) {
   1258   // CHECK-LABEL: test_mm256_testc_si256
   1259   // CHECK: call i32 @llvm.x86.avx.ptestc.256(<4 x i64> %{{.*}}, <4 x i64> %{{.*}})
   1260   return _mm256_testc_si256(A, B);
   1261 }
   1262 
   1263 int test_mm_testnzc_pd(__m128d A, __m128d B) {
   1264   // CHECK-LABEL: test_mm_testnzc_pd
   1265   // CHECK: call i32 @llvm.x86.avx.vtestnzc.pd(<2 x double> %{{.*}}, <2 x double> %{{.*}})
   1266   return _mm_testnzc_pd(A, B);
   1267 }
   1268 
   1269 int test_mm256_testnzc_pd(__m256d A, __m256d B) {
   1270   // CHECK-LABEL: test_mm256_testnzc_pd
   1271   // CHECK: call i32 @llvm.x86.avx.vtestnzc.pd.256(<4 x double> %{{.*}}, <4 x double> %{{.*}})
   1272   return _mm256_testnzc_pd(A, B);
   1273 }
   1274 
   1275 int test_mm_testnzc_ps(__m128 A, __m128 B) {
   1276   // CHECK-LABEL: test_mm_testnzc_ps
   1277   // CHECK: call i32 @llvm.x86.avx.vtestnzc.ps(<4 x float> %{{.*}}, <4 x float> %{{.*}})
   1278   return _mm_testnzc_ps(A, B);
   1279 }
   1280 
   1281 int test_mm256_testnzc_ps(__m256 A, __m256 B) {
   1282   // CHECK-LABEL: test_mm256_testnzc_ps
   1283   // CHECK: call i32 @llvm.x86.avx.vtestnzc.ps.256(<8 x float> %{{.*}}, <8 x float> %{{.*}})
   1284   return _mm256_testnzc_ps(A, B);
   1285 }
   1286 
   1287 int test_mm256_testnzc_si256(__m256 A, __m256 B) {
   1288   // CHECK-LABEL: test_mm256_testnzc_si256
   1289   // CHECK: call i32 @llvm.x86.avx.ptestnzc.256(<4 x i64> %{{.*}}, <4 x i64> %{{.*}})
   1290   return _mm256_testnzc_si256(A, B);
   1291 }
   1292 
   1293 int test_mm_testz_pd(__m128d A, __m128d B) {
   1294   // CHECK-LABEL: test_mm_testz_pd
   1295   // CHECK: call i32 @llvm.x86.avx.vtestz.pd(<2 x double> %{{.*}}, <2 x double> %{{.*}})
   1296   return _mm_testz_pd(A, B);
   1297 }
   1298 
   1299 int test_mm256_testz_pd(__m256d A, __m256d B) {
   1300   // CHECK-LABEL: test_mm256_testz_pd
   1301   // CHECK: call i32 @llvm.x86.avx.vtestz.pd.256(<4 x double> %{{.*}}, <4 x double> %{{.*}})
   1302   return _mm256_testz_pd(A, B);
   1303 }
   1304 
   1305 int test_mm_testz_ps(__m128 A, __m128 B) {
   1306   // CHECK-LABEL: test_mm_testz_ps
   1307   // CHECK: call i32 @llvm.x86.avx.vtestz.ps(<4 x float> %{{.*}}, <4 x float> %{{.*}})
   1308   return _mm_testz_ps(A, B);
   1309 }
   1310 
   1311 int test_mm256_testz_ps(__m256 A, __m256 B) {
   1312   // CHECK-LABEL: test_mm256_testz_ps
   1313   // CHECK: call i32 @llvm.x86.avx.vtestz.ps.256(<8 x float> %{{.*}}, <8 x float> %{{.*}})
   1314   return _mm256_testz_ps(A, B);
   1315 }
   1316 
   1317 int test_mm256_testz_si256(__m256 A, __m256 B) {
   1318   // CHECK-LABEL: test_mm256_testz_si256
   1319   // CHECK: call i32 @llvm.x86.avx.ptestz.256(<4 x i64> %{{.*}}, <4 x i64> %{{.*}})
   1320   return _mm256_testz_si256(A, B);
   1321 }
   1322 
   1323 __m256 test_mm256_undefined_ps() {
   1324   // CHECK-LABEL: @test_mm256_undefined_ps
   1325   // CHECK: ret <8 x float> undef
   1326   return _mm256_undefined_ps();
   1327 }
   1328 
   1329 __m256d test_mm256_undefined_pd() {
   1330   // CHECK-LABEL: @test_mm256_undefined_pd
   1331   // CHECK: ret <4 x double> undef
   1332   return _mm256_undefined_pd();
   1333 }
   1334 
   1335 __m256i test_mm256_undefined_si256() {
   1336   // CHECK-LABEL: @test_mm256_undefined_si256
   1337   // CHECK: ret <4 x i64> undef
   1338   return _mm256_undefined_si256();
   1339 }
   1340 
   1341 __m256d test_mm256_unpackhi_pd(__m256d A, __m256d B) {
   1342   // CHECK-LABEL: test_mm256_unpackhi_pd
   1343   // CHECK: shufflevector <4 x double> %{{.*}}, <4 x double> %{{.*}}, <4 x i32> <i32 1, i32 5, i32 3, i32 7>
   1344   return _mm256_unpackhi_pd(A, B);
   1345 }
   1346 
   1347 __m256 test_mm256_unpackhi_ps(__m256 A, __m256 B) {
   1348   // CHECK-LABEL: test_mm256_unpackhi_ps
   1349   // CHECK: shufflevector <8 x float> %{{.*}}, <8 x float> %{{.*}}, <8 x i32> <i32 2, i32 10, i32 3, i32 11, i32 6, i32 14, i32 7, i32 15>
   1350   return _mm256_unpackhi_ps(A, B);
   1351 }
   1352 
   1353 __m256d test_mm256_unpacklo_pd(__m256d A, __m256d B) {
   1354   // CHECK-LABEL: test_mm256_unpacklo_pd
   1355   // CHECK: shufflevector <4 x double> %{{.*}}, <4 x double> %{{.*}}, <4 x i32> <i32 0, i32 4, i32 2, i32 6>
   1356   return _mm256_unpacklo_pd(A, B);
   1357 }
   1358 
   1359 __m256 test_mm256_unpacklo_ps(__m256 A, __m256 B) {
   1360   // CHECK-LABEL: test_mm256_unpacklo_ps
   1361   // CHECK: shufflevector <8 x float> %{{.*}}, <8 x float> %{{.*}}, <8 x i32> <i32 0, i32 8, i32 1, i32 9, i32 4, i32 12, i32 5, i32 13>
   1362   return _mm256_unpacklo_ps(A, B);
   1363 }
   1364 
   1365 __m256d test_mm256_xor_pd(__m256d A, __m256d B) {
   1366   // CHECK-LABEL: test_mm256_xor_pd
   1367   // CHECK: xor <4 x i64>
   1368   return _mm256_xor_pd(A, B);
   1369 }
   1370 
   1371 __m256 test_mm256_xor_ps(__m256 A, __m256 B) {
   1372   // CHECK-LABEL: test_mm256_xor_ps
   1373   // CHECK: xor <8 x i32>
   1374   return _mm256_xor_ps(A, B);
   1375 }
   1376 
   1377 void test_mm256_zeroall() {
   1378   // CHECK-LABEL: test_mm256_zeroall
   1379   // CHECK: call void @llvm.x86.avx.vzeroall()
   1380   return _mm256_zeroall();
   1381 }
   1382 
   1383 void test_mm256_zeroupper() {
   1384   // CHECK-LABEL: test_mm256_zeroupper
   1385   // CHECK: call void @llvm.x86.avx.vzeroupper()
   1386   return _mm256_zeroupper();
   1387 }
   1388 
   1389 double test_mm256_cvtsd_f64(__m256d __a)
   1390 {
   1391  // CHECK-LABEL: @test_mm256_cvtsd_f64
   1392  // CHECK: extractelement <4 x double> %{{.*}}, i32 0
   1393  return _mm256_cvtsd_f64(__a);
   1394 }
   1395 
   1396 int test_mm256_cvtsi256_si32(__m256i __a)
   1397 {
   1398  // CHECK-LABEL: @test_mm256_cvtsi256_si32
   1399  // CHECK: extractelement <8 x i32> %{{.*}}, i32 0
   1400  return _mm256_cvtsi256_si32(__a);
   1401 }
   1402 
   1403 float test_mm256_cvtss_f32(__m256 __a)
   1404 {
   1405  // CHECK-LABEL: @test_mm256_cvtss_f32
   1406  // CHECK: extractelement <8 x float> %{{.*}}, i32 0
   1407  return _mm256_cvtss_f32(__a);
   1408 }
   1409