From: Alexander Ivchenko Date: Thu, 19 Apr 2018 12:15:11 +0000 (+0000) Subject: Lowering x86 adds/addus/subs/subus intrinsics (clang) X-Git-Url: https://granicus.if.org/sourcecode?a=commitdiff_plain;h=2ce56cc5c916ecf349d1ac9129ff68d4611ec0a4;p=clang Lowering x86 adds/addus/subs/subus intrinsics (clang) This is the patch that lowers x86 intrinsics to native IR in order to enable optimizations. Patch by tkrupa Differential Revision: https://reviews.llvm.org/D44786 git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@330323 91177308-0d34-0410-b5e6-96231b3b80d8 --- diff --git a/lib/CodeGen/CGBuiltin.cpp b/lib/CodeGen/CGBuiltin.cpp index 6a2f2b0a4a..6b2484b8c8 100644 --- a/lib/CodeGen/CGBuiltin.cpp +++ b/lib/CodeGen/CGBuiltin.cpp @@ -8449,6 +8449,76 @@ static Value *EmitX86SExtMask(CodeGenFunction &CGF, Value *Op, return CGF.Builder.CreateSExt(Mask, DstTy, "vpmovm2"); } +// Emit addition or subtraction with saturation. +// Handles both signed and unsigned intrinsics. +static Value *EmitX86AddSubSatExpr(CodeGenFunction &CGF, const CallExpr *E, + SmallVectorImpl &Ops, + bool IsAddition, bool Signed) { + + // Collect vector elements and type data. + llvm::Type *ResultType = CGF.ConvertType(E->getType()); + int NumElements = ResultType->getVectorNumElements(); + Value *Res; + if (!IsAddition && !Signed) { + Value *ICmp = CGF.Builder.CreateICmp(ICmpInst::ICMP_UGT, Ops[0], Ops[1]); + Value *Select = CGF.Builder.CreateSelect(ICmp, Ops[0], Ops[1]); + Res = CGF.Builder.CreateSub(Select, Ops[1]); + } else { + unsigned EltSizeInBits = ResultType->getScalarSizeInBits(); + llvm::Type *ExtElementType = EltSizeInBits == 8 ? + CGF.Builder.getInt16Ty() : + CGF.Builder.getInt32Ty(); + + // Extending vectors to next possible width to make space for possible + // overflow. + llvm::Type *ExtType = llvm::VectorType::get(ExtElementType, NumElements); + Value *VecA = Signed ? CGF.Builder.CreateSExt(Ops[0], ExtType) + : CGF.Builder.CreateZExt(Ops[0], ExtType); + Value *VecB = Signed ? CGF.Builder.CreateSExt(Ops[1], ExtType) + : CGF.Builder.CreateZExt(Ops[1], ExtType); + + llvm::Value *ExtProduct = IsAddition ? CGF.Builder.CreateAdd(VecA, VecB) + : CGF.Builder.CreateSub(VecA, VecB); + + // Create vector of the same type as expected result with max possible + // values and extend it to the same type as the product of the addition. + APInt SignedMaxValue = + llvm::APInt::getSignedMaxValue(EltSizeInBits); + Value *Max = Signed ? llvm::ConstantInt::get(ResultType, SignedMaxValue) + : llvm::Constant::getAllOnesValue(ResultType); + Value *ExtMaxVec = Signed ? CGF.Builder.CreateSExt(Max, ExtType) + : CGF.Builder.CreateZExt(Max, ExtType); + // In Product, replace all overflowed values with max values of non-extended + // type. + ICmpInst::Predicate Pred = Signed ? ICmpInst::ICMP_SLE : ICmpInst::ICMP_ULE; + Value *Cmp = CGF.Builder.CreateICmp(Pred, ExtProduct, + ExtMaxVec); // 1 if no overflow. + Value *SaturatedProduct = CGF.Builder.CreateSelect( + Cmp, ExtProduct, ExtMaxVec); // If overflowed, copy from max values. + + if (Signed) { + APInt SignedMinValue = + llvm::APInt::getSignedMinValue(EltSizeInBits); + Value *Min = llvm::ConstantInt::get(ResultType, SignedMinValue); + Value *ExtMinVec = CGF.Builder.CreateSExt(Min, ExtType); + Value *IsNegative = + CGF.Builder.CreateICmp(ICmpInst::ICMP_SLT, SaturatedProduct, ExtMinVec); + SaturatedProduct = + CGF.Builder.CreateSelect(IsNegative, ExtMinVec, SaturatedProduct); + } + + Res = CGF.Builder.CreateTrunc(SaturatedProduct, + ResultType); // Trunc to ResultType. + } + if (E->getNumArgs() == 4) { // For masked intrinsics. + Value *VecSRC = Ops[2]; + Value *Mask = Ops[3]; + return EmitX86Select(CGF, Mask, Res, VecSRC); + } + + return Res; +} + Value *CodeGenFunction::EmitX86CpuIs(const CallExpr *E) { const Expr *CPUExpr = E->getArg(0)->IgnoreParenCasts(); StringRef CPUStr = cast(CPUExpr)->getString(); @@ -9516,10 +9586,37 @@ Value *CodeGenFunction::EmitX86BuiltinExpr(unsigned BuiltinID, Load->setVolatile(true); return Load; } + case X86::BI__builtin_ia32_paddusb512_mask: + case X86::BI__builtin_ia32_paddusw512_mask: + case X86::BI__builtin_ia32_paddusb256: + case X86::BI__builtin_ia32_paddusw256: + case X86::BI__builtin_ia32_paddusb128: + case X86::BI__builtin_ia32_paddusw128: + return EmitX86AddSubSatExpr(*this, E, Ops, true, false); // Add, unsigned. + case X86::BI__builtin_ia32_paddsb512_mask: + case X86::BI__builtin_ia32_paddsw512_mask: + case X86::BI__builtin_ia32_paddsb256: + case X86::BI__builtin_ia32_paddsw256: + case X86::BI__builtin_ia32_paddsb128: + case X86::BI__builtin_ia32_paddsw128: + return EmitX86AddSubSatExpr(*this, E, Ops, true, true); // Add, signed. + case X86::BI__builtin_ia32_psubusb512_mask: + case X86::BI__builtin_ia32_psubusw512_mask: + case X86::BI__builtin_ia32_psubusb256: + case X86::BI__builtin_ia32_psubusw256: + case X86::BI__builtin_ia32_psubusb128: + case X86::BI__builtin_ia32_psubusw128: + return EmitX86AddSubSatExpr(*this, E, Ops, false, false); // Sub, unsigned. + case X86::BI__builtin_ia32_psubsb512_mask: + case X86::BI__builtin_ia32_psubsw512_mask: + case X86::BI__builtin_ia32_psubsb256: + case X86::BI__builtin_ia32_psubsw256: + case X86::BI__builtin_ia32_psubsb128: + case X86::BI__builtin_ia32_psubsw128: + return EmitX86AddSubSatExpr(*this, E, Ops, false, true); // Sub, signed. } } - Value *CodeGenFunction::EmitPPCBuiltinExpr(unsigned BuiltinID, const CallExpr *E) { SmallVector Ops; diff --git a/test/CodeGen/avx2-builtins.c b/test/CodeGen/avx2-builtins.c index 15a17628f4..e142eea586 100644 --- a/test/CodeGen/avx2-builtins.c +++ b/test/CodeGen/avx2-builtins.c @@ -56,25 +56,53 @@ __m256i test_mm256_add_epi64(__m256i a, __m256i b) { __m256i test_mm256_adds_epi8(__m256i a, __m256i b) { // CHECK-LABEL: test_mm256_adds_epi8 - // CHECK: call <32 x i8> @llvm.x86.avx2.padds.b(<32 x i8> %{{.*}}, <32 x i8> %{{.*}}) + // CHECK-NOT: call <32 x i8> @llvm.x86.avx2.padds.b(<32 x i8> %{{.*}}, <32 x i8> %{{.*}}) + // CHECK: sext <32 x i8> %{{.*}} to <32 x i16> + // CHECK: sext <32 x i8> %{{.*}} to <32 x i16> + // CHECK: add <32 x i16> %{{.*}}, %{{.*}} + // CHECK: icmp sle <32 x i16> %{{.*}}, + // CHECK: select <32 x i1> %{{.*}}, <32 x i16> %{{.*}}, <32 x i16> + // CHECK: icmp slt <32 x i16> %{{.*}}, + // CHECK: select <32 x i1> %{{.*}}, <32 x i16> , <32 x i16> %{{.*}} + // CHECK: trunc <32 x i16> %{{.*}} to <32 x i8> return _mm256_adds_epi8(a, b); } __m256i test_mm256_adds_epi16(__m256i a, __m256i b) { // CHECK-LABEL: test_mm256_adds_epi16 - // CHECK: call <16 x i16> @llvm.x86.avx2.padds.w(<16 x i16> %{{.*}}, <16 x i16> %{{.*}}) + // CHECK-NOT: call <16 x i16> @llvm.x86.avx2.padds.w(<16 x i16> %{{.*}}, <16 x i16> %{{.*}}) + // CHECK: sext <16 x i16> %{{.*}} to <16 x i32> + // CHECK: sext <16 x i16> %{{.*}} to <16 x i32> + // CHECK: add <16 x i32> %{{.*}}, %{{.*}} + // CHECK: icmp sle <16 x i32> %{{.*}}, + // CHECK: select <16 x i1> %{{.*}}, <16 x i32> %{{.*}}, <16 x i32> + // CHECK: icmp slt <16 x i32> %{{.*}}, + // CHECK: select <16 x i1> %{{.*}}, <16 x i32> , <16 x i32> %{{.*}} + // CHECK: trunc <16 x i32> %{{.*}} to <16 x i16> return _mm256_adds_epi16(a, b); } __m256i test_mm256_adds_epu8(__m256i a, __m256i b) { // CHECK-LABEL: test_mm256_adds_epu8 - // CHECK: call <32 x i8> @llvm.x86.avx2.paddus.b(<32 x i8> %{{.*}}, <32 x i8> %{{.*}}) + // CHECK-NOT: call <32 x i8> @llvm.x86.avx2.paddus.b(<32 x i8> %{{.*}}, <32 x i8> %{{.*}}) + // CHECK: zext <32 x i8> %{{.*}} to <32 x i16> + // CHECK: zext <32 x i8> %{{.*}} to <32 x i16> + // CHECK: add <32 x i16> %{{.*}}, %{{.*}} + // CHECK: icmp ule <32 x i16> %{{.*}}, + // CHECK: select <32 x i1> %{{.*}}, <32 x i16> %{{.*}}, <32 x i16> + // CHECK: trunc <32 x i16> %{{.*}} to <32 x i8> return _mm256_adds_epu8(a, b); } __m256i test_mm256_adds_epu16(__m256i a, __m256i b) { // CHECK-LABEL: test_mm256_adds_epu16 - // CHECK: call <16 x i16> @llvm.x86.avx2.paddus.w(<16 x i16> %{{.*}}, <16 x i16> %{{.*}}) + // CHECK-NOT: call <16 x i16> @llvm.x86.avx2.paddus.w(<16 x i16> %{{.*}}, <16 x i16> %{{.*}}) + // CHECK: zext <16 x i16> %{{.*}} to <16 x i32> + // CHECK: zext <16 x i16> %{{.*}} to <16 x i32> + // CHECK: add <16 x i32> %{{.*}}, %{{.*}} + // CHECK: icmp ule <16 x i32> %{{.*}}, + // CHECK: select <16 x i1> %{{.*}}, <16 x i32> %{{.*}}, <16 x i32> + // CHECK: trunc <16 x i32> %{{.*}} to <16 x i16> return _mm256_adds_epu16(a, b); } @@ -1171,25 +1199,47 @@ __m256i test_mm256_sub_epi64(__m256i a, __m256i b) { __m256i test_mm256_subs_epi8(__m256i a, __m256i b) { // CHECK-LABEL: test_mm256_subs_epi8 - // CHECK: call <32 x i8> @llvm.x86.avx2.psubs.b(<32 x i8> %{{.*}}, <32 x i8> %{{.*}}) + // CHECK-NOT: call <32 x i8> @llvm.x86.avx2.psubs.b(<32 x i8> %{{.*}}, <32 x i8> %{{.*}}) + // CHECK: sext <32 x i8> %{{.*}} to <32 x i16> + // CHECK: sext <32 x i8> %{{.*}} to <32 x i16> + // CHECK: sub <32 x i16> %{{.*}}, %{{.*}} + // CHECK: icmp sle <32 x i16> %{{.*}}, + // CHECK: select <32 x i1> %{{.*}}, <32 x i16> %{{.*}}, <32 x i16> + // CHECK: icmp slt <32 x i16> %{{.*}}, + // CHECK: select <32 x i1> %{{.*}}, <32 x i16> , <32 x i16> %{{.*}} + // CHECK: trunc <32 x i16> %{{.*}} to <32 x i8> return _mm256_subs_epi8(a, b); } __m256i test_mm256_subs_epi16(__m256i a, __m256i b) { // CHECK-LABEL: test_mm256_subs_epi16 - // CHECK: call <16 x i16> @llvm.x86.avx2.psubs.w(<16 x i16> %{{.*}}, <16 x i16> %{{.*}}) + // CHECK-NOT: call <16 x i16> @llvm.x86.avx2.psubs.w(<16 x i16> %{{.*}}, <16 x i16> %{{.*}}) + // CHECK: sext <16 x i16> %{{.*}} to <16 x i32> + // CHECK: sext <16 x i16> %{{.*}} to <16 x i32> + // CHECK: sub <16 x i32> %{{.*}}, %{{.*}} + // CHECK: icmp sle <16 x i32> %{{.*}}, + // CHECK: select <16 x i1> %{{.*}}, <16 x i32> %{{.*}}, <16 x i32> + // CHECK: icmp slt <16 x i32> %{{.*}}, + // CHECK: select <16 x i1> %{{.*}}, <16 x i32> , <16 x i32> %{{.*}} + // CHECK: trunc <16 x i32> %{{.*}} to <16 x i16> return _mm256_subs_epi16(a, b); } __m256i test_mm256_subs_epu8(__m256i a, __m256i b) { // CHECK-LABEL: test_mm256_subs_epu8 - // CHECK: call <32 x i8> @llvm.x86.avx2.psubus.b(<32 x i8> %{{.*}}, <32 x i8> %{{.*}}) + // CHECK-NOT: call <32 x i8> @llvm.x86.avx2.psubus.b(<32 x i8> %{{.*}}, <32 x i8> %{{.*}}) + // CHECK: icmp ugt <32 x i8> {{.*}}, {{.*}} + // CHECK: select <32 x i1> {{.*}}, <32 x i8> {{.*}}, <32 x i8> {{.*}} + // CHECK: sub <32 x i8> {{.*}}, {{.*}} return _mm256_subs_epu8(a, b); } __m256i test_mm256_subs_epu16(__m256i a, __m256i b) { // CHECK-LABEL: test_mm256_subs_epu16 - // CHECK: call <16 x i16> @llvm.x86.avx2.psubus.w(<16 x i16> %{{.*}}, <16 x i16> %{{.*}}) + // CHECK-NOT: call <16 x i16> @llvm.x86.avx2.psubus.w(<16 x i16> %{{.*}}, <16 x i16> %{{.*}}) + // CHECK: icmp ugt <16 x i16> {{.*}}, {{.*}} + // CHECK: select <16 x i1> {{.*}}, <16 x i16> {{.*}}, <16 x i16> {{.*}} + // CHECK: sub <16 x i16> {{.*}}, {{.*}} return _mm256_subs_epu16(a, b); } diff --git a/test/CodeGen/avx512bw-builtins.c b/test/CodeGen/avx512bw-builtins.c index bb644c4423..2c5c82b105 100644 --- a/test/CodeGen/avx512bw-builtins.c +++ b/test/CodeGen/avx512bw-builtins.c @@ -594,62 +594,154 @@ __m512i test_mm512_maskz_packus_epi16(__mmask64 __M, __m512i __A, __m512i __B) { } __m512i test_mm512_adds_epi8(__m512i __A, __m512i __B) { // CHECK-LABEL: @test_mm512_adds_epi8 - // CHECK: @llvm.x86.avx512.mask.padds.b.512 + // CHECK-NOT: @llvm.x86.avx512.mask.padds.b.512 + // CHECK: sext <64 x i8> %{{.*}} to <64 x i16> + // CHECK: sext <64 x i8> %{{.*}} to <64 x i16> + // CHECK: add <64 x i16> %{{.*}}, %{{.*}} + // CHECK: icmp sle <64 x i16> %{{.*}}, + // CHECK: select <64 x i1> %{{.*}}, <64 x i16> %{{.*}}, <64 x i16> + // CHECK: icmp slt <64 x i16> %{{.*}}, + // CHECK: select <64 x i1> %{{.*}}, <64 x i16> , <64 x i16> %{{.*}} + // CHECK: trunc <64 x i16> %{{.*}} to <64 x i8> return _mm512_adds_epi8(__A,__B); } __m512i test_mm512_mask_adds_epi8(__m512i __W, __mmask64 __U, __m512i __A, __m512i __B) { // CHECK-LABEL: @test_mm512_mask_adds_epi8 - // CHECK: @llvm.x86.avx512.mask.padds.b.512 - return _mm512_mask_adds_epi8(__W,__U,__A,__B); + // CHECK-NOT: @llvm.x86.avx512.mask.padds.b.512 + // CHECK: sext <64 x i8> %{{.*}} to <64 x i16> + // CHECK: sext <64 x i8> %{{.*}} to <64 x i16> + // CHECK: add <64 x i16> %{{.*}}, %{{.*}} + // CHECK: icmp sle <64 x i16> %{{.*}}, + // CHECK: select <64 x i1> %{{.*}}, <64 x i16> %{{.*}}, <64 x i16> + // CHECK: icmp slt <64 x i16> %{{.*}}, + // CHECK: select <64 x i1> %{{.*}}, <64 x i16> , <64 x i16> %{{.*}} + // CHECK: trunc <64 x i16> %{{.*}} to <64 x i8> + // CHECK: select <64 x i1> %{{.*}}, <64 x i8> %{{.*}}, <64 x i8> %{{.*}} + return _mm512_mask_adds_epi8(__W,__U,__A,__B); } __m512i test_mm512_maskz_adds_epi8(__mmask64 __U, __m512i __A, __m512i __B) { // CHECK-LABEL: @test_mm512_maskz_adds_epi8 - // CHECK: @llvm.x86.avx512.mask.padds.b.512 + // CHECK-NOT: @llvm.x86.avx512.mask.padds.b.512 + // CHECK: sext <64 x i8> %{{.*}} to <64 x i16> + // CHECK: sext <64 x i8> %{{.*}} to <64 x i16> + // CHECK: add <64 x i16> %{{.*}}, %{{.*}} + // CHECK: icmp sle <64 x i16> %{{.*}}, + // CHECK: select <64 x i1> %{{.*}}, <64 x i16> %{{.*}}, <64 x i16> + // CHECK: icmp slt <64 x i16> %{{.*}}, + // CHECK: select <64 x i1> %{{.*}}, <64 x i16> , <64 x i16> %{{.*}} + // CHECK: trunc <64 x i16> %{{.*}} to <64 x i8> + // CHECK: select <64 x i1> %{{.*}}, <64 x i8> %{{.*}}, <64 x i8> %{{.*}} return _mm512_maskz_adds_epi8(__U,__A,__B); } __m512i test_mm512_adds_epi16(__m512i __A, __m512i __B) { // CHECK-LABEL: @test_mm512_adds_epi16 - // CHECK: @llvm.x86.avx512.mask.padds.w.512 - return _mm512_adds_epi16(__A,__B); + // CHECK-NOT: @llvm.x86.avx512.mask.padds.w.512 + // CHECK: sext <32 x i16> %{{.*}} to <32 x i32> + // CHECK: sext <32 x i16> %{{.*}} to <32 x i32> + // CHECK: add <32 x i32> %{{.*}}, %{{.*}} + // CHECK: icmp sle <32 x i32> %{{.*}}, + // CHECK: select <32 x i1> %{{.*}}, <32 x i32> %{{.*}}, <32 x i32> + // CHECK: icmp slt <32 x i32> %{{.*}}, + // CHECK: select <32 x i1> %{{.*}}, <32 x i32> , <32 x i32> %{{.*}} + // CHECK: trunc <32 x i32> %{{.*}} to <32 x i16> + return _mm512_adds_epi16(__A,__B); } __m512i test_mm512_mask_adds_epi16(__m512i __W, __mmask32 __U, __m512i __A, __m512i __B) { // CHECK-LABEL: @test_mm512_mask_adds_epi16 - // CHECK: @llvm.x86.avx512.mask.padds.w.512 + // CHECK-NOT: @llvm.x86.avx512.mask.padds.w.512 + // CHECK: sext <32 x i16> %{{.*}} to <32 x i32> + // CHECK: sext <32 x i16> %{{.*}} to <32 x i32> + // CHECK: add <32 x i32> %{{.*}}, %{{.*}} + // CHECK: icmp sle <32 x i32> %{{.*}}, + // CHECK: select <32 x i1> %{{.*}}, <32 x i32> %{{.*}}, <32 x i32> + // CHECK: icmp slt <32 x i32> %{{.*}}, + // CHECK: select <32 x i1> %{{.*}}, <32 x i32> , <32 x i32> %{{.*}} + // CHECK: trunc <32 x i32> %{{.*}} to <32 x i16> + // CHECK: select <32 x i1> %{{.*}}, <32 x i16> %{{.*}}, <32 x i16> %{{.*}} return _mm512_mask_adds_epi16(__W,__U,__A,__B); } __m512i test_mm512_maskz_adds_epi16(__mmask32 __U, __m512i __A, __m512i __B) { // CHECK-LABEL: @test_mm512_maskz_adds_epi16 - // CHECK: @llvm.x86.avx512.mask.padds.w.512 - return _mm512_maskz_adds_epi16(__U,__A,__B); + // CHECK-NOT: @llvm.x86.avx512.mask.padds.w.512 + // CHECK: sext <32 x i16> %{{.*}} to <32 x i32> + // CHECK: sext <32 x i16> %{{.*}} to <32 x i32> + // CHECK: add <32 x i32> %{{.*}}, %{{.*}} + // CHECK: icmp sle <32 x i32> %{{.*}}, + // CHECK: select <32 x i1> %{{.*}}, <32 x i32> %{{.*}}, <32 x i32> + // CHECK: icmp slt <32 x i32> %{{.*}}, + // CHECK: select <32 x i1> %{{.*}}, <32 x i32> , <32 x i32> %{{.*}} + // CHECK: trunc <32 x i32> %{{.*}} to <32 x i16> + // CHECK: select <32 x i1> %{{.*}}, <32 x i16> %{{.*}}, <32 x i16> %{{.*}} +return _mm512_maskz_adds_epi16(__U,__A,__B); } __m512i test_mm512_adds_epu8(__m512i __A, __m512i __B) { // CHECK-LABEL: @test_mm512_adds_epu8 - // CHECK: @llvm.x86.avx512.mask.paddus.b.512 + // CHECK-NOT: @llvm.x86.avx512.mask.paddus.b.512 + // CHECK: zext <64 x i8> %{{.*}} to <64 x i16> + // CHECK: zext <64 x i8> %{{.*}} to <64 x i16> + // CHECK: add <64 x i16> %{{.*}}, %{{.*}} + // CHECK: icmp ule <64 x i16> %{{.*}}, + // CHECK: select <64 x i1> %{{.*}}, <64 x i16> %{{.*}}, <64 x i16> + // CHECK: trunc <64 x i16> %{{.*}} to <64 x i8> return _mm512_adds_epu8(__A,__B); } __m512i test_mm512_mask_adds_epu8(__m512i __W, __mmask64 __U, __m512i __A, __m512i __B) { // CHECK-LABEL: @test_mm512_mask_adds_epu8 - // CHECK: @llvm.x86.avx512.mask.paddus.b.512 + // CHECK-NOT: @llvm.x86.avx512.mask.paddus.b.512 + // CHECK: zext <64 x i8> %{{.*}} to <64 x i16> + // CHECK: zext <64 x i8> %{{.*}} to <64 x i16> + // CHECK: add <64 x i16> %{{.*}}, %{{.*}} + // CHECK: icmp ule <64 x i16> %{{.*}}, + // CHECK: select <64 x i1> %{{.*}}, <64 x i16> %{{.*}}, <64 x i16> + // CHECK: trunc <64 x i16> %{{.*}} to <64 x i8> + // CHECK: select <64 x i1> %{{.*}}, <64 x i8> %{{.*}}, <64 x i8> %{{.*}} return _mm512_mask_adds_epu8(__W,__U,__A,__B); } __m512i test_mm512_maskz_adds_epu8(__mmask64 __U, __m512i __A, __m512i __B) { // CHECK-LABEL: @test_mm512_maskz_adds_epu8 - // CHECK: @llvm.x86.avx512.mask.paddus.b.512 + // CHECK-NOT: @llvm.x86.avx512.mask.paddus.b.512 + // CHECK: zext <64 x i8> %{{.*}} to <64 x i16> + // CHECK: zext <64 x i8> %{{.*}} to <64 x i16> + // CHECK: add <64 x i16> %{{.*}}, %{{.*}} + // CHECK: icmp ule <64 x i16> %{{.*}}, + // CHECK: select <64 x i1> %{{.*}}, <64 x i16> %{{.*}}, <64 x i16> + // CHECK: trunc <64 x i16> %{{.*}} to <64 x i8> + // CHECK: select <64 x i1> %{{.*}}, <64 x i8> %{{.*}}, <64 x i8> %{{.*}} return _mm512_maskz_adds_epu8(__U,__A,__B); } __m512i test_mm512_adds_epu16(__m512i __A, __m512i __B) { // CHECK-LABEL: @test_mm512_adds_epu16 - // CHECK: @llvm.x86.avx512.mask.paddus.w.512 + // CHECK-NOT: @llvm.x86.avx512.mask.paddus.w.512 + // CHECK: zext <32 x i16> %{{.*}} to <32 x i32> + // CHECK: zext <32 x i16> %{{.*}} to <32 x i32> + // CHECK: add <32 x i32> %{{.*}}, %{{.*}} + // CHECK: icmp ule <32 x i32> %{{.*}}, + // CHECK: select <32 x i1> %{{.*}}, <32 x i32> %{{.*}}, <32 x i32> + // CHECK: trunc <32 x i32> %{{.*}} to <32 x i16> return _mm512_adds_epu16(__A,__B); } __m512i test_mm512_mask_adds_epu16(__m512i __W, __mmask32 __U, __m512i __A, __m512i __B) { // CHECK-LABEL: @test_mm512_mask_adds_epu16 - // CHECK: @llvm.x86.avx512.mask.paddus.w.512 + // CHECK-NOT: @llvm.x86.avx512.mask.paddus.w.512 + // CHECK: zext <32 x i16> %{{.*}} to <32 x i32> + // CHECK: zext <32 x i16> %{{.*}} to <32 x i32> + // CHECK: add <32 x i32> %{{.*}}, %{{.*}} + // CHECK: icmp ule <32 x i32> %{{.*}}, + // CHECK: select <32 x i1> %{{.*}}, <32 x i32> %{{.*}}, <32 x i32> + // CHECK: trunc <32 x i32> %{{.*}} to <32 x i16> + // CHECK: select <32 x i1> %{{.*}}, <32 x i16> %{{.*}}, <32 x i16> %{{.*}} return _mm512_mask_adds_epu16(__W,__U,__A,__B); } __m512i test_mm512_maskz_adds_epu16(__mmask32 __U, __m512i __A, __m512i __B) { // CHECK-LABEL: @test_mm512_maskz_adds_epu16 - // CHECK: @llvm.x86.avx512.mask.paddus.w.512 + // CHECK-NOT: @llvm.x86.avx512.mask.paddus.w.512 + // CHECK: zext <32 x i16> %{{.*}} to <32 x i32> + // CHECK: zext <32 x i16> %{{.*}} to <32 x i32> + // CHECK: add <32 x i32> %{{.*}}, %{{.*}} + // CHECK: icmp ule <32 x i32> %{{.*}}, + // CHECK: select <32 x i1> %{{.*}}, <32 x i32> %{{.*}}, <32 x i32> + // CHECK: trunc <32 x i32> %{{.*}} to <32 x i16> + // CHECK: select <32 x i1> %{{.*}}, <32 x i16> %{{.*}}, <32 x i16> %{{.*}} return _mm512_maskz_adds_epu16(__U,__A,__B); } __m512i test_mm512_avg_epu8(__m512i __A, __m512i __B) { @@ -903,63 +995,137 @@ __m512i test_mm512_maskz_shuffle_epi8(__mmask64 __U, __m512i __A, __m512i __B) { } __m512i test_mm512_subs_epi8(__m512i __A, __m512i __B) { // CHECK-LABEL: @test_mm512_subs_epi8 - // CHECK: @llvm.x86.avx512.mask.psubs.b.512 - return _mm512_subs_epi8(__A,__B); + // CHECK-NOT: @llvm.x86.avx512.mask.psubs.b.512 + // CHECK: sext <64 x i8> %{{.*}} to <64 x i16> + // CHECK: sext <64 x i8> %{{.*}} to <64 x i16> + // CHECK: sub <64 x i16> %{{.*}}, %{{.*}} + // CHECK: icmp sle <64 x i16> %{{.*}}, + // CHECK: select <64 x i1> %{{.*}}, <64 x i16> %{{.*}}, <64 x i16> + // CHECK: icmp slt <64 x i16> %{{.*}}, + // CHECK: select <64 x i1> %{{.*}}, <64 x i16> , <64 x i16> %{{.*}} + // CHECK: trunc <64 x i16> %{{.*}} to <64 x i8> +return _mm512_subs_epi8(__A,__B); } __m512i test_mm512_mask_subs_epi8(__m512i __W, __mmask64 __U, __m512i __A, __m512i __B) { // CHECK-LABEL: @test_mm512_mask_subs_epi8 - // CHECK: @llvm.x86.avx512.mask.psubs.b.512 - return _mm512_mask_subs_epi8(__W,__U,__A,__B); + // CHECK-NOT: @llvm.x86.avx512.mask.psubs.b.512 + // CHECK: sext <64 x i8> %{{.*}} to <64 x i16> + // CHECK: sext <64 x i8> %{{.*}} to <64 x i16> + // CHECK: sub <64 x i16> %{{.*}}, %{{.*}} + // CHECK: icmp sle <64 x i16> %{{.*}}, + // CHECK: select <64 x i1> %{{.*}}, <64 x i16> %{{.*}}, <64 x i16> + // CHECK: icmp slt <64 x i16> %{{.*}}, + // CHECK: select <64 x i1> %{{.*}}, <64 x i16> , <64 x i16> %{{.*}} + // CHECK: trunc <64 x i16> %{{.*}} to <64 x i8> + // CHECK: select <64 x i1> %{{.*}}, <64 x i8> %{{.*}}, <64 x i8> %{{.*}} +return _mm512_mask_subs_epi8(__W,__U,__A,__B); } __m512i test_mm512_maskz_subs_epi8(__mmask64 __U, __m512i __A, __m512i __B) { // CHECK-LABEL: @test_mm512_maskz_subs_epi8 - // CHECK: @llvm.x86.avx512.mask.psubs.b.512 - return _mm512_maskz_subs_epi8(__U,__A,__B); + // CHECK-NOT: @llvm.x86.avx512.mask.psubs.b.512 + // CHECK: sext <64 x i8> %{{.*}} to <64 x i16> + // CHECK: sext <64 x i8> %{{.*}} to <64 x i16> + // CHECK: sub <64 x i16> %{{.*}}, %{{.*}} + // CHECK: icmp sle <64 x i16> %{{.*}}, + // CHECK: select <64 x i1> %{{.*}}, <64 x i16> %{{.*}}, <64 x i16> + // CHECK: icmp slt <64 x i16> %{{.*}}, + // CHECK: select <64 x i1> %{{.*}}, <64 x i16> , <64 x i16> %{{.*}} + // CHECK: trunc <64 x i16> %{{.*}} to <64 x i8> + // CHECK: select <64 x i1> %{{.*}}, <64 x i8> %{{.*}}, <64 x i8> %{{.*}} +return _mm512_maskz_subs_epi8(__U,__A,__B); } __m512i test_mm512_subs_epi16(__m512i __A, __m512i __B) { // CHECK-LABEL: @test_mm512_subs_epi16 - // CHECK: @llvm.x86.avx512.mask.psubs.w.512 - return _mm512_subs_epi16(__A,__B); + // CHECK-NOT: @llvm.x86.avx512.mask.psubs.w.512 + // CHECK: sext <32 x i16> %{{.*}} to <32 x i32> + // CHECK: sext <32 x i16> %{{.*}} to <32 x i32> + // CHECK: sub <32 x i32> %{{.*}}, %{{.*}} + // CHECK: icmp sle <32 x i32> %{{.*}}, + // CHECK: select <32 x i1> %{{.*}}, <32 x i32> %{{.*}}, <32 x i32> + // CHECK: icmp slt <32 x i32> %{{.*}}, + // CHECK: select <32 x i1> %{{.*}}, <32 x i32> , <32 x i32> %{{.*}} + // CHECK: trunc <32 x i32> %{{.*}} to <32 x i16> +return _mm512_subs_epi16(__A,__B); } __m512i test_mm512_mask_subs_epi16(__m512i __W, __mmask32 __U, __m512i __A, __m512i __B) { // CHECK-LABEL: @test_mm512_mask_subs_epi16 - // CHECK: @llvm.x86.avx512.mask.psubs.w.512 - return _mm512_mask_subs_epi16(__W,__U,__A,__B); + // CHECK-NOT: @llvm.x86.avx512.mask.psubs.w.512 + // CHECK: sext <32 x i16> %{{.*}} to <32 x i32> + // CHECK: sext <32 x i16> %{{.*}} to <32 x i32> + // CHECK: sub <32 x i32> %{{.*}}, %{{.*}} + // CHECK: icmp sle <32 x i32> %{{.*}}, + // CHECK: select <32 x i1> %{{.*}}, <32 x i32> %{{.*}}, <32 x i32> + // CHECK: icmp slt <32 x i32> %{{.*}}, + // CHECK: select <32 x i1> %{{.*}}, <32 x i32> , <32 x i32> %{{.*}} + // CHECK: trunc <32 x i32> %{{.*}} to <32 x i16> + // CHECK: select <32 x i1> %{{.*}}, <32 x i16> %{{.*}}, <32 x i16> %{{.*}} +return _mm512_mask_subs_epi16(__W,__U,__A,__B); } __m512i test_mm512_maskz_subs_epi16(__mmask32 __U, __m512i __A, __m512i __B) { // CHECK-LABEL: @test_mm512_maskz_subs_epi16 - // CHECK: @llvm.x86.avx512.mask.psubs.w.512 - return _mm512_maskz_subs_epi16(__U,__A,__B); + // CHECK-NOT: @llvm.x86.avx512.mask.psubs.w.512 + // CHECK: sext <32 x i16> %{{.*}} to <32 x i32> + // CHECK: sext <32 x i16> %{{.*}} to <32 x i32> + // CHECK: sub <32 x i32> %{{.*}}, %{{.*}} + // CHECK: icmp sle <32 x i32> %{{.*}}, + // CHECK: select <32 x i1> %{{.*}}, <32 x i32> %{{.*}}, <32 x i32> + // CHECK: icmp slt <32 x i32> %{{.*}}, + // CHECK: select <32 x i1> %{{.*}}, <32 x i32> , <32 x i32> %{{.*}} + // CHECK: trunc <32 x i32> %{{.*}} to <32 x i16> + // CHECK: select <32 x i1> %{{.*}}, <32 x i16> %{{.*}}, <32 x i16> %{{.*}} +return _mm512_maskz_subs_epi16(__U,__A,__B); } __m512i test_mm512_subs_epu8(__m512i __A, __m512i __B) { // CHECK-LABEL: @test_mm512_subs_epu8 - // CHECK: @llvm.x86.avx512.mask.psubus.b.512 - return _mm512_subs_epu8(__A,__B); + // CHECK-NOT: @llvm.x86.avx512.mask.psubus.b.512 + // CHECK: icmp ugt <64 x i8> {{.*}}, {{.*}} + // CHECK: select <64 x i1> {{.*}}, <64 x i8> {{.*}}, <64 x i8> {{.*}} + // CHECK: sub <64 x i8> {{.*}}, {{.*}} +return _mm512_subs_epu8(__A,__B); } __m512i test_mm512_mask_subs_epu8(__m512i __W, __mmask64 __U, __m512i __A, __m512i __B) { // CHECK-LABEL: @test_mm512_mask_subs_epu8 - // CHECK: @llvm.x86.avx512.mask.psubus.b.512 - return _mm512_mask_subs_epu8(__W,__U,__A,__B); + // CHECK-NOT: @llvm.x86.avx512.mask.psubus.b.512 + // CHECK: icmp ugt <64 x i8> {{.*}}, {{.*}} + // CHECK: select <64 x i1> {{.*}}, <64 x i8> {{.*}}, <64 x i8> {{.*}} + // CHECK: sub <64 x i8> {{.*}}, {{.*}} + // CHECK: select <64 x i1> %{{.*}}, <64 x i8> %{{.*}}, <64 x i8> %{{.*}} +return _mm512_mask_subs_epu8(__W,__U,__A,__B); } __m512i test_mm512_maskz_subs_epu8(__mmask64 __U, __m512i __A, __m512i __B) { // CHECK-LABEL: @test_mm512_maskz_subs_epu8 - // CHECK: @llvm.x86.avx512.mask.psubus.b.512 - return _mm512_maskz_subs_epu8(__U,__A,__B); + // CHECK-NOT: @llvm.x86.avx512.mask.psubus.b.512 + // CHECK: icmp ugt <64 x i8> {{.*}}, {{.*}} + // CHECK: select <64 x i1> {{.*}}, <64 x i8> {{.*}}, <64 x i8> {{.*}} + // CHECK: sub <64 x i8> {{.*}}, {{.*}} + // CHECK: select <64 x i1> %{{.*}}, <64 x i8> %{{.*}}, <64 x i8> %{{.*}} +return _mm512_maskz_subs_epu8(__U,__A,__B); } __m512i test_mm512_subs_epu16(__m512i __A, __m512i __B) { // CHECK-LABEL: @test_mm512_subs_epu16 - // CHECK: @llvm.x86.avx512.mask.psubus.w.512 - return _mm512_subs_epu16(__A,__B); + // CHECK-NOT: @llvm.x86.avx512.mask.psubus.w.512 + // CHECK: icmp ugt <32 x i16> {{.*}}, {{.*}} + // CHECK: select <32 x i1> {{.*}}, <32 x i16> {{.*}}, <32 x i16> {{.*}} + // CHECK: sub <32 x i16> {{.*}}, {{.*}} +return _mm512_subs_epu16(__A,__B); } __m512i test_mm512_mask_subs_epu16(__m512i __W, __mmask32 __U, __m512i __A, __m512i __B) { // CHECK-LABEL: @test_mm512_mask_subs_epu16 - // CHECK: @llvm.x86.avx512.mask.psubus.w.512 - return _mm512_mask_subs_epu16(__W,__U,__A,__B); + // CHECK-NOT: @llvm.x86.avx512.mask.psubus.w.512 + // CHECK: icmp ugt <32 x i16> {{.*}}, {{.*}} + // CHECK: select <32 x i1> {{.*}}, <32 x i16> {{.*}}, <32 x i16> {{.*}} + // CHECK: sub <32 x i16> {{.*}}, {{.*}} + // CHECK: select <32 x i1> %{{.*}}, <32 x i16> %{{.*}}, <32 x i16> %{{.*}} +return _mm512_mask_subs_epu16(__W,__U,__A,__B); } __m512i test_mm512_maskz_subs_epu16(__mmask32 __U, __m512i __A, __m512i __B) { // CHECK-LABEL: @test_mm512_maskz_subs_epu16 - // CHECK: @llvm.x86.avx512.mask.psubus.w.512 - return _mm512_maskz_subs_epu16(__U,__A,__B); + // CHECK-NOT: @llvm.x86.avx512.mask.psubus.w.512 + // CHECK: icmp ugt <32 x i16> {{.*}}, {{.*}} + // CHECK: select <32 x i1> {{.*}}, <32 x i16> {{.*}}, <32 x i16> {{.*}} + // CHECK: sub <32 x i16> {{.*}}, {{.*}} + // CHECK: select <32 x i1> %{{.*}}, <32 x i16> %{{.*}}, <32 x i16> %{{.*}} +return _mm512_maskz_subs_epu16(__U,__A,__B); } __m512i test_mm512_mask2_permutex2var_epi16(__m512i __A, __m512i __I, __mmask32 __U, __m512i __B) { // CHECK-LABEL: @test_mm512_mask2_permutex2var_epi16 diff --git a/test/CodeGen/avx512vlbw-builtins.c b/test/CodeGen/avx512vlbw-builtins.c index 7adc50c231..a41a2efd25 100644 --- a/test/CodeGen/avx512vlbw-builtins.c +++ b/test/CodeGen/avx512vlbw-builtins.c @@ -1075,97 +1075,211 @@ __m256i test_mm256_mask_packus_epi16(__m256i __W, __mmask32 __M, __m256i __A, __m128i test_mm_mask_adds_epi8(__m128i __W, __mmask16 __U, __m128i __A, __m128i __B) { // CHECK-LABEL: @test_mm_mask_adds_epi8 - // CHECK: @llvm.x86.sse2.padds.b + // CHECK-NOT: @llvm.x86.sse2.padds.b + // CHECK: sext <16 x i8> %{{.*}} to <16 x i16> + // CHECK: sext <16 x i8> %{{.*}} to <16 x i16> + // CHECK: add <16 x i16> %{{.*}}, %{{.*}} + // CHECK: icmp sle <16 x i16> %{{.*}}, + // CHECK: select <16 x i1> %{{.*}}, <16 x i16> %{{.*}}, <16 x i16> + // CHECK: icmp slt <16 x i16> %{{.*}}, + + // CHECK: select <16 x i1> %{{.*}}, <16 x i16> , <16 x i16> %{{.*}} + // CHECK: trunc <16 x i16> %{{.*}} to <16 x i8> // CHECK: select <16 x i1> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}} return _mm_mask_adds_epi8(__W,__U,__A,__B); } __m128i test_mm_maskz_adds_epi8(__mmask16 __U, __m128i __A, __m128i __B) { // CHECK-LABEL: @test_mm_maskz_adds_epi8 - // CHECK: @llvm.x86.sse2.padds.b + // CHECK-NOT: @llvm.x86.sse2.padds.b + // CHECK: sext <16 x i8> %{{.*}} to <16 x i16> + // CHECK: sext <16 x i8> %{{.*}} to <16 x i16> + // CHECK: add <16 x i16> %{{.*}}, %{{.*}} + // CHECK: icmp sle <16 x i16> %{{.*}}, + // CHECK: select <16 x i1> %{{.*}}, <16 x i16> %{{.*}}, <16 x i16> + // CHECK: icmp slt <16 x i16> %{{.*}}, + + // CHECK: select <16 x i1> %{{.*}}, <16 x i16> , <16 x i16> %{{.*}} + // CHECK: trunc <16 x i16> %{{.*}} to <16 x i8> // CHECK: select <16 x i1> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}} return _mm_maskz_adds_epi8(__U,__A,__B); } __m256i test_mm256_mask_adds_epi8(__m256i __W, __mmask32 __U, __m256i __A, __m256i __B) { // CHECK-LABEL: @test_mm256_mask_adds_epi8 - // CHECK: @llvm.x86.avx2.padds.b + // CHECK-NOT: @llvm.x86.avx2.padds.b + // CHECK: sext <32 x i8> %{{.*}} to <32 x i16> + // CHECK: sext <32 x i8> %{{.*}} to <32 x i16> + // CHECK: add <32 x i16> %{{.*}}, %{{.*}} + // CHECK: icmp sle <32 x i16> %{{.*}}, + // CHECK: select <32 x i1> %{{.*}}, <32 x i16> %{{.*}}, <32 x i16> + // CHECK: icmp slt <32 x i16> %{{.*}}, + // CHECK: select <32 x i1> %{{.*}}, <32 x i16> , <32 x i16> %{{.*}} + // CHECK: trunc <32 x i16> %{{.*}} to <32 x i8> // CHECK: select <32 x i1> %{{.*}}, <32 x i8> %{{.*}}, <32 x i8> %{{.*}} return _mm256_mask_adds_epi8(__W,__U,__A,__B); } __m256i test_mm256_maskz_adds_epi8(__mmask32 __U, __m256i __A, __m256i __B) { // CHECK-LABEL: @test_mm256_maskz_adds_epi8 - // CHECK: @llvm.x86.avx2.padds.b + // CHECK-NOT: @llvm.x86.avx2.padds.b + // CHECK: sext <32 x i8> %{{.*}} to <32 x i16> + // CHECK: sext <32 x i8> %{{.*}} to <32 x i16> + // CHECK: add <32 x i16> %{{.*}}, %{{.*}} + // CHECK: icmp sle <32 x i16> %{{.*}}, + // CHECK: select <32 x i1> %{{.*}}, <32 x i16> %{{.*}}, <32 x i16> + // CHECK: icmp slt <32 x i16> %{{.*}}, + // CHECK: select <32 x i1> %{{.*}}, <32 x i16> , <32 x i16> %{{.*}} + // CHECK: trunc <32 x i16> %{{.*}} to <32 x i8> // CHECK: select <32 x i1> %{{.*}}, <32 x i8> %{{.*}}, <32 x i8> %{{.*}} return _mm256_maskz_adds_epi8(__U,__A,__B); } __m128i test_mm_mask_adds_epi16(__m128i __W, __mmask8 __U, __m128i __A, __m128i __B) { // CHECK-LABEL: @test_mm_mask_adds_epi16 - // CHECK: @llvm.x86.sse2.padds.w + // CHECK-NOT: @llvm.x86.sse2.padds.w + // CHECK: sext <8 x i16> %{{.*}} to <8 x i32> + // CHECK: sext <8 x i16> %{{.*}} to <8 x i32> + // CHECK: add <8 x i32> %{{.*}}, %{{.*}} + // CHECK: icmp sle <8 x i32> %{{.*}}, + // CHECK: select <8 x i1> %{{.*}}, <8 x i32> %{{.*}}, <8 x i32> + // CHECK: icmp slt <8 x i32> %{{.*}}, + // CHECK: select <8 x i1> %{{.*}}, <8 x i32> , <8 x i32> %{{.*}} + // CHECK: trunc <8 x i32> %{{.*}} to <8 x i16> // CHECK: select <8 x i1> %{{.*}}, <8 x i16> %{{.*}}, <8 x i16> %{{.*}} return _mm_mask_adds_epi16(__W,__U,__A,__B); } __m128i test_mm_maskz_adds_epi16(__mmask8 __U, __m128i __A, __m128i __B) { // CHECK-LABEL: @test_mm_maskz_adds_epi16 - // CHECK: @llvm.x86.sse2.padds.w + // CHECK-NOT: @llvm.x86.sse2.padds.w + // CHECK: sext <8 x i16> %{{.*}} to <8 x i32> + // CHECK: sext <8 x i16> %{{.*}} to <8 x i32> + // CHECK: add <8 x i32> %{{.*}}, %{{.*}} + // CHECK: icmp sle <8 x i32> %{{.*}}, + // CHECK: select <8 x i1> %{{.*}}, <8 x i32> %{{.*}}, <8 x i32> + // CHECK: icmp slt <8 x i32> %{{.*}}, + // CHECK: select <8 x i1> %{{.*}}, <8 x i32> , <8 x i32> %{{.*}} + // CHECK: trunc <8 x i32> %{{.*}} to <8 x i16> // CHECK: select <8 x i1> %{{.*}}, <8 x i16> %{{.*}}, <8 x i16> %{{.*}} return _mm_maskz_adds_epi16(__U,__A,__B); } __m256i test_mm256_mask_adds_epi16(__m256i __W, __mmask16 __U, __m256i __A, __m256i __B) { // CHECK-LABEL: @test_mm256_mask_adds_epi16 - // CHECK: @llvm.x86.avx2.padds.w + // CHECK-NOT: @llvm.x86.avx2.padds.w + // CHECK: sext <16 x i16> %{{.*}} to <16 x i32> + // CHECK: sext <16 x i16> %{{.*}} to <16 x i32> + // CHECK: add <16 x i32> %{{.*}}, %{{.*}} + // CHECK: icmp sle <16 x i32> %{{.*}}, + // CHECK: select <16 x i1> %{{.*}}, <16 x i32> %{{.*}}, <16 x i32> + // CHECK: icmp slt <16 x i32> %{{.*}}, + // CHECK: select <16 x i1> %{{.*}}, <16 x i32> , <16 x i32> %{{.*}} + // CHECK: trunc <16 x i32> %{{.*}} to <16 x i16> // CHECK: select <16 x i1> %{{.*}}, <16 x i16> %{{.*}}, <16 x i16> %{{.*}} return _mm256_mask_adds_epi16(__W,__U,__A,__B); } __m256i test_mm256_maskz_adds_epi16(__mmask16 __U, __m256i __A, __m256i __B) { // CHECK-LABEL: @test_mm256_maskz_adds_epi16 - // CHECK: @llvm.x86.avx2.padds.w + // CHECK-NOT: @llvm.x86.avx2.padds.w + // CHECK: sext <16 x i16> %{{.*}} to <16 x i32> + // CHECK: sext <16 x i16> %{{.*}} to <16 x i32> + // CHECK: add <16 x i32> %{{.*}}, %{{.*}} + // CHECK: icmp sle <16 x i32> %{{.*}}, + // CHECK: select <16 x i1> %{{.*}}, <16 x i32> %{{.*}}, <16 x i32> + // CHECK: icmp slt <16 x i32> %{{.*}}, + // CHECK: select <16 x i1> %{{.*}}, <16 x i32> , <16 x i32> %{{.*}} + // CHECK: trunc <16 x i32> %{{.*}} to <16 x i16> // CHECK: select <16 x i1> %{{.*}}, <16 x i16> %{{.*}}, <16 x i16> %{{.*}} return _mm256_maskz_adds_epi16(__U,__A,__B); } -__m128i test_mm_mask_adds_epu8(__m128i __W, __mmask16 __U, __m128i __A, __m128i __B) { +__m128i test_mm_mask_adds_epu8(__m128i __W, __mmask16 __U, __m128i __A, __m128i __B) { // CHECK-LABEL: @test_mm_mask_adds_epu8 - // CHECK: @llvm.x86.sse2.paddus.b + // CHECK-NOT: @llvm.x86.sse2.paddus.b + // CHECK: zext <16 x i8> %{{.*}} to <16 x i16> + // CHECK: zext <16 x i8> %{{.*}} to <16 x i16> + // CHECK: add <16 x i16> %{{.*}}, %{{.*}} + // CHECK: icmp ule <16 x i16> %{{.*}}, + // CHECK: select <16 x i1> %{{.*}}, <16 x i16> %{{.*}}, <16 x i16> + // CHECK: trunc <16 x i16> %{{.*}} to <16 x i8> // CHECK: select <16 x i1> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}} return _mm_mask_adds_epu8(__W,__U,__A,__B); } __m128i test_mm_maskz_adds_epu8(__mmask16 __U, __m128i __A, __m128i __B) { // CHECK-LABEL: @test_mm_maskz_adds_epu8 - // CHECK: @llvm.x86.sse2.paddus.b + // CHECK-NOT: @llvm.x86.sse2.paddus.b + // CHECK: zext <16 x i8> %{{.*}} to <16 x i16> + // CHECK: zext <16 x i8> %{{.*}} to <16 x i16> + // CHECK: add <16 x i16> %{{.*}}, %{{.*}} + // CHECK: icmp ule <16 x i16> %{{.*}}, + // CHECK: select <16 x i1> %{{.*}}, <16 x i16> %{{.*}}, <16 x i16> + // CHECK: trunc <16 x i16> %{{.*}} to <16 x i8> // CHECK: select <16 x i1> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}} return _mm_maskz_adds_epu8(__U,__A,__B); } __m256i test_mm256_mask_adds_epu8(__m256i __W, __mmask32 __U, __m256i __A, __m256i __B) { // CHECK-LABEL: @test_mm256_mask_adds_epu8 - // CHECK: @llvm.x86.avx2.paddus.b + // CHECK-NOT: @llvm.x86.avx2.paddus.b + // CHECK: zext <32 x i8> %{{.*}} to <32 x i16> + // CHECK: zext <32 x i8> %{{.*}} to <32 x i16> + // CHECK: add <32 x i16> %{{.*}}, %{{.*}} + // CHECK: icmp ule <32 x i16> %{{.*}}, + // CHECK: select <32 x i1> %{{.*}}, <32 x i16> %{{.*}}, <32 x i16> + // CHECK: trunc <32 x i16> %{{.*}} to <32 x i8> // CHECK: select <32 x i1> %{{.*}}, <32 x i8> %{{.*}}, <32 x i8> %{{.*}} return _mm256_mask_adds_epu8(__W,__U,__A,__B); } __m256i test_mm256_maskz_adds_epu8(__mmask32 __U, __m256i __A, __m256i __B) { // CHECK-LABEL: @test_mm256_maskz_adds_epu8 - // CHECK: @llvm.x86.avx2.paddus.b + // CHECK-NOT: @llvm.x86.avx2.paddus.b + // CHECK: zext <32 x i8> %{{.*}} to <32 x i16> + // CHECK: zext <32 x i8> %{{.*}} to <32 x i16> + // CHECK: add <32 x i16> %{{.*}}, %{{.*}} + // CHECK: icmp ule <32 x i16> %{{.*}}, + // CHECK: select <32 x i1> %{{.*}}, <32 x i16> %{{.*}}, <32 x i16> + // CHECK: trunc <32 x i16> %{{.*}} to <32 x i8> // CHECK: select <32 x i1> %{{.*}}, <32 x i8> %{{.*}}, <32 x i8> %{{.*}} return _mm256_maskz_adds_epu8(__U,__A,__B); } __m128i test_mm_mask_adds_epu16(__m128i __W, __mmask8 __U, __m128i __A, __m128i __B) { // CHECK-LABEL: @test_mm_mask_adds_epu16 - // CHECK: @llvm.x86.sse2.paddus.w + // CHECK-NOT: @llvm.x86.sse2.paddus.w + // CHECK: zext <8 x i16> %{{.*}} to <8 x i32> + // CHECK: zext <8 x i16> %{{.*}} to <8 x i32> + // CHECK: add <8 x i32> %{{.*}}, %{{.*}} + // CHECK: icmp ule <8 x i32> %{{.*}}, + // CHECK: select <8 x i1> %{{.*}}, <8 x i32> %{{.*}}, <8 x i32> + // CHECK: trunc <8 x i32> %{{.*}} to <8 x i16> // CHECK: select <8 x i1> %{{.*}}, <8 x i16> %{{.*}}, <8 x i16> %{{.*}} return _mm_mask_adds_epu16(__W,__U,__A,__B); } __m128i test_mm_maskz_adds_epu16(__mmask8 __U, __m128i __A, __m128i __B) { // CHECK-LABEL: @test_mm_maskz_adds_epu16 - // CHECK: @llvm.x86.sse2.paddus.w + // CHECK-NOT: @llvm.x86.sse2.paddus.w + // CHECK: zext <8 x i16> %{{.*}} to <8 x i32> + // CHECK: zext <8 x i16> %{{.*}} to <8 x i32> + // CHECK: add <8 x i32> %{{.*}}, %{{.*}} + // CHECK: icmp ule <8 x i32> %{{.*}}, + // CHECK: select <8 x i1> %{{.*}}, <8 x i32> %{{.*}}, <8 x i32> + // CHECK: trunc <8 x i32> %{{.*}} to <8 x i16> // CHECK: select <8 x i1> %{{.*}}, <8 x i16> %{{.*}}, <8 x i16> %{{.*}} return _mm_maskz_adds_epu16(__U,__A,__B); } __m256i test_mm256_mask_adds_epu16(__m256i __W, __mmask16 __U, __m256i __A, __m256i __B) { // CHECK-LABEL: @test_mm256_mask_adds_epu16 - // CHECK: @llvm.x86.avx2.paddus.w + // CHECK-NOT: @llvm.x86.avx2.paddus.w + // CHECK: zext <16 x i16> %{{.*}} to <16 x i32> + // CHECK: zext <16 x i16> %{{.*}} to <16 x i32> + // CHECK: add <16 x i32> %{{.*}}, %{{.*}} + // CHECK: icmp ule <16 x i32> %{{.*}}, + // CHECK: select <16 x i1> %{{.*}}, <16 x i32> %{{.*}}, <16 x i32> + // CHECK: trunc <16 x i32> %{{.*}} to <16 x i16> // CHECK: select <16 x i1> %{{.*}}, <16 x i16> %{{.*}}, <16 x i16> %{{.*}} return _mm256_mask_adds_epu16(__W,__U,__A,__B); } __m256i test_mm256_maskz_adds_epu16(__mmask16 __U, __m256i __A, __m256i __B) { // CHECK-LABEL: @test_mm256_maskz_adds_epu16 - // CHECK: @llvm.x86.avx2.paddus.w + // CHECK-NOT: @llvm.x86.avx2.paddus.w + // CHECK: zext <16 x i16> %{{.*}} to <16 x i32> + // CHECK: zext <16 x i16> %{{.*}} to <16 x i32> + // CHECK: add <16 x i32> %{{.*}}, %{{.*}} + // CHECK: icmp ule <16 x i32> %{{.*}}, + // CHECK: select <16 x i1> %{{.*}}, <16 x i32> %{{.*}}, <16 x i32> + // CHECK: trunc <16 x i32> %{{.*}} to <16 x i16> // CHECK: select <16 x i1> %{{.*}}, <16 x i16> %{{.*}}, <16 x i16> %{{.*}} return _mm256_maskz_adds_epu16(__U,__A,__B); } @@ -1519,102 +1633,191 @@ __m256i test_mm256_maskz_shuffle_epi8(__mmask32 __U, __m256i __A, __m256i __B) { } __m128i test_mm_mask_subs_epi8(__m128i __W, __mmask16 __U, __m128i __A, __m128i __B) { // CHECK-LABEL: @test_mm_mask_subs_epi8 - // CHECK: @llvm.x86.sse2.psubs.b + // CHECK-NOT: @llvm.x86.sse2.psubs.b + // CHECK: sext <16 x i8> %{{.*}} to <16 x i16> + // CHECK: sext <16 x i8> %{{.*}} to <16 x i16> + // CHECK: sub <16 x i16> %{{.*}}, %{{.*}} + // CHECK: icmp sle <16 x i16> %{{.*}}, + // CHECK: select <16 x i1> %{{.*}}, <16 x i16> %{{.*}}, <16 x i16> + // CHECK: icmp slt <16 x i16> %{{.*}}, + + // CHECK: select <16 x i1> %{{.*}}, <16 x i16> , <16 x i16> %{{.*}} + // CHECK: trunc <16 x i16> %{{.*}} to <16 x i8> // CHECK: select <16 x i1> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}} return _mm_mask_subs_epi8(__W,__U,__A,__B); } __m128i test_mm_maskz_subs_epi8(__mmask16 __U, __m128i __A, __m128i __B) { // CHECK-LABEL: @test_mm_maskz_subs_epi8 - // CHECK: @llvm.x86.sse2.psubs.b + // CHECK-NOT: @llvm.x86.sse2.psubs.b + // CHECK: sext <16 x i8> %{{.*}} to <16 x i16> + // CHECK: sext <16 x i8> %{{.*}} to <16 x i16> + // CHECK: sub <16 x i16> %{{.*}}, %{{.*}} + // CHECK: icmp sle <16 x i16> %{{.*}}, + // CHECK: select <16 x i1> %{{.*}}, <16 x i16> %{{.*}}, <16 x i16> + // CHECK: icmp slt <16 x i16> %{{.*}}, + + // CHECK: select <16 x i1> %{{.*}}, <16 x i16> , <16 x i16> %{{.*}} + // CHECK: trunc <16 x i16> %{{.*}} to <16 x i8> // CHECK: select <16 x i1> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}} return _mm_maskz_subs_epi8(__U,__A,__B); } __m256i test_mm256_mask_subs_epi8(__m256i __W, __mmask32 __U, __m256i __A, __m256i __B) { // CHECK-LABEL: @test_mm256_mask_subs_epi8 - // CHECK: @llvm.x86.avx2.psubs.b + // CHECK-NOT: @llvm.x86.avx2.psubs.b + // CHECK: sext <32 x i8> %{{.*}} to <32 x i16> + // CHECK: sext <32 x i8> %{{.*}} to <32 x i16> + // CHECK: sub <32 x i16> %{{.*}}, %{{.*}} + // CHECK: icmp sle <32 x i16> %{{.*}}, + // CHECK: select <32 x i1> %{{.*}}, <32 x i16> %{{.*}}, <32 x i16> + // CHECK: icmp slt <32 x i16> %{{.*}}, + // CHECK: select <32 x i1> %{{.*}}, <32 x i16> , <32 x i16> %{{.*}} + // CHECK: trunc <32 x i16> %{{.*}} to <32 x i8> // CHECK: select <32 x i1> %{{.*}}, <32 x i8> %{{.*}}, <32 x i8> %{{.*}} return _mm256_mask_subs_epi8(__W,__U,__A,__B); } __m256i test_mm256_maskz_subs_epi8(__mmask32 __U, __m256i __A, __m256i __B) { // CHECK-LABEL: @test_mm256_maskz_subs_epi8 - // CHECK: @llvm.x86.avx2.psubs.b + // CHECK-NOT: @llvm.x86.avx2.psubs.b + // CHECK: sext <32 x i8> %{{.*}} to <32 x i16> + // CHECK: sext <32 x i8> %{{.*}} to <32 x i16> + // CHECK: sub <32 x i16> %{{.*}}, %{{.*}} + // CHECK: icmp sle <32 x i16> %{{.*}}, + // CHECK: select <32 x i1> %{{.*}}, <32 x i16> %{{.*}}, <32 x i16> + // CHECK: icmp slt <32 x i16> %{{.*}}, + // CHECK: select <32 x i1> %{{.*}}, <32 x i16> , <32 x i16> %{{.*}} + // CHECK: trunc <32 x i16> %{{.*}} to <32 x i8> // CHECK: select <32 x i1> %{{.*}}, <32 x i8> %{{.*}}, <32 x i8> %{{.*}} return _mm256_maskz_subs_epi8(__U,__A,__B); } __m128i test_mm_mask_subs_epi16(__m128i __W, __mmask8 __U, __m128i __A, __m128i __B) { // CHECK-LABEL: @test_mm_mask_subs_epi16 - // CHECK: @llvm.x86.sse2.psubs.w + // CHECK-NOT: @llvm.x86.sse2.psubs.w + // CHECK: sext <8 x i16> %{{.*}} to <8 x i32> + // CHECK: sext <8 x i16> %{{.*}} to <8 x i32> + // CHECK: sub <8 x i32> %{{.*}}, %{{.*}} + // CHECK: icmp sle <8 x i32> %{{.*}}, + // CHECK: select <8 x i1> %{{.*}}, <8 x i32> %{{.*}}, <8 x i32> + // CHECK: icmp slt <8 x i32> %{{.*}}, + // CHECK: select <8 x i1> %{{.*}}, <8 x i32> , <8 x i32> %{{.*}} + // CHECK: trunc <8 x i32> %{{.*}} to <8 x i16> // CHECK: select <8 x i1> %{{.*}}, <8 x i16> %{{.*}}, <8 x i16> %{{.*}} return _mm_mask_subs_epi16(__W,__U,__A,__B); } __m128i test_mm_maskz_subs_epi16(__mmask8 __U, __m128i __A, __m128i __B) { // CHECK-LABEL: @test_mm_maskz_subs_epi16 - // CHECK: @llvm.x86.sse2.psubs.w + // CHECK-NOT: @llvm.x86.sse2.psubs.w + // CHECK: sext <8 x i16> %{{.*}} to <8 x i32> + // CHECK: sext <8 x i16> %{{.*}} to <8 x i32> + // CHECK: sub <8 x i32> %{{.*}}, %{{.*}} + // CHECK: icmp sle <8 x i32> %{{.*}}, + // CHECK: select <8 x i1> %{{.*}}, <8 x i32> %{{.*}}, <8 x i32> + // CHECK: icmp slt <8 x i32> %{{.*}}, + // CHECK: select <8 x i1> %{{.*}}, <8 x i32> , <8 x i32> %{{.*}} + // CHECK: trunc <8 x i32> %{{.*}} to <8 x i16> // CHECK: select <8 x i1> %{{.*}}, <8 x i16> %{{.*}}, <8 x i16> %{{.*}} return _mm_maskz_subs_epi16(__U,__A,__B); } __m256i test_mm256_mask_subs_epi16(__m256i __W, __mmask16 __U, __m256i __A, __m256i __B) { // CHECK-LABEL: @test_mm256_mask_subs_epi16 - // CHECK: @llvm.x86.avx2.psubs.w + // CHECK-NOT: @llvm.x86.avx2.psubs.w + // CHECK: sext <16 x i16> %{{.*}} to <16 x i32> + // CHECK: sext <16 x i16> %{{.*}} to <16 x i32> + // CHECK: sub <16 x i32> %{{.*}}, %{{.*}} + // CHECK: icmp sle <16 x i32> %{{.*}}, + // CHECK: select <16 x i1> %{{.*}}, <16 x i32> %{{.*}}, <16 x i32> + // CHECK: icmp slt <16 x i32> %{{.*}}, + // CHECK: select <16 x i1> %{{.*}}, <16 x i32> , <16 x i32> %{{.*}} + // CHECK: trunc <16 x i32> %{{.*}} to <16 x i16> // CHECK: select <16 x i1> %{{.*}}, <16 x i16> %{{.*}}, <16 x i16> %{{.*}} return _mm256_mask_subs_epi16(__W,__U,__A,__B); } __m256i test_mm256_maskz_subs_epi16(__mmask16 __U, __m256i __A, __m256i __B) { // CHECK-LABEL: @test_mm256_maskz_subs_epi16 - // CHECK: @llvm.x86.avx2.psubs.w + // CHECK-NOT: @llvm.x86.avx2.psubs.w + // CHECK: sext <16 x i16> %{{.*}} to <16 x i32> + // CHECK: sext <16 x i16> %{{.*}} to <16 x i32> + // CHECK: sub <16 x i32> %{{.*}}, %{{.*}} + // CHECK: icmp sle <16 x i32> %{{.*}}, + // CHECK: select <16 x i1> %{{.*}}, <16 x i32> %{{.*}}, <16 x i32> + // CHECK: icmp slt <16 x i32> %{{.*}}, + // CHECK: select <16 x i1> %{{.*}}, <16 x i32> , <16 x i32> %{{.*}} + // CHECK: trunc <16 x i32> %{{.*}} to <16 x i16> // CHECK: select <16 x i1> %{{.*}}, <16 x i16> %{{.*}}, <16 x i16> %{{.*}} return _mm256_maskz_subs_epi16(__U,__A,__B); } __m128i test_mm_mask_subs_epu8(__m128i __W, __mmask16 __U, __m128i __A, __m128i __B) { // CHECK-LABEL: @test_mm_mask_subs_epu8 - // CHECK: @llvm.x86.sse2.psubus.b + // CHECK-NOT: @llvm.x86.sse2.psubus.b + // CHECK: icmp ugt <16 x i8> {{.*}}, {{.*}} + // CHECK: select <16 x i1> {{.*}}, <16 x i8> {{.*}}, <16 x i8> {{.*}} + // CHECK: sub <16 x i8> {{.*}}, {{.*}} // CHECK: select <16 x i1> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}} return _mm_mask_subs_epu8(__W,__U,__A,__B); } __m128i test_mm_maskz_subs_epu8(__mmask16 __U, __m128i __A, __m128i __B) { // CHECK-LABEL: @test_mm_maskz_subs_epu8 - // CHECK: @llvm.x86.sse2.psubus.b + // CHECK-NOT: @llvm.x86.sse2.psubus.b + // CHECK: icmp ugt <16 x i8> {{.*}}, {{.*}} + // CHECK: select <16 x i1> {{.*}}, <16 x i8> {{.*}}, <16 x i8> {{.*}} + // CHECK: sub <16 x i8> {{.*}}, {{.*}} // CHECK: select <16 x i1> %{{.*}}, <16 x i8> %{{.*}}, <16 x i8> %{{.*}} return _mm_maskz_subs_epu8(__U,__A,__B); } __m256i test_mm256_mask_subs_epu8(__m256i __W, __mmask32 __U, __m256i __A, __m256i __B) { // CHECK-LABEL: @test_mm256_mask_subs_epu8 - // CHECK: @llvm.x86.avx2.psubus.b + // CHECK-NOT: @llvm.x86.avx2.psubus.b + // CHECK: icmp ugt <32 x i8> {{.*}}, {{.*}} + // CHECK: select <32 x i1> {{.*}}, <32 x i8> {{.*}}, <32 x i8> {{.*}} + // CHECK: sub <32 x i8> {{.*}}, {{.*}} // CHECK: select <32 x i1> %{{.*}}, <32 x i8> %{{.*}}, <32 x i8> %{{.*}} return _mm256_mask_subs_epu8(__W,__U,__A,__B); } __m256i test_mm256_maskz_subs_epu8(__mmask32 __U, __m256i __A, __m256i __B) { // CHECK-LABEL: @test_mm256_maskz_subs_epu8 - // CHECK: @llvm.x86.avx2.psubus.b + // CHECK-NOT: @llvm.x86.avx2.psubus.b + // CHECK: icmp ugt <32 x i8> {{.*}}, {{.*}} + // CHECK: select <32 x i1> {{.*}}, <32 x i8> {{.*}}, <32 x i8> {{.*}} + // CHECK: sub <32 x i8> {{.*}}, {{.*}} // CHECK: select <32 x i1> %{{.*}}, <32 x i8> %{{.*}}, <32 x i8> %{{.*}} return _mm256_maskz_subs_epu8(__U,__A,__B); } __m128i test_mm_mask_subs_epu16(__m128i __W, __mmask8 __U, __m128i __A, __m128i __B) { // CHECK-LABEL: @test_mm_mask_subs_epu16 - // CHECK: @llvm.x86.sse2.psubus.w + // CHECK-NOT: @llvm.x86.sse2.psubus.w + // CHECK: icmp ugt <8 x i16> {{.*}}, {{.*}} + // CHECK: select <8 x i1> {{.*}}, <8 x i16> {{.*}}, <8 x i16> {{.*}} + // CHECK: sub <8 x i16> {{.*}}, {{.*}} // CHECK: select <8 x i1> %{{.*}}, <8 x i16> %{{.*}}, <8 x i16> %{{.*}} return _mm_mask_subs_epu16(__W,__U,__A,__B); } __m128i test_mm_maskz_subs_epu16(__mmask8 __U, __m128i __A, __m128i __B) { // CHECK-LABEL: @test_mm_maskz_subs_epu16 - // CHECK: @llvm.x86.sse2.psubus.w + // CHECK-NOT: @llvm.x86.sse2.psubus.w + // CHECK: icmp ugt <8 x i16> {{.*}}, {{.*}} + // CHECK: select <8 x i1> {{.*}}, <8 x i16> {{.*}}, <8 x i16> {{.*}} + // CHECK: sub <8 x i16> {{.*}}, {{.*}} // CHECK: select <8 x i1> %{{.*}}, <8 x i16> %{{.*}}, <8 x i16> %{{.*}} return _mm_maskz_subs_epu16(__U,__A,__B); } __m256i test_mm256_mask_subs_epu16(__m256i __W, __mmask16 __U, __m256i __A, __m256i __B) { // CHECK-LABEL: @test_mm256_mask_subs_epu16 - // CHECK: @llvm.x86.avx2.psubus.w + // CHECK-NOT: @llvm.x86.avx2.psubus.w + // CHECK: icmp ugt <16 x i16> {{.*}}, {{.*}} + // CHECK: select <16 x i1> {{.*}}, <16 x i16> {{.*}}, <16 x i16> {{.*}} + // CHECK: sub <16 x i16> {{.*}}, {{.*}} // CHECK: select <16 x i1> %{{.*}}, <16 x i16> %{{.*}}, <16 x i16> %{{.*}} return _mm256_mask_subs_epu16(__W,__U,__A,__B); } __m256i test_mm256_maskz_subs_epu16(__mmask16 __U, __m256i __A, __m256i __B) { // CHECK-LABEL: @test_mm256_maskz_subs_epu16 - // CHECK: @llvm.x86.avx2.psubus.w + // CHECK-NOT: @llvm.x86.avx2.psubus.w + // CHECK: icmp ugt <16 x i16> {{.*}}, {{.*}} + // CHECK: select <16 x i1> {{.*}}, <16 x i16> {{.*}}, <16 x i16> {{.*}} + // CHECK: sub <16 x i16> {{.*}}, {{.*}} // CHECK: select <16 x i1> %{{.*}}, <16 x i16> %{{.*}}, <16 x i16> %{{.*}} return _mm256_maskz_subs_epu16(__U,__A,__B); } - __m128i test_mm_mask2_permutex2var_epi16(__m128i __A, __m128i __I, __mmask8 __U, __m128i __B) { // CHECK-LABEL: @test_mm_mask2_permutex2var_epi16 // CHECK: @llvm.x86.avx512.mask.vpermi2var.hi.128 diff --git a/test/CodeGen/sse2-builtins.c b/test/CodeGen/sse2-builtins.c index 4ddb121ad1..26fc939b91 100644 --- a/test/CodeGen/sse2-builtins.c +++ b/test/CodeGen/sse2-builtins.c @@ -47,25 +47,53 @@ __m128d test_mm_add_sd(__m128d A, __m128d B) { __m128i test_mm_adds_epi8(__m128i A, __m128i B) { // CHECK-LABEL: test_mm_adds_epi8 - // CHECK: call <16 x i8> @llvm.x86.sse2.padds.b(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) + // CHECK-NOT: call <16 x i8> @llvm.x86.sse2.padds.b(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) + // CHECK: sext <16 x i8> %{{.*}} to <16 x i16> + // CHECK: sext <16 x i8> %{{.*}} to <16 x i16> + // CHECK: add <16 x i16> %{{.*}}, %{{.*}} + // CHECK: icmp sle <16 x i16> %{{.*}}, + // CHECK: select <16 x i1> %{{.*}}, <16 x i16> %{{.*}}, <16 x i16> + // CHECK: icmp slt <16 x i16> %{{.*}}, + // CHECK: select <16 x i1> %{{.*}}, <16 x i16> , <16 x i16> %{{.*}} + // CHECK: trunc <16 x i16> %{{.*}} to <16 x i8> return _mm_adds_epi8(A, B); } __m128i test_mm_adds_epi16(__m128i A, __m128i B) { // CHECK-LABEL: test_mm_adds_epi16 - // CHECK: call <8 x i16> @llvm.x86.sse2.padds.w(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) + // CHECK-NOT: call <8 x i16> @llvm.x86.sse2.padds.w(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) + // CHECK: sext <8 x i16> %{{.*}} to <8 x i32> + // CHECK: sext <8 x i16> %{{.*}} to <8 x i32> + // CHECK: add <8 x i32> %{{.*}}, %{{.*}} + // CHECK: icmp sle <8 x i32> %{{.*}}, + // CHECK: select <8 x i1> %{{.*}}, <8 x i32> %{{.*}}, <8 x i32> + // CHECK: icmp slt <8 x i32> %{{.*}}, + // CHECK: select <8 x i1> %{{.*}}, <8 x i32> , <8 x i32> %{{.*}} + // CHECK: trunc <8 x i32> %{{.*}} to <8 x i16> return _mm_adds_epi16(A, B); } __m128i test_mm_adds_epu8(__m128i A, __m128i B) { // CHECK-LABEL: test_mm_adds_epu8 - // CHECK: call <16 x i8> @llvm.x86.sse2.paddus.b(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) + // CHECK-NOT: call <16 x i8> @llvm.x86.sse2.paddus.b(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) + // CHECK: zext <16 x i8> %{{.*}} to <16 x i16> + // CHECK: zext <16 x i8> %{{.*}} to <16 x i16> + // CHECK: add <16 x i16> %{{.*}}, %{{.*}} + // CHECK: icmp ule <16 x i16> %{{.*}}, + // CHECK: select <16 x i1> %{{.*}}, <16 x i16> %{{.*}}, <16 x i16> + // CHECK: trunc <16 x i16> %{{.*}} to <16 x i8> return _mm_adds_epu8(A, B); } __m128i test_mm_adds_epu16(__m128i A, __m128i B) { // CHECK-LABEL: test_mm_adds_epu16 - // CHECK: call <8 x i16> @llvm.x86.sse2.paddus.w(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) + // CHECK-NOT: call <8 x i16> @llvm.x86.sse2.paddus.w(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) + // CHECK: zext <8 x i16> %{{.*}} to <8 x i32> + // CHECK: zext <8 x i16> %{{.*}} to <8 x i32> + // CHECK: add <8 x i32> %{{.*}}, %{{.*}} + // CHECK: icmp ule <8 x i32> %{{.*}}, + // CHECK: select <8 x i1> %{{.*}}, <8 x i32> %{{.*}}, <8 x i32> + // CHECK: trunc <8 x i32> %{{.*}} to <8 x i16> return _mm_adds_epu16(A, B); } @@ -1416,25 +1444,47 @@ __m128d test_mm_sub_sd(__m128d A, __m128d B) { __m128i test_mm_subs_epi8(__m128i A, __m128i B) { // CHECK-LABEL: test_mm_subs_epi8 - // CHECK: call <16 x i8> @llvm.x86.sse2.psubs.b(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) + // CHECK-NOT: call <16 x i8> @llvm.x86.sse2.psubs.b(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) + // CHECK: sext <16 x i8> %{{.*}} to <16 x i16> + // CHECK: sext <16 x i8> %{{.*}} to <16 x i16> + // CHECK: sub <16 x i16> %{{.*}}, %{{.*}} + // CHECK: icmp sle <16 x i16> %{{.*}}, + // CHECK: select <16 x i1> %{{.*}}, <16 x i16> %{{.*}}, <16 x i16> + // CHECK: icmp slt <16 x i16> %{{.*}}, + // CHECK: select <16 x i1> %{{.*}}, <16 x i16> , <16 x i16> %{{.*}} + // CHECK: trunc <16 x i16> %{{.*}} to <16 x i8> return _mm_subs_epi8(A, B); } __m128i test_mm_subs_epi16(__m128i A, __m128i B) { // CHECK-LABEL: test_mm_subs_epi16 - // CHECK: call <8 x i16> @llvm.x86.sse2.psubs.w(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) + // CHECK-NOT: call <8 x i16> @llvm.x86.sse2.psubs.w(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) + // CHECK: sext <8 x i16> %{{.*}} to <8 x i32> + // CHECK: sext <8 x i16> %{{.*}} to <8 x i32> + // CHECK: sub <8 x i32> %{{.*}}, %{{.*}} + // CHECK: icmp sle <8 x i32> %{{.*}}, + // CHECK: select <8 x i1> %{{.*}}, <8 x i32> %{{.*}}, <8 x i32> + // CHECK: icmp slt <8 x i32> %{{.*}}, + // CHECK: select <8 x i1> %{{.*}}, <8 x i32> , <8 x i32> %{{.*}} + // CHECK: trunc <8 x i32> %{{.*}} to <8 x i16> return _mm_subs_epi16(A, B); } __m128i test_mm_subs_epu8(__m128i A, __m128i B) { // CHECK-LABEL: test_mm_subs_epu8 - // CHECK: call <16 x i8> @llvm.x86.sse2.psubus.b(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) + // CHECK-NOT: call <16 x i8> @llvm.x86.sse2.psubus.b(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) + // CHECK: icmp ugt <16 x i8> {{.*}}, {{.*}} + // CHECK: select <16 x i1> {{.*}}, <16 x i8> {{.*}}, <16 x i8> {{.*}} + // CHECK: sub <16 x i8> {{.*}}, {{.*}} return _mm_subs_epu8(A, B); } __m128i test_mm_subs_epu16(__m128i A, __m128i B) { // CHECK-LABEL: test_mm_subs_epu16 - // CHECK: call <8 x i16> @llvm.x86.sse2.psubus.w(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) + // CHECK-NOT: call <8 x i16> @llvm.x86.sse2.psubus.w(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) + // CHECK: icmp ugt <8 x i16> {{.*}}, {{.*}} + // CHECK: select <8 x i1> {{.*}}, <8 x i16> {{.*}}, <8 x i16> {{.*}} + // CHECK: sub <8 x i16> {{.*}}, {{.*}} return _mm_subs_epu16(A, B); }