test/CodeGen/avx-builtins.c

   1 // RUN: %clang_cc1 -ffreestanding %s -triple=x86_64-apple-darwin -target-feature +avx -emit-llvm -o - -Wall -Werror | FileCheck %s
   2 // RUN: %clang_cc1 -ffreestanding %s -triple=x86_64-apple-darwin -target-feature +avx -fno-signed-char -emit-llvm -o - -Wall -Werror | FileCheck %s
   3
   4
   5 #include <x86intrin.h>
   6
   7 // NOTE: This should match the tests in llvm/test/CodeGen/X86/sse-intrinsics-fast-isel.ll
   8
   9 __m256d test_mm256_add_pd(__m256d A, __m256d B) {
  10   // CHECK-LABEL: test_mm256_add_pd
  11   // CHECK: fadd <4 x double>
  12   return _mm256_add_pd(A, B);
  13 }
  14
  15 __m256 test_mm256_add_ps(__m256 A, __m256 B) {
  16   // CHECK-LABEL: test_mm256_add_ps
  17   // CHECK: fadd <8 x float>
  18   return _mm256_add_ps(A, B);
  19 }
  20
  21 __m256d test_mm256_addsub_pd(__m256d A, __m256d B) {
  22   // CHECK-LABEL: test_mm256_addsub_pd
  23   // CHECK: call <4 x double> @llvm.x86.avx.addsub.pd.256(<4 x double> %{{.*}}, <4 x double> %{{.*}})
  24   return _mm256_addsub_pd(A, B);
  25 }
  26
  27 __m256 test_mm256_addsub_ps(__m256 A, __m256 B) {
  28   // CHECK-LABEL: test_mm256_addsub_ps
  29   // CHECK: call <8 x float> @llvm.x86.avx.addsub.ps.256(<8 x float> %{{.*}}, <8 x float> %{{.*}})
  30   return _mm256_addsub_ps(A, B);
  31 }
  32
  33 __m256d test_mm256_and_pd(__m256d A, __m256d B) {
  34   // CHECK-LABEL: test_mm256_and_pd
  35   // CHECK: and <4 x i64>
  36   return _mm256_and_pd(A, B);
  37 }
  38
  39 __m256 test_mm256_and_ps(__m256 A, __m256 B) {
  40   // CHECK-LABEL: test_mm256_and_ps
  41   // CHECK: and <8 x i32>
  42   return _mm256_and_ps(A, B);
  43 }
  44
  45 __m256d test_mm256_andnot_pd(__m256d A, __m256d B) {
  46   // CHECK-LABEL: test_mm256_andnot_pd
  47   // CHECK: xor <4 x i64> %{{.*}}, <i64 -1, i64 -1, i64 -1, i64 -1>
  48   // CHECK: and <4 x i64>
  49   return _mm256_andnot_pd(A, B);
  50 }
  51
  52 __m256 test_mm256_andnot_ps(__m256 A, __m256 B) {
  53   // CHECK-LABEL: test_mm256_andnot_ps
  54   // CHECK: xor <8 x i32> %{{.*}}, <i32 -1, i32 -1, i32 -1, i32 -1, i32 -1, i32 -1, i32 -1, i32 -1>
  55   // CHECK: and <8 x i32>
  56   return _mm256_andnot_ps(A, B);
  57 }
  58
  59 __m256d test_mm256_blend_pd(__m256d A, __m256d B) {
  60   // CHECK-LABEL: test_mm256_blend_pd
  61   // CHECK: shufflevector <4 x double> %{{.*}}, <4 x double> %{{.*}}, <4 x i32> <i32 4, i32 1, i32 6, i32 3>
  62   return _mm256_blend_pd(A, B, 0x35);
  63 }
  64
  65 __m256 test_mm256_blend_ps(__m256 A, __m256 B) {
  66   // CHECK-LABEL: test_mm256_blend_ps
  67   // 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>
  68   return _mm256_blend_ps(A, B, 0x35);
  69 }
  70
  71 __m256d test_mm256_blendv_pd(__m256d V1, __m256d V2, __m256d V3) {
  72   // CHECK-LABEL: test_mm256_blendv_pd
  73   // CHECK: call <4 x double> @llvm.x86.avx.blendv.pd.256(<4 x double> %{{.*}}, <4 x double> %{{.*}}, <4 x double> %{{.*}})
  74   return _mm256_blendv_pd(V1, V2, V3);
  75 }
  76
  77 __m256 test_mm256_blendv_ps(__m256 V1, __m256 V2, __m256 V3) {
  78   // CHECK-LABEL: test_mm256_blendv_ps
  79   // CHECK: call <8 x float> @llvm.x86.avx.blendv.ps.256(<8 x float> %{{.*}}, <8 x float> %{{.*}}, <8 x float> %{{.*}})
  80   return _mm256_blendv_ps(V1, V2, V3);
  81 }
  82
  83 __m256d test_mm256_broadcast_pd(__m128d* A) {
  84   // CHECK-LABEL: test_mm256_broadcast_pd
  85   // CHECK: load <2 x double>, <2 x double>* %{{.*}}, align 1{{$}}
  86   // CHECK: shufflevector <2 x double> %{{.*}}, <2 x double> %{{.*}}, <4 x i32> <i32 0, i32 1, i32 0, i32 1>
  87   return _mm256_broadcast_pd(A);
  88 }
  89
  90 __m256 test_mm256_broadcast_ps(__m128* A) {
  91   // CHECK-LABEL: test_mm256_broadcast_ps
  92   // CHECK: load <4 x float>, <4 x float>* %{{.*}}, align 1{{$}}
  93   // CHECK: shufflevector <4 x float> %{{.*}}, <4 x float> %{{.*}}, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 0, i32 1, i32 2, i32 3>
  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: call <4 x i32> @llvm.x86.avx.cvtt.pd2dq.256(<4 x double> %{{.*}})
 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: call <8 x i32> @llvm.x86.avx.cvtt.ps2dq.256(<8 x float> %{{.*}})
 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> zeroinitializer, <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> zeroinitializer, <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> zeroinitializer, <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> zeroinitializer, <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> zeroinitializer, <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> zeroinitializer, <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> zeroinitializer, <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> zeroinitializer, <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> zeroinitializer, <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> zeroinitializer, <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> zeroinitializer, <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> zeroinitializer
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> zeroinitializer
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> zeroinitializer
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 }