From a54c21e742ac9fffe83c0cfec4fa164f28599880 Mon Sep 17 00:00:00 2001 From: Craig Topper Date: Wed, 15 Jun 2016 14:06:34 +0000 Subject: [PATCH] [AVX512] Use native IR for mask pcmpeq/pcmpgt intrinsics. llvm-svn: 272787 --- clang/lib/CodeGen/CGBuiltin.cpp | 49 ++++++++++++++++++++++++ clang/test/CodeGen/avx512bw-builtins.c | 20 ++++++---- clang/test/CodeGen/avx512f-builtins.c | 20 ++++++---- clang/test/CodeGen/avx512vl-builtins.c | 40 +++++++++++-------- clang/test/CodeGen/avx512vlbw-builtins.c | 40 +++++++++++-------- 5 files changed, 121 insertions(+), 48 deletions(-) diff --git a/clang/lib/CodeGen/CGBuiltin.cpp b/clang/lib/CodeGen/CGBuiltin.cpp index 298707874f39..462f1a7d6c56 100644 --- a/clang/lib/CodeGen/CGBuiltin.cpp +++ b/clang/lib/CodeGen/CGBuiltin.cpp @@ -6414,6 +6414,29 @@ static Value *EmitX86Select(CodeGenFunction &CGF, return CGF.Builder.CreateSelect(Mask, Op0, Op1); } +static Value *EmitX86MaskedCompare(CodeGenFunction &CGF, CmpInst::Predicate P, + SmallVectorImpl &Ops) { + unsigned NumElts = Ops[0]->getType()->getVectorNumElements(); + Value *Cmp = CGF.Builder.CreateICmp(P, Ops[0], Ops[1]); + + const auto *C = dyn_cast(Ops[2]); + if (!C || !C->isAllOnesValue()) + Cmp = CGF.Builder.CreateAnd(Cmp, getMaskVecValue(CGF, Ops[2], NumElts)); + + if (NumElts < 8) { + uint32_t Indices[8]; + for (unsigned i = 0; i != NumElts; ++i) + Indices[i] = i; + for (unsigned i = NumElts; i != 8; ++i) + Indices[i] = NumElts; + Cmp = CGF.Builder.CreateShuffleVector(Cmp, UndefValue::get(Cmp->getType()), + Indices); + } + return CGF.Builder.CreateBitCast(Cmp, + IntegerType::get(CGF.getLLVMContext(), + std::max(NumElts, 8U))); +} + Value *CodeGenFunction::EmitX86BuiltinExpr(unsigned BuiltinID, const CallExpr *E) { if (BuiltinID == X86::BI__builtin_ms_va_start || @@ -6807,6 +6830,32 @@ Value *CodeGenFunction::EmitX86BuiltinExpr(unsigned BuiltinID, case X86::BI__builtin_ia32_selectpd_256: case X86::BI__builtin_ia32_selectpd_512: return EmitX86Select(*this, Ops[0], Ops[1], Ops[2]); + case X86::BI__builtin_ia32_pcmpeqb128_mask: + case X86::BI__builtin_ia32_pcmpeqb256_mask: + case X86::BI__builtin_ia32_pcmpeqb512_mask: + case X86::BI__builtin_ia32_pcmpeqw128_mask: + case X86::BI__builtin_ia32_pcmpeqw256_mask: + case X86::BI__builtin_ia32_pcmpeqw512_mask: + case X86::BI__builtin_ia32_pcmpeqd128_mask: + case X86::BI__builtin_ia32_pcmpeqd256_mask: + case X86::BI__builtin_ia32_pcmpeqd512_mask: + case X86::BI__builtin_ia32_pcmpeqq128_mask: + case X86::BI__builtin_ia32_pcmpeqq256_mask: + case X86::BI__builtin_ia32_pcmpeqq512_mask: + return EmitX86MaskedCompare(*this, ICmpInst::ICMP_EQ, Ops); + case X86::BI__builtin_ia32_pcmpgtb128_mask: + case X86::BI__builtin_ia32_pcmpgtb256_mask: + case X86::BI__builtin_ia32_pcmpgtb512_mask: + case X86::BI__builtin_ia32_pcmpgtw128_mask: + case X86::BI__builtin_ia32_pcmpgtw256_mask: + case X86::BI__builtin_ia32_pcmpgtw512_mask: + case X86::BI__builtin_ia32_pcmpgtd128_mask: + case X86::BI__builtin_ia32_pcmpgtd256_mask: + case X86::BI__builtin_ia32_pcmpgtd512_mask: + case X86::BI__builtin_ia32_pcmpgtq128_mask: + case X86::BI__builtin_ia32_pcmpgtq256_mask: + case X86::BI__builtin_ia32_pcmpgtq512_mask: + return EmitX86MaskedCompare(*this, ICmpInst::ICMP_SGT, Ops); // 3DNow! case X86::BI__builtin_ia32_pswapdsf: case X86::BI__builtin_ia32_pswapdsi: { diff --git a/clang/test/CodeGen/avx512bw-builtins.c b/clang/test/CodeGen/avx512bw-builtins.c index d598ae925e41..099f25553ce7 100644 --- a/clang/test/CodeGen/avx512bw-builtins.c +++ b/clang/test/CodeGen/avx512bw-builtins.c @@ -8,49 +8,53 @@ __mmask64 test_mm512_cmpeq_epi8_mask(__m512i __a, __m512i __b) { // CHECK-LABEL: @test_mm512_cmpeq_epi8_mask - // CHECK: @llvm.x86.avx512.mask.pcmpeq.b.512 + // CHECK: icmp eq <64 x i8> %{{.*}}, %{{.*}} return (__mmask64)_mm512_cmpeq_epi8_mask(__a, __b); } __mmask64 test_mm512_mask_cmpeq_epi8_mask(__mmask64 __u, __m512i __a, __m512i __b) { // CHECK-LABEL: @test_mm512_mask_cmpeq_epi8_mask - // CHECK: @llvm.x86.avx512.mask.pcmpeq.b.512 + // CHECK: icmp eq <64 x i8> %{{.*}}, %{{.*}} + // CHECK: and <64 x i1> %{{.*}}, %{{.*}} return (__mmask64)_mm512_mask_cmpeq_epi8_mask(__u, __a, __b); } __mmask32 test_mm512_cmpeq_epi16_mask(__m512i __a, __m512i __b) { // CHECK-LABEL: @test_mm512_cmpeq_epi16_mask - // CHECK: @llvm.x86.avx512.mask.pcmpeq.w.512 + // CHECK: icmp eq <32 x i16> %{{.*}}, %{{.*}} return (__mmask32)_mm512_cmpeq_epi16_mask(__a, __b); } __mmask32 test_mm512_mask_cmpeq_epi16_mask(__mmask32 __u, __m512i __a, __m512i __b) { // CHECK-LABEL: @test_mm512_mask_cmpeq_epi16_mask - // CHECK: @llvm.x86.avx512.mask.pcmpeq.w.512 + // CHECK: icmp eq <32 x i16> %{{.*}}, %{{.*}} + // CHECK: and <32 x i1> %{{.*}}, %{{.*}} return (__mmask32)_mm512_mask_cmpeq_epi16_mask(__u, __a, __b); } __mmask64 test_mm512_cmpgt_epi8_mask(__m512i __a, __m512i __b) { // CHECK-LABEL: @test_mm512_cmpgt_epi8_mask - // CHECK: @llvm.x86.avx512.mask.pcmpgt.b.512 + // CHECK: icmp sgt <64 x i8> %{{.*}}, %{{.*}} return (__mmask64)_mm512_cmpgt_epi8_mask(__a, __b); } __mmask64 test_mm512_mask_cmpgt_epi8_mask(__mmask64 __u, __m512i __a, __m512i __b) { // CHECK-LABEL: @test_mm512_mask_cmpgt_epi8_mask - // CHECK: @llvm.x86.avx512.mask.pcmpgt.b.512 + // CHECK: icmp sgt <64 x i8> %{{.*}}, %{{.*}} + // CHECK: and <64 x i1> %{{.*}}, %{{.*}} return (__mmask64)_mm512_mask_cmpgt_epi8_mask(__u, __a, __b); } __mmask32 test_mm512_cmpgt_epi16_mask(__m512i __a, __m512i __b) { // CHECK-LABEL: @test_mm512_cmpgt_epi16_mask - // CHECK: @llvm.x86.avx512.mask.pcmpgt.w.512 + // CHECK: icmp sgt <32 x i16> %{{.*}}, %{{.*}} return (__mmask32)_mm512_cmpgt_epi16_mask(__a, __b); } __mmask32 test_mm512_mask_cmpgt_epi16_mask(__mmask32 __u, __m512i __a, __m512i __b) { // CHECK-LABEL: @test_mm512_mask_cmpgt_epi16_mask - // CHECK: @llvm.x86.avx512.mask.pcmpgt.w.512 + // CHECK: icmp sgt <32 x i16> %{{.*}}, %{{.*}} + // CHECK: and <32 x i1> %{{.*}}, %{{.*}} return (__mmask32)_mm512_mask_cmpgt_epi16_mask(__u, __a, __b); } diff --git a/clang/test/CodeGen/avx512f-builtins.c b/clang/test/CodeGen/avx512f-builtins.c index cd0ce8a2f24a..c8a17ea2e7f7 100644 --- a/clang/test/CodeGen/avx512f-builtins.c +++ b/clang/test/CodeGen/avx512f-builtins.c @@ -932,49 +932,53 @@ __m512 test_mm512_mask3_fnmsub_ps(__m512 __A, __m512 __B, __m512 __C, __mmask16 __mmask16 test_mm512_cmpeq_epi32_mask(__m512i __a, __m512i __b) { // CHECK-LABEL: @test_mm512_cmpeq_epi32_mask - // CHECK: @llvm.x86.avx512.mask.pcmpeq.d.512 + // CHECK: icmp eq <16 x i32> %{{.*}}, %{{.*}} return (__mmask16)_mm512_cmpeq_epi32_mask(__a, __b); } __mmask16 test_mm512_mask_cmpeq_epi32_mask(__mmask16 __u, __m512i __a, __m512i __b) { // CHECK-LABEL: @test_mm512_mask_cmpeq_epi32_mask - // CHECK: @llvm.x86.avx512.mask.pcmpeq.d.512 + // CHECK: icmp eq <16 x i32> %{{.*}}, %{{.*}} + // CHECK: and <16 x i1> %{{.*}}, %{{.*}} return (__mmask16)_mm512_mask_cmpeq_epi32_mask(__u, __a, __b); } __mmask8 test_mm512_mask_cmpeq_epi64_mask(__mmask8 __u, __m512i __a, __m512i __b) { // CHECK-LABEL: @test_mm512_mask_cmpeq_epi64_mask - // CHECK: @llvm.x86.avx512.mask.pcmpeq.q.512 + // CHECK: icmp eq <8 x i64> %{{.*}}, %{{.*}} + // CHECK: and <8 x i1> %{{.*}}, %{{.*}} return (__mmask8)_mm512_mask_cmpeq_epi64_mask(__u, __a, __b); } __mmask8 test_mm512_cmpeq_epi64_mask(__m512i __a, __m512i __b) { // CHECK-LABEL: @test_mm512_cmpeq_epi64_mask - // CHECK: @llvm.x86.avx512.mask.pcmpeq.q.512 + // CHECK: icmp eq <8 x i64> %{{.*}}, %{{.*}} return (__mmask8)_mm512_cmpeq_epi64_mask(__a, __b); } __mmask16 test_mm512_cmpgt_epi32_mask(__m512i __a, __m512i __b) { // CHECK-LABEL: @test_mm512_cmpgt_epi32_mask - // CHECK: @llvm.x86.avx512.mask.pcmpgt.d.512 + // CHECK: icmp sgt <16 x i32> %{{.*}}, %{{.*}} return (__mmask16)_mm512_cmpgt_epi32_mask(__a, __b); } __mmask16 test_mm512_mask_cmpgt_epi32_mask(__mmask16 __u, __m512i __a, __m512i __b) { // CHECK-LABEL: @test_mm512_mask_cmpgt_epi32_mask - // CHECK: @llvm.x86.avx512.mask.pcmpgt.d.512 + // CHECK: icmp sgt <16 x i32> %{{.*}}, %{{.*}} + // CHECK: and <16 x i1> %{{.*}}, %{{.*}} return (__mmask16)_mm512_mask_cmpgt_epi32_mask(__u, __a, __b); } __mmask8 test_mm512_mask_cmpgt_epi64_mask(__mmask8 __u, __m512i __a, __m512i __b) { // CHECK-LABEL: @test_mm512_mask_cmpgt_epi64_mask - // CHECK: @llvm.x86.avx512.mask.pcmpgt.q.512 + // CHECK: icmp sgt <8 x i64> %{{.*}}, %{{.*}} + // CHECK: and <8 x i1> %{{.*}}, %{{.*}} return (__mmask8)_mm512_mask_cmpgt_epi64_mask(__u, __a, __b); } __mmask8 test_mm512_cmpgt_epi64_mask(__m512i __a, __m512i __b) { // CHECK-LABEL: @test_mm512_cmpgt_epi64_mask - // CHECK: @llvm.x86.avx512.mask.pcmpgt.q.512 + // CHECK: icmp sgt <8 x i64> %{{.*}}, %{{.*}} return (__mmask8)_mm512_cmpgt_epi64_mask(__a, __b); } diff --git a/clang/test/CodeGen/avx512vl-builtins.c b/clang/test/CodeGen/avx512vl-builtins.c index f7375523dc28..974a88e4f02d 100644 --- a/clang/test/CodeGen/avx512vl-builtins.c +++ b/clang/test/CodeGen/avx512vl-builtins.c @@ -6741,96 +6741,104 @@ __m128i test_mm256_maskz_cvt_roundps_ph(__mmask8 __U, __m256 __A) { __mmask8 test_mm_cmpeq_epi32_mask(__m128i __a, __m128i __b) { // CHECK-LABEL: @test_mm_cmpeq_epi32_mask - // CHECK: @llvm.x86.avx512.mask.pcmpeq.d.128 + // CHECK: icmp eq <4 x i32> %{{.*}}, %{{.*}} return (__mmask8)_mm_cmpeq_epi32_mask(__a, __b); } __mmask8 test_mm_mask_cmpeq_epi32_mask(__mmask8 __u, __m128i __a, __m128i __b) { // CHECK-LABEL: @test_mm_mask_cmpeq_epi32_mask - // CHECK: @llvm.x86.avx512.mask.pcmpeq.d.128 + // CHECK: icmp eq <4 x i32> %{{.*}}, %{{.*}} + // CHECK: and <4 x i1> %{{.*}}, %{{.*}} return (__mmask8)_mm_mask_cmpeq_epi32_mask(__u, __a, __b); } __mmask8 test_mm_mask_cmpeq_epi64_mask(__mmask8 __u, __m128i __a, __m128i __b) { // CHECK-LABEL: @test_mm_mask_cmpeq_epi64_mask - // CHECK: @llvm.x86.avx512.mask.pcmpeq.q.128 + // CHECK: icmp eq <2 x i64> %{{.*}}, %{{.*}} + // CHECK: and <2 x i1> %{{.*}}, %{{.*}} return (__mmask8)_mm_mask_cmpeq_epi64_mask(__u, __a, __b); } __mmask8 test_mm_cmpeq_epi64_mask(__m128i __a, __m128i __b) { // CHECK-LABEL: @test_mm_cmpeq_epi64_mask - // CHECK: @llvm.x86.avx512.mask.pcmpeq.q.128 + // CHECK: icmp eq <2 x i64> %{{.*}}, %{{.*}} return (__mmask8)_mm_cmpeq_epi64_mask(__a, __b); } __mmask8 test_mm_cmpgt_epi32_mask(__m128i __a, __m128i __b) { // CHECK-LABEL: @test_mm_cmpgt_epi32_mask - // CHECK: @llvm.x86.avx512.mask.pcmpgt.d.128 + // CHECK: icmp sgt <4 x i32> %{{.*}}, %{{.*}} return (__mmask8)_mm_cmpgt_epi32_mask(__a, __b); } __mmask8 test_mm_mask_cmpgt_epi32_mask(__mmask8 __u, __m128i __a, __m128i __b) { // CHECK-LABEL: @test_mm_mask_cmpgt_epi32_mask - // CHECK: @llvm.x86.avx512.mask.pcmpgt.d.128 + // CHECK: icmp sgt <4 x i32> %{{.*}}, %{{.*}} + // CHECK: and <4 x i1> %{{.*}}, %{{.*}} return (__mmask8)_mm_mask_cmpgt_epi32_mask(__u, __a, __b); } __mmask8 test_mm_mask_cmpgt_epi64_mask(__mmask8 __u, __m128i __a, __m128i __b) { // CHECK-LABEL: @test_mm_mask_cmpgt_epi64_mask - // CHECK: @llvm.x86.avx512.mask.pcmpgt.q.128 + // CHECK: icmp sgt <2 x i64> %{{.*}}, %{{.*}} + // CHECK: and <2 x i1> %{{.*}}, %{{.*}} return (__mmask8)_mm_mask_cmpgt_epi64_mask(__u, __a, __b); } __mmask8 test_mm_cmpgt_epi64_mask(__m128i __a, __m128i __b) { // CHECK-LABEL: @test_mm_cmpgt_epi64_mask - // CHECK: @llvm.x86.avx512.mask.pcmpgt.q.128 + // CHECK: icmp sgt <2 x i64> %{{.*}}, %{{.*}} return (__mmask8)_mm_cmpgt_epi64_mask(__a, __b); } __mmask8 test_mm256_cmpeq_epi32_mask(__m256i __a, __m256i __b) { // CHECK-LABEL: @test_mm256_cmpeq_epi32_mask - // CHECK: @llvm.x86.avx512.mask.pcmpeq.d.256 + // CHECK: icmp eq <8 x i32> %{{.*}}, %{{.*}} return (__mmask8)_mm256_cmpeq_epi32_mask(__a, __b); } __mmask8 test_mm256_mask_cmpeq_epi32_mask(__mmask8 __u, __m256i __a, __m256i __b) { // CHECK-LABEL: @test_mm256_mask_cmpeq_epi32_mask - // CHECK: @llvm.x86.avx512.mask.pcmpeq.d.256 + // CHECK: icmp eq <8 x i32> %{{.*}}, %{{.*}} + // CHECK: and <8 x i1> %{{.*}}, %{{.*}} return (__mmask8)_mm256_mask_cmpeq_epi32_mask(__u, __a, __b); } __mmask8 test_mm256_mask_cmpeq_epi64_mask(__mmask8 __u, __m256i __a, __m256i __b) { // CHECK-LABEL: @test_mm256_mask_cmpeq_epi64_mask - // CHECK: @llvm.x86.avx512.mask.pcmpeq.q.256 + // CHECK: icmp eq <4 x i64> %{{.*}}, %{{.*}} + // CHECK: and <4 x i1> %{{.*}}, %{{.*}} return (__mmask8)_mm256_mask_cmpeq_epi64_mask(__u, __a, __b); } __mmask8 test_mm256_cmpeq_epi64_mask(__m256i __a, __m256i __b) { // CHECK-LABEL: @test_mm256_cmpeq_epi64_mask - // CHECK: @llvm.x86.avx512.mask.pcmpeq.q.256 + // CHECK: icmp eq <4 x i64> %{{.*}}, %{{.*}} return (__mmask8)_mm256_cmpeq_epi64_mask(__a, __b); } __mmask8 test_mm256_cmpgt_epi32_mask(__m256i __a, __m256i __b) { // CHECK-LABEL: @test_mm256_cmpgt_epi32_mask - // CHECK: @llvm.x86.avx512.mask.pcmpgt.d.256 + // CHECK: icmp sgt <8 x i32> %{{.*}}, %{{.*}} return (__mmask8)_mm256_cmpgt_epi32_mask(__a, __b); } __mmask8 test_mm256_mask_cmpgt_epi32_mask(__mmask8 __u, __m256i __a, __m256i __b) { // CHECK-LABEL: @test_mm256_mask_cmpgt_epi32_mask - // CHECK: @llvm.x86.avx512.mask.pcmpgt.d.256 + // CHECK: icmp sgt <8 x i32> %{{.*}}, %{{.*}} + // CHECK: and <8 x i1> %{{.*}}, %{{.*}} return (__mmask8)_mm256_mask_cmpgt_epi32_mask(__u, __a, __b); } __mmask8 test_mm256_mask_cmpgt_epi64_mask(__mmask8 __u, __m256i __a, __m256i __b) { // CHECK-LABEL: @test_mm256_mask_cmpgt_epi64_mask - // CHECK: @llvm.x86.avx512.mask.pcmpgt.q.256 + // CHECK: icmp sgt <4 x i64> %{{.*}}, %{{.*}} + // CHECK: and <4 x i1> %{{.*}}, %{{.*}} return (__mmask8)_mm256_mask_cmpgt_epi64_mask(__u, __a, __b); } __mmask8 test_mm256_cmpgt_epi64_mask(__m256i __a, __m256i __b) { // CHECK-LABEL: @test_mm256_cmpgt_epi64_mask - // CHECK: @llvm.x86.avx512.mask.pcmpgt.q.256 + // CHECK: icmp sgt <4 x i64> %{{.*}}, %{{.*}} return (__mmask8)_mm256_cmpgt_epi64_mask(__a, __b); } diff --git a/clang/test/CodeGen/avx512vlbw-builtins.c b/clang/test/CodeGen/avx512vlbw-builtins.c index 05eda2f758ce..7500adbbb73f 100644 --- a/clang/test/CodeGen/avx512vlbw-builtins.c +++ b/clang/test/CodeGen/avx512vlbw-builtins.c @@ -8,97 +8,105 @@ __mmask32 test_mm256_cmpeq_epi8_mask(__m256i __a, __m256i __b) { // CHECK-LABEL: @test_mm256_cmpeq_epi8_mask - // CHECK: @llvm.x86.avx512.mask.pcmpeq.b.256 + // CHECK: icmp eq <32 x i8> %{{.*}}, %{{.*}} return (__mmask32)_mm256_cmpeq_epi8_mask(__a, __b); } __mmask32 test_mm256_mask_cmpeq_epi8_mask(__mmask32 __u, __m256i __a, __m256i __b) { // CHECK-LABEL: @test_mm256_mask_cmpeq_epi8_mask - // CHECK: @llvm.x86.avx512.mask.pcmpeq.b.256 + // CHECK: icmp eq <32 x i8> %{{.*}}, %{{.*}} + // CHECK: and <32 x i1> %{{.*}}, %{{.*}} return (__mmask32)_mm256_mask_cmpeq_epi8_mask(__u, __a, __b); } __mmask16 test_mm_cmpeq_epi8_mask(__m128i __a, __m128i __b) { // CHECK-LABEL: @test_mm_cmpeq_epi8_mask - // CHECK: @llvm.x86.avx512.mask.pcmpeq.b.128 + // CHECK: icmp eq <16 x i8> %{{.*}}, %{{.*}} return (__mmask16)_mm_cmpeq_epi8_mask(__a, __b); } __mmask16 test_mm_mask_cmpeq_epi8_mask(__mmask16 __u, __m128i __a, __m128i __b) { // CHECK-LABEL: @test_mm_mask_cmpeq_epi8_mask - // CHECK: @llvm.x86.avx512.mask.pcmpeq.b.128 + // CHECK: icmp eq <16 x i8> %{{.*}}, %{{.*}} + // CHECK: and <16 x i1> %{{.*}}, %{{.*}} return (__mmask16)_mm_mask_cmpeq_epi8_mask(__u, __a, __b); } __mmask16 test_mm256_cmpeq_epi16_mask(__m256i __a, __m256i __b) { // CHECK-LABEL: @test_mm256_cmpeq_epi16_mask - // CHECK: @llvm.x86.avx512.mask.pcmpeq.w.256 + // CHECK: icmp eq <16 x i16> %{{.*}}, %{{.*}} return (__mmask16)_mm256_cmpeq_epi16_mask(__a, __b); } __mmask16 test_mm256_mask_cmpeq_epi16_mask(__mmask16 __u, __m256i __a, __m256i __b) { // CHECK-LABEL: @test_mm256_mask_cmpeq_epi16_mask - // CHECK: @llvm.x86.avx512.mask.pcmpeq.w.256 + // CHECK: icmp eq <16 x i16> %{{.*}}, %{{.*}} + // CHECK: and <16 x i1> %{{.*}}, %{{.*}} return (__mmask16)_mm256_mask_cmpeq_epi16_mask(__u, __a, __b); } __mmask8 test_mm_cmpeq_epi16_mask(__m128i __a, __m128i __b) { // CHECK-LABEL: @test_mm_cmpeq_epi16_mask - // CHECK: @llvm.x86.avx512.mask.pcmpeq.w.128 + // CHECK: icmp eq <8 x i16> %{{.*}}, %{{.*}} return (__mmask8)_mm_cmpeq_epi16_mask(__a, __b); } __mmask8 test_mm_mask_cmpeq_epi16_mask(__mmask8 __u, __m128i __a, __m128i __b) { // CHECK-LABEL: @test_mm_mask_cmpeq_epi16_mask - // CHECK: @llvm.x86.avx512.mask.pcmpeq.w.128 + // CHECK: icmp eq <8 x i16> %{{.*}}, %{{.*}} + // CHECK: and <8 x i1> %{{.*}}, %{{.*}} return (__mmask8)_mm_mask_cmpeq_epi16_mask(__u, __a, __b); } __mmask32 test_mm256_cmpgt_epi8_mask(__m256i __a, __m256i __b) { // CHECK-LABEL: @test_mm256_cmpgt_epi8_mask - // CHECK: @llvm.x86.avx512.mask.pcmpgt.b.256 + // CHECK: icmp sgt <32 x i8> %{{.*}}, %{{.*}} return (__mmask32)_mm256_cmpgt_epi8_mask(__a, __b); } __mmask32 test_mm256_mask_cmpgt_epi8_mask(__mmask32 __u, __m256i __a, __m256i __b) { // CHECK-LABEL: @test_mm256_mask_cmpgt_epi8_mask - // CHECK: @llvm.x86.avx512.mask.pcmpgt.b.256 + // CHECK: icmp sgt <32 x i8> %{{.*}}, %{{.*}} + // CHECK: and <32 x i1> %{{.*}}, %{{.*}} return (__mmask32)_mm256_mask_cmpgt_epi8_mask(__u, __a, __b); } __mmask16 test_mm_cmpgt_epi8_mask(__m128i __a, __m128i __b) { // CHECK-LABEL: @test_mm_cmpgt_epi8_mask - // CHECK: @llvm.x86.avx512.mask.pcmpgt.b.128 + // CHECK: icmp sgt <16 x i8> %{{.*}}, %{{.*}} return (__mmask16)_mm_cmpgt_epi8_mask(__a, __b); } __mmask16 test_mm_mask_cmpgt_epi8_mask(__mmask16 __u, __m128i __a, __m128i __b) { // CHECK-LABEL: @test_mm_mask_cmpgt_epi8_mask - // CHECK: @llvm.x86.avx512.mask.pcmpgt.b.128 + // CHECK: icmp sgt <16 x i8> %{{.*}}, %{{.*}} + // CHECK: and <16 x i1> %{{.*}}, %{{.*}} return (__mmask16)_mm_mask_cmpgt_epi8_mask(__u, __a, __b); } __mmask16 test_mm256_cmpgt_epi16_mask(__m256i __a, __m256i __b) { // CHECK-LABEL: @test_mm256_cmpgt_epi16_mask - // CHECK: @llvm.x86.avx512.mask.pcmpgt.w.256 + // CHECK: icmp sgt <16 x i16> %{{.*}}, %{{.*}} return (__mmask16)_mm256_cmpgt_epi16_mask(__a, __b); } __mmask16 test_mm256_mask_cmpgt_epi16_mask(__mmask16 __u, __m256i __a, __m256i __b) { // CHECK-LABEL: @test_mm256_mask_cmpgt_epi16_mask - // CHECK: @llvm.x86.avx512.mask.pcmpgt.w.256 + // CHECK: icmp sgt <16 x i16> %{{.*}}, %{{.*}} + // CHECK: and <16 x i1> %{{.*}}, %{{.*}} return (__mmask16)_mm256_mask_cmpgt_epi16_mask(__u, __a, __b); } __mmask8 test_mm_cmpgt_epi16_mask(__m128i __a, __m128i __b) { // CHECK-LABEL: @test_mm_cmpgt_epi16_mask - // CHECK: @llvm.x86.avx512.mask.pcmpgt.w.128 + // CHECK: icmp sgt <8 x i16> %{{.*}}, %{{.*}} return (__mmask8)_mm_cmpgt_epi16_mask(__a, __b); } __mmask8 test_mm_mask_cmpgt_epi16_mask(__mmask8 __u, __m128i __a, __m128i __b) { // CHECK-LABEL: @test_mm_mask_cmpgt_epi16_mask - // CHECK: @llvm.x86.avx512.mask.pcmpgt.w.128 + // CHECK: icmp sgt <8 x i16> %{{.*}}, %{{.*}} + // CHECK: and <8 x i1> %{{.*}}, %{{.*}} return (__mmask8)_mm_mask_cmpgt_epi16_mask(__u, __a, __b); }