Index: lib/CodeGen/CGBuiltin.cpp =================================================================== --- lib/CodeGen/CGBuiltin.cpp +++ lib/CodeGen/CGBuiltin.cpp @@ -8475,6 +8475,84 @@ 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 (!Signed) { + if (IsAddition) { + // ADDUS: a > (a+b) ? ~0 : (a+b) + // If Ops[0] > Add, overflow occured. + Value *Add = CGF.Builder.CreateAdd(Ops[0], Ops[1]); + Value *ICmp = CGF.Builder.CreateICmp(ICmpInst::ICMP_UGT, Ops[0], Add); + Value *Max = llvm::Constant::getAllOnesValue(ResultType); + Res = CGF.Builder.CreateSelect(ICmp, Max, Add); + } else { + // SUBUS: max(a, b) - b + 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 { + // ADDS/SUBS: sign extend both ops, select result/max value depending on + // overflow and truncate selected value. + 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 = CGF.Builder.CreateSExt(Ops[0], ExtType); + Value *VecB = CGF.Builder.CreateSExt(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 = llvm::ConstantInt::get(ResultType, SignedMaxValue); + Value *ExtMaxVec = CGF.Builder.CreateSExt(Max, ExtType); + + // In Product, replace all overflowed values with max values of non-extended + // type. + Value *Cmp = CGF.Builder.CreateICmp(ICmpInst::ICMP_SLE, ExtProduct, + ExtMaxVec); // 1 if no overflow. + Value *SaturatedProduct = CGF.Builder.CreateSelect( + Cmp, ExtProduct, ExtMaxVec); // If overflowed, copy from max values. + + 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(); @@ -9550,10 +9628,37 @@ 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; Index: test/CodeGen/avx2-builtins.c =================================================================== --- test/CodeGen/avx2-builtins.c +++ test/CodeGen/avx2-builtins.c @@ -56,25 +56,47 @@ __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: add <32 x i8> %{{.*}}, %{{.*}} + // CHECK: icmp ugt <32 x i8> %{{.*}}, %{{.*}} + // CHECK: select <32 x i1> %{{.*}}, <32 x i8> , <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: add <16 x i16> %{{.*}}, %{{.*}} + // CHECK: icmp ugt <16 x i16> %{{.*}}, %{{.*}} + // CHECK: select <16 x i1> %{{.*}}, <16 x i16> , <16 x i16> {{.*}} return _mm256_adds_epu16(a, b); } @@ -1171,25 +1193,47 @@ __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); } Index: test/CodeGen/avx512bw-builtins.c =================================================================== --- test/CodeGen/avx512bw-builtins.c +++ test/CodeGen/avx512bw-builtins.c @@ -594,62 +594,136 @@ } __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: add <64 x i8> %{{.*}}, %{{.*}} + // CHECK: icmp ugt <64 x i8> %{{.*}}, %{{.*}} + // CHECK: select <64 x i1> %{{.*}}, <64 x i8> , <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: add <64 x i8> %{{.*}}, %{{.*}} + // CHECK: icmp ugt <64 x i8> %{{.*}}, %{{.*}} + // CHECK: select <64 x i1> %{{.*}}, <64 x i8> , <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: add <64 x i8> %{{.*}}, %{{.*}} + // CHECK: icmp ugt <64 x i8> %{{.*}}, %{{.*}} + // CHECK: select <64 x i1> %{{.*}}, <64 x i8> , <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: add <32 x i16> %{{.*}}, %{{.*}} + // CHECK: icmp ugt <32 x i16> %{{.*}}, %{{.*}} + // CHECK: select <32 x i1> %{{.*}}, <32 x i16> , <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: add <32 x i16> %{{.*}}, %{{.*}} + // CHECK: icmp ugt <32 x i16> %{{.*}}, %{{.*}} + // CHECK: select <32 x i1> %{{.*}}, <32 x i16> , <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: add <32 x i16> %{{.*}}, %{{.*}} + // CHECK: icmp ugt <32 x i16> %{{.*}}, %{{.*}} + // CHECK: select <32 x i1> %{{.*}}, <32 x i16> , <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 +977,137 @@ } __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 Index: test/CodeGen/avx512vlbw-builtins.c =================================================================== --- test/CodeGen/avx512vlbw-builtins.c +++ test/CodeGen/avx512vlbw-builtins.c @@ -1075,97 +1075,187 @@ __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: add <16 x i8> %{{.*}}, %{{.*}} + // CHECK: icmp ugt <16 x i8> %{{.*}}, %{{.*}} + // CHECK: select <16 x i1> %{{.*}}, <16 x i8> , <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: add <16 x i8> %{{.*}}, %{{.*}} + // CHECK: icmp ugt <16 x i8> %{{.*}}, %{{.*}} + // CHECK: select <16 x i1> %{{.*}}, <16 x i8> , <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: add <32 x i8> %{{.*}}, %{{.*}} + // CHECK: icmp ugt <32 x i8> %{{.*}}, %{{.*}} + // CHECK: select <32 x i1> %{{.*}}, <32 x i8> , <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: add <32 x i8> %{{.*}}, %{{.*}} + // CHECK: icmp ugt <32 x i8> %{{.*}}, %{{.*}} + // CHECK: select <32 x i1> %{{.*}}, <32 x i8> , <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: add <8 x i16> %{{.*}}, %{{.*}} + // CHECK: icmp ugt <8 x i16> %{{.*}}, %{{.*}} + // CHECK: select <8 x i1> %{{.*}}, <8 x i16> , <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: add <8 x i16> %{{.*}}, %{{.*}} + // CHECK: icmp ugt <8 x i16> %{{.*}}, %{{.*}} + // CHECK: select <8 x i1> %{{.*}}, <8 x i16> , <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: add <16 x i16> %{{.*}}, %{{.*}} + // CHECK: icmp ugt <16 x i16> %{{.*}}, %{{.*}} + // CHECK: select <16 x i1> %{{.*}}, <16 x i16> , <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: add <16 x i16> %{{.*}}, %{{.*}} + // CHECK: icmp ugt <16 x i16> %{{.*}}, %{{.*}} + // CHECK: select <16 x i1> %{{.*}}, <16 x i16> , <16 x i16> {{.*}} // CHECK: select <16 x i1> %{{.*}}, <16 x i16> %{{.*}}, <16 x i16> %{{.*}} return _mm256_maskz_adds_epu16(__U,__A,__B); } @@ -1519,102 +1609,191 @@ } __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 Index: test/CodeGen/sse2-builtins.c =================================================================== --- test/CodeGen/sse2-builtins.c +++ test/CodeGen/sse2-builtins.c @@ -47,25 +47,47 @@ __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: add <16 x i8> %{{.*}}, %{{.*}} + // CHECK: icmp ugt <16 x i8> %{{.*}}, %{{.*}} + // CHECK: select <16 x i1> %{{.*}}, <16 x i8> , <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: add <8 x i16> %{{.*}}, %{{.*}} + // CHECK: icmp ugt <8 x i16> %{{.*}}, %{{.*}} + // CHECK: select <8 x i1> %{{.*}}, <8 x i16> , <8 x i16> {{.*}} return _mm_adds_epu16(A, B); } @@ -1416,25 +1438,47 @@ __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); }