clang/test/CodeGen/X86/avx-builtins.c

   1 // RUN: %clang_cc1 -flax-vector-conversions=none -ffreestanding %s -triple=x86_64-apple-darwin -target-feature +avx -emit-llvm -o - -Wall -Werror | FileCheck %s --check-prefixes=CHECK,X64
   2 // RUN: %clang_cc1 -flax-vector-conversions=none -ffreestanding %s -triple=x86_64-apple-darwin -target-feature +avx -fno-signed-char -emit-llvm -o - -Wall -Werror | FileCheck %s --check-prefixes=CHECK,X64
   3 // RUN: %clang_cc1 -flax-vector-conversions=none -ffreestanding %s -triple=i386-apple-darwin -target-feature +avx -emit-llvm -o - -Wall -Werror | FileCheck %s --check-prefixes=CHECK,X86
   4 // RUN: %clang_cc1 -flax-vector-conversions=none -ffreestanding %s -triple=i386-apple-darwin -target-feature +avx -fno-signed-char -emit-llvm -o - -Wall -Werror | FileCheck %s --check-prefixes=CHECK,X86
   5 // RUN: %clang_cc1 -flax-vector-conversions=none -fms-extensions -fms-compatibility -ffreestanding %s -triple=x86_64-windows-msvc -target-feature +avx -emit-llvm -o - -Wall -Werror | FileCheck %s --check-prefixes=CHECK,X64
   6
   7
   8 #include <immintrin.h>
   9
  10 // NOTE: This should match the tests in llvm/test/CodeGen/X86/sse-intrinsics-fast-isel.ll
  11
  12 __m256d test_mm256_add_pd(__m256d A, __m256d B) {
  13   // CHECK-LABEL: test_mm256_add_pd
  14   // CHECK: fadd <4 x double>
  15   return _mm256_add_pd(A, B);
  16 }
  17
  18 __m256 test_mm256_add_ps(__m256 A, __m256 B) {
  19   // CHECK-LABEL: test_mm256_add_ps
  20   // CHECK: fadd <8 x float>
  21   return _mm256_add_ps(A, B);
  22 }
  23
  24 __m256d test_mm256_addsub_pd(__m256d A, __m256d B) {
  25   // CHECK-LABEL: test_mm256_addsub_pd
  26   // CHECK: call <4 x double> @llvm.x86.avx.addsub.pd.256(<4 x double> %{{.*}}, <4 x double> %{{.*}})
  27   return _mm256_addsub_pd(A, B);
  28 }
  29
  30 __m256 test_mm256_addsub_ps(__m256 A, __m256 B) {
  31   // CHECK-LABEL: test_mm256_addsub_ps
  32   // CHECK: call <8 x float> @llvm.x86.avx.addsub.ps.256(<8 x float> %{{.*}}, <8 x float> %{{.*}})
  33   return _mm256_addsub_ps(A, B);
  34 }
  35
  36 __m256d test_mm256_and_pd(__m256d A, __m256d B) {
  37   // CHECK-LABEL: test_mm256_and_pd
  38   // CHECK: and <4 x i64>
  39   return _mm256_and_pd(A, B);
  40 }
  41
  42 __m256 test_mm256_and_ps(__m256 A, __m256 B) {
  43   // CHECK-LABEL: test_mm256_and_ps
  44   // CHECK: and <8 x i32>
  45   return _mm256_and_ps(A, B);
  46 }
  47
  48 __m256d test_mm256_andnot_pd(__m256d A, __m256d B) {
  49   // CHECK-LABEL: test_mm256_andnot_pd
  50   // CHECK: xor <4 x i64> %{{.*}}, <i64 -1, i64 -1, i64 -1, i64 -1>
  51   // CHECK: and <4 x i64>
  52   return _mm256_andnot_pd(A, B);
  53 }
  54
  55 __m256 test_mm256_andnot_ps(__m256 A, __m256 B) {
  56   // CHECK-LABEL: test_mm256_andnot_ps
  57   // CHECK: xor <8 x i32> %{{.*}}, <i32 -1, i32 -1, i32 -1, i32 -1, i32 -1, i32 -1, i32 -1, i32 -1>
  58   // CHECK: and <8 x i32>
  59   return _mm256_andnot_ps(A, B);
  60 }
  61
  62 __m256d test_mm256_blend_pd(__m256d A, __m256d B) {
  63   // CHECK-LABEL: test_mm256_blend_pd
  64   // CHECK: shufflevector <4 x double> %{{.*}}, <4 x double> %{{.*}}, <4 x i32> <i32 4, i32 1, i32 6, i32 3>
  65   return _mm256_blend_pd(A, B, 0x05);
  66 }
  67
  68 __m256 test_mm256_blend_ps(__m256 A, __m256 B) {
  69   // CHECK-LABEL: test_mm256_blend_ps
  70   // 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>
  71   return _mm256_blend_ps(A, B, 0x35);
  72 }
  73
  74 __m256d test_mm256_blendv_pd(__m256d V1, __m256d V2, __m256d V3) {
  75   // CHECK-LABEL: test_mm256_blendv_pd
  76   // CHECK: call <4 x double> @llvm.x86.avx.blendv.pd.256(<4 x double> %{{.*}}, <4 x double> %{{.*}}, <4 x double> %{{.*}})
  77   return _mm256_blendv_pd(V1, V2, V3);
  78 }
  79
  80 __m256 test_mm256_blendv_ps(__m256 V1, __m256 V2, __m256 V3) {
  81   // CHECK-LABEL: test_mm256_blendv_ps
  82   // CHECK: call <8 x float> @llvm.x86.avx.blendv.ps.256(<8 x float> %{{.*}}, <8 x float> %{{.*}}, <8 x float> %{{.*}})
  83   return _mm256_blendv_ps(V1, V2, V3);
  84 }
  85
  86 __m256d test_mm256_broadcast_pd(__m128d* A) {
  87   // CHECK-LABEL: test_mm256_broadcast_pd
  88   // CHECK: load <2 x double>, ptr %{{.*}}, align 1{{$}}
  89   // CHECK: shufflevector <2 x double> %{{.*}}, <2 x double> %{{.*}}, <4 x i32> <i32 0, i32 1, i32 0, i32 1>
  90   return _mm256_broadcast_pd(A);
  91 }
  92
  93 __m256 test_mm256_broadcast_ps(__m128* A) {
  94   // CHECK-LABEL: test_mm256_broadcast_ps
  95   // CHECK: load <4 x float>, ptr %{{.*}}, align 1{{$}}
  96   // 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>
  97   return _mm256_broadcast_ps(A);
  98 }
  99
 100 __m256d test_mm256_broadcast_sd(double* A) {
 101   // CHECK-LABEL: test_mm256_broadcast_sd
 102   // CHECK: load double, ptr %{{.*}}, align 1{{$}}
 103   // CHECK: insertelement <4 x double> undef, double %{{.*}}, i32 0
 104   // CHECK: insertelement <4 x double> %{{.*}}, double %{{.*}}, i32 1
 105   // CHECK: insertelement <4 x double> %{{.*}}, double %{{.*}}, i32 2
 106   // CHECK: insertelement <4 x double> %{{.*}}, double %{{.*}}, i32 3
 107   return _mm256_broadcast_sd(A);
 108 }
 109
 110 __m128 test_mm_broadcast_ss(float* A) {
 111   // CHECK-LABEL: test_mm_broadcast_ss
 112   // CHECK: load float, ptr %{{.*}}, align 1{{$}}
 113   // CHECK: insertelement <4 x float> undef, float %{{.*}}, i32 0
 114   // CHECK: insertelement <4 x float> %{{.*}}, float %{{.*}}, i32 1
 115   // CHECK: insertelement <4 x float> %{{.*}}, float %{{.*}}, i32 2
 116   // CHECK: insertelement <4 x float> %{{.*}}, float %{{.*}}, i32 3
 117   return _mm_broadcast_ss(A);
 118 }
 119
 120 __m256 test_mm256_broadcast_ss(float* A) {
 121   // CHECK-LABEL: test_mm256_broadcast_ss
 122   // CHECK: load float, ptr %{{.*}}, align 1{{$}}
 123   // CHECK: insertelement <8 x float> undef, float %{{.*}}, i32 0
 124   // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 1
 125   // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 2
 126   // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 3
 127   // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 4
 128   // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 5
 129   // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 6
 130   // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 7
 131   return _mm256_broadcast_ss(A);
 132 }
 133
 134 __m256 test_mm256_castpd_ps(__m256d A) {
 135   // CHECK-LABEL: test_mm256_castpd_ps
 136   return _mm256_castpd_ps(A);
 137 }
 138
 139 __m256i test_mm256_castpd_si256(__m256d A) {
 140   // CHECK-LABEL: test_mm256_castpd_si256
 141   return _mm256_castpd_si256(A);
 142 }
 143
 144 __m256d test_mm256_castpd128_pd256(__m128d A) {
 145   // CHECK-LABEL: test_mm256_castpd128_pd256
 146   // CHECK: [[A:%.*]] = freeze <2 x double> poison
 147   // CHECK: shufflevector <2 x double> %{{.*}}, <2 x double> [[A]], <4 x i32> <i32 0, i32 1, i32 2, i32 3>
 148   return _mm256_castpd128_pd256(A);
 149 }
 150
 151 __m128d test_mm256_castpd256_pd128(__m256d A) {
 152   // CHECK-LABEL: test_mm256_castpd256_pd128
 153   // CHECK: shufflevector <4 x double> %{{.*}}, <4 x double> %{{.*}}, <2 x i32> <i32 0, i32 1>
 154   return _mm256_castpd256_pd128(A);
 155 }
 156
 157 __m256d test_mm256_castps_pd(__m256 A) {
 158   // CHECK-LABEL: test_mm256_castps_pd
 159   return _mm256_castps_pd(A);
 160 }
 161
 162 __m256i test_mm256_castps_si256(__m256 A) {
 163   // CHECK-LABEL: test_mm256_castps_si256
 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: [[A:%.*]] = freeze <4 x float> poison
 170   // CHECK: shufflevector <4 x float> %{{.*}}, <4 x float> [[A]], <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7>
 171   return _mm256_castps128_ps256(A);
 172 }
 173
 174 __m128 test_mm256_castps256_ps128(__m256 A) {
 175   // CHECK-LABEL: test_mm256_castps256_ps128
 176   // CHECK: shufflevector <8 x float> %{{.*}}, <8 x float> %{{.*}}, <4 x i32> <i32 0, i32 1, i32 2, i32 3>
 177   return _mm256_castps256_ps128(A);
 178 }
 179
 180 __m256i test_mm256_castsi128_si256(__m128i A) {
 181   // CHECK-LABEL: test_mm256_castsi128_si256
 182   // CHECK: [[A:%.*]] = freeze <2 x i64> poison
 183   // CHECK: shufflevector <2 x i64> %{{.*}}, <2 x i64> [[A]], <4 x i32> <i32 0, i32 1, i32 2, i32 3>
 184   return _mm256_castsi128_si256(A);
 185 }
 186
 187 __m256d test_mm256_castsi256_pd(__m256i A) {
 188   // CHECK-LABEL: test_mm256_castsi256_pd
 189   return _mm256_castsi256_pd(A);
 190 }
 191
 192 __m256 test_mm256_castsi256_ps(__m256i A) {
 193   // CHECK-LABEL: test_mm256_castsi256_ps
 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 __m256d test_mm256_cmp_pd_eq_oq(__m256d a, __m256d b) {
 216   // CHECK-LABEL: test_mm256_cmp_pd_eq_oq
 217   // CHECK: fcmp oeq <4 x double> %{{.*}}, %{{.*}}
 218   return _mm256_cmp_pd(a, b, _CMP_EQ_OQ);
 219 }
 220
 221 __m256d test_mm256_cmp_pd_lt_os(__m256d a, __m256d b) {
 222   // CHECK-LABEL: test_mm256_cmp_pd_lt_os
 223   // CHECK: fcmp olt <4 x double> %{{.*}}, %{{.*}}
 224   return _mm256_cmp_pd(a, b, _CMP_LT_OS);
 225 }
 226
 227 __m256d test_mm256_cmp_pd_le_os(__m256d a, __m256d b) {
 228   // CHECK-LABEL: test_mm256_cmp_pd_le_os
 229   // CHECK: fcmp ole <4 x double> %{{.*}}, %{{.*}}
 230   return _mm256_cmp_pd(a, b, _CMP_LE_OS);
 231 }
 232
 233 __m256d test_mm256_cmp_pd_unord_q(__m256d a, __m256d b) {
 234   // CHECK-LABEL: test_mm256_cmp_pd_unord_q
 235   // CHECK: fcmp uno <4 x double> %{{.*}}, %{{.*}}
 236   return _mm256_cmp_pd(a, b, _CMP_UNORD_Q);
 237 }
 238
 239 __m256d test_mm256_cmp_pd_neq_uq(__m256d a, __m256d b) {
 240   // CHECK-LABEL: test_mm256_cmp_pd_neq_uq
 241   // CHECK: fcmp une <4 x double> %{{.*}}, %{{.*}}
 242   return _mm256_cmp_pd(a, b, _CMP_NEQ_UQ);
 243 }
 244
 245 __m256d test_mm256_cmp_pd_nlt_us(__m256d a, __m256d b) {
 246   // CHECK-LABEL: test_mm256_cmp_pd_nlt_us
 247   // CHECK: fcmp uge <4 x double> %{{.*}}, %{{.*}}
 248   return _mm256_cmp_pd(a, b, _CMP_NLT_US);
 249 }
 250
 251 __m256d test_mm256_cmp_pd_nle_us(__m256d a, __m256d b) {
 252   // CHECK-LABEL: test_mm256_cmp_pd_nle_us
 253   // CHECK: fcmp ugt <4 x double> %{{.*}}, %{{.*}}
 254   return _mm256_cmp_pd(a, b, _CMP_NLE_US);
 255 }
 256
 257 __m256d test_mm256_cmp_pd_ord_q(__m256d a, __m256d b) {
 258   // CHECK-LABEL: test_mm256_cmp_pd_ord_q
 259   // CHECK: fcmp ord <4 x double> %{{.*}}, %{{.*}}
 260   return _mm256_cmp_pd(a, b, _CMP_ORD_Q);
 261 }
 262
 263 __m256d test_mm256_cmp_pd_eq_uq(__m256d a, __m256d b) {
 264   // CHECK-LABEL: test_mm256_cmp_pd_eq_uq
 265   // CHECK: fcmp ueq <4 x double> %{{.*}}, %{{.*}}
 266   return _mm256_cmp_pd(a, b, _CMP_EQ_UQ);
 267 }
 268
 269 __m256d test_mm256_cmp_pd_nge_us(__m256d a, __m256d b) {
 270   // CHECK-LABEL: test_mm256_cmp_pd_nge_us
 271   // CHECK: fcmp ult <4 x double> %{{.*}}, %{{.*}}
 272   return _mm256_cmp_pd(a, b, _CMP_NGE_US);
 273 }
 274
 275 __m256d test_mm256_cmp_pd_ngt_us(__m256d a, __m256d b) {
 276   // CHECK-LABEL: test_mm256_cmp_pd_ngt_us
 277   // CHECK: fcmp ule <4 x double> %{{.*}}, %{{.*}}
 278   return _mm256_cmp_pd(a, b, _CMP_NGT_US);
 279 }
 280
 281 __m256d test_mm256_cmp_pd_false_oq(__m256d a, __m256d b) {
 282   // CHECK-LABEL: test_mm256_cmp_pd_false_oq
 283   // CHECK: fcmp false <4 x double> %{{.*}}, %{{.*}}
 284   return _mm256_cmp_pd(a, b, _CMP_FALSE_OQ);
 285 }
 286
 287 __m256d test_mm256_cmp_pd_neq_oq(__m256d a, __m256d b) {
 288   // CHECK-LABEL: test_mm256_cmp_pd_neq_oq
 289   // CHECK: fcmp one <4 x double> %{{.*}}, %{{.*}}
 290   return _mm256_cmp_pd(a, b, _CMP_NEQ_OQ);
 291 }
 292
 293 __m256d test_mm256_cmp_pd_ge_os(__m256d a, __m256d b) {
 294   // CHECK-LABEL: test_mm256_cmp_pd_ge_os
 295   // CHECK: fcmp oge <4 x double> %{{.*}}, %{{.*}}
 296   return _mm256_cmp_pd(a, b, _CMP_GE_OS);
 297 }
 298
 299 __m256d test_mm256_cmp_pd_gt_os(__m256d a, __m256d b) {
 300   // CHECK-LABEL: test_mm256_cmp_pd_gt_os
 301   // CHECK: fcmp ogt <4 x double> %{{.*}}, %{{.*}}
 302   return _mm256_cmp_pd(a, b, _CMP_GT_OS);
 303 }
 304
 305 __m256d test_mm256_cmp_pd_true_uq(__m256d a, __m256d b) {
 306   // CHECK-LABEL: test_mm256_cmp_pd_true_uq
 307   // CHECK: fcmp true <4 x double> %{{.*}}, %{{.*}}
 308   return _mm256_cmp_pd(a, b, _CMP_TRUE_UQ);
 309 }
 310
 311 __m256d test_mm256_cmp_pd_eq_os(__m256d a, __m256d b) {
 312   // CHECK-LABEL: test_mm256_cmp_pd_eq_os
 313   // CHECK: fcmp oeq <4 x double> %{{.*}}, %{{.*}}
 314   return _mm256_cmp_pd(a, b, _CMP_EQ_OS);
 315 }
 316
 317 __m256d test_mm256_cmp_pd_lt_oq(__m256d a, __m256d b) {
 318   // CHECK-LABEL: test_mm256_cmp_pd_lt_oq
 319   // CHECK: fcmp olt <4 x double> %{{.*}}, %{{.*}}
 320   return _mm256_cmp_pd(a, b, _CMP_LT_OQ);
 321 }
 322
 323 __m256d test_mm256_cmp_pd_le_oq(__m256d a, __m256d b) {
 324   // CHECK-LABEL: test_mm256_cmp_pd_le_oq
 325   // CHECK: fcmp ole <4 x double> %{{.*}}, %{{.*}}
 326   return _mm256_cmp_pd(a, b, _CMP_LE_OQ);
 327 }
 328
 329 __m256d test_mm256_cmp_pd_unord_s(__m256d a, __m256d b) {
 330   // CHECK-LABEL: test_mm256_cmp_pd_unord_s
 331   // CHECK: fcmp uno <4 x double> %{{.*}}, %{{.*}}
 332   return _mm256_cmp_pd(a, b, _CMP_UNORD_S);
 333 }
 334
 335 __m256d test_mm256_cmp_pd_neq_us(__m256d a, __m256d b) {
 336   // CHECK-LABEL: test_mm256_cmp_pd_neq_us
 337   // CHECK: fcmp une <4 x double> %{{.*}}, %{{.*}}
 338   return _mm256_cmp_pd(a, b, _CMP_NEQ_US);
 339 }
 340
 341 __m256d test_mm256_cmp_pd_nlt_uq(__m256d a, __m256d b) {
 342   // CHECK-LABEL: test_mm256_cmp_pd_nlt_uq
 343   // CHECK: fcmp uge <4 x double> %{{.*}}, %{{.*}}
 344   return _mm256_cmp_pd(a, b, _CMP_NLT_UQ);
 345 }
 346
 347 __m256d test_mm256_cmp_pd_nle_uq(__m256d a, __m256d b) {
 348   // CHECK-LABEL: test_mm256_cmp_pd_nle_uq
 349   // CHECK: fcmp ugt <4 x double> %{{.*}}, %{{.*}}
 350   return _mm256_cmp_pd(a, b, _CMP_NLE_UQ);
 351 }
 352
 353 __m256d test_mm256_cmp_pd_ord_s(__m256d a, __m256d b) {
 354   // CHECK-LABEL: test_mm256_cmp_pd_ord_s
 355   // CHECK: fcmp ord <4 x double> %{{.*}}, %{{.*}}
 356   return _mm256_cmp_pd(a, b, _CMP_ORD_S);
 357 }
 358
 359 __m256d test_mm256_cmp_pd_eq_us(__m256d a, __m256d b) {
 360   // CHECK-LABEL: test_mm256_cmp_pd_eq_us
 361   // CHECK: fcmp ueq <4 x double> %{{.*}}, %{{.*}}
 362   return _mm256_cmp_pd(a, b, _CMP_EQ_US);
 363 }
 364
 365 __m256d test_mm256_cmp_pd_nge_uq(__m256d a, __m256d b) {
 366   // CHECK-LABEL: test_mm256_cmp_pd_nge_uq
 367   // CHECK: fcmp ult <4 x double> %{{.*}}, %{{.*}}
 368   return _mm256_cmp_pd(a, b, _CMP_NGE_UQ);
 369 }
 370
 371 __m256d test_mm256_cmp_pd_ngt_uq(__m256d a, __m256d b) {
 372   // CHECK-LABEL: test_mm256_cmp_pd_ngt_uq
 373   // CHECK: fcmp ule <4 x double> %{{.*}}, %{{.*}}
 374   return _mm256_cmp_pd(a, b, _CMP_NGT_UQ);
 375 }
 376
 377 __m256d test_mm256_cmp_pd_false_os(__m256d a, __m256d b) {
 378   // CHECK-LABEL: test_mm256_cmp_pd_false_os
 379   // CHECK: fcmp false <4 x double> %{{.*}}, %{{.*}}
 380   return _mm256_cmp_pd(a, b, _CMP_FALSE_OS);
 381 }
 382
 383 __m256d test_mm256_cmp_pd_neq_os(__m256d a, __m256d b) {
 384   // CHECK-LABEL: test_mm256_cmp_pd_neq_os
 385   // CHECK: fcmp one <4 x double> %{{.*}}, %{{.*}}
 386   return _mm256_cmp_pd(a, b, _CMP_NEQ_OS);
 387 }
 388
 389 __m256d test_mm256_cmp_pd_ge_oq(__m256d a, __m256d b) {
 390   // CHECK-LABEL: test_mm256_cmp_pd_ge_oq
 391   // CHECK: fcmp oge <4 x double> %{{.*}}, %{{.*}}
 392   return _mm256_cmp_pd(a, b, _CMP_GE_OQ);
 393 }
 394
 395 __m256d test_mm256_cmp_pd_gt_oq(__m256d a, __m256d b) {
 396   // CHECK-LABEL: test_mm256_cmp_pd_gt_oq
 397   // CHECK: fcmp ogt <4 x double> %{{.*}}, %{{.*}}
 398   return _mm256_cmp_pd(a, b, _CMP_GT_OQ);
 399 }
 400
 401 __m256d test_mm256_cmp_pd_true_us(__m256d a, __m256d b) {
 402   // CHECK-LABEL: test_mm256_cmp_pd_true_us
 403   // CHECK: fcmp true <4 x double> %{{.*}}, %{{.*}}
 404   return _mm256_cmp_pd(a, b, _CMP_TRUE_US);
 405 }
 406
 407 __m256 test_mm256_cmp_ps_eq_oq(__m256 a, __m256 b) {
 408   // CHECK-LABEL: test_mm256_cmp_ps_eq_oq
 409   // CHECK: fcmp oeq <8 x float> %{{.*}}, %{{.*}}
 410   return _mm256_cmp_ps(a, b, _CMP_EQ_OQ);
 411 }
 412
 413 __m256 test_mm256_cmp_ps_lt_os(__m256 a, __m256 b) {
 414   // CHECK-LABEL: test_mm256_cmp_ps_lt_os
 415   // CHECK: fcmp olt <8 x float> %{{.*}}, %{{.*}}
 416   return _mm256_cmp_ps(a, b, _CMP_LT_OS);
 417 }
 418
 419 __m256 test_mm256_cmp_ps_le_os(__m256 a, __m256 b) {
 420   // CHECK-LABEL: test_mm256_cmp_ps_le_os
 421   // CHECK: fcmp ole <8 x float> %{{.*}}, %{{.*}}
 422   return _mm256_cmp_ps(a, b, _CMP_LE_OS);
 423 }
 424
 425 __m256 test_mm256_cmp_ps_unord_q(__m256 a, __m256 b) {
 426   // CHECK-LABEL: test_mm256_cmp_ps_unord_q
 427   // CHECK: fcmp uno <8 x float> %{{.*}}, %{{.*}}
 428   return _mm256_cmp_ps(a, b, _CMP_UNORD_Q);
 429 }
 430
 431 __m256 test_mm256_cmp_ps_neq_uq(__m256 a, __m256 b) {
 432   // CHECK-LABEL: test_mm256_cmp_ps_neq_uq
 433   // CHECK: fcmp une <8 x float> %{{.*}}, %{{.*}}
 434   return _mm256_cmp_ps(a, b, _CMP_NEQ_UQ);
 435 }
 436
 437 __m256 test_mm256_cmp_ps_nlt_us(__m256 a, __m256 b) {
 438   // CHECK-LABEL: test_mm256_cmp_ps_nlt_us
 439   // CHECK: fcmp uge <8 x float> %{{.*}}, %{{.*}}
 440   return _mm256_cmp_ps(a, b, _CMP_NLT_US);
 441 }
 442
 443 __m256 test_mm256_cmp_ps_nle_us(__m256 a, __m256 b) {
 444   // CHECK-LABEL: test_mm256_cmp_ps_nle_us
 445   // CHECK: fcmp ugt <8 x float> %{{.*}}, %{{.*}}
 446   return _mm256_cmp_ps(a, b, _CMP_NLE_US);
 447 }
 448
 449 __m256 test_mm256_cmp_ps_ord_q(__m256 a, __m256 b) {
 450   // CHECK-LABEL: test_mm256_cmp_ps_ord_q
 451   // CHECK: fcmp ord <8 x float> %{{.*}}, %{{.*}}
 452   return _mm256_cmp_ps(a, b, _CMP_ORD_Q);
 453 }
 454
 455 __m256 test_mm256_cmp_ps_eq_uq(__m256 a, __m256 b) {
 456   // CHECK-LABEL: test_mm256_cmp_ps_eq_uq
 457   // CHECK: fcmp ueq <8 x float> %{{.*}}, %{{.*}}
 458   return _mm256_cmp_ps(a, b, _CMP_EQ_UQ);
 459 }
 460
 461 __m256 test_mm256_cmp_ps_nge_us(__m256 a, __m256 b) {
 462   // CHECK-LABEL: test_mm256_cmp_ps_nge_us
 463   // CHECK: fcmp ult <8 x float> %{{.*}}, %{{.*}}
 464   return _mm256_cmp_ps(a, b, _CMP_NGE_US);
 465 }
 466
 467 __m256 test_mm256_cmp_ps_ngt_us(__m256 a, __m256 b) {
 468   // CHECK-LABEL: test_mm256_cmp_ps_ngt_us
 469   // CHECK: fcmp ule <8 x float> %{{.*}}, %{{.*}}
 470   return _mm256_cmp_ps(a, b, _CMP_NGT_US);
 471 }
 472
 473 __m256 test_mm256_cmp_ps_false_oq(__m256 a, __m256 b) {
 474   // CHECK-LABEL: test_mm256_cmp_ps_false_oq
 475   // CHECK: fcmp false <8 x float> %{{.*}}, %{{.*}}
 476   return _mm256_cmp_ps(a, b, _CMP_FALSE_OQ);
 477 }
 478
 479 __m256 test_mm256_cmp_ps_neq_oq(__m256 a, __m256 b) {
 480   // CHECK-LABEL: test_mm256_cmp_ps_neq_oq
 481   // CHECK: fcmp one <8 x float> %{{.*}}, %{{.*}}
 482   return _mm256_cmp_ps(a, b, _CMP_NEQ_OQ);
 483 }
 484
 485 __m256 test_mm256_cmp_ps_ge_os(__m256 a, __m256 b) {
 486   // CHECK-LABEL: test_mm256_cmp_ps_ge_os
 487   // CHECK: fcmp oge <8 x float> %{{.*}}, %{{.*}}
 488   return _mm256_cmp_ps(a, b, _CMP_GE_OS);
 489 }
 490
 491 __m256 test_mm256_cmp_ps_gt_os(__m256 a, __m256 b) {
 492   // CHECK-LABEL: test_mm256_cmp_ps_gt_os
 493   // CHECK: fcmp ogt <8 x float> %{{.*}}, %{{.*}}
 494   return _mm256_cmp_ps(a, b, _CMP_GT_OS);
 495 }
 496
 497 __m256 test_mm256_cmp_ps_true_uq(__m256 a, __m256 b) {
 498   // CHECK-LABEL: test_mm256_cmp_ps_true_uq
 499   // CHECK: fcmp true <8 x float> %{{.*}}, %{{.*}}
 500   return _mm256_cmp_ps(a, b, _CMP_TRUE_UQ);
 501 }
 502
 503 __m256 test_mm256_cmp_ps_eq_os(__m256 a, __m256 b) {
 504   // CHECK-LABEL: test_mm256_cmp_ps_eq_os
 505   // CHECK: fcmp oeq <8 x float> %{{.*}}, %{{.*}}
 506   return _mm256_cmp_ps(a, b, _CMP_EQ_OS);
 507 }
 508
 509 __m256 test_mm256_cmp_ps_lt_oq(__m256 a, __m256 b) {
 510   // CHECK-LABEL: test_mm256_cmp_ps_lt_oq
 511   // CHECK: fcmp olt <8 x float> %{{.*}}, %{{.*}}
 512   return _mm256_cmp_ps(a, b, _CMP_LT_OQ);
 513 }
 514
 515 __m256 test_mm256_cmp_ps_le_oq(__m256 a, __m256 b) {
 516   // CHECK-LABEL: test_mm256_cmp_ps_le_oq
 517   // CHECK: fcmp ole <8 x float> %{{.*}}, %{{.*}}
 518   return _mm256_cmp_ps(a, b, _CMP_LE_OQ);
 519 }
 520
 521 __m256 test_mm256_cmp_ps_unord_s(__m256 a, __m256 b) {
 522   // CHECK-LABEL: test_mm256_cmp_ps_unord_s
 523   // CHECK: fcmp uno <8 x float> %{{.*}}, %{{.*}}
 524   return _mm256_cmp_ps(a, b, _CMP_UNORD_S);
 525 }
 526
 527 __m256 test_mm256_cmp_ps_neq_us(__m256 a, __m256 b) {
 528   // CHECK-LABEL: test_mm256_cmp_ps_neq_us
 529   // CHECK: fcmp une <8 x float> %{{.*}}, %{{.*}}
 530   return _mm256_cmp_ps(a, b, _CMP_NEQ_US);
 531 }
 532
 533 __m256 test_mm256_cmp_ps_nlt_uq(__m256 a, __m256 b) {
 534   // CHECK-LABEL: test_mm256_cmp_ps_nlt_uq
 535   // CHECK: fcmp uge <8 x float> %{{.*}}, %{{.*}}
 536   return _mm256_cmp_ps(a, b, _CMP_NLT_UQ);
 537 }
 538
 539 __m256 test_mm256_cmp_ps_nle_uq(__m256 a, __m256 b) {
 540   // CHECK-LABEL: test_mm256_cmp_ps_nle_uq
 541   // CHECK: fcmp ugt <8 x float> %{{.*}}, %{{.*}}
 542   return _mm256_cmp_ps(a, b, _CMP_NLE_UQ);
 543 }
 544
 545 __m256 test_mm256_cmp_ps_ord_s(__m256 a, __m256 b) {
 546   // CHECK-LABEL: test_mm256_cmp_ps_ord_s
 547   // CHECK: fcmp ord <8 x float> %{{.*}}, %{{.*}}
 548   return _mm256_cmp_ps(a, b, _CMP_ORD_S);
 549 }
 550
 551 __m256 test_mm256_cmp_ps_eq_us(__m256 a, __m256 b) {
 552   // CHECK-LABEL: test_mm256_cmp_ps_eq_us
 553   // CHECK: fcmp ueq <8 x float> %{{.*}}, %{{.*}}
 554   return _mm256_cmp_ps(a, b, _CMP_EQ_US);
 555 }
 556
 557 __m256 test_mm256_cmp_ps_nge_uq(__m256 a, __m256 b) {
 558   // CHECK-LABEL: test_mm256_cmp_ps_nge_uq
 559   // CHECK: fcmp ult <8 x float> %{{.*}}, %{{.*}}
 560   return _mm256_cmp_ps(a, b, _CMP_NGE_UQ);
 561 }
 562
 563 __m256 test_mm256_cmp_ps_ngt_uq(__m256 a, __m256 b) {
 564   // CHECK-LABEL: test_mm256_cmp_ps_ngt_uq
 565   // CHECK: fcmp ule <8 x float> %{{.*}}, %{{.*}}
 566   return _mm256_cmp_ps(a, b, _CMP_NGT_UQ);
 567 }
 568
 569 __m256 test_mm256_cmp_ps_false_os(__m256 a, __m256 b) {
 570   // CHECK-LABEL: test_mm256_cmp_ps_false_os
 571   // CHECK: fcmp false <8 x float> %{{.*}}, %{{.*}}
 572   return _mm256_cmp_ps(a, b, _CMP_FALSE_OS);
 573 }
 574
 575 __m256 test_mm256_cmp_ps_neq_os(__m256 a, __m256 b) {
 576   // CHECK-LABEL: test_mm256_cmp_ps_neq_os
 577   // CHECK: fcmp one <8 x float> %{{.*}}, %{{.*}}
 578   return _mm256_cmp_ps(a, b, _CMP_NEQ_OS);
 579 }
 580
 581 __m256 test_mm256_cmp_ps_ge_oq(__m256 a, __m256 b) {
 582   // CHECK-LABEL: test_mm256_cmp_ps_ge_oq
 583   // CHECK: fcmp oge <8 x float> %{{.*}}, %{{.*}}
 584   return _mm256_cmp_ps(a, b, _CMP_GE_OQ);
 585 }
 586
 587 __m256 test_mm256_cmp_ps_gt_oq(__m256 a, __m256 b) {
 588   // CHECK-LABEL: test_mm256_cmp_ps_gt_oq
 589   // CHECK: fcmp ogt <8 x float> %{{.*}}, %{{.*}}
 590   return _mm256_cmp_ps(a, b, _CMP_GT_OQ);
 591 }
 592
 593 __m256 test_mm256_cmp_ps_true_us(__m256 a, __m256 b) {
 594   // CHECK-LABEL: test_mm256_cmp_ps_true_us
 595   // CHECK: fcmp true <8 x float> %{{.*}}, %{{.*}}
 596   return _mm256_cmp_ps(a, b, _CMP_TRUE_US);
 597 }
 598
 599 __m128d test_mm_cmp_pd_eq_oq(__m128d a, __m128d b) {
 600   // CHECK-LABEL: test_mm_cmp_pd_eq_oq
 601   // CHECK: fcmp oeq <2 x double> %{{.*}}, %{{.*}}
 602   return _mm_cmp_pd(a, b, _CMP_EQ_OQ);
 603 }
 604
 605 __m128d test_mm_cmp_pd_lt_os(__m128d a, __m128d b) {
 606   // CHECK-LABEL: test_mm_cmp_pd_lt_os
 607   // CHECK: fcmp olt <2 x double> %{{.*}}, %{{.*}}
 608   return _mm_cmp_pd(a, b, _CMP_LT_OS);
 609 }
 610
 611 __m128d test_mm_cmp_pd_le_os(__m128d a, __m128d b) {
 612   // CHECK-LABEL: test_mm_cmp_pd_le_os
 613   // CHECK: fcmp ole <2 x double> %{{.*}}, %{{.*}}
 614   return _mm_cmp_pd(a, b, _CMP_LE_OS);
 615 }
 616
 617 __m128d test_mm_cmp_pd_unord_q(__m128d a, __m128d b) {
 618   // CHECK-LABEL: test_mm_cmp_pd_unord_q
 619   // CHECK: fcmp uno <2 x double> %{{.*}}, %{{.*}}
 620   return _mm_cmp_pd(a, b, _CMP_UNORD_Q);
 621 }
 622
 623 __m128d test_mm_cmp_pd_neq_uq(__m128d a, __m128d b) {
 624   // CHECK-LABEL: test_mm_cmp_pd_neq_uq
 625   // CHECK: fcmp une <2 x double> %{{.*}}, %{{.*}}
 626   return _mm_cmp_pd(a, b, _CMP_NEQ_UQ);
 627 }
 628
 629 __m128d test_mm_cmp_pd_nlt_us(__m128d a, __m128d b) {
 630   // CHECK-LABEL: test_mm_cmp_pd_nlt_us
 631   // CHECK: fcmp uge <2 x double> %{{.*}}, %{{.*}}
 632   return _mm_cmp_pd(a, b, _CMP_NLT_US);
 633 }
 634
 635 __m128d test_mm_cmp_pd_nle_us(__m128d a, __m128d b) {
 636   // CHECK-LABEL: test_mm_cmp_pd_nle_us
 637   // CHECK: fcmp ugt <2 x double> %{{.*}}, %{{.*}}
 638   return _mm_cmp_pd(a, b, _CMP_NLE_US);
 639 }
 640
 641 __m128d test_mm_cmp_pd_ord_q(__m128d a, __m128d b) {
 642   // CHECK-LABEL: test_mm_cmp_pd_ord_q
 643   // CHECK: fcmp ord <2 x double> %{{.*}}, %{{.*}}
 644   return _mm_cmp_pd(a, b, _CMP_ORD_Q);
 645 }
 646
 647 __m128d test_mm_cmp_pd_eq_uq(__m128d a, __m128d b) {
 648   // CHECK-LABEL: test_mm_cmp_pd_eq_uq
 649   // CHECK: fcmp ueq <2 x double> %{{.*}}, %{{.*}}
 650   return _mm_cmp_pd(a, b, _CMP_EQ_UQ);
 651 }
 652
 653 __m128d test_mm_cmp_pd_nge_us(__m128d a, __m128d b) {
 654   // CHECK-LABEL: test_mm_cmp_pd_nge_us
 655   // CHECK: fcmp ult <2 x double> %{{.*}}, %{{.*}}
 656   return _mm_cmp_pd(a, b, _CMP_NGE_US);
 657 }
 658
 659 __m128d test_mm_cmp_pd_ngt_us(__m128d a, __m128d b) {
 660   // CHECK-LABEL: test_mm_cmp_pd_ngt_us
 661   // CHECK: fcmp ule <2 x double> %{{.*}}, %{{.*}}
 662   return _mm_cmp_pd(a, b, _CMP_NGT_US);
 663 }
 664
 665 __m128d test_mm_cmp_pd_false_oq(__m128d a, __m128d b) {
 666   // CHECK-LABEL: test_mm_cmp_pd_false_oq
 667   // CHECK: fcmp false <2 x double> %{{.*}}, %{{.*}}
 668   return _mm_cmp_pd(a, b, _CMP_FALSE_OQ);
 669 }
 670
 671 __m128d test_mm_cmp_pd_neq_oq(__m128d a, __m128d b) {
 672   // CHECK-LABEL: test_mm_cmp_pd_neq_oq
 673   // CHECK: fcmp one <2 x double> %{{.*}}, %{{.*}}
 674   return _mm_cmp_pd(a, b, _CMP_NEQ_OQ);
 675 }
 676
 677 __m128d test_mm_cmp_pd_ge_os(__m128d a, __m128d b) {
 678   // CHECK-LABEL: test_mm_cmp_pd_ge_os
 679   // CHECK: fcmp oge <2 x double> %{{.*}}, %{{.*}}
 680   return _mm_cmp_pd(a, b, _CMP_GE_OS);
 681 }
 682
 683 __m128d test_mm_cmp_pd_gt_os(__m128d a, __m128d b) {
 684   // CHECK-LABEL: test_mm_cmp_pd_gt_os
 685   // CHECK: fcmp ogt <2 x double> %{{.*}}, %{{.*}}
 686   return _mm_cmp_pd(a, b, _CMP_GT_OS);
 687 }
 688
 689 __m128d test_mm_cmp_pd_true_uq(__m128d a, __m128d b) {
 690   // CHECK-LABEL: test_mm_cmp_pd_true_uq
 691   // CHECK: fcmp true <2 x double> %{{.*}}, %{{.*}}
 692   return _mm_cmp_pd(a, b, _CMP_TRUE_UQ);
 693 }
 694
 695 __m128d test_mm_cmp_pd_eq_os(__m128d a, __m128d b) {
 696   // CHECK-LABEL: test_mm_cmp_pd_eq_os
 697   // CHECK: fcmp oeq <2 x double> %{{.*}}, %{{.*}}
 698   return _mm_cmp_pd(a, b, _CMP_EQ_OS);
 699 }
 700
 701 __m128d test_mm_cmp_pd_lt_oq(__m128d a, __m128d b) {
 702   // CHECK-LABEL: test_mm_cmp_pd_lt_oq
 703   // CHECK: fcmp olt <2 x double> %{{.*}}, %{{.*}}
 704   return _mm_cmp_pd(a, b, _CMP_LT_OQ);
 705 }
 706
 707 __m128d test_mm_cmp_pd_le_oq(__m128d a, __m128d b) {
 708   // CHECK-LABEL: test_mm_cmp_pd_le_oq
 709   // CHECK: fcmp ole <2 x double> %{{.*}}, %{{.*}}
 710   return _mm_cmp_pd(a, b, _CMP_LE_OQ);
 711 }
 712
 713 __m128d test_mm_cmp_pd_unord_s(__m128d a, __m128d b) {
 714   // CHECK-LABEL: test_mm_cmp_pd_unord_s
 715   // CHECK: fcmp uno <2 x double> %{{.*}}, %{{.*}}
 716   return _mm_cmp_pd(a, b, _CMP_UNORD_S);
 717 }
 718
 719 __m128d test_mm_cmp_pd_neq_us(__m128d a, __m128d b) {
 720   // CHECK-LABEL: test_mm_cmp_pd_neq_us
 721   // CHECK: fcmp une <2 x double> %{{.*}}, %{{.*}}
 722   return _mm_cmp_pd(a, b, _CMP_NEQ_US);
 723 }
 724
 725 __m128d test_mm_cmp_pd_nlt_uq(__m128d a, __m128d b) {
 726   // CHECK-LABEL: test_mm_cmp_pd_nlt_uq
 727   // CHECK: fcmp uge <2 x double> %{{.*}}, %{{.*}}
 728   return _mm_cmp_pd(a, b, _CMP_NLT_UQ);
 729 }
 730
 731 __m128d test_mm_cmp_pd_nle_uq(__m128d a, __m128d b) {
 732   // CHECK-LABEL: test_mm_cmp_pd_nle_uq
 733   // CHECK: fcmp ugt <2 x double> %{{.*}}, %{{.*}}
 734   return _mm_cmp_pd(a, b, _CMP_NLE_UQ);
 735 }
 736
 737 __m128d test_mm_cmp_pd_ord_s(__m128d a, __m128d b) {
 738   // CHECK-LABEL: test_mm_cmp_pd_ord_s
 739   // CHECK: fcmp ord <2 x double> %{{.*}}, %{{.*}}
 740   return _mm_cmp_pd(a, b, _CMP_ORD_S);
 741 }
 742
 743 __m128d test_mm_cmp_pd_eq_us(__m128d a, __m128d b) {
 744   // CHECK-LABEL: test_mm_cmp_pd_eq_us
 745   // CHECK: fcmp ueq <2 x double> %{{.*}}, %{{.*}}
 746   return _mm_cmp_pd(a, b, _CMP_EQ_US);
 747 }
 748
 749 __m128d test_mm_cmp_pd_nge_uq(__m128d a, __m128d b) {
 750   // CHECK-LABEL: test_mm_cmp_pd_nge_uq
 751   // CHECK: fcmp ult <2 x double> %{{.*}}, %{{.*}}
 752   return _mm_cmp_pd(a, b, _CMP_NGE_UQ);
 753 }
 754
 755 __m128d test_mm_cmp_pd_ngt_uq(__m128d a, __m128d b) {
 756   // CHECK-LABEL: test_mm_cmp_pd_ngt_uq
 757   // CHECK: fcmp ule <2 x double> %{{.*}}, %{{.*}}
 758   return _mm_cmp_pd(a, b, _CMP_NGT_UQ);
 759 }
 760
 761 __m128d test_mm_cmp_pd_false_os(__m128d a, __m128d b) {
 762   // CHECK-LABEL: test_mm_cmp_pd_false_os
 763   // CHECK: fcmp false <2 x double> %{{.*}}, %{{.*}}
 764   return _mm_cmp_pd(a, b, _CMP_FALSE_OS);
 765 }
 766
 767 __m128d test_mm_cmp_pd_neq_os(__m128d a, __m128d b) {
 768   // CHECK-LABEL: test_mm_cmp_pd_neq_os
 769   // CHECK: fcmp one <2 x double> %{{.*}}, %{{.*}}
 770   return _mm_cmp_pd(a, b, _CMP_NEQ_OS);
 771 }
 772
 773 __m128d test_mm_cmp_pd_ge_oq(__m128d a, __m128d b) {
 774   // CHECK-LABEL: test_mm_cmp_pd_ge_oq
 775   // CHECK: fcmp oge <2 x double> %{{.*}}, %{{.*}}
 776   return _mm_cmp_pd(a, b, _CMP_GE_OQ);
 777 }
 778
 779 __m128d test_mm_cmp_pd_gt_oq(__m128d a, __m128d b) {
 780   // CHECK-LABEL: test_mm_cmp_pd_gt_oq
 781   // CHECK: fcmp ogt <2 x double> %{{.*}}, %{{.*}}
 782   return _mm_cmp_pd(a, b, _CMP_GT_OQ);
 783 }
 784
 785 __m128d test_mm_cmp_pd_true_us(__m128d a, __m128d b) {
 786   // CHECK-LABEL: test_mm_cmp_pd_true_us
 787   // CHECK: fcmp true <2 x double> %{{.*}}, %{{.*}}
 788   return _mm_cmp_pd(a, b, _CMP_TRUE_US);
 789 }
 790
 791 __m128 test_mm_cmp_ps_eq_oq(__m128 a, __m128 b) {
 792   // CHECK-LABEL: test_mm_cmp_ps_eq_oq
 793   // CHECK: fcmp oeq <4 x float> %{{.*}}, %{{.*}}
 794   return _mm_cmp_ps(a, b, _CMP_EQ_OQ);
 795 }
 796
 797 __m128 test_mm_cmp_ps_lt_os(__m128 a, __m128 b) {
 798   // CHECK-LABEL: test_mm_cmp_ps_lt_os
 799   // CHECK: fcmp olt <4 x float> %{{.*}}, %{{.*}}
 800   return _mm_cmp_ps(a, b, _CMP_LT_OS);
 801 }
 802
 803 __m128 test_mm_cmp_ps_le_os(__m128 a, __m128 b) {
 804   // CHECK-LABEL: test_mm_cmp_ps_le_os
 805   // CHECK: fcmp ole <4 x float> %{{.*}}, %{{.*}}
 806   return _mm_cmp_ps(a, b, _CMP_LE_OS);
 807 }
 808
 809 __m128 test_mm_cmp_ps_unord_q(__m128 a, __m128 b) {
 810   // CHECK-LABEL: test_mm_cmp_ps_unord_q
 811   // CHECK: fcmp uno <4 x float> %{{.*}}, %{{.*}}
 812   return _mm_cmp_ps(a, b, _CMP_UNORD_Q);
 813 }
 814
 815 __m128 test_mm_cmp_ps_neq_uq(__m128 a, __m128 b) {
 816   // CHECK-LABEL: test_mm_cmp_ps_neq_uq
 817   // CHECK: fcmp une <4 x float> %{{.*}}, %{{.*}}
 818   return _mm_cmp_ps(a, b, _CMP_NEQ_UQ);
 819 }
 820
 821 __m128 test_mm_cmp_ps_nlt_us(__m128 a, __m128 b) {
 822   // CHECK-LABEL: test_mm_cmp_ps_nlt_us
 823   // CHECK: fcmp uge <4 x float> %{{.*}}, %{{.*}}
 824   return _mm_cmp_ps(a, b, _CMP_NLT_US);
 825 }
 826
 827 __m128 test_mm_cmp_ps_nle_us(__m128 a, __m128 b) {
 828   // CHECK-LABEL: test_mm_cmp_ps_nle_us
 829   // CHECK: fcmp ugt <4 x float> %{{.*}}, %{{.*}}
 830   return _mm_cmp_ps(a, b, _CMP_NLE_US);
 831 }
 832
 833 __m128 test_mm_cmp_ps_ord_q(__m128 a, __m128 b) {
 834   // CHECK-LABEL: test_mm_cmp_ps_ord_q
 835   // CHECK: fcmp ord <4 x float> %{{.*}}, %{{.*}}
 836   return _mm_cmp_ps(a, b, _CMP_ORD_Q);
 837 }
 838
 839 __m128 test_mm_cmp_ps_eq_uq(__m128 a, __m128 b) {
 840   // CHECK-LABEL: test_mm_cmp_ps_eq_uq
 841   // CHECK: fcmp ueq <4 x float> %{{.*}}, %{{.*}}
 842   return _mm_cmp_ps(a, b, _CMP_EQ_UQ);
 843 }
 844
 845 __m128 test_mm_cmp_ps_nge_us(__m128 a, __m128 b) {
 846   // CHECK-LABEL: test_mm_cmp_ps_nge_us
 847   // CHECK: fcmp ult <4 x float> %{{.*}}, %{{.*}}
 848   return _mm_cmp_ps(a, b, _CMP_NGE_US);
 849 }
 850
 851 __m128 test_mm_cmp_ps_ngt_us(__m128 a, __m128 b) {
 852   // CHECK-LABEL: test_mm_cmp_ps_ngt_us
 853   // CHECK: fcmp ule <4 x float> %{{.*}}, %{{.*}}
 854   return _mm_cmp_ps(a, b, _CMP_NGT_US);
 855 }
 856
 857 __m128 test_mm_cmp_ps_false_oq(__m128 a, __m128 b) {
 858   // CHECK-LABEL: test_mm_cmp_ps_false_oq
 859   // CHECK: fcmp false <4 x float> %{{.*}}, %{{.*}}
 860   return _mm_cmp_ps(a, b, _CMP_FALSE_OQ);
 861 }
 862
 863 __m128 test_mm_cmp_ps_neq_oq(__m128 a, __m128 b) {
 864   // CHECK-LABEL: test_mm_cmp_ps_neq_oq
 865   // CHECK: fcmp one <4 x float> %{{.*}}, %{{.*}}
 866   return _mm_cmp_ps(a, b, _CMP_NEQ_OQ);
 867 }
 868
 869 __m128 test_mm_cmp_ps_ge_os(__m128 a, __m128 b) {
 870   // CHECK-LABEL: test_mm_cmp_ps_ge_os
 871   // CHECK: fcmp oge <4 x float> %{{.*}}, %{{.*}}
 872   return _mm_cmp_ps(a, b, _CMP_GE_OS);
 873 }
 874
 875 __m128 test_mm_cmp_ps_gt_os(__m128 a, __m128 b) {
 876   // CHECK-LABEL: test_mm_cmp_ps_gt_os
 877   // CHECK: fcmp ogt <4 x float> %{{.*}}, %{{.*}}
 878   return _mm_cmp_ps(a, b, _CMP_GT_OS);
 879 }
 880
 881 __m128 test_mm_cmp_ps_true_uq(__m128 a, __m128 b) {
 882   // CHECK-LABEL: test_mm_cmp_ps_true_uq
 883   // CHECK: fcmp true <4 x float> %{{.*}}, %{{.*}}
 884   return _mm_cmp_ps(a, b, _CMP_TRUE_UQ);
 885 }
 886
 887 __m128 test_mm_cmp_ps_eq_os(__m128 a, __m128 b) {
 888   // CHECK-LABEL: test_mm_cmp_ps_eq_os
 889   // CHECK: fcmp oeq <4 x float> %{{.*}}, %{{.*}}
 890   return _mm_cmp_ps(a, b, _CMP_EQ_OS);
 891 }
 892
 893 __m128 test_mm_cmp_ps_lt_oq(__m128 a, __m128 b) {
 894   // CHECK-LABEL: test_mm_cmp_ps_lt_oq
 895   // CHECK: fcmp olt <4 x float> %{{.*}}, %{{.*}}
 896   return _mm_cmp_ps(a, b, _CMP_LT_OQ);
 897 }
 898
 899 __m128 test_mm_cmp_ps_le_oq(__m128 a, __m128 b) {
 900   // CHECK-LABEL: test_mm_cmp_ps_le_oq
 901   // CHECK: fcmp ole <4 x float> %{{.*}}, %{{.*}}
 902   return _mm_cmp_ps(a, b, _CMP_LE_OQ);
 903 }
 904
 905 __m128 test_mm_cmp_ps_unord_s(__m128 a, __m128 b) {
 906   // CHECK-LABEL: test_mm_cmp_ps_unord_s
 907   // CHECK: fcmp uno <4 x float> %{{.*}}, %{{.*}}
 908   return _mm_cmp_ps(a, b, _CMP_UNORD_S);
 909 }
 910
 911 __m128 test_mm_cmp_ps_neq_us(__m128 a, __m128 b) {
 912   // CHECK-LABEL: test_mm_cmp_ps_neq_us
 913   // CHECK: fcmp une <4 x float> %{{.*}}, %{{.*}}
 914   return _mm_cmp_ps(a, b, _CMP_NEQ_US);
 915 }
 916
 917 __m128 test_mm_cmp_ps_nlt_uq(__m128 a, __m128 b) {
 918   // CHECK-LABEL: test_mm_cmp_ps_nlt_uq
 919   // CHECK: fcmp uge <4 x float> %{{.*}}, %{{.*}}
 920   return _mm_cmp_ps(a, b, _CMP_NLT_UQ);
 921 }
 922
 923 __m128 test_mm_cmp_ps_nle_uq(__m128 a, __m128 b) {
 924   // CHECK-LABEL: test_mm_cmp_ps_nle_uq
 925   // CHECK: fcmp ugt <4 x float> %{{.*}}, %{{.*}}
 926   return _mm_cmp_ps(a, b, _CMP_NLE_UQ);
 927 }
 928
 929 __m128 test_mm_cmp_ps_ord_s(__m128 a, __m128 b) {
 930   // CHECK-LABEL: test_mm_cmp_ps_ord_s
 931   // CHECK: fcmp ord <4 x float> %{{.*}}, %{{.*}}
 932   return _mm_cmp_ps(a, b, _CMP_ORD_S);
 933 }
 934
 935 __m128 test_mm_cmp_ps_eq_us(__m128 a, __m128 b) {
 936   // CHECK-LABEL: test_mm_cmp_ps_eq_us
 937   // CHECK: fcmp ueq <4 x float> %{{.*}}, %{{.*}}
 938   return _mm_cmp_ps(a, b, _CMP_EQ_US);
 939 }
 940
 941 __m128 test_mm_cmp_ps_nge_uq(__m128 a, __m128 b) {
 942   // CHECK-LABEL: test_mm_cmp_ps_nge_uq
 943   // CHECK: fcmp ult <4 x float> %{{.*}}, %{{.*}}
 944   return _mm_cmp_ps(a, b, _CMP_NGE_UQ);
 945 }
 946
 947 __m128 test_mm_cmp_ps_ngt_uq(__m128 a, __m128 b) {
 948   // CHECK-LABEL: test_mm_cmp_ps_ngt_uq
 949   // CHECK: fcmp ule <4 x float> %{{.*}}, %{{.*}}
 950   return _mm_cmp_ps(a, b, _CMP_NGT_UQ);
 951 }
 952
 953 __m128 test_mm_cmp_ps_false_os(__m128 a, __m128 b) {
 954   // CHECK-LABEL: test_mm_cmp_ps_false_os
 955   // CHECK: fcmp false <4 x float> %{{.*}}, %{{.*}}
 956   return _mm_cmp_ps(a, b, _CMP_FALSE_OS);
 957 }
 958
 959 __m128 test_mm_cmp_ps_neq_os(__m128 a, __m128 b) {
 960   // CHECK-LABEL: test_mm_cmp_ps_neq_os
 961   // CHECK: fcmp one <4 x float> %{{.*}}, %{{.*}}
 962   return _mm_cmp_ps(a, b, _CMP_NEQ_OS);
 963 }
 964
 965 __m128 test_mm_cmp_ps_ge_oq(__m128 a, __m128 b) {
 966   // CHECK-LABEL: test_mm_cmp_ps_ge_oq
 967   // CHECK: fcmp oge <4 x float> %{{.*}}, %{{.*}}
 968   return _mm_cmp_ps(a, b, _CMP_GE_OQ);
 969 }
 970
 971 __m128 test_mm_cmp_ps_gt_oq(__m128 a, __m128 b) {
 972   // CHECK-LABEL: test_mm_cmp_ps_gt_oq
 973   // CHECK: fcmp ogt <4 x float> %{{.*}}, %{{.*}}
 974   return _mm_cmp_ps(a, b, _CMP_GT_OQ);
 975 }
 976
 977 __m128 test_mm_cmp_ps_true_us(__m128 a, __m128 b) {
 978   // CHECK-LABEL: test_mm_cmp_ps_true_us
 979   // CHECK: fcmp true <4 x float> %{{.*}}, %{{.*}}
 980   return _mm_cmp_ps(a, b, _CMP_TRUE_US);
 981 }
 982
 983 __m128d test_mm_cmp_sd(__m128d A, __m128d B) {
 984   // CHECK-LABEL: test_mm_cmp_sd
 985   // CHECK: call <2 x double> @llvm.x86.sse2.cmp.sd(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i8 13)
 986   return _mm_cmp_sd(A, B, _CMP_GE_OS);
 987 }
 988
 989 __m128 test_mm_cmp_ss(__m128 A, __m128 B) {
 990   // CHECK-LABEL: test_mm_cmp_ss
 991   // CHECK: call <4 x float> @llvm.x86.sse.cmp.ss(<4 x float> %{{.*}}, <4 x float> %{{.*}}, i8 13)
 992   return _mm_cmp_ss(A, B, _CMP_GE_OS);
 993 }
 994
 995 __m256d test_mm256_cvtepi32_pd(__m128i A) {
 996   // CHECK-LABEL: test_mm256_cvtepi32_pd
 997   // CHECK: sitofp <4 x i32> %{{.*}} to <4 x double>
 998   return _mm256_cvtepi32_pd(A);
 999 }
1000
1001 __m256 test_mm256_cvtepi32_ps(__m256i A) {
1002   // CHECK-LABEL: test_mm256_cvtepi32_ps
1003   // CHECK: sitofp <8 x i32> %{{.*}} to <8 x float>
1004   return _mm256_cvtepi32_ps(A);
1005 }
1006
1007 __m128i test_mm256_cvtpd_epi32(__m256d A) {
1008   // CHECK-LABEL: test_mm256_cvtpd_epi32
1009   // CHECK: call <4 x i32> @llvm.x86.avx.cvt.pd2dq.256(<4 x double> %{{.*}})
1010   return _mm256_cvtpd_epi32(A);
1011 }
1012
1013 __m128 test_mm256_cvtpd_ps(__m256d A) {
1014   // CHECK-LABEL: test_mm256_cvtpd_ps
1015   // CHECK: call <4 x float> @llvm.x86.avx.cvt.pd2.ps.256(<4 x double> %{{.*}})
1016   return _mm256_cvtpd_ps(A);
1017 }
1018
1019 __m256i test_mm256_cvtps_epi32(__m256 A) {
1020   // CHECK-LABEL: test_mm256_cvtps_epi32
1021   // CHECK: call <8 x i32> @llvm.x86.avx.cvt.ps2dq.256(<8 x float> %{{.*}})
1022   return _mm256_cvtps_epi32(A);
1023 }
1024
1025 __m256d test_mm256_cvtps_pd(__m128 A) {
1026   // CHECK-LABEL: test_mm256_cvtps_pd
1027   // CHECK: fpext <4 x float> %{{.*}} to <4 x double>
1028   return _mm256_cvtps_pd(A);
1029 }
1030
1031 __m128i test_mm256_cvttpd_epi32(__m256d A) {
1032   // CHECK-LABEL: test_mm256_cvttpd_epi32
1033   // CHECK: call <4 x i32> @llvm.x86.avx.cvtt.pd2dq.256(<4 x double> %{{.*}})
1034   return _mm256_cvttpd_epi32(A);
1035 }
1036
1037 __m256i test_mm256_cvttps_epi32(__m256 A) {
1038   // CHECK-LABEL: test_mm256_cvttps_epi32
1039   // CHECK: call <8 x i32> @llvm.x86.avx.cvtt.ps2dq.256(<8 x float> %{{.*}})
1040   return _mm256_cvttps_epi32(A);
1041 }
1042
1043 __m256d test_mm256_div_pd(__m256d A, __m256d B) {
1044   // CHECK-LABEL: test_mm256_div_pd
1045   // CHECK: fdiv <4 x double>
1046   return _mm256_div_pd(A, B);
1047 }
1048
1049 __m256 test_mm256_div_ps(__m256 A, __m256 B) {
1050   // CHECK-LABEL: test_mm256_div_ps
1051   // CHECK: fdiv <8 x float>
1052   return _mm256_div_ps(A, B);
1053 }
1054
1055 __m256 test_mm256_dp_ps(__m256 A, __m256 B) {
1056   // CHECK-LABEL: test_mm256_dp_ps
1057   // CHECK: call <8 x float> @llvm.x86.avx.dp.ps.256(<8 x float> {{.*}}, <8 x float> {{.*}}, i8 7)
1058   return _mm256_dp_ps(A, B, 7);
1059 }
1060
1061 int test_mm256_extract_epi8(__m256i A) {
1062   // CHECK-LABEL: test_mm256_extract_epi8
1063   // CHECK: extractelement <32 x i8> %{{.*}}, {{i32|i64}} 31
1064   // CHECK: zext i8 %{{.*}} to i32
1065   return _mm256_extract_epi8(A, 31);
1066 }
1067
1068 int test_mm256_extract_epi16(__m256i A) {
1069   // CHECK-LABEL: test_mm256_extract_epi16
1070   // CHECK: extractelement <16 x i16> %{{.*}}, {{i32|i64}} 15
1071   // CHECK: zext i16 %{{.*}} to i32
1072   return _mm256_extract_epi16(A, 15);
1073 }
1074
1075 int test_mm256_extract_epi32(__m256i A) {
1076   // CHECK-LABEL: test_mm256_extract_epi32
1077   // CHECK: extractelement <8 x i32> %{{.*}}, {{i32|i64}} 7
1078   return _mm256_extract_epi32(A, 7);
1079 }
1080
1081 #if __x86_64__
1082 long long test_mm256_extract_epi64(__m256i A) {
1083   // X64-LABEL: test_mm256_extract_epi64
1084   // X64: extractelement <4 x i64> %{{.*}}, {{i32|i64}} 3
1085   return _mm256_extract_epi64(A, 3);
1086 }
1087 #endif
1088
1089 __m128d test_mm256_extractf128_pd(__m256d A) {
1090   // CHECK-LABEL: test_mm256_extractf128_pd
1091   // CHECK: shufflevector <4 x double> %{{.*}}, <4 x double> poison, <2 x i32> <i32 2, i32 3>
1092   return _mm256_extractf128_pd(A, 1);
1093 }
1094
1095 __m128 test_mm256_extractf128_ps(__m256 A) {
1096   // CHECK-LABEL: test_mm256_extractf128_ps
1097   // CHECK: shufflevector <8 x float> %{{.*}}, <8 x float> poison, <4 x i32> <i32 4, i32 5, i32 6, i32 7>
1098   return _mm256_extractf128_ps(A, 1);
1099 }
1100
1101 __m128i test_mm256_extractf128_si256(__m256i A) {
1102   // CHECK-LABEL: test_mm256_extractf128_si256
1103   // CHECK: shufflevector <8 x i32> %{{.*}}, <8 x i32> poison, <4 x i32> <i32 4, i32 5, i32 6, i32 7>
1104   return _mm256_extractf128_si256(A, 1);
1105 }
1106
1107 __m256d test_mm256_floor_pd(__m256d x) {
1108   // CHECK-LABEL: test_mm256_floor_pd
1109   // CHECK: call <4 x double> @llvm.x86.avx.round.pd.256(<4 x double> %{{.*}}, i32 1)
1110   return _mm256_floor_pd(x);
1111 }
1112
1113 __m256 test_mm_floor_ps(__m256 x) {
1114   // CHECK-LABEL: test_mm_floor_ps
1115   // CHECK: call <8 x float> @llvm.x86.avx.round.ps.256(<8 x float> %{{.*}}, i32 1)
1116   return _mm256_floor_ps(x);
1117 }
1118
1119 __m256d test_mm256_hadd_pd(__m256d A, __m256d B) {
1120   // CHECK-LABEL: test_mm256_hadd_pd
1121   // CHECK: call <4 x double> @llvm.x86.avx.hadd.pd.256(<4 x double> %{{.*}}, <4 x double> %{{.*}})
1122   return _mm256_hadd_pd(A, B);
1123 }
1124
1125 __m256 test_mm256_hadd_ps(__m256 A, __m256 B) {
1126   // CHECK-LABEL: test_mm256_hadd_ps
1127   // CHECK: call <8 x float> @llvm.x86.avx.hadd.ps.256(<8 x float> %{{.*}}, <8 x float> %{{.*}})
1128   return _mm256_hadd_ps(A, B);
1129 }
1130
1131 __m256d test_mm256_hsub_pd(__m256d A, __m256d B) {
1132   // CHECK-LABEL: test_mm256_hsub_pd
1133   // CHECK: call <4 x double> @llvm.x86.avx.hsub.pd.256(<4 x double> %{{.*}}, <4 x double> %{{.*}})
1134   return _mm256_hsub_pd(A, B);
1135 }
1136
1137 __m256 test_mm256_hsub_ps(__m256 A, __m256 B) {
1138   // CHECK-LABEL: test_mm256_hsub_ps
1139   // CHECK: call <8 x float> @llvm.x86.avx.hsub.ps.256(<8 x float> %{{.*}}, <8 x float> %{{.*}})
1140   return _mm256_hsub_ps(A, B);
1141 }
1142
1143 __m256i test_mm256_insert_epi8(__m256i x, char b) {
1144   // CHECK-LABEL: test_mm256_insert_epi8
1145   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, {{i32|i64}} 14
1146   return _mm256_insert_epi8(x, b, 14);
1147 }
1148
1149 __m256i test_mm256_insert_epi16(__m256i x, int b) {
1150   // CHECK-LABEL: test_mm256_insert_epi16
1151   // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, {{i32|i64}} 4
1152   return _mm256_insert_epi16(x, b, 4);
1153 }
1154
1155 __m256i test_mm256_insert_epi32(__m256i x, int b) {
1156   // CHECK-LABEL: test_mm256_insert_epi32
1157   // CHECK: insertelement <8 x i32> %{{.*}}, i32 %{{.*}}, {{i32|i64}} 5
1158   return _mm256_insert_epi32(x, b, 5);
1159 }
1160
1161 #if __x86_64__
1162 __m256i test_mm256_insert_epi64(__m256i x, long long b) {
1163   // X64-LABEL: test_mm256_insert_epi64
1164   // X64: insertelement <4 x i64> %{{.*}}, i64 %{{.*}}, {{i32|i64}} 2
1165   return _mm256_insert_epi64(x, b, 2);
1166 }
1167 #endif
1168
1169 __m256d test_mm256_insertf128_pd(__m256d A, __m128d B) {
1170   // CHECK-LABEL: test_mm256_insertf128_pd
1171   // CHECK: shufflevector <2 x double> %{{.*}}, <2 x double> poison, <4 x i32> <i32 0, i32 1, i32 2, i32 3>
1172   // CHECK: shufflevector <4 x double> %{{.*}}, <4 x double> %{{.*}}, <4 x i32> <i32 4, i32 5, i32 2, i32 3>
1173   return _mm256_insertf128_pd(A, B, 0);
1174 }
1175
1176 __m256 test_mm256_insertf128_ps(__m256 A, __m128 B) {
1177   // CHECK-LABEL: test_mm256_insertf128_ps
1178   // CHECK: shufflevector <4 x float> %{{.*}}, <4 x float> poison, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7>
1179   // 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>
1180   return _mm256_insertf128_ps(A, B, 1);
1181 }
1182
1183 __m256i test_mm256_insertf128_si256(__m256i A, __m128i B) {
1184   // CHECK-LABEL: test_mm256_insertf128_si256
1185   // CHECK: shufflevector <4 x i32> %{{.*}}, <4 x i32> poison, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7>
1186   // CHECK: shufflevector <8 x i32> %{{.*}}, <8 x i32> %{{.*}}, <8 x i32> <i32 8, i32 9, i32 10, i32 11, i32 4, i32 5, i32 6, i32 7>
1187   return _mm256_insertf128_si256(A, B, 0);
1188 }
1189
1190 __m256i test_mm256_lddqu_si256(__m256i* A) {
1191   // CHECK-LABEL: test_mm256_lddqu_si256
1192   // CHECK: call <32 x i8> @llvm.x86.avx.ldu.dq.256(ptr %{{.*}})
1193   return _mm256_lddqu_si256(A);
1194 }
1195
1196 __m256d test_mm256_load_pd(double* A) {
1197   // CHECK-LABEL: test_mm256_load_pd
1198   // CHECK: load <4 x double>, ptr %{{.*}}, align 32
1199   return _mm256_load_pd(A);
1200 }
1201
1202 __m256 test_mm256_load_ps(float* A) {
1203   // CHECK-LABEL: test_mm256_load_ps
1204   // CHECK: load <8 x float>, ptr %{{.*}}, align 32
1205   return _mm256_load_ps(A);
1206 }
1207
1208 __m256i test_mm256_load_si256(__m256i* A) {
1209   // CHECK-LABEL: test_mm256_load_si256
1210   // CHECK: load <4 x i64>, ptr %{{.*}}, align 32
1211   return _mm256_load_si256(A);
1212 }
1213
1214 __m256d test_mm256_loadu_pd(double* A) {
1215   // CHECK-LABEL: test_mm256_loadu_pd
1216   // CHECK: load <4 x double>, ptr %{{.*}}, align 1{{$}}
1217   return _mm256_loadu_pd(A);
1218 }
1219
1220 __m256 test_mm256_loadu_ps(float* A) {
1221   // CHECK-LABEL: test_mm256_loadu_ps
1222   // CHECK: load <8 x float>, ptr %{{.*}}, align 1{{$}}
1223   return _mm256_loadu_ps(A);
1224 }
1225
1226 __m256i test_mm256_loadu_si256(__m256i* A) {
1227   // CHECK-LABEL: test_mm256_loadu_si256
1228   // CHECK: load <4 x i64>, ptr %{{.+}}, align 1{{$}}
1229   return _mm256_loadu_si256(A);
1230 }
1231
1232 __m256 test_mm256_loadu2_m128(float* A, float* B) {
1233   // CHECK-LABEL: test_mm256_loadu2_m128
1234   // CHECK: load <4 x float>, ptr %{{.*}}, align 1{{$}}
1235   // CHECK: load <4 x float>, ptr %{{.*}}, align 1{{$}}
1236   // 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>
1237   return _mm256_loadu2_m128(A, B);
1238 }
1239
1240 __m256d test_mm256_loadu2_m128d(double* A, double* B) {
1241   // CHECK-LABEL: test_mm256_loadu2_m128d
1242   // CHECK: load <2 x double>, ptr %{{.*}}, align 1{{$}}
1243   // CHECK: load <2 x double>, ptr %{{.*}}, align 1{{$}}
1244   // CHECK: shufflevector <2 x double> %{{.*}}, <2 x double> %{{.*}}, <4 x i32> <i32 0, i32 1, i32 2, i32 3>
1245   return _mm256_loadu2_m128d(A, B);
1246 }
1247
1248 __m256i test_mm256_loadu2_m128i(__m128i* A, __m128i* B) {
1249   // CHECK-LABEL: test_mm256_loadu2_m128i
1250   // CHECK: load <2 x i64>, ptr %{{.*}}, align 1{{$}}
1251   // CHECK: load <2 x i64>, ptr %{{.*}}, align 1{{$}}
1252   // CHECK: shufflevector <2 x i64> %{{.*}}, <2 x i64> %{{.*}}, <4 x i32> <i32 0, i32 1, i32 2, i32 3>
1253   return _mm256_loadu2_m128i(A, B);
1254 }
1255
1256 __m128d test_mm_maskload_pd(double* A, __m128i B) {
1257   // CHECK-LABEL: test_mm_maskload_pd
1258   // CHECK: call <2 x double> @llvm.x86.avx.maskload.pd(ptr %{{.*}}, <2 x i64> %{{.*}})
1259   return _mm_maskload_pd(A, B);
1260 }
1261
1262 __m256d test_mm256_maskload_pd(double* A, __m256i B) {
1263   // CHECK-LABEL: test_mm256_maskload_pd
1264   // CHECK: call <4 x double> @llvm.x86.avx.maskload.pd.256(ptr %{{.*}}, <4 x i64> %{{.*}})
1265   return _mm256_maskload_pd(A, B);
1266 }
1267
1268 __m128 test_mm_maskload_ps(float* A, __m128i B) {
1269   // CHECK-LABEL: test_mm_maskload_ps
1270   // CHECK: call <4 x float> @llvm.x86.avx.maskload.ps(ptr %{{.*}}, <4 x i32> %{{.*}})
1271   return _mm_maskload_ps(A, B);
1272 }
1273
1274 __m256 test_mm256_maskload_ps(float* A, __m256i B) {
1275   // CHECK-LABEL: test_mm256_maskload_ps
1276   // CHECK: call <8 x float> @llvm.x86.avx.maskload.ps.256(ptr %{{.*}}, <8 x i32> %{{.*}})
1277   return _mm256_maskload_ps(A, B);
1278 }
1279
1280 void test_mm_maskstore_pd(double* A, __m128i B, __m128d C) {
1281   // CHECK-LABEL: test_mm_maskstore_pd
1282   // CHECK: call void @llvm.x86.avx.maskstore.pd(ptr %{{.*}}, <2 x i64> %{{.*}}, <2 x double> %{{.*}})
1283   _mm_maskstore_pd(A, B, C);
1284 }
1285
1286 void test_mm256_maskstore_pd(double* A, __m256i B, __m256d C) {
1287   // CHECK-LABEL: test_mm256_maskstore_pd
1288   // CHECK: call void @llvm.x86.avx.maskstore.pd.256(ptr %{{.*}}, <4 x i64> %{{.*}}, <4 x double> %{{.*}})
1289   _mm256_maskstore_pd(A, B, C);
1290 }
1291
1292 void test_mm_maskstore_ps(float* A, __m128i B, __m128 C) {
1293   // CHECK-LABEL: test_mm_maskstore_ps
1294   // CHECK: call void @llvm.x86.avx.maskstore.ps(ptr %{{.*}}, <4 x i32> %{{.*}}, <4 x float> %{{.*}})
1295   _mm_maskstore_ps(A, B, C);
1296 }
1297
1298 void test_mm256_maskstore_ps(float* A, __m256i B, __m256 C) {
1299   // CHECK-LABEL: test_mm256_maskstore_ps
1300   // CHECK: call void @llvm.x86.avx.maskstore.ps.256(ptr %{{.*}}, <8 x i32> %{{.*}}, <8 x float> %{{.*}})
1301   _mm256_maskstore_ps(A, B, C);
1302 }
1303
1304 __m256d test_mm256_max_pd(__m256d A, __m256d B) {
1305   // CHECK-LABEL: test_mm256_max_pd
1306   // CHECK: call <4 x double> @llvm.x86.avx.max.pd.256(<4 x double> %{{.*}}, <4 x double> %{{.*}})
1307   return _mm256_max_pd(A, B);
1308 }
1309
1310 __m256 test_mm256_max_ps(__m256 A, __m256 B) {
1311   // CHECK-LABEL: test_mm256_max_ps
1312   // CHECK: call <8 x float> @llvm.x86.avx.max.ps.256(<8 x float> %{{.*}}, <8 x float> %{{.*}})
1313   return _mm256_max_ps(A, B);
1314 }
1315
1316 __m256d test_mm256_min_pd(__m256d A, __m256d B) {
1317   // CHECK-LABEL: test_mm256_min_pd
1318   // CHECK: call <4 x double> @llvm.x86.avx.min.pd.256(<4 x double> %{{.*}}, <4 x double> %{{.*}})
1319   return _mm256_min_pd(A, B);
1320 }
1321
1322 __m256 test_mm256_min_ps(__m256 A, __m256 B) {
1323   // CHECK-LABEL: test_mm256_min_ps
1324   // CHECK: call <8 x float> @llvm.x86.avx.min.ps.256(<8 x float> %{{.*}}, <8 x float> %{{.*}})
1325   return _mm256_min_ps(A, B);
1326 }
1327
1328 __m256d test_mm256_movedup_pd(__m256d A) {
1329   // CHECK-LABEL: test_mm256_movedup_pd
1330   // CHECK: shufflevector <4 x double> %{{.*}}, <4 x double> %{{.*}}, <4 x i32> <i32 0, i32 0, i32 2, i32 2>
1331   return _mm256_movedup_pd(A);
1332 }
1333
1334 __m256 test_mm256_movehdup_ps(__m256 A) {
1335   // CHECK-LABEL: test_mm256_movehdup_ps
1336   // 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>
1337   return _mm256_movehdup_ps(A);
1338 }
1339
1340 __m256 test_mm256_moveldup_ps(__m256 A) {
1341   // CHECK-LABEL: test_mm256_moveldup_ps
1342   // 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>
1343   return _mm256_moveldup_ps(A);
1344 }
1345
1346 int test_mm256_movemask_pd(__m256d A) {
1347   // CHECK-LABEL: test_mm256_movemask_pd
1348   // CHECK: call i32 @llvm.x86.avx.movmsk.pd.256(<4 x double> %{{.*}})
1349   return _mm256_movemask_pd(A);
1350 }
1351
1352 int test_mm256_movemask_ps(__m256 A) {
1353   // CHECK-LABEL: test_mm256_movemask_ps
1354   // CHECK: call i32 @llvm.x86.avx.movmsk.ps.256(<8 x float> %{{.*}})
1355   return _mm256_movemask_ps(A);
1356 }
1357
1358 __m256d test_mm256_mul_pd(__m256d A, __m256d B) {
1359   // CHECK-LABEL: test_mm256_mul_pd
1360   // CHECK: fmul <4 x double>
1361   return _mm256_mul_pd(A, B);
1362 }
1363
1364 __m256 test_mm256_mul_ps(__m256 A, __m256 B) {
1365   // CHECK-LABEL: test_mm256_mul_ps
1366   // CHECK: fmul <8 x float>
1367   return _mm256_mul_ps(A, B);
1368 }
1369
1370 __m256d test_mm256_or_pd(__m256d A, __m256d B) {
1371   // CHECK-LABEL: test_mm256_or_pd
1372   // CHECK: or <4 x i64>
1373   return _mm256_or_pd(A, B);
1374 }
1375
1376 __m256 test_mm256_or_ps(__m256 A, __m256 B) {
1377   // CHECK-LABEL: test_mm256_or_ps
1378   // CHECK: or <8 x i32>
1379   return _mm256_or_ps(A, B);
1380 }
1381
1382 __m128d test_mm_permute_pd(__m128d A) {
1383   // CHECK-LABEL: test_mm_permute_pd
1384   // CHECK: shufflevector <2 x double> %{{.*}}, <2 x double> poison, <2 x i32> <i32 1, i32 0>
1385   return _mm_permute_pd(A, 1);
1386 }
1387
1388 __m256d test_mm256_permute_pd(__m256d A) {
1389   // CHECK-LABEL: test_mm256_permute_pd
1390   // CHECK: shufflevector <4 x double> %{{.*}}, <4 x double> poison, <4 x i32> <i32 1, i32 0, i32 3, i32 2>
1391   return _mm256_permute_pd(A, 5);
1392 }
1393
1394 __m128 test_mm_permute_ps(__m128 A) {
1395   // CHECK-LABEL: test_mm_permute_ps
1396   // CHECK: shufflevector <4 x float> %{{.*}}, <4 x float> poison, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
1397   return _mm_permute_ps(A, 0x1b);
1398 }
1399
1400 // Test case for PR12401
1401 __m128 test2_mm_permute_ps(__m128 a) {
1402   // CHECK-LABEL: test2_mm_permute_ps
1403   // CHECK: shufflevector <4 x float> %{{.*}}, <4 x float> poison, <4 x i32> <i32 2, i32 1, i32 2, i32 3>
1404   return _mm_permute_ps(a, 0xe6);
1405 }
1406
1407 __m256 test_mm256_permute_ps(__m256 A) {
1408   // CHECK-LABEL: test_mm256_permute_ps
1409   // CHECK: shufflevector <8 x float> %{{.*}}, <8 x float> poison, <8 x i32> <i32 3, i32 2, i32 1, i32 0, i32 7, i32 6, i32 5, i32 4>
1410   return _mm256_permute_ps(A, 0x1b);
1411 }
1412
1413 __m256d test_mm256_permute2f128_pd(__m256d A, __m256d B) {
1414   // CHECK-LABEL: test_mm256_permute2f128_pd
1415   // CHECK: shufflevector <4 x double> %{{.*}}, <4 x double> %{{.*}}, <4 x i32> <i32 2, i32 3, i32 6, i32 7>
1416   return _mm256_permute2f128_pd(A, B, 0x31);
1417 }
1418
1419 __m256 test_mm256_permute2f128_ps(__m256 A, __m256 B) {
1420   // CHECK-LABEL: test_mm256_permute2f128_ps
1421   // CHECK: shufflevector <8 x float> %{{.*}}, <8 x float> %{{.*}}, <8 x i32> <i32 4, i32 5, i32 6, i32 7, i32 12, i32 13, i32 14, i32 15>
1422   return _mm256_permute2f128_ps(A, B, 0x13);
1423 }
1424
1425 __m256i test_mm256_permute2f128_si256(__m256i A, __m256i B) {
1426   // CHECK-LABEL: test_mm256_permute2f128_si256
1427   // CHECK: shufflevector <8 x i32> %{{.*}}, <8 x i32> %{{.*}}, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 8, i32 9, i32 10, i32 11>
1428   return _mm256_permute2f128_si256(A, B, 0x20);
1429 }
1430
1431 __m128d test_mm_permutevar_pd(__m128d A, __m128i B) {
1432   // CHECK-LABEL: test_mm_permutevar_pd
1433   // CHECK: call <2 x double> @llvm.x86.avx.vpermilvar.pd(<2 x double> %{{.*}}, <2 x i64> %{{.*}})
1434   return _mm_permutevar_pd(A, B);
1435 }
1436
1437 __m256d test_mm256_permutevar_pd(__m256d A, __m256i B) {
1438   // CHECK-LABEL: test_mm256_permutevar_pd
1439   // CHECK: call <4 x double> @llvm.x86.avx.vpermilvar.pd.256(<4 x double> %{{.*}}, <4 x i64> %{{.*}})
1440   return _mm256_permutevar_pd(A, B);
1441 }
1442
1443 __m128 test_mm_permutevar_ps(__m128 A, __m128i B) {
1444   // CHECK-LABEL: test_mm_permutevar_ps
1445   // CHECK: call <4 x float> @llvm.x86.avx.vpermilvar.ps(<4 x float> %{{.*}}, <4 x i32> %{{.*}})
1446   return _mm_permutevar_ps(A, B);
1447 }
1448
1449 __m256 test_mm256_permutevar_ps(__m256 A, __m256i B) {
1450   // CHECK-LABEL: test_mm256_permutevar_ps
1451   // CHECK: call <8 x float> @llvm.x86.avx.vpermilvar.ps.256(<8 x float> %{{.*}}, <8 x i32> %{{.*}})
1452   return _mm256_permutevar_ps(A, B);
1453 }
1454
1455 __m256 test_mm256_rcp_ps(__m256 A) {
1456   // CHECK-LABEL: test_mm256_rcp_ps
1457   // CHECK: call <8 x float> @llvm.x86.avx.rcp.ps.256(<8 x float> %{{.*}})
1458   return _mm256_rcp_ps(A);
1459 }
1460
1461 __m256d test_mm256_round_pd(__m256d x) {
1462   // CHECK-LABEL: test_mm256_round_pd
1463   // CHECK: call <4 x double> @llvm.x86.avx.round.pd.256(<4 x double> %{{.*}}, i32 4)
1464   return _mm256_round_pd(x, 4);
1465 }
1466
1467 __m256 test_mm256_round_ps(__m256 x) {
1468   // CHECK-LABEL: test_mm256_round_ps
1469   // CHECK: call <8 x float> @llvm.x86.avx.round.ps.256(<8 x float> %{{.*}}, i32 4)
1470   return _mm256_round_ps(x, 4);
1471 }
1472
1473 __m256 test_mm256_rsqrt_ps(__m256 A) {
1474   // CHECK-LABEL: test_mm256_rsqrt_ps
1475   // CHECK: call <8 x float> @llvm.x86.avx.rsqrt.ps.256(<8 x float> %{{.*}})
1476   return _mm256_rsqrt_ps(A);
1477 }
1478
1479 __m256i test_mm256_set_epi8(char A0, char A1, char A2, char A3, char A4, char A5, char A6, char A7,
1480                             char A8, char A9, char A10, char A11, char A12, char A13, char A14, char A15,
1481                             char A16, char A17, char A18, char A19, char A20, char A21, char A22, char A23,
1482                             char A24, char A25, char A26, char A27, char A28, char A29, char A30, char A31) {
1483   // CHECK-LABEL: test_mm256_set_epi8
1484   // CHECK: insertelement <32 x i8> undef, i8 %{{.*}}, i32 0
1485   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 1
1486   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 2
1487   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 3
1488   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 4
1489   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 5
1490   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 6
1491   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 7
1492   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 8
1493   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 9
1494   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 10
1495   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 11
1496   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 12
1497   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 13
1498   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 14
1499   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 15
1500   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 16
1501   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 17
1502   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 18
1503   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 19
1504   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 20
1505   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 21
1506   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 22
1507   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 23
1508   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 24
1509   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 25
1510   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 26
1511   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 27
1512   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 28
1513   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 29
1514   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 30
1515   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 31
1516   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);
1517 }
1518
1519 __m256i test_mm256_set_epi16(short A0, short A1, short A2, short A3, short A4, short A5, short A6, short A7,
1520                              short A8, short A9, short A10, short A11, short A12, short A13, short A14, short A15) {
1521   // CHECK-LABEL: test_mm256_set_epi16
1522   // CHECK: insertelement <16 x i16> undef, i16 %{{.*}}, i32 0
1523   // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 1
1524   // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 2
1525   // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 3
1526   // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 4
1527   // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 5
1528   // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 6
1529   // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 7
1530   // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 8
1531   // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 9
1532   // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 10
1533   // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 11
1534   // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 12
1535   // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 13
1536   // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 14
1537   // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 15
1538   return _mm256_set_epi16(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15);
1539 }
1540
1541 __m256i test_mm256_set_epi32(int A0, int A1, int A2, int A3, int A4, int A5, int A6, int A7) {
1542   // CHECK-LABEL: test_mm256_set_epi32
1543   // CHECK: insertelement <8 x i32> undef, i32 %{{.*}}, i32 0
1544   // CHECK: insertelement <8 x i32> %{{.*}}, i32 %{{.*}}, i32 1
1545   // CHECK: insertelement <8 x i32> %{{.*}}, i32 %{{.*}}, i32 2
1546   // CHECK: insertelement <8 x i32> %{{.*}}, i32 %{{.*}}, i32 3
1547   // CHECK: insertelement <8 x i32> %{{.*}}, i32 %{{.*}}, i32 4
1548   // CHECK: insertelement <8 x i32> %{{.*}}, i32 %{{.*}}, i32 5
1549   // CHECK: insertelement <8 x i32> %{{.*}}, i32 %{{.*}}, i32 6
1550   // CHECK: insertelement <8 x i32> %{{.*}}, i32 %{{.*}}, i32 7
1551   return _mm256_set_epi32(A0, A1, A2, A3, A4, A5, A6, A7);
1552 }
1553
1554 __m256i test_mm256_set_epi64x(long long A0, long long A1, long long A2, long long A3) {
1555   // CHECK-LABEL: test_mm256_set_epi64x
1556   // CHECK: insertelement <4 x i64> undef, i64 %{{.*}}, i32 0
1557   // CHECK: insertelement <4 x i64> %{{.*}}, i64 %{{.*}}, i32 1
1558   // CHECK: insertelement <4 x i64> %{{.*}}, i64 %{{.*}}, i32 2
1559   // CHECK: insertelement <4 x i64> %{{.*}}, i64 %{{.*}}, i32 3
1560   return _mm256_set_epi64x(A0, A1, A2, A3);
1561 }
1562
1563 __m256 test_mm256_set_m128(__m128 A, __m128 B) {
1564   // CHECK-LABEL: test_mm256_set_m128
1565   // 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>
1566   return _mm256_set_m128(A, B);
1567 }
1568
1569 __m256d test_mm256_set_m128d(__m128d A, __m128d B) {
1570   // CHECK-LABEL: test_mm256_set_m128d
1571   // CHECK: shufflevector <2 x double> %{{.*}}, <2 x double> %{{.*}}, <4 x i32> <i32 0, i32 1, i32 2, i32 3>
1572   return _mm256_set_m128d(A, B);
1573 }
1574
1575 __m256i test_mm256_set_m128i(__m128i A, __m128i B) {
1576   // CHECK-LABEL: test_mm256_set_m128i
1577   // CHECK: shufflevector <2 x i64> %{{.*}}, <2 x i64> %{{.*}}, <4 x i32> <i32 0, i32 1, i32 2, i32 3>
1578   return _mm256_set_m128i(A, B);
1579 }
1580
1581 __m256d test_mm256_set_pd(double A0, double A1, double A2, double A3) {
1582   // CHECK-LABEL: test_mm256_set_pd
1583   // CHECK: insertelement <4 x double> undef, double %{{.*}}, i32 0
1584   // CHECK: insertelement <4 x double> %{{.*}}, double %{{.*}}, i32 1
1585   // CHECK: insertelement <4 x double> %{{.*}}, double %{{.*}}, i32 2
1586   // CHECK: insertelement <4 x double> %{{.*}}, double %{{.*}}, i32 3
1587   return _mm256_set_pd(A0, A1, A2, A3);
1588 }
1589
1590 __m256 test_mm256_set_ps(float A0, float A1, float A2, float A3, float A4, float A5, float A6, float A7) {
1591   // CHECK-LABEL: test_mm256_set_ps
1592   // CHECK: insertelement <8 x float> undef, float %{{.*}}, i32 0
1593   // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 1
1594   // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 2
1595   // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 3
1596   // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 4
1597   // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 5
1598   // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 6
1599   // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 7
1600   return _mm256_set_ps(A0, A1, A2, A3, A4, A5, A6, A7);
1601 }
1602
1603 __m256i test_mm256_set1_epi8(char A) {
1604   // CHECK-LABEL: test_mm256_set1_epi8
1605   // CHECK: insertelement <32 x i8> undef, i8 %{{.*}}, i32 0
1606   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 1
1607   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 2
1608   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 3
1609   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 4
1610   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 5
1611   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 6
1612   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 7
1613   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 8
1614   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 9
1615   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 10
1616   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 11
1617   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 12
1618   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 13
1619   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 14
1620   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 15
1621   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 16
1622   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 17
1623   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 18
1624   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 19
1625   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 20
1626   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 21
1627   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 22
1628   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 23
1629   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 24
1630   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 25
1631   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 26
1632   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 27
1633   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 28
1634   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 29
1635   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 30
1636   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 31
1637   return _mm256_set1_epi8(A);
1638 }
1639
1640 __m256i test_mm256_set1_epi16(short A) {
1641   // CHECK-LABEL: test_mm256_set1_epi16
1642   // CHECK: insertelement <16 x i16> undef, i16 %{{.*}}, i32 0
1643   // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 1
1644   // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 2
1645   // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 3
1646   // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 4
1647   // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 5
1648   // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 6
1649   // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 7
1650   // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 8
1651   // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 9
1652   // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 10
1653   // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 11
1654   // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 12
1655   // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 13
1656   // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 14
1657   // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 15
1658   return _mm256_set1_epi16(A);
1659 }
1660
1661 __m256i test_mm256_set1_epi32(int A) {
1662   // CHECK-LABEL: test_mm256_set1_epi32
1663   // CHECK: insertelement <8 x i32> undef, i32 %{{.*}}, i32 0
1664   // CHECK: insertelement <8 x i32> %{{.*}}, i32 %{{.*}}, i32 1
1665   // CHECK: insertelement <8 x i32> %{{.*}}, i32 %{{.*}}, i32 2
1666   // CHECK: insertelement <8 x i32> %{{.*}}, i32 %{{.*}}, i32 3
1667   // CHECK: insertelement <8 x i32> %{{.*}}, i32 %{{.*}}, i32 4
1668   // CHECK: insertelement <8 x i32> %{{.*}}, i32 %{{.*}}, i32 5
1669   // CHECK: insertelement <8 x i32> %{{.*}}, i32 %{{.*}}, i32 6
1670   // CHECK: insertelement <8 x i32> %{{.*}}, i32 %{{.*}}, i32 7
1671   return _mm256_set1_epi32(A);
1672 }
1673
1674 __m256i test_mm256_set1_epi64x(long long A) {
1675   // CHECK-LABEL: test_mm256_set1_epi64x
1676   // CHECK: insertelement <4 x i64> undef, i64 %{{.*}}, i32 0
1677   // CHECK: insertelement <4 x i64> %{{.*}}, i64 %{{.*}}, i32 1
1678   // CHECK: insertelement <4 x i64> %{{.*}}, i64 %{{.*}}, i32 2
1679   // CHECK: insertelement <4 x i64> %{{.*}}, i64 %{{.*}}, i32 3
1680   return _mm256_set1_epi64x(A);
1681 }
1682
1683 __m256d test_mm256_set1_pd(double A) {
1684   // CHECK-LABEL: test_mm256_set1_pd
1685   // CHECK: insertelement <4 x double> undef, double %{{.*}}, i32 0
1686   // CHECK: insertelement <4 x double> %{{.*}}, double %{{.*}}, i32 1
1687   // CHECK: insertelement <4 x double> %{{.*}}, double %{{.*}}, i32 2
1688   // CHECK: insertelement <4 x double> %{{.*}}, double %{{.*}}, i32 3
1689   return _mm256_set1_pd(A);
1690 }
1691
1692 __m256 test_mm256_set1_ps(float A) {
1693   // CHECK-LABEL: test_mm256_set1_ps
1694   // CHECK: insertelement <8 x float> undef, float %{{.*}}, i32 0
1695   // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 1
1696   // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 2
1697   // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 3
1698   // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 4
1699   // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 5
1700   // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 6
1701   // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 7
1702   return _mm256_set1_ps(A);
1703 }
1704
1705 __m256i test_mm256_setr_epi8(char A0, char A1, char A2, char A3, char A4, char A5, char A6, char A7,
1706                              char A8, char A9, char A10, char A11, char A12, char A13, char A14, char A15,
1707                              char A16, char A17, char A18, char A19, char A20, char A21, char A22, char A23,
1708                              char A24, char A25, char A26, char A27, char A28, char A29, char A30, char A31) {
1709   // CHECK-LABEL: test_mm256_setr_epi8
1710   // CHECK: insertelement <32 x i8> undef, i8 %{{.*}}, i32 0
1711   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 1
1712   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 2
1713   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 3
1714   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 4
1715   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 5
1716   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 6
1717   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 7
1718   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 8
1719   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 9
1720   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 10
1721   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 11
1722   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 12
1723   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 13
1724   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 14
1725   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 15
1726   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 16
1727   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 17
1728   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 18
1729   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 19
1730   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 20
1731   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 21
1732   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 22
1733   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 23
1734   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 24
1735   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 25
1736   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 26
1737   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 27
1738   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 28
1739   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 29
1740   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 30
1741   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 31
1742   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);
1743 }
1744
1745 __m256i test_mm256_setr_epi16(short A0, short A1, short A2, short A3, short A4, short A5, short A6, short A7,
1746                               short A8, short A9, short A10, short A11, short A12, short A13, short A14, short A15) {
1747   // CHECK-LABEL: test_mm256_setr_epi16
1748   // CHECK: insertelement <16 x i16> undef, i16 %{{.*}}, i32 0
1749   // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 1
1750   // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 2
1751   // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 3
1752   // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 4
1753   // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 5
1754   // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 6
1755   // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 7
1756   // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 8
1757   // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 9
1758   // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 10
1759   // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 11
1760   // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 12
1761   // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 13
1762   // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 14
1763   // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 15
1764   return _mm256_setr_epi16(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15);
1765 }
1766
1767 __m256i test_mm256_setr_epi32(int A0, int A1, int A2, int A3, int A4, int A5, int A6, int A7) {
1768   // CHECK-LABEL: test_mm256_setr_epi32
1769   // CHECK: insertelement <8 x i32> undef, i32 %{{.*}}, i32 0
1770   // CHECK: insertelement <8 x i32> %{{.*}}, i32 %{{.*}}, i32 1
1771   // CHECK: insertelement <8 x i32> %{{.*}}, i32 %{{.*}}, i32 2
1772   // CHECK: insertelement <8 x i32> %{{.*}}, i32 %{{.*}}, i32 3
1773   // CHECK: insertelement <8 x i32> %{{.*}}, i32 %{{.*}}, i32 4
1774   // CHECK: insertelement <8 x i32> %{{.*}}, i32 %{{.*}}, i32 5
1775   // CHECK: insertelement <8 x i32> %{{.*}}, i32 %{{.*}}, i32 6
1776   // CHECK: insertelement <8 x i32> %{{.*}}, i32 %{{.*}}, i32 7
1777   return _mm256_setr_epi32(A0, A1, A2, A3, A4, A5, A6, A7);
1778 }
1779
1780 __m256i test_mm256_setr_epi64x(long long A0, long long A1, long long A2, long long A3) {
1781   // CHECK-LABEL: test_mm256_setr_epi64x
1782   // CHECK: insertelement <4 x i64> undef, i64 %{{.*}}, i32 0
1783   // CHECK: insertelement <4 x i64> %{{.*}}, i64 %{{.*}}, i32 1
1784   // CHECK: insertelement <4 x i64> %{{.*}}, i64 %{{.*}}, i32 2
1785   // CHECK: insertelement <4 x i64> %{{.*}}, i64 %{{.*}}, i32 3
1786   return _mm256_setr_epi64x(A0, A1, A2, A3);
1787 }
1788
1789 __m256 test_mm256_setr_m128(__m128 A, __m128 B) {
1790   // CHECK-LABEL: test_mm256_setr_m128
1791   // 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>
1792   return _mm256_setr_m128(A, B);
1793 }
1794
1795 __m256d test_mm256_setr_m128d(__m128d A, __m128d B) {
1796   // CHECK-LABEL: test_mm256_setr_m128d
1797   // CHECK: shufflevector <2 x double> %{{.*}}, <2 x double> %{{.*}}, <4 x i32> <i32 0, i32 1, i32 2, i32 3>
1798   return _mm256_setr_m128d(A, B);
1799 }
1800
1801 __m256i test_mm256_setr_m128i(__m128i A, __m128i B) {
1802   // CHECK-LABEL: test_mm256_setr_m128i
1803   // CHECK: shufflevector <2 x i64> %{{.*}}, <2 x i64> %{{.*}}, <4 x i32> <i32 0, i32 1, i32 2, i32 3>
1804   return _mm256_setr_m128i(A, B);
1805 }
1806
1807 __m256d test_mm256_setr_pd(double A0, double A1, double A2, double A3) {
1808   // CHECK-LABEL: test_mm256_setr_pd
1809   // CHECK: insertelement <4 x double> undef, double %{{.*}}, i32 0
1810   // CHECK: insertelement <4 x double> %{{.*}}, double %{{.*}}, i32 1
1811   // CHECK: insertelement <4 x double> %{{.*}}, double %{{.*}}, i32 2
1812   // CHECK: insertelement <4 x double> %{{.*}}, double %{{.*}}, i32 3
1813   return _mm256_setr_pd(A0, A1, A2, A3);
1814 }
1815
1816 __m256 test_mm256_setr_ps(float A0, float A1, float A2, float A3, float A4, float A5, float A6, float A7) {
1817   // CHECK-LABEL: test_mm256_setr_ps
1818   // CHECK: insertelement <8 x float> undef, float %{{.*}}, i32 0
1819   // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 1
1820   // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 2
1821   // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 3
1822   // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 4
1823   // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 5
1824   // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 6
1825   // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 7
1826   return _mm256_setr_ps(A0, A1, A2, A3, A4, A5, A6, A7);
1827 }
1828
1829 __m256d test_mm256_setzero_pd(void) {
1830   // CHECK-LABEL: test_mm256_setzero_pd
1831   // CHECK: store <4 x double> zeroinitializer
1832   return _mm256_setzero_pd();
1833 }
1834
1835 __m256 test_mm256_setzero_ps(void) {
1836   // CHECK-LABEL: test_mm256_setzero_ps
1837   // CHECK: store <8 x float> zeroinitializer
1838   return _mm256_setzero_ps();
1839 }
1840
1841 __m256i test_mm256_setzero_si256(void) {
1842   // CHECK-LABEL: test_mm256_setzero_si256
1843   // CHECK: store <4 x i64> zeroinitializer
1844   return _mm256_setzero_si256();
1845 }
1846
1847 __m256d test_mm256_shuffle_pd(__m256d A, __m256d B) {
1848   // CHECK-LABEL: test_mm256_shuffle_pd
1849   // CHECK: shufflevector <4 x double> %{{.*}}, <4 x double> %{{.*}}, <4 x i32> <i32 0, i32 4, i32 2, i32 6>
1850   return _mm256_shuffle_pd(A, B, 0);
1851 }
1852
1853 __m256 test_mm256_shuffle_ps(__m256 A, __m256 B) {
1854   // CHECK-LABEL: test_mm256_shuffle_ps
1855   // 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>
1856   return _mm256_shuffle_ps(A, B, 0);
1857 }
1858
1859 __m256d test_mm256_sqrt_pd(__m256d A) {
1860   // CHECK-LABEL: test_mm256_sqrt_pd
1861   // CHECK: call <4 x double> @llvm.sqrt.v4f64(<4 x double> %{{.*}})
1862   return _mm256_sqrt_pd(A);
1863 }
1864
1865 __m256 test_mm256_sqrt_ps(__m256 A) {
1866   // CHECK-LABEL: test_mm256_sqrt_ps
1867   // CHECK: call <8 x float> @llvm.sqrt.v8f32(<8 x float> %{{.*}})
1868   return _mm256_sqrt_ps(A);
1869 }
1870
1871 void test_mm256_store_pd(double* A, __m256d B) {
1872   // CHECK-LABEL: test_mm256_store_pd
1873   // CHECK: store <4 x double> %{{.*}}, ptr %{{.*}}, align 32
1874   _mm256_store_pd(A, B);
1875 }
1876
1877 void test_mm256_store_ps(float* A, __m256 B) {
1878   // CHECK-LABEL: test_mm256_store_ps
1879   // CHECK: store <8 x float> %{{.*}}, ptr %{{.*}}, align 32
1880   _mm256_store_ps(A, B);
1881 }
1882
1883 void test_mm256_store_si256(__m256i* A, __m256i B) {
1884   // CHECK-LABEL: test_mm256_store_si256
1885   // CHECK: store <4 x i64> %{{.*}}, ptr %{{.*}}, align 32
1886   _mm256_store_si256(A, B);
1887 }
1888
1889 void test_mm256_storeu_pd(double* A, __m256d B) {
1890   // CHECK-LABEL: test_mm256_storeu_pd
1891   // CHECK:   store <4 x double> %{{.*}}, ptr %{{.*}}, align 1{{$}}
1892   // CHECK-NEXT: ret void
1893   _mm256_storeu_pd(A, B);
1894 }
1895
1896 void test_mm256_storeu_ps(float* A, __m256 B) {
1897   // CHECK-LABEL: test_mm256_storeu_ps
1898   // CHECK: store <8 x float> %{{.*}}, ptr %{{.*}}, align 1{{$}}
1899   // CHECk-NEXT: ret void
1900   _mm256_storeu_ps(A, B);
1901 }
1902
1903 void test_mm256_storeu_si256(__m256i* A, __m256i B) {
1904   // CHECK-LABEL: test_mm256_storeu_si256
1905   // CHECK: store <4 x i64> %{{.*}}, ptr %{{.*}}, align 1{{$}}
1906   // CHECk-NEXT: ret void
1907   _mm256_storeu_si256(A, B);
1908 }
1909
1910 void test_mm256_storeu2_m128(float* A, float* B, __m256 C) {
1911   // CHECK-LABEL: test_mm256_storeu2_m128
1912   // CHECK: shufflevector <8 x float> %{{.*}}, <8 x float> %{{.*}}, <4 x i32> <i32 0, i32 1, i32 2, i32 3>
1913   // CHECK: store <4 x float> %{{.*}}, ptr %{{.*}}, align 1{{$}}
1914   // CHECK: shufflevector <8 x float> %{{.*}}, <8 x float> poison, <4 x i32> <i32 4, i32 5, i32 6, i32 7>
1915   // CHECK: store <4 x float> %{{.*}}, ptr %{{.*}}, align 1{{$}}
1916   _mm256_storeu2_m128(A, B, C);
1917 }
1918
1919 void test_mm256_storeu2_m128d(double* A, double* B, __m256d C) {
1920   // CHECK-LABEL: test_mm256_storeu2_m128d
1921   // CHECK: shufflevector <4 x double> %{{.*}}, <4 x double> %{{.*}}, <2 x i32> <i32 0, i32 1>
1922   // CHECK: store <2 x double> %{{.*}}, ptr %{{.*}}, align 1{{$}}
1923   // CHECK: shufflevector <4 x double> %{{.*}}, <4 x double> poison, <2 x i32> <i32 2, i32 3>
1924   // CHECK: store <2 x double> %{{.*}}, ptr %{{.*}}, align 1{{$}}
1925   _mm256_storeu2_m128d(A, B, C);
1926 }
1927
1928 void test_mm256_storeu2_m128i(__m128i* A, __m128i* B, __m256i C) {
1929   // CHECK-LABEL: test_mm256_storeu2_m128i
1930   // CHECK: shufflevector <4 x i64> %{{.*}}, <4 x i64> %{{.*}}, <2 x i32> <i32 0, i32 1>
1931   // CHECK: store <2 x i64> %{{.*}}, ptr %{{.*}}, align 1{{$}}
1932   // CHECK: shufflevector <8 x i32> %{{.*}}, <8 x i32> poison, <4 x i32> <i32 4, i32 5, i32 6, i32 7>
1933   // CHECK: store <2 x i64> %{{.*}}, ptr %{{.*}}, align 1{{$}}
1934   _mm256_storeu2_m128i(A, B, C);
1935 }
1936
1937 void test_mm256_stream_pd(double* A, __m256d B) {
1938   // CHECK-LABEL: test_mm256_stream_pd
1939   // CHECK: store <4 x double> %{{.*}}, ptr %{{.*}}, align 32, !nontemporal
1940   _mm256_stream_pd(A, B);
1941 }
1942
1943 void test_mm256_stream_pd_void(void *A, __m256d B) {
1944   // CHECK-LABEL: test_mm256_stream_pd_void
1945   // CHECK: store <4 x double> %{{.*}}, ptr %{{.*}}, align 32, !nontemporal
1946   _mm256_stream_pd(A, B);
1947 }
1948
1949 void test_mm256_stream_ps(float* A, __m256 B) {
1950   // CHECK-LABEL: test_mm256_stream_ps
1951   // CHECK: store <8 x float> %{{.*}}, ptr %{{.*}}, align 32, !nontemporal
1952   _mm256_stream_ps(A, B);
1953 }
1954
1955 void test_mm256_stream_ps_void(void *A, __m256 B) {
1956   // CHECK-LABEL: test_mm256_stream_ps_void
1957   // CHECK: store <8 x float> %{{.*}}, ptr %{{.*}}, align 32, !nontemporal
1958   _mm256_stream_ps(A, B);
1959 }
1960
1961 void test_mm256_stream_si256(__m256i* A, __m256i B) {
1962   // CHECK-LABEL: test_mm256_stream_si256
1963   // CHECK: store <4 x i64> %{{.*}}, ptr %{{.*}}, align 32, !nontemporal
1964   _mm256_stream_si256(A, B);
1965 }
1966
1967 void test_mm256_stream_si256_void(void *A, __m256i B) {
1968   // CHECK-LABEL: test_mm256_stream_si256_void
1969   // CHECK: store <4 x i64> %{{.*}}, ptr %{{.*}}, align 32, !nontemporal
1970   _mm256_stream_si256(A, B);
1971 }
1972
1973 __m256d test_mm256_sub_pd(__m256d A, __m256d B) {
1974   // CHECK-LABEL: test_mm256_sub_pd
1975   // CHECK: fsub <4 x double>
1976   return _mm256_sub_pd(A, B);
1977 }
1978
1979 __m256 test_mm256_sub_ps(__m256 A, __m256 B) {
1980   // CHECK-LABEL: test_mm256_sub_ps
1981   // CHECK: fsub <8 x float>
1982   return _mm256_sub_ps(A, B);
1983 }
1984
1985 int test_mm_testc_pd(__m128d A, __m128d B) {
1986   // CHECK-LABEL: test_mm_testc_pd
1987   // CHECK: call i32 @llvm.x86.avx.vtestc.pd(<2 x double> %{{.*}}, <2 x double> %{{.*}})
1988   return _mm_testc_pd(A, B);
1989 }
1990
1991 int test_mm256_testc_pd(__m256d A, __m256d B) {
1992   // CHECK-LABEL: test_mm256_testc_pd
1993   // CHECK: call i32 @llvm.x86.avx.vtestc.pd.256(<4 x double> %{{.*}}, <4 x double> %{{.*}})
1994   return _mm256_testc_pd(A, B);
1995 }
1996
1997 int test_mm_testc_ps(__m128 A, __m128 B) {
1998   // CHECK-LABEL: test_mm_testc_ps
1999   // CHECK: call i32 @llvm.x86.avx.vtestc.ps(<4 x float> %{{.*}}, <4 x float> %{{.*}})
2000   return _mm_testc_ps(A, B);
2001 }
2002
2003 int test_mm256_testc_ps(__m256 A, __m256 B) {
2004   // CHECK-LABEL: test_mm256_testc_ps
2005   // CHECK: call i32 @llvm.x86.avx.vtestc.ps.256(<8 x float> %{{.*}}, <8 x float> %{{.*}})
2006   return _mm256_testc_ps(A, B);
2007 }
2008
2009 int test_mm256_testc_si256(__m256i A, __m256i B) {
2010   // CHECK-LABEL: test_mm256_testc_si256
2011   // CHECK: call i32 @llvm.x86.avx.ptestc.256(<4 x i64> %{{.*}}, <4 x i64> %{{.*}})
2012   return _mm256_testc_si256(A, B);
2013 }
2014
2015 int test_mm_testnzc_pd(__m128d A, __m128d B) {
2016   // CHECK-LABEL: test_mm_testnzc_pd
2017   // CHECK: call i32 @llvm.x86.avx.vtestnzc.pd(<2 x double> %{{.*}}, <2 x double> %{{.*}})
2018   return _mm_testnzc_pd(A, B);
2019 }
2020
2021 int test_mm256_testnzc_pd(__m256d A, __m256d B) {
2022   // CHECK-LABEL: test_mm256_testnzc_pd
2023   // CHECK: call i32 @llvm.x86.avx.vtestnzc.pd.256(<4 x double> %{{.*}}, <4 x double> %{{.*}})
2024   return _mm256_testnzc_pd(A, B);
2025 }
2026
2027 int test_mm_testnzc_ps(__m128 A, __m128 B) {
2028   // CHECK-LABEL: test_mm_testnzc_ps
2029   // CHECK: call i32 @llvm.x86.avx.vtestnzc.ps(<4 x float> %{{.*}}, <4 x float> %{{.*}})
2030   return _mm_testnzc_ps(A, B);
2031 }
2032
2033 int test_mm256_testnzc_ps(__m256 A, __m256 B) {
2034   // CHECK-LABEL: test_mm256_testnzc_ps
2035   // CHECK: call i32 @llvm.x86.avx.vtestnzc.ps.256(<8 x float> %{{.*}}, <8 x float> %{{.*}})
2036   return _mm256_testnzc_ps(A, B);
2037 }
2038
2039 int test_mm256_testnzc_si256(__m256i A, __m256i B) {
2040   // CHECK-LABEL: test_mm256_testnzc_si256
2041   // CHECK: call i32 @llvm.x86.avx.ptestnzc.256(<4 x i64> %{{.*}}, <4 x i64> %{{.*}})
2042   return _mm256_testnzc_si256(A, B);
2043 }
2044
2045 int test_mm_testz_pd(__m128d A, __m128d B) {
2046   // CHECK-LABEL: test_mm_testz_pd
2047   // CHECK: call i32 @llvm.x86.avx.vtestz.pd(<2 x double> %{{.*}}, <2 x double> %{{.*}})
2048   return _mm_testz_pd(A, B);
2049 }
2050
2051 int test_mm256_testz_pd(__m256d A, __m256d B) {
2052   // CHECK-LABEL: test_mm256_testz_pd
2053   // CHECK: call i32 @llvm.x86.avx.vtestz.pd.256(<4 x double> %{{.*}}, <4 x double> %{{.*}})
2054   return _mm256_testz_pd(A, B);
2055 }
2056
2057 int test_mm_testz_ps(__m128 A, __m128 B) {
2058   // CHECK-LABEL: test_mm_testz_ps
2059   // CHECK: call i32 @llvm.x86.avx.vtestz.ps(<4 x float> %{{.*}}, <4 x float> %{{.*}})
2060   return _mm_testz_ps(A, B);
2061 }
2062
2063 int test_mm256_testz_ps(__m256 A, __m256 B) {
2064   // CHECK-LABEL: test_mm256_testz_ps
2065   // CHECK: call i32 @llvm.x86.avx.vtestz.ps.256(<8 x float> %{{.*}}, <8 x float> %{{.*}})
2066   return _mm256_testz_ps(A, B);
2067 }
2068
2069 int test_mm256_testz_si256(__m256i A, __m256i B) {
2070   // CHECK-LABEL: test_mm256_testz_si256
2071   // CHECK: call i32 @llvm.x86.avx.ptestz.256(<4 x i64> %{{.*}}, <4 x i64> %{{.*}})
2072   return _mm256_testz_si256(A, B);
2073 }
2074
2075 __m256 test_mm256_undefined_ps(void) {
2076   // X64-LABEL: test_mm256_undefined_ps
2077   // X64: ret <8 x float> zeroinitializer
2078   //
2079   // X86-LABEL: test_mm256_undefined_ps
2080   // X86: store <8 x float> zeroinitializer
2081   return _mm256_undefined_ps();
2082 }
2083
2084 __m256d test_mm256_undefined_pd(void) {
2085   // X64-LABEL: test_mm256_undefined_pd
2086   // X64: ret <4 x double> zeroinitializer
2087   //
2088   // X86-LABEL: test_mm256_undefined_pd
2089   // X86: store <4 x double> zeroinitializer
2090   return _mm256_undefined_pd();
2091 }
2092
2093 __m256i test_mm256_undefined_si256(void) {
2094   // X64-LABEL: test_mm256_undefined_si256
2095   // X64: ret <4 x i64> zeroinitializer
2096   //
2097   // X86-LABEL: test_mm256_undefined_si256
2098   // X86: store <4 x i64> zeroinitializer
2099   return _mm256_undefined_si256();
2100 }
2101
2102 __m256d test_mm256_unpackhi_pd(__m256d A, __m256d B) {
2103   // CHECK-LABEL: test_mm256_unpackhi_pd
2104   // CHECK: shufflevector <4 x double> %{{.*}}, <4 x double> %{{.*}}, <4 x i32> <i32 1, i32 5, i32 3, i32 7>
2105   return _mm256_unpackhi_pd(A, B);
2106 }
2107
2108 __m256 test_mm256_unpackhi_ps(__m256 A, __m256 B) {
2109   // CHECK-LABEL: test_mm256_unpackhi_ps
2110   // 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>
2111   return _mm256_unpackhi_ps(A, B);
2112 }
2113
2114 __m256d test_mm256_unpacklo_pd(__m256d A, __m256d B) {
2115   // CHECK-LABEL: test_mm256_unpacklo_pd
2116   // CHECK: shufflevector <4 x double> %{{.*}}, <4 x double> %{{.*}}, <4 x i32> <i32 0, i32 4, i32 2, i32 6>
2117   return _mm256_unpacklo_pd(A, B);
2118 }
2119
2120 __m256 test_mm256_unpacklo_ps(__m256 A, __m256 B) {
2121   // CHECK-LABEL: test_mm256_unpacklo_ps
2122   // 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>
2123   return _mm256_unpacklo_ps(A, B);
2124 }
2125
2126 __m256d test_mm256_xor_pd(__m256d A, __m256d B) {
2127   // CHECK-LABEL: test_mm256_xor_pd
2128   // CHECK: xor <4 x i64>
2129   return _mm256_xor_pd(A, B);
2130 }
2131
2132 __m256 test_mm256_xor_ps(__m256 A, __m256 B) {
2133   // CHECK-LABEL: test_mm256_xor_ps
2134   // CHECK: xor <8 x i32>
2135   return _mm256_xor_ps(A, B);
2136 }
2137
2138 void test_mm256_zeroall(void) {
2139   // CHECK-LABEL: test_mm256_zeroall
2140   // CHECK: call void @llvm.x86.avx.vzeroall()
2141   return _mm256_zeroall();
2142 }
2143
2144 void test_mm256_zeroupper(void) {
2145   // CHECK-LABEL: test_mm256_zeroupper
2146   // CHECK: call void @llvm.x86.avx.vzeroupper()
2147   return _mm256_zeroupper();
2148 }
2149
2150 __m256d test_mm256_zextpd128_pd256(__m128d A) {
2151   // CHECK-LABEL: test_mm256_zextpd128_pd256
2152   // CHECK: store <2 x double> zeroinitializer
2153   // CHECK: shufflevector <2 x double> %{{.*}}, <2 x double> %{{.*}}, <4 x i32> <i32 0, i32 1, i32 2, i32 3>
2154   return _mm256_zextpd128_pd256(A);
2155 }
2156
2157 __m256 test_mm256_zextps128_ps256(__m128 A) {
2158   // CHECK-LABEL: test_mm256_zextps128_ps256
2159   // CHECK: store <4 x float> zeroinitializer
2160   // 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>
2161   return _mm256_zextps128_ps256(A);
2162 }
2163
2164 __m256i test_mm256_zextsi128_si256(__m128i A) {
2165   // CHECK-LABEL: test_mm256_zextsi128_si256
2166   // CHECK: store <2 x i64> zeroinitializer
2167   // CHECK: shufflevector <2 x i64> %{{.*}}, <2 x i64> %{{.*}}, <4 x i32> <i32 0, i32 1, i32 2, i32 3>
2168   return _mm256_zextsi128_si256(A);
2169 }
2170
2171 double test_mm256_cvtsd_f64(__m256d __a)
2172 {
2173   // CHECK-LABEL: test_mm256_cvtsd_f64
2174   // CHECK: extractelement <4 x double> %{{.*}}, i32 0
2175   return _mm256_cvtsd_f64(__a);
2176 }
2177
2178 int test_mm256_cvtsi256_si32(__m256i __a)
2179 {
2180   // CHECK-LABEL: test_mm256_cvtsi256_si32
2181   // CHECK: extractelement <8 x i32> %{{.*}}, i32 0
2182   return _mm256_cvtsi256_si32(__a);
2183 }
2184
2185 float test_mm256_cvtss_f32(__m256 __a)
2186 {
2187   // CHECK-LABEL: test_mm256_cvtss_f32
2188   // CHECK: extractelement <8 x float> %{{.*}}, i32 0
2189   return _mm256_cvtss_f32(__a);
2190 }