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

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