From: Elena Demikhovsky Date: Mon, 11 May 2015 09:03:41 +0000 (+0000) Subject: AVX-512: Changed CC parameter in "cmp" intrinsic X-Git-Url: https://granicus.if.org/sourcecode?a=commitdiff_plain;h=b1b67fa1856896b7494c4ee515a53f345bc230ca;p=clang AVX-512: Changed CC parameter in "cmp" intrinsic from i8 to i32 according to the Intel Spec git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@236980 91177308-0d34-0410-b5e6-96231b3b80d8 --- diff --git a/include/clang/Basic/BuiltinsX86.def b/include/clang/Basic/BuiltinsX86.def index 8b3c579c69..1a597b5c27 100644 --- a/include/clang/Basic/BuiltinsX86.def +++ b/include/clang/Basic/BuiltinsX86.def @@ -945,30 +945,30 @@ BUILTIN(__builtin_ia32_scatterpfqpd, "vUcV8LLiv*IiIi", "") BUILTIN(__builtin_ia32_scatterpfqps, "vUcV8LLiv*IiIi", "") BUILTIN(__builtin_ia32_knothi, "UsUs", "") -BUILTIN(__builtin_ia32_cmpb128_mask, "UsV16cV16cIcUs", "") -BUILTIN(__builtin_ia32_cmpd128_mask, "UcV4iV4iIcUc", "") -BUILTIN(__builtin_ia32_cmpq128_mask, "UcV2LLiV2LLiIcUc", "") -BUILTIN(__builtin_ia32_cmpw128_mask, "UcV8sV8sIcUc", "") -BUILTIN(__builtin_ia32_cmpb256_mask, "UiV32cV32cIcUi", "") -BUILTIN(__builtin_ia32_cmpd256_mask, "UcV8iV8iIcUc", "") -BUILTIN(__builtin_ia32_cmpq256_mask, "UcV4LLiV4LLiIcUc", "") -BUILTIN(__builtin_ia32_cmpw256_mask, "UsV16sV16sIcUs", "") -BUILTIN(__builtin_ia32_cmpb512_mask, "ULLiV64cV64cIcULLi", "") -BUILTIN(__builtin_ia32_cmpd512_mask, "UsV16iV16iIcUs", "") -BUILTIN(__builtin_ia32_cmpq512_mask, "UcV8LLiV8LLiIcUc", "") -BUILTIN(__builtin_ia32_cmpw512_mask, "UiV32sV32sIcUi", "") -BUILTIN(__builtin_ia32_ucmpb128_mask, "UsV16cV16cIcUs", "") -BUILTIN(__builtin_ia32_ucmpd128_mask, "UcV4iV4iIcUc", "") -BUILTIN(__builtin_ia32_ucmpq128_mask, "UcV2LLiV2LLiIcUc", "") -BUILTIN(__builtin_ia32_ucmpw128_mask, "UcV8sV8sIcUc", "") -BUILTIN(__builtin_ia32_ucmpb256_mask, "UiV32cV32cIcUi", "") -BUILTIN(__builtin_ia32_ucmpd256_mask, "UcV8iV8iIcUc", "") -BUILTIN(__builtin_ia32_ucmpq256_mask, "UcV4LLiV4LLiIcUc", "") -BUILTIN(__builtin_ia32_ucmpw256_mask, "UsV16sV16sIcUs", "") -BUILTIN(__builtin_ia32_ucmpb512_mask, "ULLiV64cV64cIcULLi", "") -BUILTIN(__builtin_ia32_ucmpd512_mask, "UsV16iV16iIcUs", "") -BUILTIN(__builtin_ia32_ucmpq512_mask, "UcV8LLiV8LLiIcUc", "") -BUILTIN(__builtin_ia32_ucmpw512_mask, "UiV32sV32sIcUi", "") +BUILTIN(__builtin_ia32_cmpb128_mask, "UsV16cV16cIiUs", "") +BUILTIN(__builtin_ia32_cmpd128_mask, "UcV4iV4iIiUc", "") +BUILTIN(__builtin_ia32_cmpq128_mask, "UcV2LLiV2LLiIiUc", "") +BUILTIN(__builtin_ia32_cmpw128_mask, "UcV8sV8sIiUc", "") +BUILTIN(__builtin_ia32_cmpb256_mask, "UiV32cV32cIiUi", "") +BUILTIN(__builtin_ia32_cmpd256_mask, "UcV8iV8iIiUc", "") +BUILTIN(__builtin_ia32_cmpq256_mask, "UcV4LLiV4LLiIiUc", "") +BUILTIN(__builtin_ia32_cmpw256_mask, "UsV16sV16sIiUs", "") +BUILTIN(__builtin_ia32_cmpb512_mask, "ULLiV64cV64cIiULLi", "") +BUILTIN(__builtin_ia32_cmpd512_mask, "UsV16iV16iIiUs", "") +BUILTIN(__builtin_ia32_cmpq512_mask, "UcV8LLiV8LLiIiUc", "") +BUILTIN(__builtin_ia32_cmpw512_mask, "UiV32sV32sIiUi", "") +BUILTIN(__builtin_ia32_ucmpb128_mask, "UsV16cV16cIiUs", "") +BUILTIN(__builtin_ia32_ucmpd128_mask, "UcV4iV4iIiUc", "") +BUILTIN(__builtin_ia32_ucmpq128_mask, "UcV2LLiV2LLiIiUc", "") +BUILTIN(__builtin_ia32_ucmpw128_mask, "UcV8sV8sIiUc", "") +BUILTIN(__builtin_ia32_ucmpb256_mask, "UiV32cV32cIiUi", "") +BUILTIN(__builtin_ia32_ucmpd256_mask, "UcV8iV8iIiUc", "") +BUILTIN(__builtin_ia32_ucmpq256_mask, "UcV4LLiV4LLiIiUc", "") +BUILTIN(__builtin_ia32_ucmpw256_mask, "UsV16sV16sIiUs", "") +BUILTIN(__builtin_ia32_ucmpb512_mask, "ULLiV64cV64cIiULLi", "") +BUILTIN(__builtin_ia32_ucmpd512_mask, "UsV16iV16iIiUs", "") +BUILTIN(__builtin_ia32_ucmpq512_mask, "UcV8LLiV8LLiIiUc", "") +BUILTIN(__builtin_ia32_ucmpw512_mask, "UiV32sV32sIiUi", "") BUILTIN(__builtin_ia32_paddd256_mask, "V8iV8iV8iV8iUc", "") BUILTIN(__builtin_ia32_paddq256_mask, "V4LLiV4LLiV4LLiV4LLiUc", "") diff --git a/test/CodeGen/avx512bw-builtins.c b/test/CodeGen/avx512bw-builtins.c index 143a2e9346..452d737bea 100644 --- a/test/CodeGen/avx512bw-builtins.c +++ b/test/CodeGen/avx512bw-builtins.c @@ -52,289 +52,289 @@ __mmask32 test_mm512_mask_cmpgt_epi16_mask(__mmask32 __u, __m512i __a, __m512i _ __mmask64 test_mm512_cmpeq_epu8_mask(__m512i __a, __m512i __b) { // CHECK-LABEL: @test_mm512_cmpeq_epu8_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.b.512(<64 x i8> {{.*}}, <64 x i8> {{.*}}, i8 0, i64 -1) + // CHECK: @llvm.x86.avx512.mask.ucmp.b.512(<64 x i8> {{.*}}, <64 x i8> {{.*}}, i32 0, i64 -1) return (__mmask64)_mm512_cmpeq_epu8_mask(__a, __b); } __mmask64 test_mm512_mask_cmpeq_epu8_mask(__mmask64 __u, __m512i __a, __m512i __b) { // CHECK-LABEL: @test_mm512_mask_cmpeq_epu8_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.b.512(<64 x i8> {{.*}}, <64 x i8> {{.*}}, i8 0, i64 {{.*}}) + // CHECK: @llvm.x86.avx512.mask.ucmp.b.512(<64 x i8> {{.*}}, <64 x i8> {{.*}}, i32 0, i64 {{.*}}) return (__mmask64)_mm512_mask_cmpeq_epu8_mask(__u, __a, __b); } __mmask32 test_mm512_cmpeq_epu16_mask(__m512i __a, __m512i __b) { // CHECK-LABEL: @test_mm512_cmpeq_epu16_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.w.512(<32 x i16> {{.*}}, <32 x i16> {{.*}}, i8 0, i32 -1) + // CHECK: @llvm.x86.avx512.mask.ucmp.w.512(<32 x i16> {{.*}}, <32 x i16> {{.*}}, i32 0, i32 -1) return (__mmask32)_mm512_cmpeq_epu16_mask(__a, __b); } __mmask32 test_mm512_mask_cmpeq_epu16_mask(__mmask32 __u, __m512i __a, __m512i __b) { // CHECK-LABEL: @test_mm512_mask_cmpeq_epu16_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.w.512(<32 x i16> {{.*}}, <32 x i16> {{.*}}, i8 0, i32 {{.*}}) + // CHECK: @llvm.x86.avx512.mask.ucmp.w.512(<32 x i16> {{.*}}, <32 x i16> {{.*}}, i32 0, i32 {{.*}}) return (__mmask32)_mm512_mask_cmpeq_epu16_mask(__u, __a, __b); } __mmask64 test_mm512_cmpgt_epu8_mask(__m512i __a, __m512i __b) { // CHECK-LABEL: @test_mm512_cmpgt_epu8_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.b.512(<64 x i8> {{.*}}, <64 x i8> {{.*}}, i8 6, i64 -1) + // CHECK: @llvm.x86.avx512.mask.ucmp.b.512(<64 x i8> {{.*}}, <64 x i8> {{.*}}, i32 6, i64 -1) return (__mmask64)_mm512_cmpgt_epu8_mask(__a, __b); } __mmask64 test_mm512_mask_cmpgt_epu8_mask(__mmask64 __u, __m512i __a, __m512i __b) { // CHECK-LABEL: @test_mm512_mask_cmpgt_epu8_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.b.512(<64 x i8> {{.*}}, <64 x i8> {{.*}}, i8 6, i64 {{.*}}) + // CHECK: @llvm.x86.avx512.mask.ucmp.b.512(<64 x i8> {{.*}}, <64 x i8> {{.*}}, i32 6, i64 {{.*}}) return (__mmask64)_mm512_mask_cmpgt_epu8_mask(__u, __a, __b); } __mmask32 test_mm512_cmpgt_epu16_mask(__m512i __a, __m512i __b) { // CHECK-LABEL: @test_mm512_cmpgt_epu16_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.w.512(<32 x i16> {{.*}}, <32 x i16> {{.*}}, i8 6, i32 -1) + // CHECK: @llvm.x86.avx512.mask.ucmp.w.512(<32 x i16> {{.*}}, <32 x i16> {{.*}}, i32 6, i32 -1) return (__mmask32)_mm512_cmpgt_epu16_mask(__a, __b); } __mmask32 test_mm512_mask_cmpgt_epu16_mask(__mmask32 __u, __m512i __a, __m512i __b) { // CHECK-LABEL: @test_mm512_mask_cmpgt_epu16_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.w.512(<32 x i16> {{.*}}, <32 x i16> {{.*}}, i8 6, i32 {{.*}}) + // CHECK: @llvm.x86.avx512.mask.ucmp.w.512(<32 x i16> {{.*}}, <32 x i16> {{.*}}, i32 6, i32 {{.*}}) return (__mmask32)_mm512_mask_cmpgt_epu16_mask(__u, __a, __b); } __mmask64 test_mm512_cmpge_epi8_mask(__m512i __a, __m512i __b) { // CHECK-LABEL: @test_mm512_cmpge_epi8_mask - // CHECK: @llvm.x86.avx512.mask.cmp.b.512(<64 x i8> {{.*}}, <64 x i8> {{.*}}, i8 5, i64 -1) + // CHECK: @llvm.x86.avx512.mask.cmp.b.512(<64 x i8> {{.*}}, <64 x i8> {{.*}}, i32 5, i64 -1) return (__mmask64)_mm512_cmpge_epi8_mask(__a, __b); } __mmask64 test_mm512_mask_cmpge_epi8_mask(__mmask64 __u, __m512i __a, __m512i __b) { // CHECK-LABEL: @test_mm512_mask_cmpge_epi8_mask - // CHECK: @llvm.x86.avx512.mask.cmp.b.512(<64 x i8> {{.*}}, <64 x i8> {{.*}}, i8 5, i64 {{.*}}) + // CHECK: @llvm.x86.avx512.mask.cmp.b.512(<64 x i8> {{.*}}, <64 x i8> {{.*}}, i32 5, i64 {{.*}}) return (__mmask64)_mm512_mask_cmpge_epi8_mask(__u, __a, __b); } __mmask64 test_mm512_cmpge_epu8_mask(__m512i __a, __m512i __b) { // CHECK-LABEL: @test_mm512_cmpge_epu8_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.b.512(<64 x i8> {{.*}}, <64 x i8> {{.*}}, i8 5, i64 -1) + // CHECK: @llvm.x86.avx512.mask.ucmp.b.512(<64 x i8> {{.*}}, <64 x i8> {{.*}}, i32 5, i64 -1) return (__mmask64)_mm512_cmpge_epu8_mask(__a, __b); } __mmask64 test_mm512_mask_cmpge_epu8_mask(__mmask64 __u, __m512i __a, __m512i __b) { // CHECK-LABEL: @test_mm512_mask_cmpge_epu8_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.b.512(<64 x i8> {{.*}}, <64 x i8> {{.*}}, i8 5, i64 {{.*}}) + // CHECK: @llvm.x86.avx512.mask.ucmp.b.512(<64 x i8> {{.*}}, <64 x i8> {{.*}}, i32 5, i64 {{.*}}) return (__mmask64)_mm512_mask_cmpge_epu8_mask(__u, __a, __b); } __mmask32 test_mm512_cmpge_epi16_mask(__m512i __a, __m512i __b) { // CHECK-LABEL: @test_mm512_cmpge_epi16_mask - // CHECK: @llvm.x86.avx512.mask.cmp.w.512(<32 x i16> {{.*}}, <32 x i16> {{.*}}, i8 5, i32 -1) + // CHECK: @llvm.x86.avx512.mask.cmp.w.512(<32 x i16> {{.*}}, <32 x i16> {{.*}}, i32 5, i32 -1) return (__mmask32)_mm512_cmpge_epi16_mask(__a, __b); } __mmask32 test_mm512_mask_cmpge_epi16_mask(__mmask32 __u, __m512i __a, __m512i __b) { // CHECK-LABEL: @test_mm512_mask_cmpge_epi16_mask - // CHECK: @llvm.x86.avx512.mask.cmp.w.512(<32 x i16> {{.*}}, <32 x i16> {{.*}}, i8 5, i32 {{.*}}) + // CHECK: @llvm.x86.avx512.mask.cmp.w.512(<32 x i16> {{.*}}, <32 x i16> {{.*}}, i32 5, i32 {{.*}}) return (__mmask32)_mm512_mask_cmpge_epi16_mask(__u, __a, __b); } __mmask32 test_mm512_cmpge_epu16_mask(__m512i __a, __m512i __b) { // CHECK-LABEL: @test_mm512_cmpge_epu16_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.w.512(<32 x i16> {{.*}}, <32 x i16> {{.*}}, i8 5, i32 -1) + // CHECK: @llvm.x86.avx512.mask.ucmp.w.512(<32 x i16> {{.*}}, <32 x i16> {{.*}}, i32 5, i32 -1) return (__mmask32)_mm512_cmpge_epu16_mask(__a, __b); } __mmask32 test_mm512_mask_cmpge_epu16_mask(__mmask32 __u, __m512i __a, __m512i __b) { // CHECK-LABEL: @test_mm512_mask_cmpge_epu16_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.w.512(<32 x i16> {{.*}}, <32 x i16> {{.*}}, i8 5, i32 {{.*}}) + // CHECK: @llvm.x86.avx512.mask.ucmp.w.512(<32 x i16> {{.*}}, <32 x i16> {{.*}}, i32 5, i32 {{.*}}) return (__mmask32)_mm512_mask_cmpge_epu16_mask(__u, __a, __b); } __mmask64 test_mm512_cmple_epi8_mask(__m512i __a, __m512i __b) { // CHECK-LABEL: @test_mm512_cmple_epi8_mask - // CHECK: @llvm.x86.avx512.mask.cmp.b.512(<64 x i8> {{.*}}, <64 x i8> {{.*}}, i8 2, i64 -1) + // CHECK: @llvm.x86.avx512.mask.cmp.b.512(<64 x i8> {{.*}}, <64 x i8> {{.*}}, i32 2, i64 -1) return (__mmask64)_mm512_cmple_epi8_mask(__a, __b); } __mmask64 test_mm512_mask_cmple_epi8_mask(__mmask64 __u, __m512i __a, __m512i __b) { // CHECK-LABEL: @test_mm512_mask_cmple_epi8_mask - // CHECK: @llvm.x86.avx512.mask.cmp.b.512(<64 x i8> {{.*}}, <64 x i8> {{.*}}, i8 2, i64 {{.*}}) + // CHECK: @llvm.x86.avx512.mask.cmp.b.512(<64 x i8> {{.*}}, <64 x i8> {{.*}}, i32 2, i64 {{.*}}) return (__mmask64)_mm512_mask_cmple_epi8_mask(__u, __a, __b); } __mmask64 test_mm512_cmple_epu8_mask(__m512i __a, __m512i __b) { // CHECK-LABEL: @test_mm512_cmple_epu8_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.b.512(<64 x i8> {{.*}}, <64 x i8> {{.*}}, i8 2, i64 -1) + // CHECK: @llvm.x86.avx512.mask.ucmp.b.512(<64 x i8> {{.*}}, <64 x i8> {{.*}}, i32 2, i64 -1) return (__mmask64)_mm512_cmple_epu8_mask(__a, __b); } __mmask64 test_mm512_mask_cmple_epu8_mask(__mmask64 __u, __m512i __a, __m512i __b) { // CHECK-LABEL: @test_mm512_mask_cmple_epu8_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.b.512(<64 x i8> {{.*}}, <64 x i8> {{.*}}, i8 2, i64 {{.*}}) + // CHECK: @llvm.x86.avx512.mask.ucmp.b.512(<64 x i8> {{.*}}, <64 x i8> {{.*}}, i32 2, i64 {{.*}}) return (__mmask64)_mm512_mask_cmple_epu8_mask(__u, __a, __b); } __mmask32 test_mm512_cmple_epi16_mask(__m512i __a, __m512i __b) { // CHECK-LABEL: @test_mm512_cmple_epi16_mask - // CHECK: @llvm.x86.avx512.mask.cmp.w.512(<32 x i16> {{.*}}, <32 x i16> {{.*}}, i8 2, i32 -1) + // CHECK: @llvm.x86.avx512.mask.cmp.w.512(<32 x i16> {{.*}}, <32 x i16> {{.*}}, i32 2, i32 -1) return (__mmask32)_mm512_cmple_epi16_mask(__a, __b); } __mmask32 test_mm512_mask_cmple_epi16_mask(__mmask32 __u, __m512i __a, __m512i __b) { // CHECK-LABEL: @test_mm512_mask_cmple_epi16_mask - // CHECK: @llvm.x86.avx512.mask.cmp.w.512(<32 x i16> {{.*}}, <32 x i16> {{.*}}, i8 2, i32 {{.*}}) + // CHECK: @llvm.x86.avx512.mask.cmp.w.512(<32 x i16> {{.*}}, <32 x i16> {{.*}}, i32 2, i32 {{.*}}) return (__mmask32)_mm512_mask_cmple_epi16_mask(__u, __a, __b); } __mmask32 test_mm512_cmple_epu16_mask(__m512i __a, __m512i __b) { // CHECK-LABEL: @test_mm512_cmple_epu16_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.w.512(<32 x i16> {{.*}}, <32 x i16> {{.*}}, i8 2, i32 -1) + // CHECK: @llvm.x86.avx512.mask.ucmp.w.512(<32 x i16> {{.*}}, <32 x i16> {{.*}}, i32 2, i32 -1) return (__mmask32)_mm512_cmple_epu16_mask(__a, __b); } __mmask32 test_mm512_mask_cmple_epu16_mask(__mmask32 __u, __m512i __a, __m512i __b) { // CHECK-LABEL: @test_mm512_mask_cmple_epu16_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.w.512(<32 x i16> {{.*}}, <32 x i16> {{.*}}, i8 2, i32 {{.*}}) + // CHECK: @llvm.x86.avx512.mask.ucmp.w.512(<32 x i16> {{.*}}, <32 x i16> {{.*}}, i32 2, i32 {{.*}}) return (__mmask32)_mm512_mask_cmple_epu16_mask(__u, __a, __b); } __mmask64 test_mm512_cmplt_epi8_mask(__m512i __a, __m512i __b) { // CHECK-LABEL: @test_mm512_cmplt_epi8_mask - // CHECK: @llvm.x86.avx512.mask.cmp.b.512(<64 x i8> {{.*}}, <64 x i8> {{.*}}, i8 1, i64 -1) + // CHECK: @llvm.x86.avx512.mask.cmp.b.512(<64 x i8> {{.*}}, <64 x i8> {{.*}}, i32 1, i64 -1) return (__mmask64)_mm512_cmplt_epi8_mask(__a, __b); } __mmask64 test_mm512_mask_cmplt_epi8_mask(__mmask64 __u, __m512i __a, __m512i __b) { // CHECK-LABEL: @test_mm512_mask_cmplt_epi8_mask - // CHECK: @llvm.x86.avx512.mask.cmp.b.512(<64 x i8> {{.*}}, <64 x i8> {{.*}}, i8 1, i64 {{.*}}) + // CHECK: @llvm.x86.avx512.mask.cmp.b.512(<64 x i8> {{.*}}, <64 x i8> {{.*}}, i32 1, i64 {{.*}}) return (__mmask64)_mm512_mask_cmplt_epi8_mask(__u, __a, __b); } __mmask64 test_mm512_cmplt_epu8_mask(__m512i __a, __m512i __b) { // CHECK-LABEL: @test_mm512_cmplt_epu8_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.b.512(<64 x i8> {{.*}}, <64 x i8> {{.*}}, i8 1, i64 -1) + // CHECK: @llvm.x86.avx512.mask.ucmp.b.512(<64 x i8> {{.*}}, <64 x i8> {{.*}}, i32 1, i64 -1) return (__mmask64)_mm512_cmplt_epu8_mask(__a, __b); } __mmask64 test_mm512_mask_cmplt_epu8_mask(__mmask64 __u, __m512i __a, __m512i __b) { // CHECK-LABEL: @test_mm512_mask_cmplt_epu8_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.b.512(<64 x i8> {{.*}}, <64 x i8> {{.*}}, i8 1, i64 {{.*}}) + // CHECK: @llvm.x86.avx512.mask.ucmp.b.512(<64 x i8> {{.*}}, <64 x i8> {{.*}}, i32 1, i64 {{.*}}) return (__mmask64)_mm512_mask_cmplt_epu8_mask(__u, __a, __b); } __mmask32 test_mm512_cmplt_epi16_mask(__m512i __a, __m512i __b) { // CHECK-LABEL: @test_mm512_cmplt_epi16_mask - // CHECK: @llvm.x86.avx512.mask.cmp.w.512(<32 x i16> {{.*}}, <32 x i16> {{.*}}, i8 1, i32 -1) + // CHECK: @llvm.x86.avx512.mask.cmp.w.512(<32 x i16> {{.*}}, <32 x i16> {{.*}}, i32 1, i32 -1) return (__mmask32)_mm512_cmplt_epi16_mask(__a, __b); } __mmask32 test_mm512_mask_cmplt_epi16_mask(__mmask32 __u, __m512i __a, __m512i __b) { // CHECK-LABEL: @test_mm512_mask_cmplt_epi16_mask - // CHECK: @llvm.x86.avx512.mask.cmp.w.512(<32 x i16> {{.*}}, <32 x i16> {{.*}}, i8 1, i32 {{.*}}) + // CHECK: @llvm.x86.avx512.mask.cmp.w.512(<32 x i16> {{.*}}, <32 x i16> {{.*}}, i32 1, i32 {{.*}}) return (__mmask32)_mm512_mask_cmplt_epi16_mask(__u, __a, __b); } __mmask32 test_mm512_cmplt_epu16_mask(__m512i __a, __m512i __b) { // CHECK-LABEL: @test_mm512_cmplt_epu16_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.w.512(<32 x i16> {{.*}}, <32 x i16> {{.*}}, i8 1, i32 -1) + // CHECK: @llvm.x86.avx512.mask.ucmp.w.512(<32 x i16> {{.*}}, <32 x i16> {{.*}}, i32 1, i32 -1) return (__mmask32)_mm512_cmplt_epu16_mask(__a, __b); } __mmask32 test_mm512_mask_cmplt_epu16_mask(__mmask32 __u, __m512i __a, __m512i __b) { // CHECK-LABEL: @test_mm512_mask_cmplt_epu16_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.w.512(<32 x i16> {{.*}}, <32 x i16> {{.*}}, i8 1, i32 {{.*}}) + // CHECK: @llvm.x86.avx512.mask.ucmp.w.512(<32 x i16> {{.*}}, <32 x i16> {{.*}}, i32 1, i32 {{.*}}) return (__mmask32)_mm512_mask_cmplt_epu16_mask(__u, __a, __b); } __mmask64 test_mm512_cmpneq_epi8_mask(__m512i __a, __m512i __b) { // CHECK-LABEL: @test_mm512_cmpneq_epi8_mask - // CHECK: @llvm.x86.avx512.mask.cmp.b.512(<64 x i8> {{.*}}, <64 x i8> {{.*}}, i8 4, i64 -1) + // CHECK: @llvm.x86.avx512.mask.cmp.b.512(<64 x i8> {{.*}}, <64 x i8> {{.*}}, i32 4, i64 -1) return (__mmask64)_mm512_cmpneq_epi8_mask(__a, __b); } __mmask64 test_mm512_mask_cmpneq_epi8_mask(__mmask64 __u, __m512i __a, __m512i __b) { // CHECK-LABEL: @test_mm512_mask_cmpneq_epi8_mask - // CHECK: @llvm.x86.avx512.mask.cmp.b.512(<64 x i8> {{.*}}, <64 x i8> {{.*}}, i8 4, i64 {{.*}}) + // CHECK: @llvm.x86.avx512.mask.cmp.b.512(<64 x i8> {{.*}}, <64 x i8> {{.*}}, i32 4, i64 {{.*}}) return (__mmask64)_mm512_mask_cmpneq_epi8_mask(__u, __a, __b); } __mmask64 test_mm512_cmpneq_epu8_mask(__m512i __a, __m512i __b) { // CHECK-LABEL: @test_mm512_cmpneq_epu8_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.b.512(<64 x i8> {{.*}}, <64 x i8> {{.*}}, i8 4, i64 -1) + // CHECK: @llvm.x86.avx512.mask.ucmp.b.512(<64 x i8> {{.*}}, <64 x i8> {{.*}}, i32 4, i64 -1) return (__mmask64)_mm512_cmpneq_epu8_mask(__a, __b); } __mmask64 test_mm512_mask_cmpneq_epu8_mask(__mmask64 __u, __m512i __a, __m512i __b) { // CHECK-LABEL: @test_mm512_mask_cmpneq_epu8_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.b.512(<64 x i8> {{.*}}, <64 x i8> {{.*}}, i8 4, i64 {{.*}}) + // CHECK: @llvm.x86.avx512.mask.ucmp.b.512(<64 x i8> {{.*}}, <64 x i8> {{.*}}, i32 4, i64 {{.*}}) return (__mmask64)_mm512_mask_cmpneq_epu8_mask(__u, __a, __b); } __mmask32 test_mm512_cmpneq_epi16_mask(__m512i __a, __m512i __b) { // CHECK-LABEL: @test_mm512_cmpneq_epi16_mask - // CHECK: @llvm.x86.avx512.mask.cmp.w.512(<32 x i16> {{.*}}, <32 x i16> {{.*}}, i8 4, i32 -1) + // CHECK: @llvm.x86.avx512.mask.cmp.w.512(<32 x i16> {{.*}}, <32 x i16> {{.*}}, i32 4, i32 -1) return (__mmask32)_mm512_cmpneq_epi16_mask(__a, __b); } __mmask32 test_mm512_mask_cmpneq_epi16_mask(__mmask32 __u, __m512i __a, __m512i __b) { // CHECK-LABEL: @test_mm512_mask_cmpneq_epi16_mask - // CHECK: @llvm.x86.avx512.mask.cmp.w.512(<32 x i16> {{.*}}, <32 x i16> {{.*}}, i8 4, i32 {{.*}}) + // CHECK: @llvm.x86.avx512.mask.cmp.w.512(<32 x i16> {{.*}}, <32 x i16> {{.*}}, i32 4, i32 {{.*}}) return (__mmask32)_mm512_mask_cmpneq_epi16_mask(__u, __a, __b); } __mmask32 test_mm512_cmpneq_epu16_mask(__m512i __a, __m512i __b) { // CHECK-LABEL: @test_mm512_cmpneq_epu16_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.w.512(<32 x i16> {{.*}}, <32 x i16> {{.*}}, i8 4, i32 -1) + // CHECK: @llvm.x86.avx512.mask.ucmp.w.512(<32 x i16> {{.*}}, <32 x i16> {{.*}}, i32 4, i32 -1) return (__mmask32)_mm512_cmpneq_epu16_mask(__a, __b); } __mmask32 test_mm512_mask_cmpneq_epu16_mask(__mmask32 __u, __m512i __a, __m512i __b) { // CHECK-LABEL: @test_mm512_mask_cmpneq_epu16_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.w.512(<32 x i16> {{.*}}, <32 x i16> {{.*}}, i8 4, i32 {{.*}}) + // CHECK: @llvm.x86.avx512.mask.ucmp.w.512(<32 x i16> {{.*}}, <32 x i16> {{.*}}, i32 4, i32 {{.*}}) return (__mmask32)_mm512_mask_cmpneq_epu16_mask(__u, __a, __b); } __mmask64 test_mm512_cmp_epi8_mask(__m512i __a, __m512i __b) { // CHECK-LABEL: @test_mm512_cmp_epi8_mask - // CHECK: @llvm.x86.avx512.mask.cmp.b.512(<64 x i8> {{.*}}, <64 x i8> {{.*}}, i8 7, i64 -1) + // CHECK: @llvm.x86.avx512.mask.cmp.b.512(<64 x i8> {{.*}}, <64 x i8> {{.*}}, i32 7, i64 -1) return (__mmask64)_mm512_cmp_epi8_mask(__a, __b, 7); } __mmask64 test_mm512_mask_cmp_epi8_mask(__mmask64 __u, __m512i __a, __m512i __b) { // CHECK-LABEL: @test_mm512_mask_cmp_epi8_mask - // CHECK: @llvm.x86.avx512.mask.cmp.b.512(<64 x i8> {{.*}}, <64 x i8> {{.*}}, i8 7, i64 {{.*}}) + // CHECK: @llvm.x86.avx512.mask.cmp.b.512(<64 x i8> {{.*}}, <64 x i8> {{.*}}, i32 7, i64 {{.*}}) return (__mmask64)_mm512_mask_cmp_epi8_mask(__u, __a, __b, 7); } __mmask64 test_mm512_cmp_epu8_mask(__m512i __a, __m512i __b) { // CHECK-LABEL: @test_mm512_cmp_epu8_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.b.512(<64 x i8> {{.*}}, <64 x i8> {{.*}}, i8 7, i64 -1) + // CHECK: @llvm.x86.avx512.mask.ucmp.b.512(<64 x i8> {{.*}}, <64 x i8> {{.*}}, i32 7, i64 -1) return (__mmask64)_mm512_cmp_epu8_mask(__a, __b, 7); } __mmask64 test_mm512_mask_cmp_epu8_mask(__mmask64 __u, __m512i __a, __m512i __b) { // CHECK-LABEL: @test_mm512_mask_cmp_epu8_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.b.512(<64 x i8> {{.*}}, <64 x i8> {{.*}}, i8 7, i64 {{.*}}) + // CHECK: @llvm.x86.avx512.mask.ucmp.b.512(<64 x i8> {{.*}}, <64 x i8> {{.*}}, i32 7, i64 {{.*}}) return (__mmask64)_mm512_mask_cmp_epu8_mask(__u, __a, __b, 7); } __mmask32 test_mm512_cmp_epi16_mask(__m512i __a, __m512i __b) { // CHECK-LABEL: @test_mm512_cmp_epi16_mask - // CHECK: @llvm.x86.avx512.mask.cmp.w.512(<32 x i16> {{.*}}, <32 x i16> {{.*}}, i8 7, i32 -1) + // CHECK: @llvm.x86.avx512.mask.cmp.w.512(<32 x i16> {{.*}}, <32 x i16> {{.*}}, i32 7, i32 -1) return (__mmask32)_mm512_cmp_epi16_mask(__a, __b, 7); } __mmask32 test_mm512_mask_cmp_epi16_mask(__mmask32 __u, __m512i __a, __m512i __b) { // CHECK-LABEL: @test_mm512_mask_cmp_epi16_mask - // CHECK: @llvm.x86.avx512.mask.cmp.w.512(<32 x i16> {{.*}}, <32 x i16> {{.*}}, i8 7, i32 {{.*}}) + // CHECK: @llvm.x86.avx512.mask.cmp.w.512(<32 x i16> {{.*}}, <32 x i16> {{.*}}, i32 7, i32 {{.*}}) return (__mmask32)_mm512_mask_cmp_epi16_mask(__u, __a, __b, 7); } __mmask32 test_mm512_cmp_epu16_mask(__m512i __a, __m512i __b) { // CHECK-LABEL: @test_mm512_cmp_epu16_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.w.512(<32 x i16> {{.*}}, <32 x i16> {{.*}}, i8 7, i32 -1) + // CHECK: @llvm.x86.avx512.mask.ucmp.w.512(<32 x i16> {{.*}}, <32 x i16> {{.*}}, i32 7, i32 -1) return (__mmask32)_mm512_cmp_epu16_mask(__a, __b, 7); } __mmask32 test_mm512_mask_cmp_epu16_mask(__mmask32 __u, __m512i __a, __m512i __b) { // CHECK-LABEL: @test_mm512_mask_cmp_epu16_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.w.512(<32 x i16> {{.*}}, <32 x i16> {{.*}}, i8 7, i32 {{.*}}) + // CHECK: @llvm.x86.avx512.mask.ucmp.w.512(<32 x i16> {{.*}}, <32 x i16> {{.*}}, i32 7, i32 {{.*}}) return (__mmask32)_mm512_mask_cmp_epu16_mask(__u, __a, __b, 7); } diff --git a/test/CodeGen/avx512f-builtins.c b/test/CodeGen/avx512f-builtins.c index 05b861b219..2f19f99e4f 100644 --- a/test/CodeGen/avx512f-builtins.c +++ b/test/CodeGen/avx512f-builtins.c @@ -348,289 +348,289 @@ __m128 test_mm512_extractf32x4_ps(__m512 a) __mmask16 test_mm512_cmpeq_epu32_mask(__m512i __a, __m512i __b) { // CHECK-LABEL: @test_mm512_cmpeq_epu32_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.d.512(<16 x i32> {{.*}}, <16 x i32> {{.*}}, i8 0, i16 -1) + // CHECK: @llvm.x86.avx512.mask.ucmp.d.512(<16 x i32> {{.*}}, <16 x i32> {{.*}}, i32 0, i16 -1) return (__mmask16)_mm512_cmpeq_epu32_mask(__a, __b); } __mmask16 test_mm512_mask_cmpeq_epu32_mask(__mmask16 __u, __m512i __a, __m512i __b) { // CHECK-LABEL: @test_mm512_mask_cmpeq_epu32_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.d.512(<16 x i32> {{.*}}, <16 x i32> {{.*}}, i8 0, i16 {{.*}}) + // CHECK: @llvm.x86.avx512.mask.ucmp.d.512(<16 x i32> {{.*}}, <16 x i32> {{.*}}, i32 0, i16 {{.*}}) return (__mmask16)_mm512_mask_cmpeq_epu32_mask(__u, __a, __b); } __mmask8 test_mm512_cmpeq_epu64_mask(__m512i __a, __m512i __b) { // CHECK-LABEL: @test_mm512_cmpeq_epu64_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.q.512(<8 x i64> {{.*}}, <8 x i64> {{.*}}, i8 0, i8 -1) + // CHECK: @llvm.x86.avx512.mask.ucmp.q.512(<8 x i64> {{.*}}, <8 x i64> {{.*}}, i32 0, i8 -1) return (__mmask8)_mm512_cmpeq_epu64_mask(__a, __b); } __mmask8 test_mm512_mask_cmpeq_epu64_mask(__mmask8 __u, __m512i __a, __m512i __b) { // CHECK-LABEL: @test_mm512_mask_cmpeq_epu64_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.q.512(<8 x i64> {{.*}}, <8 x i64> {{.*}}, i8 0, i8 {{.*}}) + // CHECK: @llvm.x86.avx512.mask.ucmp.q.512(<8 x i64> {{.*}}, <8 x i64> {{.*}}, i32 0, i8 {{.*}}) return (__mmask8)_mm512_mask_cmpeq_epu64_mask(__u, __a, __b); } __mmask16 test_mm512_cmpge_epi32_mask(__m512i __a, __m512i __b) { // CHECK-LABEL: @test_mm512_cmpge_epi32_mask - // CHECK: @llvm.x86.avx512.mask.cmp.d.512(<16 x i32> {{.*}}, <16 x i32> {{.*}}, i8 5, i16 -1) + // CHECK: @llvm.x86.avx512.mask.cmp.d.512(<16 x i32> {{.*}}, <16 x i32> {{.*}}, i32 5, i16 -1) return (__mmask16)_mm512_cmpge_epi32_mask(__a, __b); } __mmask16 test_mm512_mask_cmpge_epi32_mask(__mmask16 __u, __m512i __a, __m512i __b) { // CHECK-LABEL: @test_mm512_mask_cmpge_epi32_mask - // CHECK: @llvm.x86.avx512.mask.cmp.d.512(<16 x i32> {{.*}}, <16 x i32> {{.*}}, i8 5, i16 {{.*}}) + // CHECK: @llvm.x86.avx512.mask.cmp.d.512(<16 x i32> {{.*}}, <16 x i32> {{.*}}, i32 5, i16 {{.*}}) return (__mmask16)_mm512_mask_cmpge_epi32_mask(__u, __a, __b); } __mmask8 test_mm512_cmpge_epi64_mask(__m512i __a, __m512i __b) { // CHECK-LABEL: @test_mm512_cmpge_epi64_mask - // CHECK: @llvm.x86.avx512.mask.cmp.q.512(<8 x i64> {{.*}}, <8 x i64> {{.*}}, i8 5, i8 -1) + // CHECK: @llvm.x86.avx512.mask.cmp.q.512(<8 x i64> {{.*}}, <8 x i64> {{.*}}, i32 5, i8 -1) return (__mmask8)_mm512_cmpge_epi64_mask(__a, __b); } __mmask8 test_mm512_mask_cmpge_epi64_mask(__mmask8 __u, __m512i __a, __m512i __b) { // CHECK-LABEL: @test_mm512_mask_cmpge_epi64_mask - // CHECK: @llvm.x86.avx512.mask.cmp.q.512(<8 x i64> {{.*}}, <8 x i64> {{.*}}, i8 5, i8 {{.*}}) + // CHECK: @llvm.x86.avx512.mask.cmp.q.512(<8 x i64> {{.*}}, <8 x i64> {{.*}}, i32 5, i8 {{.*}}) return (__mmask8)_mm512_mask_cmpge_epi64_mask(__u, __a, __b); } __mmask16 test_mm512_cmpge_epu32_mask(__m512i __a, __m512i __b) { // CHECK-LABEL: @test_mm512_cmpge_epu32_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.d.512(<16 x i32> {{.*}}, <16 x i32> {{.*}}, i8 5, i16 -1) + // CHECK: @llvm.x86.avx512.mask.ucmp.d.512(<16 x i32> {{.*}}, <16 x i32> {{.*}}, i32 5, i16 -1) return (__mmask16)_mm512_cmpge_epu32_mask(__a, __b); } __mmask16 test_mm512_mask_cmpge_epu32_mask(__mmask16 __u, __m512i __a, __m512i __b) { // CHECK-LABEL: @test_mm512_mask_cmpge_epu32_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.d.512(<16 x i32> {{.*}}, <16 x i32> {{.*}}, i8 5, i16 {{.*}}) + // CHECK: @llvm.x86.avx512.mask.ucmp.d.512(<16 x i32> {{.*}}, <16 x i32> {{.*}}, i32 5, i16 {{.*}}) return (__mmask16)_mm512_mask_cmpge_epu32_mask(__u, __a, __b); } __mmask8 test_mm512_cmpge_epu64_mask(__m512i __a, __m512i __b) { // CHECK-LABEL: @test_mm512_cmpge_epu64_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.q.512(<8 x i64> {{.*}}, <8 x i64> {{.*}}, i8 5, i8 -1) + // CHECK: @llvm.x86.avx512.mask.ucmp.q.512(<8 x i64> {{.*}}, <8 x i64> {{.*}}, i32 5, i8 -1) return (__mmask8)_mm512_cmpge_epu64_mask(__a, __b); } __mmask8 test_mm512_mask_cmpge_epu64_mask(__mmask8 __u, __m512i __a, __m512i __b) { // CHECK-LABEL: @test_mm512_mask_cmpge_epu64_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.q.512(<8 x i64> {{.*}}, <8 x i64> {{.*}}, i8 5, i8 {{.*}}) + // CHECK: @llvm.x86.avx512.mask.ucmp.q.512(<8 x i64> {{.*}}, <8 x i64> {{.*}}, i32 5, i8 {{.*}}) return (__mmask8)_mm512_mask_cmpge_epu64_mask(__u, __a, __b); } __mmask16 test_mm512_cmpgt_epu32_mask(__m512i __a, __m512i __b) { // CHECK-LABEL: @test_mm512_cmpgt_epu32_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.d.512(<16 x i32> {{.*}}, <16 x i32> {{.*}}, i8 6, i16 -1) + // CHECK: @llvm.x86.avx512.mask.ucmp.d.512(<16 x i32> {{.*}}, <16 x i32> {{.*}}, i32 6, i16 -1) return (__mmask16)_mm512_cmpgt_epu32_mask(__a, __b); } __mmask16 test_mm512_mask_cmpgt_epu32_mask(__mmask16 __u, __m512i __a, __m512i __b) { // CHECK-LABEL: @test_mm512_mask_cmpgt_epu32_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.d.512(<16 x i32> {{.*}}, <16 x i32> {{.*}}, i8 6, i16 {{.*}}) + // CHECK: @llvm.x86.avx512.mask.ucmp.d.512(<16 x i32> {{.*}}, <16 x i32> {{.*}}, i32 6, i16 {{.*}}) return (__mmask16)_mm512_mask_cmpgt_epu32_mask(__u, __a, __b); } __mmask8 test_mm512_cmpgt_epu64_mask(__m512i __a, __m512i __b) { // CHECK-LABEL: @test_mm512_cmpgt_epu64_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.q.512(<8 x i64> {{.*}}, <8 x i64> {{.*}}, i8 6, i8 -1) + // CHECK: @llvm.x86.avx512.mask.ucmp.q.512(<8 x i64> {{.*}}, <8 x i64> {{.*}}, i32 6, i8 -1) return (__mmask8)_mm512_cmpgt_epu64_mask(__a, __b); } __mmask8 test_mm512_mask_cmpgt_epu64_mask(__mmask8 __u, __m512i __a, __m512i __b) { // CHECK-LABEL: @test_mm512_mask_cmpgt_epu64_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.q.512(<8 x i64> {{.*}}, <8 x i64> {{.*}}, i8 6, i8 {{.*}}) + // CHECK: @llvm.x86.avx512.mask.ucmp.q.512(<8 x i64> {{.*}}, <8 x i64> {{.*}}, i32 6, i8 {{.*}}) return (__mmask8)_mm512_mask_cmpgt_epu64_mask(__u, __a, __b); } __mmask16 test_mm512_cmple_epi32_mask(__m512i __a, __m512i __b) { // CHECK-LABEL: @test_mm512_cmple_epi32_mask - // CHECK: @llvm.x86.avx512.mask.cmp.d.512(<16 x i32> {{.*}}, <16 x i32> {{.*}}, i8 2, i16 -1) + // CHECK: @llvm.x86.avx512.mask.cmp.d.512(<16 x i32> {{.*}}, <16 x i32> {{.*}}, i32 2, i16 -1) return (__mmask16)_mm512_cmple_epi32_mask(__a, __b); } __mmask16 test_mm512_mask_cmple_epi32_mask(__mmask16 __u, __m512i __a, __m512i __b) { // CHECK-LABEL: @test_mm512_mask_cmple_epi32_mask - // CHECK: @llvm.x86.avx512.mask.cmp.d.512(<16 x i32> {{.*}}, <16 x i32> {{.*}}, i8 2, i16 {{.*}}) + // CHECK: @llvm.x86.avx512.mask.cmp.d.512(<16 x i32> {{.*}}, <16 x i32> {{.*}}, i32 2, i16 {{.*}}) return (__mmask16)_mm512_mask_cmple_epi32_mask(__u, __a, __b); } __mmask8 test_mm512_cmple_epi64_mask(__m512i __a, __m512i __b) { // CHECK-LABEL: @test_mm512_cmple_epi64_mask - // CHECK: @llvm.x86.avx512.mask.cmp.q.512(<8 x i64> {{.*}}, <8 x i64> {{.*}}, i8 2, i8 -1) + // CHECK: @llvm.x86.avx512.mask.cmp.q.512(<8 x i64> {{.*}}, <8 x i64> {{.*}}, i32 2, i8 -1) return (__mmask8)_mm512_cmple_epi64_mask(__a, __b); } __mmask8 test_mm512_mask_cmple_epi64_mask(__mmask8 __u, __m512i __a, __m512i __b) { // CHECK-LABEL: @test_mm512_mask_cmple_epi64_mask - // CHECK: @llvm.x86.avx512.mask.cmp.q.512(<8 x i64> {{.*}}, <8 x i64> {{.*}}, i8 2, i8 {{.*}}) + // CHECK: @llvm.x86.avx512.mask.cmp.q.512(<8 x i64> {{.*}}, <8 x i64> {{.*}}, i32 2, i8 {{.*}}) return (__mmask8)_mm512_mask_cmple_epi64_mask(__u, __a, __b); } __mmask16 test_mm512_cmple_epu32_mask(__m512i __a, __m512i __b) { // CHECK-LABEL: @test_mm512_cmple_epu32_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.d.512(<16 x i32> {{.*}}, <16 x i32> {{.*}}, i8 2, i16 -1) + // CHECK: @llvm.x86.avx512.mask.ucmp.d.512(<16 x i32> {{.*}}, <16 x i32> {{.*}}, i32 2, i16 -1) return (__mmask16)_mm512_cmple_epu32_mask(__a, __b); } __mmask16 test_mm512_mask_cmple_epu32_mask(__mmask16 __u, __m512i __a, __m512i __b) { // CHECK-LABEL: @test_mm512_mask_cmple_epu32_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.d.512(<16 x i32> {{.*}}, <16 x i32> {{.*}}, i8 2, i16 {{.*}}) + // CHECK: @llvm.x86.avx512.mask.ucmp.d.512(<16 x i32> {{.*}}, <16 x i32> {{.*}}, i32 2, i16 {{.*}}) return (__mmask16)_mm512_mask_cmple_epu32_mask(__u, __a, __b); } __mmask8 test_mm512_cmple_epu64_mask(__m512i __a, __m512i __b) { // CHECK-LABEL: @test_mm512_cmple_epu64_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.q.512(<8 x i64> {{.*}}, <8 x i64> {{.*}}, i8 2, i8 -1) + // CHECK: @llvm.x86.avx512.mask.ucmp.q.512(<8 x i64> {{.*}}, <8 x i64> {{.*}}, i32 2, i8 -1) return (__mmask8)_mm512_cmple_epu64_mask(__a, __b); } __mmask8 test_mm512_mask_cmple_epu64_mask(__mmask8 __u, __m512i __a, __m512i __b) { // CHECK-LABEL: @test_mm512_mask_cmple_epu64_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.q.512(<8 x i64> {{.*}}, <8 x i64> {{.*}}, i8 2, i8 {{.*}}) + // CHECK: @llvm.x86.avx512.mask.ucmp.q.512(<8 x i64> {{.*}}, <8 x i64> {{.*}}, i32 2, i8 {{.*}}) return (__mmask8)_mm512_mask_cmple_epu64_mask(__u, __a, __b); } __mmask16 test_mm512_cmplt_epi32_mask(__m512i __a, __m512i __b) { // CHECK-LABEL: @test_mm512_cmplt_epi32_mask - // CHECK: @llvm.x86.avx512.mask.cmp.d.512(<16 x i32> {{.*}}, <16 x i32> {{.*}}, i8 1, i16 -1) + // CHECK: @llvm.x86.avx512.mask.cmp.d.512(<16 x i32> {{.*}}, <16 x i32> {{.*}}, i32 1, i16 -1) return (__mmask16)_mm512_cmplt_epi32_mask(__a, __b); } __mmask16 test_mm512_mask_cmplt_epi32_mask(__mmask16 __u, __m512i __a, __m512i __b) { // CHECK-LABEL: @test_mm512_mask_cmplt_epi32_mask - // CHECK: @llvm.x86.avx512.mask.cmp.d.512(<16 x i32> {{.*}}, <16 x i32> {{.*}}, i8 1, i16 {{.*}}) + // CHECK: @llvm.x86.avx512.mask.cmp.d.512(<16 x i32> {{.*}}, <16 x i32> {{.*}}, i32 1, i16 {{.*}}) return (__mmask16)_mm512_mask_cmplt_epi32_mask(__u, __a, __b); } __mmask8 test_mm512_cmplt_epi64_mask(__m512i __a, __m512i __b) { // CHECK-LABEL: @test_mm512_cmplt_epi64_mask - // CHECK: @llvm.x86.avx512.mask.cmp.q.512(<8 x i64> {{.*}}, <8 x i64> {{.*}}, i8 1, i8 -1) + // CHECK: @llvm.x86.avx512.mask.cmp.q.512(<8 x i64> {{.*}}, <8 x i64> {{.*}}, i32 1, i8 -1) return (__mmask8)_mm512_cmplt_epi64_mask(__a, __b); } __mmask8 test_mm512_mask_cmplt_epi64_mask(__mmask8 __u, __m512i __a, __m512i __b) { // CHECK-LABEL: @test_mm512_mask_cmplt_epi64_mask - // CHECK: @llvm.x86.avx512.mask.cmp.q.512(<8 x i64> {{.*}}, <8 x i64> {{.*}}, i8 1, i8 {{.*}}) + // CHECK: @llvm.x86.avx512.mask.cmp.q.512(<8 x i64> {{.*}}, <8 x i64> {{.*}}, i32 1, i8 {{.*}}) return (__mmask8)_mm512_mask_cmplt_epi64_mask(__u, __a, __b); } __mmask16 test_mm512_cmplt_epu32_mask(__m512i __a, __m512i __b) { // CHECK-LABEL: @test_mm512_cmplt_epu32_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.d.512(<16 x i32> {{.*}}, <16 x i32> {{.*}}, i8 1, i16 -1) + // CHECK: @llvm.x86.avx512.mask.ucmp.d.512(<16 x i32> {{.*}}, <16 x i32> {{.*}}, i32 1, i16 -1) return (__mmask16)_mm512_cmplt_epu32_mask(__a, __b); } __mmask16 test_mm512_mask_cmplt_epu32_mask(__mmask16 __u, __m512i __a, __m512i __b) { // CHECK-LABEL: @test_mm512_mask_cmplt_epu32_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.d.512(<16 x i32> {{.*}}, <16 x i32> {{.*}}, i8 1, i16 {{.*}}) + // CHECK: @llvm.x86.avx512.mask.ucmp.d.512(<16 x i32> {{.*}}, <16 x i32> {{.*}}, i32 1, i16 {{.*}}) return (__mmask16)_mm512_mask_cmplt_epu32_mask(__u, __a, __b); } __mmask8 test_mm512_cmplt_epu64_mask(__m512i __a, __m512i __b) { // CHECK-LABEL: @test_mm512_cmplt_epu64_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.q.512(<8 x i64> {{.*}}, <8 x i64> {{.*}}, i8 1, i8 -1) + // CHECK: @llvm.x86.avx512.mask.ucmp.q.512(<8 x i64> {{.*}}, <8 x i64> {{.*}}, i32 1, i8 -1) return (__mmask8)_mm512_cmplt_epu64_mask(__a, __b); } __mmask8 test_mm512_mask_cmplt_epu64_mask(__mmask8 __u, __m512i __a, __m512i __b) { // CHECK-LABEL: @test_mm512_mask_cmplt_epu64_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.q.512(<8 x i64> {{.*}}, <8 x i64> {{.*}}, i8 1, i8 {{.*}}) + // CHECK: @llvm.x86.avx512.mask.ucmp.q.512(<8 x i64> {{.*}}, <8 x i64> {{.*}}, i32 1, i8 {{.*}}) return (__mmask8)_mm512_mask_cmplt_epu64_mask(__u, __a, __b); } __mmask16 test_mm512_cmpneq_epi32_mask(__m512i __a, __m512i __b) { // CHECK-LABEL: @test_mm512_cmpneq_epi32_mask - // CHECK: @llvm.x86.avx512.mask.cmp.d.512(<16 x i32> {{.*}}, <16 x i32> {{.*}}, i8 4, i16 -1) + // CHECK: @llvm.x86.avx512.mask.cmp.d.512(<16 x i32> {{.*}}, <16 x i32> {{.*}}, i32 4, i16 -1) return (__mmask16)_mm512_cmpneq_epi32_mask(__a, __b); } __mmask16 test_mm512_mask_cmpneq_epi32_mask(__mmask16 __u, __m512i __a, __m512i __b) { // CHECK-LABEL: @test_mm512_mask_cmpneq_epi32_mask - // CHECK: @llvm.x86.avx512.mask.cmp.d.512(<16 x i32> {{.*}}, <16 x i32> {{.*}}, i8 4, i16 {{.*}}) + // CHECK: @llvm.x86.avx512.mask.cmp.d.512(<16 x i32> {{.*}}, <16 x i32> {{.*}}, i32 4, i16 {{.*}}) return (__mmask16)_mm512_mask_cmpneq_epi32_mask(__u, __a, __b); } __mmask8 test_mm512_cmpneq_epi64_mask(__m512i __a, __m512i __b) { // CHECK-LABEL: @test_mm512_cmpneq_epi64_mask - // CHECK: @llvm.x86.avx512.mask.cmp.q.512(<8 x i64> {{.*}}, <8 x i64> {{.*}}, i8 4, i8 -1) + // CHECK: @llvm.x86.avx512.mask.cmp.q.512(<8 x i64> {{.*}}, <8 x i64> {{.*}}, i32 4, i8 -1) return (__mmask8)_mm512_cmpneq_epi64_mask(__a, __b); } __mmask8 test_mm512_mask_cmpneq_epi64_mask(__mmask8 __u, __m512i __a, __m512i __b) { // CHECK-LABEL: @test_mm512_mask_cmpneq_epi64_mask - // CHECK: @llvm.x86.avx512.mask.cmp.q.512(<8 x i64> {{.*}}, <8 x i64> {{.*}}, i8 4, i8 {{.*}}) + // CHECK: @llvm.x86.avx512.mask.cmp.q.512(<8 x i64> {{.*}}, <8 x i64> {{.*}}, i32 4, i8 {{.*}}) return (__mmask8)_mm512_mask_cmpneq_epi64_mask(__u, __a, __b); } __mmask16 test_mm512_cmpneq_epu32_mask(__m512i __a, __m512i __b) { // CHECK-LABEL: @test_mm512_cmpneq_epu32_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.d.512(<16 x i32> {{.*}}, <16 x i32> {{.*}}, i8 4, i16 -1) + // CHECK: @llvm.x86.avx512.mask.ucmp.d.512(<16 x i32> {{.*}}, <16 x i32> {{.*}}, i32 4, i16 -1) return (__mmask16)_mm512_cmpneq_epu32_mask(__a, __b); } __mmask16 test_mm512_mask_cmpneq_epu32_mask(__mmask16 __u, __m512i __a, __m512i __b) { // CHECK-LABEL: @test_mm512_mask_cmpneq_epu32_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.d.512(<16 x i32> {{.*}}, <16 x i32> {{.*}}, i8 4, i16 {{.*}}) + // CHECK: @llvm.x86.avx512.mask.ucmp.d.512(<16 x i32> {{.*}}, <16 x i32> {{.*}}, i32 4, i16 {{.*}}) return (__mmask16)_mm512_mask_cmpneq_epu32_mask(__u, __a, __b); } __mmask8 test_mm512_cmpneq_epu64_mask(__m512i __a, __m512i __b) { // CHECK-LABEL: @test_mm512_cmpneq_epu64_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.q.512(<8 x i64> {{.*}}, <8 x i64> {{.*}}, i8 4, i8 -1) + // CHECK: @llvm.x86.avx512.mask.ucmp.q.512(<8 x i64> {{.*}}, <8 x i64> {{.*}}, i32 4, i8 -1) return (__mmask8)_mm512_cmpneq_epu64_mask(__a, __b); } __mmask8 test_mm512_mask_cmpneq_epu64_mask(__mmask8 __u, __m512i __a, __m512i __b) { // CHECK-LABEL: @test_mm512_mask_cmpneq_epu64_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.q.512(<8 x i64> {{.*}}, <8 x i64> {{.*}}, i8 4, i8 {{.*}}) + // CHECK: @llvm.x86.avx512.mask.ucmp.q.512(<8 x i64> {{.*}}, <8 x i64> {{.*}}, i32 4, i8 {{.*}}) return (__mmask8)_mm512_mask_cmpneq_epu64_mask(__u, __a, __b); } __mmask16 test_mm512_cmp_epi32_mask(__m512i __a, __m512i __b) { // CHECK-LABEL: @test_mm512_cmp_epi32_mask - // CHECK: @llvm.x86.avx512.mask.cmp.d.512(<16 x i32> {{.*}}, <16 x i32> {{.*}}, i8 3, i16 -1) + // CHECK: @llvm.x86.avx512.mask.cmp.d.512(<16 x i32> {{.*}}, <16 x i32> {{.*}}, i32 3, i16 -1) return (__mmask16)_mm512_cmp_epi32_mask(__a, __b, 3); } __mmask16 test_mm512_mask_cmp_epi32_mask(__mmask16 __u, __m512i __a, __m512i __b) { // CHECK-LABEL: @test_mm512_mask_cmp_epi32_mask - // CHECK: @llvm.x86.avx512.mask.cmp.d.512(<16 x i32> {{.*}}, <16 x i32> {{.*}}, i8 3, i16 {{.*}}) + // CHECK: @llvm.x86.avx512.mask.cmp.d.512(<16 x i32> {{.*}}, <16 x i32> {{.*}}, i32 3, i16 {{.*}}) return (__mmask16)_mm512_mask_cmp_epi32_mask(__u, __a, __b, 3); } __mmask8 test_mm512_cmp_epi64_mask(__m512i __a, __m512i __b) { // CHECK-LABEL: @test_mm512_cmp_epi64_mask - // CHECK: @llvm.x86.avx512.mask.cmp.q.512(<8 x i64> {{.*}}, <8 x i64> {{.*}}, i8 3, i8 -1) + // CHECK: @llvm.x86.avx512.mask.cmp.q.512(<8 x i64> {{.*}}, <8 x i64> {{.*}}, i32 3, i8 -1) return (__mmask8)_mm512_cmp_epi64_mask(__a, __b, 3); } __mmask8 test_mm512_mask_cmp_epi64_mask(__mmask8 __u, __m512i __a, __m512i __b) { // CHECK-LABEL: @test_mm512_mask_cmp_epi64_mask - // CHECK: @llvm.x86.avx512.mask.cmp.q.512(<8 x i64> {{.*}}, <8 x i64> {{.*}}, i8 3, i8 {{.*}}) + // CHECK: @llvm.x86.avx512.mask.cmp.q.512(<8 x i64> {{.*}}, <8 x i64> {{.*}}, i32 3, i8 {{.*}}) return (__mmask8)_mm512_mask_cmp_epi64_mask(__u, __a, __b, 3); } __mmask16 test_mm512_cmp_epu32_mask(__m512i __a, __m512i __b) { // CHECK-LABEL: @test_mm512_cmp_epu32_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.d.512(<16 x i32> {{.*}}, <16 x i32> {{.*}}, i8 3, i16 -1) + // CHECK: @llvm.x86.avx512.mask.ucmp.d.512(<16 x i32> {{.*}}, <16 x i32> {{.*}}, i32 3, i16 -1) return (__mmask16)_mm512_cmp_epu32_mask(__a, __b, 3); } __mmask16 test_mm512_mask_cmp_epu32_mask(__mmask16 __u, __m512i __a, __m512i __b) { // CHECK-LABEL: @test_mm512_mask_cmp_epu32_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.d.512(<16 x i32> {{.*}}, <16 x i32> {{.*}}, i8 3, i16 {{.*}}) + // CHECK: @llvm.x86.avx512.mask.ucmp.d.512(<16 x i32> {{.*}}, <16 x i32> {{.*}}, i32 3, i16 {{.*}}) return (__mmask16)_mm512_mask_cmp_epu32_mask(__u, __a, __b, 3); } __mmask8 test_mm512_cmp_epu64_mask(__m512i __a, __m512i __b) { // CHECK-LABEL: @test_mm512_cmp_epu64_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.q.512(<8 x i64> {{.*}}, <8 x i64> {{.*}}, i8 3, i8 -1) + // CHECK: @llvm.x86.avx512.mask.ucmp.q.512(<8 x i64> {{.*}}, <8 x i64> {{.*}}, i32 3, i8 -1) return (__mmask8)_mm512_cmp_epu64_mask(__a, __b, 3); } __mmask8 test_mm512_mask_cmp_epu64_mask(__mmask8 __u, __m512i __a, __m512i __b) { // CHECK-LABEL: @test_mm512_mask_cmp_epu64_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.q.512(<8 x i64> {{.*}}, <8 x i64> {{.*}}, i8 3, i8 {{.*}}) + // CHECK: @llvm.x86.avx512.mask.ucmp.q.512(<8 x i64> {{.*}}, <8 x i64> {{.*}}, i32 3, i8 {{.*}}) return (__mmask8)_mm512_mask_cmp_epu64_mask(__u, __a, __b, 3); } diff --git a/test/CodeGen/avx512vl-builtins.c b/test/CodeGen/avx512vl-builtins.c index e9b65ae0e8..9446d467f7 100644 --- a/test/CodeGen/avx512vl-builtins.c +++ b/test/CodeGen/avx512vl-builtins.c @@ -100,553 +100,553 @@ __mmask8 test_mm_mask_cmpgt_epi64_mask(__mmask8 __u, __m128i __a, __m128i __b) { __mmask8 test_mm_cmpeq_epu32_mask(__m128i __a, __m128i __b) { // CHECK-LABEL: @test_mm_cmpeq_epu32_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.d.128(<4 x i32> {{.*}}, <4 x i32> {{.*}}, i8 0, i8 -1) + // CHECK: @llvm.x86.avx512.mask.ucmp.d.128(<4 x i32> {{.*}}, <4 x i32> {{.*}}, i32 0, i8 -1) return (__mmask8)_mm_cmpeq_epu32_mask(__a, __b); } __mmask8 test_mm_mask_cmpeq_epu32_mask(__mmask8 __u, __m128i __a, __m128i __b) { // CHECK-LABEL: @test_mm_mask_cmpeq_epu32_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.d.128(<4 x i32> {{.*}}, <4 x i32> {{.*}}, i8 0, i8 {{.*}}) + // CHECK: @llvm.x86.avx512.mask.ucmp.d.128(<4 x i32> {{.*}}, <4 x i32> {{.*}}, i32 0, i8 {{.*}}) return (__mmask8)_mm_mask_cmpeq_epu32_mask(__u, __a, __b); } __mmask8 test_mm_cmpeq_epu64_mask(__m128i __a, __m128i __b) { // CHECK-LABEL: @test_mm_cmpeq_epu64_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.q.128(<2 x i64> {{.*}}, <2 x i64> {{.*}}, i8 0, i8 -1) + // CHECK: @llvm.x86.avx512.mask.ucmp.q.128(<2 x i64> {{.*}}, <2 x i64> {{.*}}, i32 0, i8 -1) return (__mmask8)_mm_cmpeq_epu64_mask(__a, __b); } __mmask8 test_mm_mask_cmpeq_epu64_mask(__mmask8 __u, __m128i __a, __m128i __b) { // CHECK-LABEL: @test_mm_mask_cmpeq_epu64_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.q.128(<2 x i64> {{.*}}, <2 x i64> {{.*}}, i8 0, i8 {{.*}}) + // CHECK: @llvm.x86.avx512.mask.ucmp.q.128(<2 x i64> {{.*}}, <2 x i64> {{.*}}, i32 0, i8 {{.*}}) return (__mmask8)_mm_mask_cmpeq_epu64_mask(__u, __a, __b); } __mmask8 test_mm_cmpge_epi32_mask(__m128i __a, __m128i __b) { // CHECK-LABEL: @test_mm_cmpge_epi32_mask - // CHECK: @llvm.x86.avx512.mask.cmp.d.128(<4 x i32> {{.*}}, <4 x i32> {{.*}}, i8 5, i8 -1) + // CHECK: @llvm.x86.avx512.mask.cmp.d.128(<4 x i32> {{.*}}, <4 x i32> {{.*}}, i32 5, i8 -1) return (__mmask8)_mm_cmpge_epi32_mask(__a, __b); } __mmask8 test_mm_mask_cmpge_epi32_mask(__mmask8 __u, __m128i __a, __m128i __b) { // CHECK-LABEL: @test_mm_mask_cmpge_epi32_mask - // CHECK: @llvm.x86.avx512.mask.cmp.d.128(<4 x i32> {{.*}}, <4 x i32> {{.*}}, i8 5, i8 {{.*}}) + // CHECK: @llvm.x86.avx512.mask.cmp.d.128(<4 x i32> {{.*}}, <4 x i32> {{.*}}, i32 5, i8 {{.*}}) return (__mmask8)_mm_mask_cmpge_epi32_mask(__u, __a, __b); } __mmask8 test_mm_cmpge_epi64_mask(__m128i __a, __m128i __b) { // CHECK-LABEL: @test_mm_cmpge_epi64_mask - // CHECK: @llvm.x86.avx512.mask.cmp.q.128(<2 x i64> {{.*}}, <2 x i64> {{.*}}, i8 5, i8 -1) + // CHECK: @llvm.x86.avx512.mask.cmp.q.128(<2 x i64> {{.*}}, <2 x i64> {{.*}}, i32 5, i8 -1) return (__mmask8)_mm_cmpge_epi64_mask(__a, __b); } __mmask8 test_mm_mask_cmpge_epi64_mask(__mmask8 __u, __m128i __a, __m128i __b) { // CHECK-LABEL: @test_mm_mask_cmpge_epi64_mask - // CHECK: @llvm.x86.avx512.mask.cmp.q.128(<2 x i64> {{.*}}, <2 x i64> {{.*}}, i8 5, i8 {{.*}}) + // CHECK: @llvm.x86.avx512.mask.cmp.q.128(<2 x i64> {{.*}}, <2 x i64> {{.*}}, i32 5, i8 {{.*}}) return (__mmask8)_mm_mask_cmpge_epi64_mask(__u, __a, __b); } __mmask8 test_mm256_cmpge_epi32_mask(__m256i __a, __m256i __b) { // CHECK-LABEL: @test_mm256_cmpge_epi32_mask - // CHECK: @llvm.x86.avx512.mask.cmp.d.256(<8 x i32> {{.*}}, <8 x i32> {{.*}}, i8 5, i8 -1) + // CHECK: @llvm.x86.avx512.mask.cmp.d.256(<8 x i32> {{.*}}, <8 x i32> {{.*}}, i32 5, i8 -1) return (__mmask8)_mm256_cmpge_epi32_mask(__a, __b); } __mmask8 test_mm256_mask_cmpge_epi32_mask(__mmask8 __u, __m256i __a, __m256i __b) { // CHECK-LABEL: @test_mm256_mask_cmpge_epi32_mask - // CHECK: @llvm.x86.avx512.mask.cmp.d.256(<8 x i32> {{.*}}, <8 x i32> {{.*}}, i8 5, i8 {{.*}}) + // CHECK: @llvm.x86.avx512.mask.cmp.d.256(<8 x i32> {{.*}}, <8 x i32> {{.*}}, i32 5, i8 {{.*}}) return (__mmask8)_mm256_mask_cmpge_epi32_mask(__u, __a, __b); } __mmask8 test_mm256_cmpge_epi64_mask(__m256i __a, __m256i __b) { // CHECK-LABEL: @test_mm256_cmpge_epi64_mask - // CHECK: @llvm.x86.avx512.mask.cmp.q.256(<4 x i64> {{.*}}, <4 x i64> {{.*}}, i8 5, i8 -1) + // CHECK: @llvm.x86.avx512.mask.cmp.q.256(<4 x i64> {{.*}}, <4 x i64> {{.*}}, i32 5, i8 -1) return (__mmask8)_mm256_cmpge_epi64_mask(__a, __b); } __mmask8 test_mm256_mask_cmpge_epi64_mask(__mmask8 __u, __m256i __a, __m256i __b) { // CHECK-LABEL: @test_mm256_mask_cmpge_epi64_mask - // CHECK: @llvm.x86.avx512.mask.cmp.q.256(<4 x i64> {{.*}}, <4 x i64> {{.*}}, i8 5, i8 {{.*}}) + // CHECK: @llvm.x86.avx512.mask.cmp.q.256(<4 x i64> {{.*}}, <4 x i64> {{.*}}, i32 5, i8 {{.*}}) return (__mmask8)_mm256_mask_cmpge_epi64_mask(__u, __a, __b); } __mmask8 test_mm_cmpge_epu32_mask(__m128i __a, __m128i __b) { // CHECK-LABEL: @test_mm_cmpge_epu32_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.d.128(<4 x i32> {{.*}}, <4 x i32> {{.*}}, i8 5, i8 -1) + // CHECK: @llvm.x86.avx512.mask.ucmp.d.128(<4 x i32> {{.*}}, <4 x i32> {{.*}}, i32 5, i8 -1) return (__mmask8)_mm_cmpge_epu32_mask(__a, __b); } __mmask8 test_mm_mask_cmpge_epu32_mask(__mmask8 __u, __m128i __a, __m128i __b) { // CHECK-LABEL: @test_mm_mask_cmpge_epu32_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.d.128(<4 x i32> {{.*}}, <4 x i32> {{.*}}, i8 5, i8 {{.*}}) + // CHECK: @llvm.x86.avx512.mask.ucmp.d.128(<4 x i32> {{.*}}, <4 x i32> {{.*}}, i32 5, i8 {{.*}}) return (__mmask8)_mm_mask_cmpge_epu32_mask(__u, __a, __b); } __mmask8 test_mm_cmpge_epu64_mask(__m128i __a, __m128i __b) { // CHECK-LABEL: @test_mm_cmpge_epu64_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.q.128(<2 x i64> {{.*}}, <2 x i64> {{.*}}, i8 5, i8 -1) + // CHECK: @llvm.x86.avx512.mask.ucmp.q.128(<2 x i64> {{.*}}, <2 x i64> {{.*}}, i32 5, i8 -1) return (__mmask8)_mm_cmpge_epu64_mask(__a, __b); } __mmask8 test_mm_mask_cmpge_epu64_mask(__mmask8 __u, __m128i __a, __m128i __b) { // CHECK-LABEL: @test_mm_mask_cmpge_epu64_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.q.128(<2 x i64> {{.*}}, <2 x i64> {{.*}}, i8 5, i8 {{.*}}) + // CHECK: @llvm.x86.avx512.mask.ucmp.q.128(<2 x i64> {{.*}}, <2 x i64> {{.*}}, i32 5, i8 {{.*}}) return (__mmask8)_mm_mask_cmpge_epu64_mask(__u, __a, __b); } __mmask8 test_mm256_cmpge_epu32_mask(__m256i __a, __m256i __b) { // CHECK-LABEL: @test_mm256_cmpge_epu32_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.d.256(<8 x i32> {{.*}}, <8 x i32> {{.*}}, i8 5, i8 -1) + // CHECK: @llvm.x86.avx512.mask.ucmp.d.256(<8 x i32> {{.*}}, <8 x i32> {{.*}}, i32 5, i8 -1) return (__mmask8)_mm256_cmpge_epu32_mask(__a, __b); } __mmask8 test_mm256_mask_cmpge_epu32_mask(__mmask8 __u, __m256i __a, __m256i __b) { // CHECK-LABEL: @test_mm256_mask_cmpge_epu32_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.d.256(<8 x i32> {{.*}}, <8 x i32> {{.*}}, i8 5, i8 {{.*}}) + // CHECK: @llvm.x86.avx512.mask.ucmp.d.256(<8 x i32> {{.*}}, <8 x i32> {{.*}}, i32 5, i8 {{.*}}) return (__mmask8)_mm256_mask_cmpge_epu32_mask(__u, __a, __b); } __mmask8 test_mm256_cmpge_epu64_mask(__m256i __a, __m256i __b) { // CHECK-LABEL: @test_mm256_cmpge_epu64_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.q.256(<4 x i64> {{.*}}, <4 x i64> {{.*}}, i8 5, i8 -1) + // CHECK: @llvm.x86.avx512.mask.ucmp.q.256(<4 x i64> {{.*}}, <4 x i64> {{.*}}, i32 5, i8 -1) return (__mmask8)_mm256_cmpge_epu64_mask(__a, __b); } __mmask8 test_mm256_mask_cmpge_epu64_mask(__mmask8 __u, __m256i __a, __m256i __b) { // CHECK-LABEL: @test_mm256_mask_cmpge_epu64_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.q.256(<4 x i64> {{.*}}, <4 x i64> {{.*}}, i8 5, i8 {{.*}}) + // CHECK: @llvm.x86.avx512.mask.ucmp.q.256(<4 x i64> {{.*}}, <4 x i64> {{.*}}, i32 5, i8 {{.*}}) return (__mmask8)_mm256_mask_cmpge_epu64_mask(__u, __a, __b); } __mmask8 test_mm_cmpgt_epu32_mask(__m128i __a, __m128i __b) { // CHECK-LABEL: @test_mm_cmpgt_epu32_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.d.128(<4 x i32> {{.*}}, <4 x i32> {{.*}}, i8 6, i8 -1) + // CHECK: @llvm.x86.avx512.mask.ucmp.d.128(<4 x i32> {{.*}}, <4 x i32> {{.*}}, i32 6, i8 -1) return (__mmask8)_mm_cmpgt_epu32_mask(__a, __b); } __mmask8 test_mm_mask_cmpgt_epu32_mask(__mmask8 __u, __m128i __a, __m128i __b) { // CHECK-LABEL: @test_mm_mask_cmpgt_epu32_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.d.128(<4 x i32> {{.*}}, <4 x i32> {{.*}}, i8 6, i8 {{.*}}) + // CHECK: @llvm.x86.avx512.mask.ucmp.d.128(<4 x i32> {{.*}}, <4 x i32> {{.*}}, i32 6, i8 {{.*}}) return (__mmask8)_mm_mask_cmpgt_epu32_mask(__u, __a, __b); } __mmask8 test_mm_cmpgt_epu64_mask(__m128i __a, __m128i __b) { // CHECK-LABEL: @test_mm_cmpgt_epu64_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.q.128(<2 x i64> {{.*}}, <2 x i64> {{.*}}, i8 6, i8 -1) + // CHECK: @llvm.x86.avx512.mask.ucmp.q.128(<2 x i64> {{.*}}, <2 x i64> {{.*}}, i32 6, i8 -1) return (__mmask8)_mm_cmpgt_epu64_mask(__a, __b); } __mmask8 test_mm_mask_cmpgt_epu64_mask(__mmask8 __u, __m128i __a, __m128i __b) { // CHECK-LABEL: @test_mm_mask_cmpgt_epu64_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.q.128(<2 x i64> {{.*}}, <2 x i64> {{.*}}, i8 6, i8 {{.*}}) + // CHECK: @llvm.x86.avx512.mask.ucmp.q.128(<2 x i64> {{.*}}, <2 x i64> {{.*}}, i32 6, i8 {{.*}}) return (__mmask8)_mm_mask_cmpgt_epu64_mask(__u, __a, __b); } __mmask8 test_mm256_cmpgt_epu32_mask(__m256i __a, __m256i __b) { // CHECK-LABEL: @test_mm256_cmpgt_epu32_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.d.256(<8 x i32> {{.*}}, <8 x i32> {{.*}}, i8 6, i8 -1) + // CHECK: @llvm.x86.avx512.mask.ucmp.d.256(<8 x i32> {{.*}}, <8 x i32> {{.*}}, i32 6, i8 -1) return (__mmask8)_mm256_cmpgt_epu32_mask(__a, __b); } __mmask8 test_mm256_mask_cmpgt_epu32_mask(__mmask8 __u, __m256i __a, __m256i __b) { // CHECK-LABEL: @test_mm256_mask_cmpgt_epu32_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.d.256(<8 x i32> {{.*}}, <8 x i32> {{.*}}, i8 6, i8 {{.*}}) + // CHECK: @llvm.x86.avx512.mask.ucmp.d.256(<8 x i32> {{.*}}, <8 x i32> {{.*}}, i32 6, i8 {{.*}}) return (__mmask8)_mm256_mask_cmpgt_epu32_mask(__u, __a, __b); } __mmask8 test_mm256_cmpgt_epu64_mask(__m256i __a, __m256i __b) { // CHECK-LABEL: @test_mm256_cmpgt_epu64_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.q.256(<4 x i64> {{.*}}, <4 x i64> {{.*}}, i8 6, i8 -1) + // CHECK: @llvm.x86.avx512.mask.ucmp.q.256(<4 x i64> {{.*}}, <4 x i64> {{.*}}, i32 6, i8 -1) return (__mmask8)_mm256_cmpgt_epu64_mask(__a, __b); } __mmask8 test_mm256_mask_cmpgt_epu64_mask(__mmask8 __u, __m256i __a, __m256i __b) { // CHECK-LABEL: @test_mm256_mask_cmpgt_epu64_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.q.256(<4 x i64> {{.*}}, <4 x i64> {{.*}}, i8 6, i8 {{.*}}) + // CHECK: @llvm.x86.avx512.mask.ucmp.q.256(<4 x i64> {{.*}}, <4 x i64> {{.*}}, i32 6, i8 {{.*}}) return (__mmask8)_mm256_mask_cmpgt_epu64_mask(__u, __a, __b); } __mmask8 test_mm_cmple_epi32_mask(__m128i __a, __m128i __b) { // CHECK-LABEL: @test_mm_cmple_epi32_mask - // CHECK: @llvm.x86.avx512.mask.cmp.d.128(<4 x i32> {{.*}}, <4 x i32> {{.*}}, i8 2, i8 -1) + // CHECK: @llvm.x86.avx512.mask.cmp.d.128(<4 x i32> {{.*}}, <4 x i32> {{.*}}, i32 2, i8 -1) return (__mmask8)_mm_cmple_epi32_mask(__a, __b); } __mmask8 test_mm_mask_cmple_epi32_mask(__mmask8 __u, __m128i __a, __m128i __b) { // CHECK-LABEL: @test_mm_mask_cmple_epi32_mask - // CHECK: @llvm.x86.avx512.mask.cmp.d.128(<4 x i32> {{.*}}, <4 x i32> {{.*}}, i8 2, i8 {{.*}}) + // CHECK: @llvm.x86.avx512.mask.cmp.d.128(<4 x i32> {{.*}}, <4 x i32> {{.*}}, i32 2, i8 {{.*}}) return (__mmask8)_mm_mask_cmple_epi32_mask(__u, __a, __b); } __mmask8 test_mm_cmple_epi64_mask(__m128i __a, __m128i __b) { // CHECK-LABEL: @test_mm_cmple_epi64_mask - // CHECK: @llvm.x86.avx512.mask.cmp.q.128(<2 x i64> {{.*}}, <2 x i64> {{.*}}, i8 2, i8 -1) + // CHECK: @llvm.x86.avx512.mask.cmp.q.128(<2 x i64> {{.*}}, <2 x i64> {{.*}}, i32 2, i8 -1) return (__mmask8)_mm_cmple_epi64_mask(__a, __b); } __mmask8 test_mm_mask_cmple_epi64_mask(__mmask8 __u, __m128i __a, __m128i __b) { // CHECK-LABEL: @test_mm_mask_cmple_epi64_mask - // CHECK: @llvm.x86.avx512.mask.cmp.q.128(<2 x i64> {{.*}}, <2 x i64> {{.*}}, i8 2, i8 {{.*}}) + // CHECK: @llvm.x86.avx512.mask.cmp.q.128(<2 x i64> {{.*}}, <2 x i64> {{.*}}, i32 2, i8 {{.*}}) return (__mmask8)_mm_mask_cmple_epi64_mask(__u, __a, __b); } __mmask8 test_mm256_cmple_epi32_mask(__m256i __a, __m256i __b) { // CHECK-LABEL: @test_mm256_cmple_epi32_mask - // CHECK: @llvm.x86.avx512.mask.cmp.d.256(<8 x i32> {{.*}}, <8 x i32> {{.*}}, i8 2, i8 -1) + // CHECK: @llvm.x86.avx512.mask.cmp.d.256(<8 x i32> {{.*}}, <8 x i32> {{.*}}, i32 2, i8 -1) return (__mmask8)_mm256_cmple_epi32_mask(__a, __b); } __mmask8 test_mm256_mask_cmple_epi32_mask(__mmask8 __u, __m256i __a, __m256i __b) { // CHECK-LABEL: @test_mm256_mask_cmple_epi32_mask - // CHECK: @llvm.x86.avx512.mask.cmp.d.256(<8 x i32> {{.*}}, <8 x i32> {{.*}}, i8 2, i8 {{.*}}) + // CHECK: @llvm.x86.avx512.mask.cmp.d.256(<8 x i32> {{.*}}, <8 x i32> {{.*}}, i32 2, i8 {{.*}}) return (__mmask8)_mm256_mask_cmple_epi32_mask(__u, __a, __b); } __mmask8 test_mm256_cmple_epi64_mask(__m256i __a, __m256i __b) { // CHECK-LABEL: @test_mm256_cmple_epi64_mask - // CHECK: @llvm.x86.avx512.mask.cmp.q.256(<4 x i64> {{.*}}, <4 x i64> {{.*}}, i8 2, i8 -1) + // CHECK: @llvm.x86.avx512.mask.cmp.q.256(<4 x i64> {{.*}}, <4 x i64> {{.*}}, i32 2, i8 -1) return (__mmask8)_mm256_cmple_epi64_mask(__a, __b); } __mmask8 test_mm256_mask_cmple_epi64_mask(__mmask8 __u, __m256i __a, __m256i __b) { // CHECK-LABEL: @test_mm256_mask_cmple_epi64_mask - // CHECK: @llvm.x86.avx512.mask.cmp.q.256(<4 x i64> {{.*}}, <4 x i64> {{.*}}, i8 2, i8 {{.*}}) + // CHECK: @llvm.x86.avx512.mask.cmp.q.256(<4 x i64> {{.*}}, <4 x i64> {{.*}}, i32 2, i8 {{.*}}) return (__mmask8)_mm256_mask_cmple_epi64_mask(__u, __a, __b); } __mmask8 test_mm_cmple_epu32_mask(__m128i __a, __m128i __b) { // CHECK-LABEL: @test_mm_cmple_epu32_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.d.128(<4 x i32> {{.*}}, <4 x i32> {{.*}}, i8 2, i8 -1) + // CHECK: @llvm.x86.avx512.mask.ucmp.d.128(<4 x i32> {{.*}}, <4 x i32> {{.*}}, i32 2, i8 -1) return (__mmask8)_mm_cmple_epu32_mask(__a, __b); } __mmask8 test_mm_mask_cmple_epu32_mask(__mmask8 __u, __m128i __a, __m128i __b) { // CHECK-LABEL: @test_mm_mask_cmple_epu32_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.d.128(<4 x i32> {{.*}}, <4 x i32> {{.*}}, i8 2, i8 {{.*}}) + // CHECK: @llvm.x86.avx512.mask.ucmp.d.128(<4 x i32> {{.*}}, <4 x i32> {{.*}}, i32 2, i8 {{.*}}) return (__mmask8)_mm_mask_cmple_epu32_mask(__u, __a, __b); } __mmask8 test_mm_cmple_epu64_mask(__m128i __a, __m128i __b) { // CHECK-LABEL: @test_mm_cmple_epu64_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.q.128(<2 x i64> {{.*}}, <2 x i64> {{.*}}, i8 2, i8 -1) + // CHECK: @llvm.x86.avx512.mask.ucmp.q.128(<2 x i64> {{.*}}, <2 x i64> {{.*}}, i32 2, i8 -1) return (__mmask8)_mm_cmple_epu64_mask(__a, __b); } __mmask8 test_mm_mask_cmple_epu64_mask(__mmask8 __u, __m128i __a, __m128i __b) { // CHECK-LABEL: @test_mm_mask_cmple_epu64_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.q.128(<2 x i64> {{.*}}, <2 x i64> {{.*}}, i8 2, i8 {{.*}}) + // CHECK: @llvm.x86.avx512.mask.ucmp.q.128(<2 x i64> {{.*}}, <2 x i64> {{.*}}, i32 2, i8 {{.*}}) return (__mmask8)_mm_mask_cmple_epu64_mask(__u, __a, __b); } __mmask8 test_mm256_cmple_epu32_mask(__m256i __a, __m256i __b) { // CHECK-LABEL: @test_mm256_cmple_epu32_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.d.256(<8 x i32> {{.*}}, <8 x i32> {{.*}}, i8 2, i8 -1) + // CHECK: @llvm.x86.avx512.mask.ucmp.d.256(<8 x i32> {{.*}}, <8 x i32> {{.*}}, i32 2, i8 -1) return (__mmask8)_mm256_cmple_epu32_mask(__a, __b); } __mmask8 test_mm256_mask_cmple_epu32_mask(__mmask8 __u, __m256i __a, __m256i __b) { // CHECK-LABEL: @test_mm256_mask_cmple_epu32_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.d.256(<8 x i32> {{.*}}, <8 x i32> {{.*}}, i8 2, i8 {{.*}}) + // CHECK: @llvm.x86.avx512.mask.ucmp.d.256(<8 x i32> {{.*}}, <8 x i32> {{.*}}, i32 2, i8 {{.*}}) return (__mmask8)_mm256_mask_cmple_epu32_mask(__u, __a, __b); } __mmask8 test_mm256_cmple_epu64_mask(__m256i __a, __m256i __b) { // CHECK-LABEL: @test_mm256_cmple_epu64_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.q.256(<4 x i64> {{.*}}, <4 x i64> {{.*}}, i8 2, i8 -1) + // CHECK: @llvm.x86.avx512.mask.ucmp.q.256(<4 x i64> {{.*}}, <4 x i64> {{.*}}, i32 2, i8 -1) return (__mmask8)_mm256_cmple_epu64_mask(__a, __b); } __mmask8 test_mm256_mask_cmple_epu64_mask(__mmask8 __u, __m256i __a, __m256i __b) { // CHECK-LABEL: @test_mm256_mask_cmple_epu64_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.q.256(<4 x i64> {{.*}}, <4 x i64> {{.*}}, i8 2, i8 {{.*}}) + // CHECK: @llvm.x86.avx512.mask.ucmp.q.256(<4 x i64> {{.*}}, <4 x i64> {{.*}}, i32 2, i8 {{.*}}) return (__mmask8)_mm256_mask_cmple_epu64_mask(__u, __a, __b); } __mmask8 test_mm_cmplt_epi32_mask(__m128i __a, __m128i __b) { // CHECK-LABEL: @test_mm_cmplt_epi32_mask - // CHECK: @llvm.x86.avx512.mask.cmp.d.128(<4 x i32> {{.*}}, <4 x i32> {{.*}}, i8 1, i8 -1) + // CHECK: @llvm.x86.avx512.mask.cmp.d.128(<4 x i32> {{.*}}, <4 x i32> {{.*}}, i32 1, i8 -1) return (__mmask8)_mm_cmplt_epi32_mask(__a, __b); } __mmask8 test_mm_mask_cmplt_epi32_mask(__mmask8 __u, __m128i __a, __m128i __b) { // CHECK-LABEL: @test_mm_mask_cmplt_epi32_mask - // CHECK: @llvm.x86.avx512.mask.cmp.d.128(<4 x i32> {{.*}}, <4 x i32> {{.*}}, i8 1, i8 {{.*}}) + // CHECK: @llvm.x86.avx512.mask.cmp.d.128(<4 x i32> {{.*}}, <4 x i32> {{.*}}, i32 1, i8 {{.*}}) return (__mmask8)_mm_mask_cmplt_epi32_mask(__u, __a, __b); } __mmask8 test_mm_cmplt_epi64_mask(__m128i __a, __m128i __b) { // CHECK-LABEL: @test_mm_cmplt_epi64_mask - // CHECK: @llvm.x86.avx512.mask.cmp.q.128(<2 x i64> {{.*}}, <2 x i64> {{.*}}, i8 1, i8 -1) + // CHECK: @llvm.x86.avx512.mask.cmp.q.128(<2 x i64> {{.*}}, <2 x i64> {{.*}}, i32 1, i8 -1) return (__mmask8)_mm_cmplt_epi64_mask(__a, __b); } __mmask8 test_mm_mask_cmplt_epi64_mask(__mmask8 __u, __m128i __a, __m128i __b) { // CHECK-LABEL: @test_mm_mask_cmplt_epi64_mask - // CHECK: @llvm.x86.avx512.mask.cmp.q.128(<2 x i64> {{.*}}, <2 x i64> {{.*}}, i8 1, i8 {{.*}}) + // CHECK: @llvm.x86.avx512.mask.cmp.q.128(<2 x i64> {{.*}}, <2 x i64> {{.*}}, i32 1, i8 {{.*}}) return (__mmask8)_mm_mask_cmplt_epi64_mask(__u, __a, __b); } __mmask8 test_mm256_cmplt_epi32_mask(__m256i __a, __m256i __b) { // CHECK-LABEL: @test_mm256_cmplt_epi32_mask - // CHECK: @llvm.x86.avx512.mask.cmp.d.256(<8 x i32> {{.*}}, <8 x i32> {{.*}}, i8 1, i8 -1) + // CHECK: @llvm.x86.avx512.mask.cmp.d.256(<8 x i32> {{.*}}, <8 x i32> {{.*}}, i32 1, i8 -1) return (__mmask8)_mm256_cmplt_epi32_mask(__a, __b); } __mmask8 test_mm256_mask_cmplt_epi32_mask(__mmask8 __u, __m256i __a, __m256i __b) { // CHECK-LABEL: @test_mm256_mask_cmplt_epi32_mask - // CHECK: @llvm.x86.avx512.mask.cmp.d.256(<8 x i32> {{.*}}, <8 x i32> {{.*}}, i8 1, i8 {{.*}}) + // CHECK: @llvm.x86.avx512.mask.cmp.d.256(<8 x i32> {{.*}}, <8 x i32> {{.*}}, i32 1, i8 {{.*}}) return (__mmask8)_mm256_mask_cmplt_epi32_mask(__u, __a, __b); } __mmask8 test_mm256_cmplt_epi64_mask(__m256i __a, __m256i __b) { // CHECK-LABEL: @test_mm256_cmplt_epi64_mask - // CHECK: @llvm.x86.avx512.mask.cmp.q.256(<4 x i64> {{.*}}, <4 x i64> {{.*}}, i8 1, i8 -1) + // CHECK: @llvm.x86.avx512.mask.cmp.q.256(<4 x i64> {{.*}}, <4 x i64> {{.*}}, i32 1, i8 -1) return (__mmask8)_mm256_cmplt_epi64_mask(__a, __b); } __mmask8 test_mm256_mask_cmplt_epi64_mask(__mmask8 __u, __m256i __a, __m256i __b) { // CHECK-LABEL: @test_mm256_mask_cmplt_epi64_mask - // CHECK: @llvm.x86.avx512.mask.cmp.q.256(<4 x i64> {{.*}}, <4 x i64> {{.*}}, i8 1, i8 {{.*}}) + // CHECK: @llvm.x86.avx512.mask.cmp.q.256(<4 x i64> {{.*}}, <4 x i64> {{.*}}, i32 1, i8 {{.*}}) return (__mmask8)_mm256_mask_cmplt_epi64_mask(__u, __a, __b); } __mmask8 test_mm_cmplt_epu32_mask(__m128i __a, __m128i __b) { // CHECK-LABEL: @test_mm_cmplt_epu32_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.d.128(<4 x i32> {{.*}}, <4 x i32> {{.*}}, i8 1, i8 -1) + // CHECK: @llvm.x86.avx512.mask.ucmp.d.128(<4 x i32> {{.*}}, <4 x i32> {{.*}}, i32 1, i8 -1) return (__mmask8)_mm_cmplt_epu32_mask(__a, __b); } __mmask8 test_mm_mask_cmplt_epu32_mask(__mmask8 __u, __m128i __a, __m128i __b) { // CHECK-LABEL: @test_mm_mask_cmplt_epu32_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.d.128(<4 x i32> {{.*}}, <4 x i32> {{.*}}, i8 1, i8 {{.*}}) + // CHECK: @llvm.x86.avx512.mask.ucmp.d.128(<4 x i32> {{.*}}, <4 x i32> {{.*}}, i32 1, i8 {{.*}}) return (__mmask8)_mm_mask_cmplt_epu32_mask(__u, __a, __b); } __mmask8 test_mm_cmplt_epu64_mask(__m128i __a, __m128i __b) { // CHECK-LABEL: @test_mm_cmplt_epu64_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.q.128(<2 x i64> {{.*}}, <2 x i64> {{.*}}, i8 1, i8 -1) + // CHECK: @llvm.x86.avx512.mask.ucmp.q.128(<2 x i64> {{.*}}, <2 x i64> {{.*}}, i32 1, i8 -1) return (__mmask8)_mm_cmplt_epu64_mask(__a, __b); } __mmask8 test_mm_mask_cmplt_epu64_mask(__mmask8 __u, __m128i __a, __m128i __b) { // CHECK-LABEL: @test_mm_mask_cmplt_epu64_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.q.128(<2 x i64> {{.*}}, <2 x i64> {{.*}}, i8 1, i8 {{.*}}) + // CHECK: @llvm.x86.avx512.mask.ucmp.q.128(<2 x i64> {{.*}}, <2 x i64> {{.*}}, i32 1, i8 {{.*}}) return (__mmask8)_mm_mask_cmplt_epu64_mask(__u, __a, __b); } __mmask8 test_mm256_cmplt_epu32_mask(__m256i __a, __m256i __b) { // CHECK-LABEL: @test_mm256_cmplt_epu32_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.d.256(<8 x i32> {{.*}}, <8 x i32> {{.*}}, i8 1, i8 -1) + // CHECK: @llvm.x86.avx512.mask.ucmp.d.256(<8 x i32> {{.*}}, <8 x i32> {{.*}}, i32 1, i8 -1) return (__mmask8)_mm256_cmplt_epu32_mask(__a, __b); } __mmask8 test_mm256_mask_cmplt_epu32_mask(__mmask8 __u, __m256i __a, __m256i __b) { // CHECK-LABEL: @test_mm256_mask_cmplt_epu32_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.d.256(<8 x i32> {{.*}}, <8 x i32> {{.*}}, i8 1, i8 {{.*}}) + // CHECK: @llvm.x86.avx512.mask.ucmp.d.256(<8 x i32> {{.*}}, <8 x i32> {{.*}}, i32 1, i8 {{.*}}) return (__mmask8)_mm256_mask_cmplt_epu32_mask(__u, __a, __b); } __mmask8 test_mm256_cmplt_epu64_mask(__m256i __a, __m256i __b) { // CHECK-LABEL: @test_mm256_cmplt_epu64_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.q.256(<4 x i64> {{.*}}, <4 x i64> {{.*}}, i8 1, i8 -1) + // CHECK: @llvm.x86.avx512.mask.ucmp.q.256(<4 x i64> {{.*}}, <4 x i64> {{.*}}, i32 1, i8 -1) return (__mmask8)_mm256_cmplt_epu64_mask(__a, __b); } __mmask8 test_mm256_mask_cmplt_epu64_mask(__mmask8 __u, __m256i __a, __m256i __b) { // CHECK-LABEL: @test_mm256_mask_cmplt_epu64_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.q.256(<4 x i64> {{.*}}, <4 x i64> {{.*}}, i8 1, i8 {{.*}}) + // CHECK: @llvm.x86.avx512.mask.ucmp.q.256(<4 x i64> {{.*}}, <4 x i64> {{.*}}, i32 1, i8 {{.*}}) return (__mmask8)_mm256_mask_cmplt_epu64_mask(__u, __a, __b); } __mmask8 test_mm_cmpneq_epi32_mask(__m128i __a, __m128i __b) { // CHECK-LABEL: @test_mm_cmpneq_epi32_mask - // CHECK: @llvm.x86.avx512.mask.cmp.d.128(<4 x i32> {{.*}}, <4 x i32> {{.*}}, i8 4, i8 -1) + // CHECK: @llvm.x86.avx512.mask.cmp.d.128(<4 x i32> {{.*}}, <4 x i32> {{.*}}, i32 4, i8 -1) return (__mmask8)_mm_cmpneq_epi32_mask(__a, __b); } __mmask8 test_mm_mask_cmpneq_epi32_mask(__mmask8 __u, __m128i __a, __m128i __b) { // CHECK-LABEL: @test_mm_mask_cmpneq_epi32_mask - // CHECK: @llvm.x86.avx512.mask.cmp.d.128(<4 x i32> {{.*}}, <4 x i32> {{.*}}, i8 4, i8 {{.*}}) + // CHECK: @llvm.x86.avx512.mask.cmp.d.128(<4 x i32> {{.*}}, <4 x i32> {{.*}}, i32 4, i8 {{.*}}) return (__mmask8)_mm_mask_cmpneq_epi32_mask(__u, __a, __b); } __mmask8 test_mm_cmpneq_epi64_mask(__m128i __a, __m128i __b) { // CHECK-LABEL: @test_mm_cmpneq_epi64_mask - // CHECK: @llvm.x86.avx512.mask.cmp.q.128(<2 x i64> {{.*}}, <2 x i64> {{.*}}, i8 4, i8 -1) + // CHECK: @llvm.x86.avx512.mask.cmp.q.128(<2 x i64> {{.*}}, <2 x i64> {{.*}}, i32 4, i8 -1) return (__mmask8)_mm_cmpneq_epi64_mask(__a, __b); } __mmask8 test_mm_mask_cmpneq_epi64_mask(__mmask8 __u, __m128i __a, __m128i __b) { // CHECK-LABEL: @test_mm_mask_cmpneq_epi64_mask - // CHECK: @llvm.x86.avx512.mask.cmp.q.128(<2 x i64> {{.*}}, <2 x i64> {{.*}}, i8 4, i8 {{.*}}) + // CHECK: @llvm.x86.avx512.mask.cmp.q.128(<2 x i64> {{.*}}, <2 x i64> {{.*}}, i32 4, i8 {{.*}}) return (__mmask8)_mm_mask_cmpneq_epi64_mask(__u, __a, __b); } __mmask8 test_mm256_cmpneq_epi32_mask(__m256i __a, __m256i __b) { // CHECK-LABEL: @test_mm256_cmpneq_epi32_mask - // CHECK: @llvm.x86.avx512.mask.cmp.d.256(<8 x i32> {{.*}}, <8 x i32> {{.*}}, i8 4, i8 -1) + // CHECK: @llvm.x86.avx512.mask.cmp.d.256(<8 x i32> {{.*}}, <8 x i32> {{.*}}, i32 4, i8 -1) return (__mmask8)_mm256_cmpneq_epi32_mask(__a, __b); } __mmask8 test_mm256_mask_cmpneq_epi32_mask(__mmask8 __u, __m256i __a, __m256i __b) { // CHECK-LABEL: @test_mm256_mask_cmpneq_epi32_mask - // CHECK: @llvm.x86.avx512.mask.cmp.d.256(<8 x i32> {{.*}}, <8 x i32> {{.*}}, i8 4, i8 {{.*}}) + // CHECK: @llvm.x86.avx512.mask.cmp.d.256(<8 x i32> {{.*}}, <8 x i32> {{.*}}, i32 4, i8 {{.*}}) return (__mmask8)_mm256_mask_cmpneq_epi32_mask(__u, __a, __b); } __mmask8 test_mm256_cmpneq_epi64_mask(__m256i __a, __m256i __b) { // CHECK-LABEL: @test_mm256_cmpneq_epi64_mask - // CHECK: @llvm.x86.avx512.mask.cmp.q.256(<4 x i64> {{.*}}, <4 x i64> {{.*}}, i8 4, i8 -1) + // CHECK: @llvm.x86.avx512.mask.cmp.q.256(<4 x i64> {{.*}}, <4 x i64> {{.*}}, i32 4, i8 -1) return (__mmask8)_mm256_cmpneq_epi64_mask(__a, __b); } __mmask8 test_mm256_mask_cmpneq_epi64_mask(__mmask8 __u, __m256i __a, __m256i __b) { // CHECK-LABEL: @test_mm256_mask_cmpneq_epi64_mask - // CHECK: @llvm.x86.avx512.mask.cmp.q.256(<4 x i64> {{.*}}, <4 x i64> {{.*}}, i8 4, i8 {{.*}}) + // CHECK: @llvm.x86.avx512.mask.cmp.q.256(<4 x i64> {{.*}}, <4 x i64> {{.*}}, i32 4, i8 {{.*}}) return (__mmask8)_mm256_mask_cmpneq_epi64_mask(__u, __a, __b); } __mmask8 test_mm_cmpneq_epu32_mask(__m128i __a, __m128i __b) { // CHECK-LABEL: @test_mm_cmpneq_epu32_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.d.128(<4 x i32> {{.*}}, <4 x i32> {{.*}}, i8 4, i8 -1) + // CHECK: @llvm.x86.avx512.mask.ucmp.d.128(<4 x i32> {{.*}}, <4 x i32> {{.*}}, i32 4, i8 -1) return (__mmask8)_mm_cmpneq_epu32_mask(__a, __b); } __mmask8 test_mm_mask_cmpneq_epu32_mask(__mmask8 __u, __m128i __a, __m128i __b) { // CHECK-LABEL: @test_mm_mask_cmpneq_epu32_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.d.128(<4 x i32> {{.*}}, <4 x i32> {{.*}}, i8 4, i8 {{.*}}) + // CHECK: @llvm.x86.avx512.mask.ucmp.d.128(<4 x i32> {{.*}}, <4 x i32> {{.*}}, i32 4, i8 {{.*}}) return (__mmask8)_mm_mask_cmpneq_epu32_mask(__u, __a, __b); } __mmask8 test_mm_cmpneq_epu64_mask(__m128i __a, __m128i __b) { // CHECK-LABEL: @test_mm_cmpneq_epu64_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.q.128(<2 x i64> {{.*}}, <2 x i64> {{.*}}, i8 4, i8 -1) + // CHECK: @llvm.x86.avx512.mask.ucmp.q.128(<2 x i64> {{.*}}, <2 x i64> {{.*}}, i32 4, i8 -1) return (__mmask8)_mm_cmpneq_epu64_mask(__a, __b); } __mmask8 test_mm_mask_cmpneq_epu64_mask(__mmask8 __u, __m128i __a, __m128i __b) { // CHECK-LABEL: @test_mm_mask_cmpneq_epu64_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.q.128(<2 x i64> {{.*}}, <2 x i64> {{.*}}, i8 4, i8 {{.*}}) + // CHECK: @llvm.x86.avx512.mask.ucmp.q.128(<2 x i64> {{.*}}, <2 x i64> {{.*}}, i32 4, i8 {{.*}}) return (__mmask8)_mm_mask_cmpneq_epu64_mask(__u, __a, __b); } __mmask8 test_mm256_cmpneq_epu32_mask(__m256i __a, __m256i __b) { // CHECK-LABEL: @test_mm256_cmpneq_epu32_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.d.256(<8 x i32> {{.*}}, <8 x i32> {{.*}}, i8 4, i8 -1) + // CHECK: @llvm.x86.avx512.mask.ucmp.d.256(<8 x i32> {{.*}}, <8 x i32> {{.*}}, i32 4, i8 -1) return (__mmask8)_mm256_cmpneq_epu32_mask(__a, __b); } __mmask8 test_mm256_mask_cmpneq_epu32_mask(__mmask8 __u, __m256i __a, __m256i __b) { // CHECK-LABEL: @test_mm256_mask_cmpneq_epu32_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.d.256(<8 x i32> {{.*}}, <8 x i32> {{.*}}, i8 4, i8 {{.*}}) + // CHECK: @llvm.x86.avx512.mask.ucmp.d.256(<8 x i32> {{.*}}, <8 x i32> {{.*}}, i32 4, i8 {{.*}}) return (__mmask8)_mm256_mask_cmpneq_epu32_mask(__u, __a, __b); } __mmask8 test_mm256_cmpneq_epu64_mask(__m256i __a, __m256i __b) { // CHECK-LABEL: @test_mm256_cmpneq_epu64_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.q.256(<4 x i64> {{.*}}, <4 x i64> {{.*}}, i8 4, i8 -1) + // CHECK: @llvm.x86.avx512.mask.ucmp.q.256(<4 x i64> {{.*}}, <4 x i64> {{.*}}, i32 4, i8 -1) return (__mmask8)_mm256_cmpneq_epu64_mask(__a, __b); } __mmask8 test_mm256_mask_cmpneq_epu64_mask(__mmask8 __u, __m256i __a, __m256i __b) { // CHECK-LABEL: @test_mm256_mask_cmpneq_epu64_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.q.256(<4 x i64> {{.*}}, <4 x i64> {{.*}}, i8 4, i8 {{.*}}) + // CHECK: @llvm.x86.avx512.mask.ucmp.q.256(<4 x i64> {{.*}}, <4 x i64> {{.*}}, i32 4, i8 {{.*}}) return (__mmask8)_mm256_mask_cmpneq_epu64_mask(__u, __a, __b); } __mmask8 test_mm_cmp_epi32_mask(__m128i __a, __m128i __b) { // CHECK-LABEL: @test_mm_cmp_epi32_mask - // CHECK: @llvm.x86.avx512.mask.cmp.d.128(<4 x i32> {{.*}}, <4 x i32> {{.*}}, i8 7, i8 -1) + // CHECK: @llvm.x86.avx512.mask.cmp.d.128(<4 x i32> {{.*}}, <4 x i32> {{.*}}, i32 7, i8 -1) return (__mmask8)_mm_cmp_epi32_mask(__a, __b, 7); } __mmask8 test_mm_mask_cmp_epi32_mask(__mmask8 __u, __m128i __a, __m128i __b) { // CHECK-LABEL: @test_mm_mask_cmp_epi32_mask - // CHECK: @llvm.x86.avx512.mask.cmp.d.128(<4 x i32> {{.*}}, <4 x i32> {{.*}}, i8 7, i8 {{.*}}) + // CHECK: @llvm.x86.avx512.mask.cmp.d.128(<4 x i32> {{.*}}, <4 x i32> {{.*}}, i32 7, i8 {{.*}}) return (__mmask8)_mm_mask_cmp_epi32_mask(__u, __a, __b, 7); } __mmask8 test_mm_cmp_epi64_mask(__m128i __a, __m128i __b) { // CHECK-LABEL: @test_mm_cmp_epi64_mask - // CHECK: @llvm.x86.avx512.mask.cmp.q.128(<2 x i64> {{.*}}, <2 x i64> {{.*}}, i8 7, i8 -1) + // CHECK: @llvm.x86.avx512.mask.cmp.q.128(<2 x i64> {{.*}}, <2 x i64> {{.*}}, i32 7, i8 -1) return (__mmask8)_mm_cmp_epi64_mask(__a, __b, 7); } __mmask8 test_mm_mask_cmp_epi64_mask(__mmask8 __u, __m128i __a, __m128i __b) { // CHECK-LABEL: @test_mm_mask_cmp_epi64_mask - // CHECK: @llvm.x86.avx512.mask.cmp.q.128(<2 x i64> {{.*}}, <2 x i64> {{.*}}, i8 7, i8 {{.*}}) + // CHECK: @llvm.x86.avx512.mask.cmp.q.128(<2 x i64> {{.*}}, <2 x i64> {{.*}}, i32 7, i8 {{.*}}) return (__mmask8)_mm_mask_cmp_epi64_mask(__u, __a, __b, 7); } __mmask8 test_mm256_cmp_epi32_mask(__m256i __a, __m256i __b) { // CHECK-LABEL: @test_mm256_cmp_epi32_mask - // CHECK: @llvm.x86.avx512.mask.cmp.d.256(<8 x i32> {{.*}}, <8 x i32> {{.*}}, i8 7, i8 -1) + // CHECK: @llvm.x86.avx512.mask.cmp.d.256(<8 x i32> {{.*}}, <8 x i32> {{.*}}, i32 7, i8 -1) return (__mmask8)_mm256_cmp_epi32_mask(__a, __b, 7); } __mmask8 test_mm256_mask_cmp_epi32_mask(__mmask8 __u, __m256i __a, __m256i __b) { // CHECK-LABEL: @test_mm256_mask_cmp_epi32_mask - // CHECK: @llvm.x86.avx512.mask.cmp.d.256(<8 x i32> {{.*}}, <8 x i32> {{.*}}, i8 7, i8 {{.*}}) + // CHECK: @llvm.x86.avx512.mask.cmp.d.256(<8 x i32> {{.*}}, <8 x i32> {{.*}}, i32 7, i8 {{.*}}) return (__mmask8)_mm256_mask_cmp_epi32_mask(__u, __a, __b, 7); } __mmask8 test_mm256_cmp_epi64_mask(__m256i __a, __m256i __b) { // CHECK-LABEL: @test_mm256_cmp_epi64_mask - // CHECK: @llvm.x86.avx512.mask.cmp.q.256(<4 x i64> {{.*}}, <4 x i64> {{.*}}, i8 7, i8 -1) + // CHECK: @llvm.x86.avx512.mask.cmp.q.256(<4 x i64> {{.*}}, <4 x i64> {{.*}}, i32 7, i8 -1) return (__mmask8)_mm256_cmp_epi64_mask(__a, __b, 7); } __mmask8 test_mm256_mask_cmp_epi64_mask(__mmask8 __u, __m256i __a, __m256i __b) { // CHECK-LABEL: @test_mm256_mask_cmp_epi64_mask - // CHECK: @llvm.x86.avx512.mask.cmp.q.256(<4 x i64> {{.*}}, <4 x i64> {{.*}}, i8 7, i8 {{.*}}) + // CHECK: @llvm.x86.avx512.mask.cmp.q.256(<4 x i64> {{.*}}, <4 x i64> {{.*}}, i32 7, i8 {{.*}}) return (__mmask8)_mm256_mask_cmp_epi64_mask(__u, __a, __b, 7); } __mmask8 test_mm_cmp_epu32_mask(__m128i __a, __m128i __b) { // CHECK-LABEL: @test_mm_cmp_epu32_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.d.128(<4 x i32> {{.*}}, <4 x i32> {{.*}}, i8 7, i8 -1) + // CHECK: @llvm.x86.avx512.mask.ucmp.d.128(<4 x i32> {{.*}}, <4 x i32> {{.*}}, i32 7, i8 -1) return (__mmask8)_mm_cmp_epu32_mask(__a, __b, 7); } __mmask8 test_mm_mask_cmp_epu32_mask(__mmask8 __u, __m128i __a, __m128i __b) { // CHECK-LABEL: @test_mm_mask_cmp_epu32_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.d.128(<4 x i32> {{.*}}, <4 x i32> {{.*}}, i8 7, i8 {{.*}}) + // CHECK: @llvm.x86.avx512.mask.ucmp.d.128(<4 x i32> {{.*}}, <4 x i32> {{.*}}, i32 7, i8 {{.*}}) return (__mmask8)_mm_mask_cmp_epu32_mask(__u, __a, __b, 7); } __mmask8 test_mm_cmp_epu64_mask(__m128i __a, __m128i __b) { // CHECK-LABEL: @test_mm_cmp_epu64_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.q.128(<2 x i64> {{.*}}, <2 x i64> {{.*}}, i8 7, i8 -1) + // CHECK: @llvm.x86.avx512.mask.ucmp.q.128(<2 x i64> {{.*}}, <2 x i64> {{.*}}, i32 7, i8 -1) return (__mmask8)_mm_cmp_epu64_mask(__a, __b, 7); } __mmask8 test_mm_mask_cmp_epu64_mask(__mmask8 __u, __m128i __a, __m128i __b) { // CHECK-LABEL: @test_mm_mask_cmp_epu64_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.q.128(<2 x i64> {{.*}}, <2 x i64> {{.*}}, i8 7, i8 {{.*}}) + // CHECK: @llvm.x86.avx512.mask.ucmp.q.128(<2 x i64> {{.*}}, <2 x i64> {{.*}}, i32 7, i8 {{.*}}) return (__mmask8)_mm_mask_cmp_epu64_mask(__u, __a, __b, 7); } __mmask8 test_mm256_cmp_epu32_mask(__m256i __a, __m256i __b) { // CHECK-LABEL: @test_mm256_cmp_epu32_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.d.256(<8 x i32> {{.*}}, <8 x i32> {{.*}}, i8 7, i8 -1) + // CHECK: @llvm.x86.avx512.mask.ucmp.d.256(<8 x i32> {{.*}}, <8 x i32> {{.*}}, i32 7, i8 -1) return (__mmask8)_mm256_cmp_epu32_mask(__a, __b, 7); } __mmask8 test_mm256_mask_cmp_epu32_mask(__mmask8 __u, __m256i __a, __m256i __b) { // CHECK-LABEL: @test_mm256_mask_cmp_epu32_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.d.256(<8 x i32> {{.*}}, <8 x i32> {{.*}}, i8 7, i8 {{.*}}) + // CHECK: @llvm.x86.avx512.mask.ucmp.d.256(<8 x i32> {{.*}}, <8 x i32> {{.*}}, i32 7, i8 {{.*}}) return (__mmask8)_mm256_mask_cmp_epu32_mask(__u, __a, __b, 7); } __mmask8 test_mm256_cmp_epu64_mask(__m256i __a, __m256i __b) { // CHECK-LABEL: @test_mm256_cmp_epu64_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.q.256(<4 x i64> {{.*}}, <4 x i64> {{.*}}, i8 7, i8 -1) + // CHECK: @llvm.x86.avx512.mask.ucmp.q.256(<4 x i64> {{.*}}, <4 x i64> {{.*}}, i32 7, i8 -1) return (__mmask8)_mm256_cmp_epu64_mask(__a, __b, 7); } __mmask8 test_mm256_mask_cmp_epu64_mask(__mmask8 __u, __m256i __a, __m256i __b) { // CHECK-LABEL: @test_mm256_mask_cmp_epu64_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.q.256(<4 x i64> {{.*}}, <4 x i64> {{.*}}, i8 7, i8 {{.*}}) + // CHECK: @llvm.x86.avx512.mask.ucmp.q.256(<4 x i64> {{.*}}, <4 x i64> {{.*}}, i32 7, i8 {{.*}}) return (__mmask8)_mm256_mask_cmp_epu64_mask(__u, __a, __b, 7); } diff --git a/test/CodeGen/avx512vlbw-builtins.c b/test/CodeGen/avx512vlbw-builtins.c index 64b7708b33..a4a12440dc 100644 --- a/test/CodeGen/avx512vlbw-builtins.c +++ b/test/CodeGen/avx512vlbw-builtins.c @@ -100,577 +100,577 @@ __mmask8 test_mm_mask_cmpgt_epi16_mask(__mmask8 __u, __m128i __a, __m128i __b) { __mmask16 test_mm_cmpeq_epu8_mask(__m128i __a, __m128i __b) { // CHECK-LABEL: @test_mm_cmpeq_epu8_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.b.128(<16 x i8> {{.*}}, <16 x i8> {{.*}}, i8 0, i16 -1) + // CHECK: @llvm.x86.avx512.mask.ucmp.b.128(<16 x i8> {{.*}}, <16 x i8> {{.*}}, i32 0, i16 -1) return (__mmask64)_mm_cmpeq_epu8_mask(__a, __b); } __mmask16 test_mm_mask_cmpeq_epu8_mask(__mmask64 __u, __m128i __a, __m128i __b) { // CHECK-LABEL: @test_mm_mask_cmpeq_epu8_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.b.128(<16 x i8> {{.*}}, <16 x i8> {{.*}}, i8 0, i16 {{.*}}) + // CHECK: @llvm.x86.avx512.mask.ucmp.b.128(<16 x i8> {{.*}}, <16 x i8> {{.*}}, i32 0, i16 {{.*}}) return (__mmask64)_mm_mask_cmpeq_epu8_mask(__u, __a, __b); } __mmask8 test_mm_cmpeq_epu16_mask(__m128i __a, __m128i __b) { // CHECK-LABEL: @test_mm_cmpeq_epu16_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.w.128(<8 x i16> {{.*}}, <8 x i16> {{.*}}, i8 0, i8 -1) + // CHECK: @llvm.x86.avx512.mask.ucmp.w.128(<8 x i16> {{.*}}, <8 x i16> {{.*}}, i32 0, i8 -1) return (__mmask32)_mm_cmpeq_epu16_mask(__a, __b); } __mmask8 test_mm_mask_cmpeq_epu16_mask(__mmask32 __u, __m128i __a, __m128i __b) { // CHECK-LABEL: @test_mm_mask_cmpeq_epu16_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.w.128(<8 x i16> {{.*}}, <8 x i16> {{.*}}, i8 0, i8 {{.*}}) + // CHECK: @llvm.x86.avx512.mask.ucmp.w.128(<8 x i16> {{.*}}, <8 x i16> {{.*}}, i32 0, i8 {{.*}}) return (__mmask32)_mm_mask_cmpeq_epu16_mask(__u, __a, __b); } __mmask32 test_mm256_cmpeq_epu8_mask(__m256i __a, __m256i __b) { // CHECK-LABEL: @test_mm256_cmpeq_epu8_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.b.256(<32 x i8> {{.*}}, <32 x i8> {{.*}}, i8 0, i32 -1) + // CHECK: @llvm.x86.avx512.mask.ucmp.b.256(<32 x i8> {{.*}}, <32 x i8> {{.*}}, i32 0, i32 -1) return (__mmask64)_mm256_cmpeq_epu8_mask(__a, __b); } __mmask32 test_mm256_mask_cmpeq_epu8_mask(__mmask64 __u, __m256i __a, __m256i __b) { // CHECK-LABEL: @test_mm256_mask_cmpeq_epu8_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.b.256(<32 x i8> {{.*}}, <32 x i8> {{.*}}, i8 0, i32 {{.*}}) + // CHECK: @llvm.x86.avx512.mask.ucmp.b.256(<32 x i8> {{.*}}, <32 x i8> {{.*}}, i32 0, i32 {{.*}}) return (__mmask64)_mm256_mask_cmpeq_epu8_mask(__u, __a, __b); } __mmask16 test_mm256_cmpeq_epu16_mask(__m256i __a, __m256i __b) { // CHECK-LABEL: @test_mm256_cmpeq_epu16_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.w.256(<16 x i16> {{.*}}, <16 x i16> {{.*}}, i8 0, i16 -1) + // CHECK: @llvm.x86.avx512.mask.ucmp.w.256(<16 x i16> {{.*}}, <16 x i16> {{.*}}, i32 0, i16 -1) return (__mmask32)_mm256_cmpeq_epu16_mask(__a, __b); } __mmask16 test_mm256_mask_cmpeq_epu16_mask(__mmask32 __u, __m256i __a, __m256i __b) { // CHECK-LABEL: @test_mm256_mask_cmpeq_epu16_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.w.256(<16 x i16> {{.*}}, <16 x i16> {{.*}}, i8 0, i16 {{.*}}) + // CHECK: @llvm.x86.avx512.mask.ucmp.w.256(<16 x i16> {{.*}}, <16 x i16> {{.*}}, i32 0, i16 {{.*}}) return (__mmask32)_mm256_mask_cmpeq_epu16_mask(__u, __a, __b); } __mmask16 test_mm_cmpgt_epu8_mask(__m128i __a, __m128i __b) { // CHECK-LABEL: @test_mm_cmpgt_epu8_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.b.128(<16 x i8> {{.*}}, <16 x i8> {{.*}}, i8 6, i16 -1) + // CHECK: @llvm.x86.avx512.mask.ucmp.b.128(<16 x i8> {{.*}}, <16 x i8> {{.*}}, i32 6, i16 -1) return (__mmask64)_mm_cmpgt_epu8_mask(__a, __b); } __mmask16 test_mm_mask_cmpgt_epu8_mask(__mmask64 __u, __m128i __a, __m128i __b) { // CHECK-LABEL: @test_mm_mask_cmpgt_epu8_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.b.128(<16 x i8> {{.*}}, <16 x i8> {{.*}}, i8 6, i16 {{.*}}) + // CHECK: @llvm.x86.avx512.mask.ucmp.b.128(<16 x i8> {{.*}}, <16 x i8> {{.*}}, i32 6, i16 {{.*}}) return (__mmask64)_mm_mask_cmpgt_epu8_mask(__u, __a, __b); } __mmask8 test_mm_cmpgt_epu16_mask(__m128i __a, __m128i __b) { // CHECK-LABEL: @test_mm_cmpgt_epu16_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.w.128(<8 x i16> {{.*}}, <8 x i16> {{.*}}, i8 6, i8 -1) + // CHECK: @llvm.x86.avx512.mask.ucmp.w.128(<8 x i16> {{.*}}, <8 x i16> {{.*}}, i32 6, i8 -1) return (__mmask32)_mm_cmpgt_epu16_mask(__a, __b); } __mmask8 test_mm_mask_cmpgt_epu16_mask(__mmask32 __u, __m128i __a, __m128i __b) { // CHECK-LABEL: @test_mm_mask_cmpgt_epu16_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.w.128(<8 x i16> {{.*}}, <8 x i16> {{.*}}, i8 6, i8 {{.*}}) + // CHECK: @llvm.x86.avx512.mask.ucmp.w.128(<8 x i16> {{.*}}, <8 x i16> {{.*}}, i32 6, i8 {{.*}}) return (__mmask32)_mm_mask_cmpgt_epu16_mask(__u, __a, __b); } __mmask32 test_mm256_cmpgt_epu8_mask(__m256i __a, __m256i __b) { // CHECK-LABEL: @test_mm256_cmpgt_epu8_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.b.256(<32 x i8> {{.*}}, <32 x i8> {{.*}}, i8 6, i32 -1) + // CHECK: @llvm.x86.avx512.mask.ucmp.b.256(<32 x i8> {{.*}}, <32 x i8> {{.*}}, i32 6, i32 -1) return (__mmask64)_mm256_cmpgt_epu8_mask(__a, __b); } __mmask32 test_mm256_mask_cmpgt_epu8_mask(__mmask64 __u, __m256i __a, __m256i __b) { // CHECK-LABEL: @test_mm256_mask_cmpgt_epu8_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.b.256(<32 x i8> {{.*}}, <32 x i8> {{.*}}, i8 6, i32 {{.*}}) + // CHECK: @llvm.x86.avx512.mask.ucmp.b.256(<32 x i8> {{.*}}, <32 x i8> {{.*}}, i32 6, i32 {{.*}}) return (__mmask64)_mm256_mask_cmpgt_epu8_mask(__u, __a, __b); } __mmask16 test_mm256_cmpgt_epu16_mask(__m256i __a, __m256i __b) { // CHECK-LABEL: @test_mm256_cmpgt_epu16_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.w.256(<16 x i16> {{.*}}, <16 x i16> {{.*}}, i8 6, i16 -1) + // CHECK: @llvm.x86.avx512.mask.ucmp.w.256(<16 x i16> {{.*}}, <16 x i16> {{.*}}, i32 6, i16 -1) return (__mmask32)_mm256_cmpgt_epu16_mask(__a, __b); } __mmask16 test_mm256_mask_cmpgt_epu16_mask(__mmask32 __u, __m256i __a, __m256i __b) { // CHECK-LABEL: @test_mm256_mask_cmpgt_epu16_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.w.256(<16 x i16> {{.*}}, <16 x i16> {{.*}}, i8 6, i16 {{.*}}) + // CHECK: @llvm.x86.avx512.mask.ucmp.w.256(<16 x i16> {{.*}}, <16 x i16> {{.*}}, i32 6, i16 {{.*}}) return (__mmask32)_mm256_mask_cmpgt_epu16_mask(__u, __a, __b); } __mmask16 test_mm_cmpge_epi8_mask(__m128i __a, __m128i __b) { // CHECK-LABEL: @test_mm_cmpge_epi8_mask - // CHECK: @llvm.x86.avx512.mask.cmp.b.128(<16 x i8> {{.*}}, <16 x i8> {{.*}}, i8 5, i16 -1) + // CHECK: @llvm.x86.avx512.mask.cmp.b.128(<16 x i8> {{.*}}, <16 x i8> {{.*}}, i32 5, i16 -1) return (__mmask64)_mm_cmpge_epi8_mask(__a, __b); } __mmask16 test_mm_mask_cmpge_epi8_mask(__mmask64 __u, __m128i __a, __m128i __b) { // CHECK-LABEL: @test_mm_mask_cmpge_epi8_mask - // CHECK: @llvm.x86.avx512.mask.cmp.b.128(<16 x i8> {{.*}}, <16 x i8> {{.*}}, i8 5, i16 {{.*}}) + // CHECK: @llvm.x86.avx512.mask.cmp.b.128(<16 x i8> {{.*}}, <16 x i8> {{.*}}, i32 5, i16 {{.*}}) return (__mmask64)_mm_mask_cmpge_epi8_mask(__u, __a, __b); } __mmask16 test_mm_cmpge_epu8_mask(__m128i __a, __m128i __b) { // CHECK-LABEL: @test_mm_cmpge_epu8_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.b.128(<16 x i8> {{.*}}, <16 x i8> {{.*}}, i8 5, i16 -1) + // CHECK: @llvm.x86.avx512.mask.ucmp.b.128(<16 x i8> {{.*}}, <16 x i8> {{.*}}, i32 5, i16 -1) return (__mmask64)_mm_cmpge_epu8_mask(__a, __b); } __mmask16 test_mm_mask_cmpge_epu8_mask(__mmask64 __u, __m128i __a, __m128i __b) { // CHECK-LABEL: @test_mm_mask_cmpge_epu8_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.b.128(<16 x i8> {{.*}}, <16 x i8> {{.*}}, i8 5, i16 {{.*}}) + // CHECK: @llvm.x86.avx512.mask.ucmp.b.128(<16 x i8> {{.*}}, <16 x i8> {{.*}}, i32 5, i16 {{.*}}) return (__mmask64)_mm_mask_cmpge_epu8_mask(__u, __a, __b); } __mmask8 test_mm_cmpge_epi16_mask(__m128i __a, __m128i __b) { // CHECK-LABEL: @test_mm_cmpge_epi16_mask - // CHECK: @llvm.x86.avx512.mask.cmp.w.128(<8 x i16> {{.*}}, <8 x i16> {{.*}}, i8 5, i8 -1) + // CHECK: @llvm.x86.avx512.mask.cmp.w.128(<8 x i16> {{.*}}, <8 x i16> {{.*}}, i32 5, i8 -1) return (__mmask32)_mm_cmpge_epi16_mask(__a, __b); } __mmask8 test_mm_mask_cmpge_epi16_mask(__mmask32 __u, __m128i __a, __m128i __b) { // CHECK-LABEL: @test_mm_mask_cmpge_epi16_mask - // CHECK: @llvm.x86.avx512.mask.cmp.w.128(<8 x i16> {{.*}}, <8 x i16> {{.*}}, i8 5, i8 {{.*}}) + // CHECK: @llvm.x86.avx512.mask.cmp.w.128(<8 x i16> {{.*}}, <8 x i16> {{.*}}, i32 5, i8 {{.*}}) return (__mmask32)_mm_mask_cmpge_epi16_mask(__u, __a, __b); } __mmask8 test_mm_cmpge_epu16_mask(__m128i __a, __m128i __b) { // CHECK-LABEL: @test_mm_cmpge_epu16_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.w.128(<8 x i16> {{.*}}, <8 x i16> {{.*}}, i8 5, i8 -1) + // CHECK: @llvm.x86.avx512.mask.ucmp.w.128(<8 x i16> {{.*}}, <8 x i16> {{.*}}, i32 5, i8 -1) return (__mmask32)_mm_cmpge_epu16_mask(__a, __b); } __mmask8 test_mm_mask_cmpge_epu16_mask(__mmask32 __u, __m128i __a, __m128i __b) { // CHECK-LABEL: @test_mm_mask_cmpge_epu16_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.w.128(<8 x i16> {{.*}}, <8 x i16> {{.*}}, i8 5, i8 {{.*}}) + // CHECK: @llvm.x86.avx512.mask.ucmp.w.128(<8 x i16> {{.*}}, <8 x i16> {{.*}}, i32 5, i8 {{.*}}) return (__mmask32)_mm_mask_cmpge_epu16_mask(__u, __a, __b); } __mmask32 test_mm256_cmpge_epi8_mask(__m256i __a, __m256i __b) { // CHECK-LABEL: @test_mm256_cmpge_epi8_mask - // CHECK: @llvm.x86.avx512.mask.cmp.b.256(<32 x i8> {{.*}}, <32 x i8> {{.*}}, i8 5, i32 -1) + // CHECK: @llvm.x86.avx512.mask.cmp.b.256(<32 x i8> {{.*}}, <32 x i8> {{.*}}, i32 5, i32 -1) return (__mmask64)_mm256_cmpge_epi8_mask(__a, __b); } __mmask32 test_mm256_mask_cmpge_epi8_mask(__mmask64 __u, __m256i __a, __m256i __b) { // CHECK-LABEL: @test_mm256_mask_cmpge_epi8_mask - // CHECK: @llvm.x86.avx512.mask.cmp.b.256(<32 x i8> {{.*}}, <32 x i8> {{.*}}, i8 5, i32 {{.*}}) + // CHECK: @llvm.x86.avx512.mask.cmp.b.256(<32 x i8> {{.*}}, <32 x i8> {{.*}}, i32 5, i32 {{.*}}) return (__mmask64)_mm256_mask_cmpge_epi8_mask(__u, __a, __b); } __mmask32 test_mm256_cmpge_epu8_mask(__m256i __a, __m256i __b) { // CHECK-LABEL: @test_mm256_cmpge_epu8_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.b.256(<32 x i8> {{.*}}, <32 x i8> {{.*}}, i8 5, i32 -1) + // CHECK: @llvm.x86.avx512.mask.ucmp.b.256(<32 x i8> {{.*}}, <32 x i8> {{.*}}, i32 5, i32 -1) return (__mmask64)_mm256_cmpge_epu8_mask(__a, __b); } __mmask32 test_mm256_mask_cmpge_epu8_mask(__mmask64 __u, __m256i __a, __m256i __b) { // CHECK-LABEL: @test_mm256_mask_cmpge_epu8_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.b.256(<32 x i8> {{.*}}, <32 x i8> {{.*}}, i8 5, i32 {{.*}}) + // CHECK: @llvm.x86.avx512.mask.ucmp.b.256(<32 x i8> {{.*}}, <32 x i8> {{.*}}, i32 5, i32 {{.*}}) return (__mmask64)_mm256_mask_cmpge_epu8_mask(__u, __a, __b); } __mmask16 test_mm256_cmpge_epi16_mask(__m256i __a, __m256i __b) { // CHECK-LABEL: @test_mm256_cmpge_epi16_mask - // CHECK: @llvm.x86.avx512.mask.cmp.w.256(<16 x i16> {{.*}}, <16 x i16> {{.*}}, i8 5, i16 -1) + // CHECK: @llvm.x86.avx512.mask.cmp.w.256(<16 x i16> {{.*}}, <16 x i16> {{.*}}, i32 5, i16 -1) return (__mmask32)_mm256_cmpge_epi16_mask(__a, __b); } __mmask16 test_mm256_mask_cmpge_epi16_mask(__mmask32 __u, __m256i __a, __m256i __b) { // CHECK-LABEL: @test_mm256_mask_cmpge_epi16_mask - // CHECK: @llvm.x86.avx512.mask.cmp.w.256(<16 x i16> {{.*}}, <16 x i16> {{.*}}, i8 5, i16 {{.*}}) + // CHECK: @llvm.x86.avx512.mask.cmp.w.256(<16 x i16> {{.*}}, <16 x i16> {{.*}}, i32 5, i16 {{.*}}) return (__mmask32)_mm256_mask_cmpge_epi16_mask(__u, __a, __b); } __mmask16 test_mm256_cmpge_epu16_mask(__m256i __a, __m256i __b) { // CHECK-LABEL: @test_mm256_cmpge_epu16_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.w.256(<16 x i16> {{.*}}, <16 x i16> {{.*}}, i8 5, i16 -1) + // CHECK: @llvm.x86.avx512.mask.ucmp.w.256(<16 x i16> {{.*}}, <16 x i16> {{.*}}, i32 5, i16 -1) return (__mmask32)_mm256_cmpge_epu16_mask(__a, __b); } __mmask16 test_mm256_mask_cmpge_epu16_mask(__mmask32 __u, __m256i __a, __m256i __b) { // CHECK-LABEL: @test_mm256_mask_cmpge_epu16_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.w.256(<16 x i16> {{.*}}, <16 x i16> {{.*}}, i8 5, i16 {{.*}}) + // CHECK: @llvm.x86.avx512.mask.ucmp.w.256(<16 x i16> {{.*}}, <16 x i16> {{.*}}, i32 5, i16 {{.*}}) return (__mmask32)_mm256_mask_cmpge_epu16_mask(__u, __a, __b); } __mmask16 test_mm_cmple_epi8_mask(__m128i __a, __m128i __b) { // CHECK-LABEL: @test_mm_cmple_epi8_mask - // CHECK: @llvm.x86.avx512.mask.cmp.b.128(<16 x i8> {{.*}}, <16 x i8> {{.*}}, i8 2, i16 -1) + // CHECK: @llvm.x86.avx512.mask.cmp.b.128(<16 x i8> {{.*}}, <16 x i8> {{.*}}, i32 2, i16 -1) return (__mmask64)_mm_cmple_epi8_mask(__a, __b); } __mmask16 test_mm_mask_cmple_epi8_mask(__mmask64 __u, __m128i __a, __m128i __b) { // CHECK-LABEL: @test_mm_mask_cmple_epi8_mask - // CHECK: @llvm.x86.avx512.mask.cmp.b.128(<16 x i8> {{.*}}, <16 x i8> {{.*}}, i8 2, i16 {{.*}}) + // CHECK: @llvm.x86.avx512.mask.cmp.b.128(<16 x i8> {{.*}}, <16 x i8> {{.*}}, i32 2, i16 {{.*}}) return (__mmask64)_mm_mask_cmple_epi8_mask(__u, __a, __b); } __mmask16 test_mm_cmple_epu8_mask(__m128i __a, __m128i __b) { // CHECK-LABEL: @test_mm_cmple_epu8_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.b.128(<16 x i8> {{.*}}, <16 x i8> {{.*}}, i8 2, i16 -1) + // CHECK: @llvm.x86.avx512.mask.ucmp.b.128(<16 x i8> {{.*}}, <16 x i8> {{.*}}, i32 2, i16 -1) return (__mmask64)_mm_cmple_epu8_mask(__a, __b); } __mmask16 test_mm_mask_cmple_epu8_mask(__mmask64 __u, __m128i __a, __m128i __b) { // CHECK-LABEL: @test_mm_mask_cmple_epu8_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.b.128(<16 x i8> {{.*}}, <16 x i8> {{.*}}, i8 2, i16 {{.*}}) + // CHECK: @llvm.x86.avx512.mask.ucmp.b.128(<16 x i8> {{.*}}, <16 x i8> {{.*}}, i32 2, i16 {{.*}}) return (__mmask64)_mm_mask_cmple_epu8_mask(__u, __a, __b); } __mmask8 test_mm_cmple_epi16_mask(__m128i __a, __m128i __b) { // CHECK-LABEL: @test_mm_cmple_epi16_mask - // CHECK: @llvm.x86.avx512.mask.cmp.w.128(<8 x i16> {{.*}}, <8 x i16> {{.*}}, i8 2, i8 -1) + // CHECK: @llvm.x86.avx512.mask.cmp.w.128(<8 x i16> {{.*}}, <8 x i16> {{.*}}, i32 2, i8 -1) return (__mmask32)_mm_cmple_epi16_mask(__a, __b); } __mmask8 test_mm_mask_cmple_epi16_mask(__mmask32 __u, __m128i __a, __m128i __b) { // CHECK-LABEL: @test_mm_mask_cmple_epi16_mask - // CHECK: @llvm.x86.avx512.mask.cmp.w.128(<8 x i16> {{.*}}, <8 x i16> {{.*}}, i8 2, i8 {{.*}}) + // CHECK: @llvm.x86.avx512.mask.cmp.w.128(<8 x i16> {{.*}}, <8 x i16> {{.*}}, i32 2, i8 {{.*}}) return (__mmask32)_mm_mask_cmple_epi16_mask(__u, __a, __b); } __mmask8 test_mm_cmple_epu16_mask(__m128i __a, __m128i __b) { // CHECK-LABEL: @test_mm_cmple_epu16_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.w.128(<8 x i16> {{.*}}, <8 x i16> {{.*}}, i8 2, i8 -1) + // CHECK: @llvm.x86.avx512.mask.ucmp.w.128(<8 x i16> {{.*}}, <8 x i16> {{.*}}, i32 2, i8 -1) return (__mmask32)_mm_cmple_epu16_mask(__a, __b); } __mmask8 test_mm_mask_cmple_epu16_mask(__mmask32 __u, __m128i __a, __m128i __b) { // CHECK-LABEL: @test_mm_mask_cmple_epu16_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.w.128(<8 x i16> {{.*}}, <8 x i16> {{.*}}, i8 2, i8 {{.*}}) + // CHECK: @llvm.x86.avx512.mask.ucmp.w.128(<8 x i16> {{.*}}, <8 x i16> {{.*}}, i32 2, i8 {{.*}}) return (__mmask32)_mm_mask_cmple_epu16_mask(__u, __a, __b); } __mmask32 test_mm256_cmple_epi8_mask(__m256i __a, __m256i __b) { // CHECK-LABEL: @test_mm256_cmple_epi8_mask - // CHECK: @llvm.x86.avx512.mask.cmp.b.256(<32 x i8> {{.*}}, <32 x i8> {{.*}}, i8 2, i32 -1) + // CHECK: @llvm.x86.avx512.mask.cmp.b.256(<32 x i8> {{.*}}, <32 x i8> {{.*}}, i32 2, i32 -1) return (__mmask64)_mm256_cmple_epi8_mask(__a, __b); } __mmask32 test_mm256_mask_cmple_epi8_mask(__mmask64 __u, __m256i __a, __m256i __b) { // CHECK-LABEL: @test_mm256_mask_cmple_epi8_mask - // CHECK: @llvm.x86.avx512.mask.cmp.b.256(<32 x i8> {{.*}}, <32 x i8> {{.*}}, i8 2, i32 {{.*}}) + // CHECK: @llvm.x86.avx512.mask.cmp.b.256(<32 x i8> {{.*}}, <32 x i8> {{.*}}, i32 2, i32 {{.*}}) return (__mmask64)_mm256_mask_cmple_epi8_mask(__u, __a, __b); } __mmask32 test_mm256_cmple_epu8_mask(__m256i __a, __m256i __b) { // CHECK-LABEL: @test_mm256_cmple_epu8_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.b.256(<32 x i8> {{.*}}, <32 x i8> {{.*}}, i8 2, i32 -1) + // CHECK: @llvm.x86.avx512.mask.ucmp.b.256(<32 x i8> {{.*}}, <32 x i8> {{.*}}, i32 2, i32 -1) return (__mmask64)_mm256_cmple_epu8_mask(__a, __b); } __mmask32 test_mm256_mask_cmple_epu8_mask(__mmask64 __u, __m256i __a, __m256i __b) { // CHECK-LABEL: @test_mm256_mask_cmple_epu8_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.b.256(<32 x i8> {{.*}}, <32 x i8> {{.*}}, i8 2, i32 {{.*}}) + // CHECK: @llvm.x86.avx512.mask.ucmp.b.256(<32 x i8> {{.*}}, <32 x i8> {{.*}}, i32 2, i32 {{.*}}) return (__mmask64)_mm256_mask_cmple_epu8_mask(__u, __a, __b); } __mmask16 test_mm256_cmple_epi16_mask(__m256i __a, __m256i __b) { // CHECK-LABEL: @test_mm256_cmple_epi16_mask - // CHECK: @llvm.x86.avx512.mask.cmp.w.256(<16 x i16> {{.*}}, <16 x i16> {{.*}}, i8 2, i16 -1) + // CHECK: @llvm.x86.avx512.mask.cmp.w.256(<16 x i16> {{.*}}, <16 x i16> {{.*}}, i32 2, i16 -1) return (__mmask32)_mm256_cmple_epi16_mask(__a, __b); } __mmask16 test_mm256_mask_cmple_epi16_mask(__mmask32 __u, __m256i __a, __m256i __b) { // CHECK-LABEL: @test_mm256_mask_cmple_epi16_mask - // CHECK: @llvm.x86.avx512.mask.cmp.w.256(<16 x i16> {{.*}}, <16 x i16> {{.*}}, i8 2, i16 {{.*}}) + // CHECK: @llvm.x86.avx512.mask.cmp.w.256(<16 x i16> {{.*}}, <16 x i16> {{.*}}, i32 2, i16 {{.*}}) return (__mmask32)_mm256_mask_cmple_epi16_mask(__u, __a, __b); } __mmask16 test_mm256_cmple_epu16_mask(__m256i __a, __m256i __b) { // CHECK-LABEL: @test_mm256_cmple_epu16_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.w.256(<16 x i16> {{.*}}, <16 x i16> {{.*}}, i8 2, i16 -1) + // CHECK: @llvm.x86.avx512.mask.ucmp.w.256(<16 x i16> {{.*}}, <16 x i16> {{.*}}, i32 2, i16 -1) return (__mmask32)_mm256_cmple_epu16_mask(__a, __b); } __mmask16 test_mm256_mask_cmple_epu16_mask(__mmask32 __u, __m256i __a, __m256i __b) { // CHECK-LABEL: @test_mm256_mask_cmple_epu16_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.w.256(<16 x i16> {{.*}}, <16 x i16> {{.*}}, i8 2, i16 {{.*}}) + // CHECK: @llvm.x86.avx512.mask.ucmp.w.256(<16 x i16> {{.*}}, <16 x i16> {{.*}}, i32 2, i16 {{.*}}) return (__mmask32)_mm256_mask_cmple_epu16_mask(__u, __a, __b); } __mmask16 test_mm_cmplt_epi8_mask(__m128i __a, __m128i __b) { // CHECK-LABEL: @test_mm_cmplt_epi8_mask - // CHECK: @llvm.x86.avx512.mask.cmp.b.128(<16 x i8> {{.*}}, <16 x i8> {{.*}}, i8 1, i16 -1) + // CHECK: @llvm.x86.avx512.mask.cmp.b.128(<16 x i8> {{.*}}, <16 x i8> {{.*}}, i32 1, i16 -1) return (__mmask64)_mm_cmplt_epi8_mask(__a, __b); } __mmask16 test_mm_mask_cmplt_epi8_mask(__mmask64 __u, __m128i __a, __m128i __b) { // CHECK-LABEL: @test_mm_mask_cmplt_epi8_mask - // CHECK: @llvm.x86.avx512.mask.cmp.b.128(<16 x i8> {{.*}}, <16 x i8> {{.*}}, i8 1, i16 {{.*}}) + // CHECK: @llvm.x86.avx512.mask.cmp.b.128(<16 x i8> {{.*}}, <16 x i8> {{.*}}, i32 1, i16 {{.*}}) return (__mmask64)_mm_mask_cmplt_epi8_mask(__u, __a, __b); } __mmask16 test_mm_cmplt_epu8_mask(__m128i __a, __m128i __b) { // CHECK-LABEL: @test_mm_cmplt_epu8_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.b.128(<16 x i8> {{.*}}, <16 x i8> {{.*}}, i8 1, i16 -1) + // CHECK: @llvm.x86.avx512.mask.ucmp.b.128(<16 x i8> {{.*}}, <16 x i8> {{.*}}, i32 1, i16 -1) return (__mmask64)_mm_cmplt_epu8_mask(__a, __b); } __mmask16 test_mm_mask_cmplt_epu8_mask(__mmask64 __u, __m128i __a, __m128i __b) { // CHECK-LABEL: @test_mm_mask_cmplt_epu8_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.b.128(<16 x i8> {{.*}}, <16 x i8> {{.*}}, i8 1, i16 {{.*}}) + // CHECK: @llvm.x86.avx512.mask.ucmp.b.128(<16 x i8> {{.*}}, <16 x i8> {{.*}}, i32 1, i16 {{.*}}) return (__mmask64)_mm_mask_cmplt_epu8_mask(__u, __a, __b); } __mmask8 test_mm_cmplt_epi16_mask(__m128i __a, __m128i __b) { // CHECK-LABEL: @test_mm_cmplt_epi16_mask - // CHECK: @llvm.x86.avx512.mask.cmp.w.128(<8 x i16> {{.*}}, <8 x i16> {{.*}}, i8 1, i8 -1) + // CHECK: @llvm.x86.avx512.mask.cmp.w.128(<8 x i16> {{.*}}, <8 x i16> {{.*}}, i32 1, i8 -1) return (__mmask32)_mm_cmplt_epi16_mask(__a, __b); } __mmask8 test_mm_mask_cmplt_epi16_mask(__mmask32 __u, __m128i __a, __m128i __b) { // CHECK-LABEL: @test_mm_mask_cmplt_epi16_mask - // CHECK: @llvm.x86.avx512.mask.cmp.w.128(<8 x i16> {{.*}}, <8 x i16> {{.*}}, i8 1, i8 {{.*}}) + // CHECK: @llvm.x86.avx512.mask.cmp.w.128(<8 x i16> {{.*}}, <8 x i16> {{.*}}, i32 1, i8 {{.*}}) return (__mmask32)_mm_mask_cmplt_epi16_mask(__u, __a, __b); } __mmask8 test_mm_cmplt_epu16_mask(__m128i __a, __m128i __b) { // CHECK-LABEL: @test_mm_cmplt_epu16_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.w.128(<8 x i16> {{.*}}, <8 x i16> {{.*}}, i8 1, i8 -1) + // CHECK: @llvm.x86.avx512.mask.ucmp.w.128(<8 x i16> {{.*}}, <8 x i16> {{.*}}, i32 1, i8 -1) return (__mmask32)_mm_cmplt_epu16_mask(__a, __b); } __mmask8 test_mm_mask_cmplt_epu16_mask(__mmask32 __u, __m128i __a, __m128i __b) { // CHECK-LABEL: @test_mm_mask_cmplt_epu16_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.w.128(<8 x i16> {{.*}}, <8 x i16> {{.*}}, i8 1, i8 {{.*}}) + // CHECK: @llvm.x86.avx512.mask.ucmp.w.128(<8 x i16> {{.*}}, <8 x i16> {{.*}}, i32 1, i8 {{.*}}) return (__mmask32)_mm_mask_cmplt_epu16_mask(__u, __a, __b); } __mmask32 test_mm256_cmplt_epi8_mask(__m256i __a, __m256i __b) { // CHECK-LABEL: @test_mm256_cmplt_epi8_mask - // CHECK: @llvm.x86.avx512.mask.cmp.b.256(<32 x i8> {{.*}}, <32 x i8> {{.*}}, i8 1, i32 -1) + // CHECK: @llvm.x86.avx512.mask.cmp.b.256(<32 x i8> {{.*}}, <32 x i8> {{.*}}, i32 1, i32 -1) return (__mmask64)_mm256_cmplt_epi8_mask(__a, __b); } __mmask32 test_mm256_mask_cmplt_epi8_mask(__mmask64 __u, __m256i __a, __m256i __b) { // CHECK-LABEL: @test_mm256_mask_cmplt_epi8_mask - // CHECK: @llvm.x86.avx512.mask.cmp.b.256(<32 x i8> {{.*}}, <32 x i8> {{.*}}, i8 1, i32 {{.*}}) + // CHECK: @llvm.x86.avx512.mask.cmp.b.256(<32 x i8> {{.*}}, <32 x i8> {{.*}}, i32 1, i32 {{.*}}) return (__mmask64)_mm256_mask_cmplt_epi8_mask(__u, __a, __b); } __mmask32 test_mm256_cmplt_epu8_mask(__m256i __a, __m256i __b) { // CHECK-LABEL: @test_mm256_cmplt_epu8_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.b.256(<32 x i8> {{.*}}, <32 x i8> {{.*}}, i8 1, i32 -1) + // CHECK: @llvm.x86.avx512.mask.ucmp.b.256(<32 x i8> {{.*}}, <32 x i8> {{.*}}, i32 1, i32 -1) return (__mmask64)_mm256_cmplt_epu8_mask(__a, __b); } __mmask32 test_mm256_mask_cmplt_epu8_mask(__mmask64 __u, __m256i __a, __m256i __b) { // CHECK-LABEL: @test_mm256_mask_cmplt_epu8_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.b.256(<32 x i8> {{.*}}, <32 x i8> {{.*}}, i8 1, i32 {{.*}}) + // CHECK: @llvm.x86.avx512.mask.ucmp.b.256(<32 x i8> {{.*}}, <32 x i8> {{.*}}, i32 1, i32 {{.*}}) return (__mmask64)_mm256_mask_cmplt_epu8_mask(__u, __a, __b); } __mmask16 test_mm256_cmplt_epi16_mask(__m256i __a, __m256i __b) { // CHECK-LABEL: @test_mm256_cmplt_epi16_mask - // CHECK: @llvm.x86.avx512.mask.cmp.w.256(<16 x i16> {{.*}}, <16 x i16> {{.*}}, i8 1, i16 -1) + // CHECK: @llvm.x86.avx512.mask.cmp.w.256(<16 x i16> {{.*}}, <16 x i16> {{.*}}, i32 1, i16 -1) return (__mmask32)_mm256_cmplt_epi16_mask(__a, __b); } __mmask16 test_mm256_mask_cmplt_epi16_mask(__mmask32 __u, __m256i __a, __m256i __b) { // CHECK-LABEL: @test_mm256_mask_cmplt_epi16_mask - // CHECK: @llvm.x86.avx512.mask.cmp.w.256(<16 x i16> {{.*}}, <16 x i16> {{.*}}, i8 1, i16 {{.*}}) + // CHECK: @llvm.x86.avx512.mask.cmp.w.256(<16 x i16> {{.*}}, <16 x i16> {{.*}}, i32 1, i16 {{.*}}) return (__mmask32)_mm256_mask_cmplt_epi16_mask(__u, __a, __b); } __mmask16 test_mm256_cmplt_epu16_mask(__m256i __a, __m256i __b) { // CHECK-LABEL: @test_mm256_cmplt_epu16_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.w.256(<16 x i16> {{.*}}, <16 x i16> {{.*}}, i8 1, i16 -1) + // CHECK: @llvm.x86.avx512.mask.ucmp.w.256(<16 x i16> {{.*}}, <16 x i16> {{.*}}, i32 1, i16 -1) return (__mmask32)_mm256_cmplt_epu16_mask(__a, __b); } __mmask16 test_mm256_mask_cmplt_epu16_mask(__mmask32 __u, __m256i __a, __m256i __b) { // CHECK-LABEL: @test_mm256_mask_cmplt_epu16_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.w.256(<16 x i16> {{.*}}, <16 x i16> {{.*}}, i8 1, i16 {{.*}}) + // CHECK: @llvm.x86.avx512.mask.ucmp.w.256(<16 x i16> {{.*}}, <16 x i16> {{.*}}, i32 1, i16 {{.*}}) return (__mmask32)_mm256_mask_cmplt_epu16_mask(__u, __a, __b); } __mmask16 test_mm_cmpneq_epi8_mask(__m128i __a, __m128i __b) { // CHECK-LABEL: @test_mm_cmpneq_epi8_mask - // CHECK: @llvm.x86.avx512.mask.cmp.b.128(<16 x i8> {{.*}}, <16 x i8> {{.*}}, i8 4, i16 -1) + // CHECK: @llvm.x86.avx512.mask.cmp.b.128(<16 x i8> {{.*}}, <16 x i8> {{.*}}, i32 4, i16 -1) return (__mmask64)_mm_cmpneq_epi8_mask(__a, __b); } __mmask16 test_mm_mask_cmpneq_epi8_mask(__mmask64 __u, __m128i __a, __m128i __b) { // CHECK-LABEL: @test_mm_mask_cmpneq_epi8_mask - // CHECK: @llvm.x86.avx512.mask.cmp.b.128(<16 x i8> {{.*}}, <16 x i8> {{.*}}, i8 4, i16 {{.*}}) + // CHECK: @llvm.x86.avx512.mask.cmp.b.128(<16 x i8> {{.*}}, <16 x i8> {{.*}}, i32 4, i16 {{.*}}) return (__mmask64)_mm_mask_cmpneq_epi8_mask(__u, __a, __b); } __mmask16 test_mm_cmpneq_epu8_mask(__m128i __a, __m128i __b) { // CHECK-LABEL: @test_mm_cmpneq_epu8_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.b.128(<16 x i8> {{.*}}, <16 x i8> {{.*}}, i8 4, i16 -1) + // CHECK: @llvm.x86.avx512.mask.ucmp.b.128(<16 x i8> {{.*}}, <16 x i8> {{.*}}, i32 4, i16 -1) return (__mmask64)_mm_cmpneq_epu8_mask(__a, __b); } __mmask16 test_mm_mask_cmpneq_epu8_mask(__mmask64 __u, __m128i __a, __m128i __b) { // CHECK-LABEL: @test_mm_mask_cmpneq_epu8_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.b.128(<16 x i8> {{.*}}, <16 x i8> {{.*}}, i8 4, i16 {{.*}}) + // CHECK: @llvm.x86.avx512.mask.ucmp.b.128(<16 x i8> {{.*}}, <16 x i8> {{.*}}, i32 4, i16 {{.*}}) return (__mmask64)_mm_mask_cmpneq_epu8_mask(__u, __a, __b); } __mmask8 test_mm_cmpneq_epi16_mask(__m128i __a, __m128i __b) { // CHECK-LABEL: @test_mm_cmpneq_epi16_mask - // CHECK: @llvm.x86.avx512.mask.cmp.w.128(<8 x i16> {{.*}}, <8 x i16> {{.*}}, i8 4, i8 -1) + // CHECK: @llvm.x86.avx512.mask.cmp.w.128(<8 x i16> {{.*}}, <8 x i16> {{.*}}, i32 4, i8 -1) return (__mmask32)_mm_cmpneq_epi16_mask(__a, __b); } __mmask8 test_mm_mask_cmpneq_epi16_mask(__mmask32 __u, __m128i __a, __m128i __b) { // CHECK-LABEL: @test_mm_mask_cmpneq_epi16_mask - // CHECK: @llvm.x86.avx512.mask.cmp.w.128(<8 x i16> {{.*}}, <8 x i16> {{.*}}, i8 4, i8 {{.*}}) + // CHECK: @llvm.x86.avx512.mask.cmp.w.128(<8 x i16> {{.*}}, <8 x i16> {{.*}}, i32 4, i8 {{.*}}) return (__mmask32)_mm_mask_cmpneq_epi16_mask(__u, __a, __b); } __mmask8 test_mm_cmpneq_epu16_mask(__m128i __a, __m128i __b) { // CHECK-LABEL: @test_mm_cmpneq_epu16_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.w.128(<8 x i16> {{.*}}, <8 x i16> {{.*}}, i8 4, i8 -1) + // CHECK: @llvm.x86.avx512.mask.ucmp.w.128(<8 x i16> {{.*}}, <8 x i16> {{.*}}, i32 4, i8 -1) return (__mmask32)_mm_cmpneq_epu16_mask(__a, __b); } __mmask8 test_mm_mask_cmpneq_epu16_mask(__mmask32 __u, __m128i __a, __m128i __b) { // CHECK-LABEL: @test_mm_mask_cmpneq_epu16_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.w.128(<8 x i16> {{.*}}, <8 x i16> {{.*}}, i8 4, i8 {{.*}}) + // CHECK: @llvm.x86.avx512.mask.ucmp.w.128(<8 x i16> {{.*}}, <8 x i16> {{.*}}, i32 4, i8 {{.*}}) return (__mmask32)_mm_mask_cmpneq_epu16_mask(__u, __a, __b); } __mmask32 test_mm256_cmpneq_epi8_mask(__m256i __a, __m256i __b) { // CHECK-LABEL: @test_mm256_cmpneq_epi8_mask - // CHECK: @llvm.x86.avx512.mask.cmp.b.256(<32 x i8> {{.*}}, <32 x i8> {{.*}}, i8 4, i32 -1) + // CHECK: @llvm.x86.avx512.mask.cmp.b.256(<32 x i8> {{.*}}, <32 x i8> {{.*}}, i32 4, i32 -1) return (__mmask64)_mm256_cmpneq_epi8_mask(__a, __b); } __mmask32 test_mm256_mask_cmpneq_epi8_mask(__mmask64 __u, __m256i __a, __m256i __b) { // CHECK-LABEL: @test_mm256_mask_cmpneq_epi8_mask - // CHECK: @llvm.x86.avx512.mask.cmp.b.256(<32 x i8> {{.*}}, <32 x i8> {{.*}}, i8 4, i32 {{.*}}) + // CHECK: @llvm.x86.avx512.mask.cmp.b.256(<32 x i8> {{.*}}, <32 x i8> {{.*}}, i32 4, i32 {{.*}}) return (__mmask64)_mm256_mask_cmpneq_epi8_mask(__u, __a, __b); } __mmask32 test_mm256_cmpneq_epu8_mask(__m256i __a, __m256i __b) { // CHECK-LABEL: @test_mm256_cmpneq_epu8_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.b.256(<32 x i8> {{.*}}, <32 x i8> {{.*}}, i8 4, i32 -1) + // CHECK: @llvm.x86.avx512.mask.ucmp.b.256(<32 x i8> {{.*}}, <32 x i8> {{.*}}, i32 4, i32 -1) return (__mmask64)_mm256_cmpneq_epu8_mask(__a, __b); } __mmask32 test_mm256_mask_cmpneq_epu8_mask(__mmask64 __u, __m256i __a, __m256i __b) { // CHECK-LABEL: @test_mm256_mask_cmpneq_epu8_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.b.256(<32 x i8> {{.*}}, <32 x i8> {{.*}}, i8 4, i32 {{.*}}) + // CHECK: @llvm.x86.avx512.mask.ucmp.b.256(<32 x i8> {{.*}}, <32 x i8> {{.*}}, i32 4, i32 {{.*}}) return (__mmask64)_mm256_mask_cmpneq_epu8_mask(__u, __a, __b); } __mmask16 test_mm256_cmpneq_epi16_mask(__m256i __a, __m256i __b) { // CHECK-LABEL: @test_mm256_cmpneq_epi16_mask - // CHECK: @llvm.x86.avx512.mask.cmp.w.256(<16 x i16> {{.*}}, <16 x i16> {{.*}}, i8 4, i16 -1) + // CHECK: @llvm.x86.avx512.mask.cmp.w.256(<16 x i16> {{.*}}, <16 x i16> {{.*}}, i32 4, i16 -1) return (__mmask32)_mm256_cmpneq_epi16_mask(__a, __b); } __mmask16 test_mm256_mask_cmpneq_epi16_mask(__mmask32 __u, __m256i __a, __m256i __b) { // CHECK-LABEL: @test_mm256_mask_cmpneq_epi16_mask - // CHECK: @llvm.x86.avx512.mask.cmp.w.256(<16 x i16> {{.*}}, <16 x i16> {{.*}}, i8 4, i16 {{.*}}) + // CHECK: @llvm.x86.avx512.mask.cmp.w.256(<16 x i16> {{.*}}, <16 x i16> {{.*}}, i32 4, i16 {{.*}}) return (__mmask32)_mm256_mask_cmpneq_epi16_mask(__u, __a, __b); } __mmask16 test_mm256_cmpneq_epu16_mask(__m256i __a, __m256i __b) { // CHECK-LABEL: @test_mm256_cmpneq_epu16_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.w.256(<16 x i16> {{.*}}, <16 x i16> {{.*}}, i8 4, i16 -1) + // CHECK: @llvm.x86.avx512.mask.ucmp.w.256(<16 x i16> {{.*}}, <16 x i16> {{.*}}, i32 4, i16 -1) return (__mmask32)_mm256_cmpneq_epu16_mask(__a, __b); } __mmask16 test_mm256_mask_cmpneq_epu16_mask(__mmask32 __u, __m256i __a, __m256i __b) { // CHECK-LABEL: @test_mm256_mask_cmpneq_epu16_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.w.256(<16 x i16> {{.*}}, <16 x i16> {{.*}}, i8 4, i16 {{.*}}) + // CHECK: @llvm.x86.avx512.mask.ucmp.w.256(<16 x i16> {{.*}}, <16 x i16> {{.*}}, i32 4, i16 {{.*}}) return (__mmask32)_mm256_mask_cmpneq_epu16_mask(__u, __a, __b); } __mmask16 test_mm_cmp_epi8_mask(__m128i __a, __m128i __b) { // CHECK-LABEL: @test_mm_cmp_epi8_mask - // CHECK: @llvm.x86.avx512.mask.cmp.b.128(<16 x i8> {{.*}}, <16 x i8> {{.*}}, i8 7, i16 -1) + // CHECK: @llvm.x86.avx512.mask.cmp.b.128(<16 x i8> {{.*}}, <16 x i8> {{.*}}, i32 7, i16 -1) return (__mmask64)_mm_cmp_epi8_mask(__a, __b, 7); } __mmask16 test_mm_mask_cmp_epi8_mask(__mmask64 __u, __m128i __a, __m128i __b) { // CHECK-LABEL: @test_mm_mask_cmp_epi8_mask - // CHECK: @llvm.x86.avx512.mask.cmp.b.128(<16 x i8> {{.*}}, <16 x i8> {{.*}}, i8 7, i16 {{.*}}) + // CHECK: @llvm.x86.avx512.mask.cmp.b.128(<16 x i8> {{.*}}, <16 x i8> {{.*}}, i32 7, i16 {{.*}}) return (__mmask64)_mm_mask_cmp_epi8_mask(__u, __a, __b, 7); } __mmask16 test_mm_cmp_epu8_mask(__m128i __a, __m128i __b) { // CHECK-LABEL: @test_mm_cmp_epu8_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.b.128(<16 x i8> {{.*}}, <16 x i8> {{.*}}, i8 7, i16 -1) + // CHECK: @llvm.x86.avx512.mask.ucmp.b.128(<16 x i8> {{.*}}, <16 x i8> {{.*}}, i32 7, i16 -1) return (__mmask64)_mm_cmp_epu8_mask(__a, __b, 7); } __mmask16 test_mm_mask_cmp_epu8_mask(__mmask64 __u, __m128i __a, __m128i __b) { // CHECK-LABEL: @test_mm_mask_cmp_epu8_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.b.128(<16 x i8> {{.*}}, <16 x i8> {{.*}}, i8 7, i16 {{.*}}) + // CHECK: @llvm.x86.avx512.mask.ucmp.b.128(<16 x i8> {{.*}}, <16 x i8> {{.*}}, i32 7, i16 {{.*}}) return (__mmask64)_mm_mask_cmp_epu8_mask(__u, __a, __b, 7); } __mmask8 test_mm_cmp_epi16_mask(__m128i __a, __m128i __b) { // CHECK-LABEL: @test_mm_cmp_epi16_mask - // CHECK: @llvm.x86.avx512.mask.cmp.w.128(<8 x i16> {{.*}}, <8 x i16> {{.*}}, i8 7, i8 -1) + // CHECK: @llvm.x86.avx512.mask.cmp.w.128(<8 x i16> {{.*}}, <8 x i16> {{.*}}, i32 7, i8 -1) return (__mmask32)_mm_cmp_epi16_mask(__a, __b, 7); } __mmask8 test_mm_mask_cmp_epi16_mask(__mmask32 __u, __m128i __a, __m128i __b) { // CHECK-LABEL: @test_mm_mask_cmp_epi16_mask - // CHECK: @llvm.x86.avx512.mask.cmp.w.128(<8 x i16> {{.*}}, <8 x i16> {{.*}}, i8 7, i8 {{.*}}) + // CHECK: @llvm.x86.avx512.mask.cmp.w.128(<8 x i16> {{.*}}, <8 x i16> {{.*}}, i32 7, i8 {{.*}}) return (__mmask32)_mm_mask_cmp_epi16_mask(__u, __a, __b, 7); } __mmask8 test_mm_cmp_epu16_mask(__m128i __a, __m128i __b) { // CHECK-LABEL: @test_mm_cmp_epu16_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.w.128(<8 x i16> {{.*}}, <8 x i16> {{.*}}, i8 7, i8 -1) + // CHECK: @llvm.x86.avx512.mask.ucmp.w.128(<8 x i16> {{.*}}, <8 x i16> {{.*}}, i32 7, i8 -1) return (__mmask32)_mm_cmp_epu16_mask(__a, __b, 7); } __mmask8 test_mm_mask_cmp_epu16_mask(__mmask32 __u, __m128i __a, __m128i __b) { // CHECK-LABEL: @test_mm_mask_cmp_epu16_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.w.128(<8 x i16> {{.*}}, <8 x i16> {{.*}}, i8 7, i8 {{.*}}) + // CHECK: @llvm.x86.avx512.mask.ucmp.w.128(<8 x i16> {{.*}}, <8 x i16> {{.*}}, i32 7, i8 {{.*}}) return (__mmask32)_mm_mask_cmp_epu16_mask(__u, __a, __b, 7); } __mmask32 test_mm256_cmp_epi8_mask(__m256i __a, __m256i __b) { // CHECK-LABEL: @test_mm256_cmp_epi8_mask - // CHECK: @llvm.x86.avx512.mask.cmp.b.256(<32 x i8> {{.*}}, <32 x i8> {{.*}}, i8 7, i32 -1) + // CHECK: @llvm.x86.avx512.mask.cmp.b.256(<32 x i8> {{.*}}, <32 x i8> {{.*}}, i32 7, i32 -1) return (__mmask64)_mm256_cmp_epi8_mask(__a, __b, 7); } __mmask32 test_mm256_mask_cmp_epi8_mask(__mmask64 __u, __m256i __a, __m256i __b) { // CHECK-LABEL: @test_mm256_mask_cmp_epi8_mask - // CHECK: @llvm.x86.avx512.mask.cmp.b.256(<32 x i8> {{.*}}, <32 x i8> {{.*}}, i8 7, i32 {{.*}}) + // CHECK: @llvm.x86.avx512.mask.cmp.b.256(<32 x i8> {{.*}}, <32 x i8> {{.*}}, i32 7, i32 {{.*}}) return (__mmask64)_mm256_mask_cmp_epi8_mask(__u, __a, __b, 7); } __mmask32 test_mm256_cmp_epu8_mask(__m256i __a, __m256i __b) { // CHECK-LABEL: @test_mm256_cmp_epu8_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.b.256(<32 x i8> {{.*}}, <32 x i8> {{.*}}, i8 7, i32 -1) + // CHECK: @llvm.x86.avx512.mask.ucmp.b.256(<32 x i8> {{.*}}, <32 x i8> {{.*}}, i32 7, i32 -1) return (__mmask64)_mm256_cmp_epu8_mask(__a, __b, 7); } __mmask32 test_mm256_mask_cmp_epu8_mask(__mmask64 __u, __m256i __a, __m256i __b) { // CHECK-LABEL: @test_mm256_mask_cmp_epu8_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.b.256(<32 x i8> {{.*}}, <32 x i8> {{.*}}, i8 7, i32 {{.*}}) + // CHECK: @llvm.x86.avx512.mask.ucmp.b.256(<32 x i8> {{.*}}, <32 x i8> {{.*}}, i32 7, i32 {{.*}}) return (__mmask64)_mm256_mask_cmp_epu8_mask(__u, __a, __b, 7); } __mmask16 test_mm256_cmp_epi16_mask(__m256i __a, __m256i __b) { // CHECK-LABEL: @test_mm256_cmp_epi16_mask - // CHECK: @llvm.x86.avx512.mask.cmp.w.256(<16 x i16> {{.*}}, <16 x i16> {{.*}}, i8 7, i16 -1) + // CHECK: @llvm.x86.avx512.mask.cmp.w.256(<16 x i16> {{.*}}, <16 x i16> {{.*}}, i32 7, i16 -1) return (__mmask32)_mm256_cmp_epi16_mask(__a, __b, 7); } __mmask16 test_mm256_mask_cmp_epi16_mask(__mmask32 __u, __m256i __a, __m256i __b) { // CHECK-LABEL: @test_mm256_mask_cmp_epi16_mask - // CHECK: @llvm.x86.avx512.mask.cmp.w.256(<16 x i16> {{.*}}, <16 x i16> {{.*}}, i8 7, i16 {{.*}}) + // CHECK: @llvm.x86.avx512.mask.cmp.w.256(<16 x i16> {{.*}}, <16 x i16> {{.*}}, i32 7, i16 {{.*}}) return (__mmask32)_mm256_mask_cmp_epi16_mask(__u, __a, __b, 7); } __mmask16 test_mm256_cmp_epu16_mask(__m256i __a, __m256i __b) { // CHECK-LABEL: @test_mm256_cmp_epu16_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.w.256(<16 x i16> {{.*}}, <16 x i16> {{.*}}, i8 7, i16 -1) + // CHECK: @llvm.x86.avx512.mask.ucmp.w.256(<16 x i16> {{.*}}, <16 x i16> {{.*}}, i32 7, i16 -1) return (__mmask32)_mm256_cmp_epu16_mask(__a, __b, 7); } __mmask16 test_mm256_mask_cmp_epu16_mask(__mmask32 __u, __m256i __a, __m256i __b) { // CHECK-LABEL: @test_mm256_mask_cmp_epu16_mask - // CHECK: @llvm.x86.avx512.mask.ucmp.w.256(<16 x i16> {{.*}}, <16 x i16> {{.*}}, i8 7, i16 {{.*}}) + // CHECK: @llvm.x86.avx512.mask.ucmp.w.256(<16 x i16> {{.*}}, <16 x i16> {{.*}}, i32 7, i16 {{.*}}) return (__mmask32)_mm256_mask_cmp_epu16_mask(__u, __a, __b, 7); } @@ -791,4 +791,4 @@ __m128i test_mm_maskz_mullo_epi16 (__mmask8 __U, __m128i __A, __m128i __B) { //CHECK-LABEL: @test_mm_maskz_mullo_epi16 //CHECK: @llvm.x86.avx512.mask.pmull.w.128 return _mm_maskz_mullo_epi16(__U , __A, __B); -} \ No newline at end of file +}