From: Chandler Carruth Date: Thu, 26 Apr 2018 21:46:01 +0000 (+0000) Subject: [x86] Revert r330322 (& r330323): Lowering x86 adds/addus/subs/subus intrinsics X-Git-Url: https://granicus.if.org/sourcecode?a=commitdiff_plain;h=b86e22b65deee32e227acae117161aab99865701;p=clang [x86] Revert r330322 (& r330323): Lowering x86 adds/addus/subs/subus intrinsics The LLVM commit introduces a crash in LLVM's instruction selection. I filed http://llvm.org/PR37260 with the test case. git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@330997 91177308-0d34-0410-b5e6-96231b3b80d8 --- diff --git a/lib/CodeGen/CGBuiltin.cpp b/lib/CodeGen/CGBuiltin.cpp index 6b2484b8c8..6a2f2b0a4a 100644 --- a/lib/CodeGen/CGBuiltin.cpp +++ b/lib/CodeGen/CGBuiltin.cpp @@ -8449,76 +8449,6 @@ 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(); @@ -9586,37 +9516,10 @@ 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 e142eea586..15a17628f4 100644 --- a/test/CodeGen/avx2-builtins.c +++ b/test/CodeGen/avx2-builtins.c @@ -56,53 +56,25 @@ __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-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> + // CHECK: call <32 x i8> @llvm.x86.avx2.padds.b(<32 x i8> %{{.*}}, <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-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> + // CHECK: call <16 x i16> @llvm.x86.avx2.padds.w(<16 x i16> %{{.*}}, <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-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> + // CHECK: call <32 x i8> @llvm.x86.avx2.paddus.b(<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-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> + // CHECK: call <16 x i16> @llvm.x86.avx2.paddus.w(<16 x i16> %{{.*}}, <16 x i16> %{{.*}}) return _mm256_adds_epu16(a, b); } @@ -1199,47 +1171,25 @@ __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-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> + // CHECK: call <32 x i8> @llvm.x86.avx2.psubs.b(<32 x i8> %{{.*}}, <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-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> + // CHECK: call <16 x i16> @llvm.x86.avx2.psubs.w(<16 x i16> %{{.*}}, <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-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> {{.*}}, {{.*}} + // CHECK: call <32 x i8> @llvm.x86.avx2.psubus.b(<32 x i8> %{{.*}}, <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-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> {{.*}}, {{.*}} + // CHECK: call <16 x i16> @llvm.x86.avx2.psubus.w(<16 x i16> %{{.*}}, <16 x i16> %{{.*}}) return _mm256_subs_epu16(a, b); } diff --git a/test/CodeGen/avx512bw-builtins.c b/test/CodeGen/avx512bw-builtins.c index 2c5c82b105..bb644c4423 100644 --- a/test/CodeGen/avx512bw-builtins.c +++ b/test/CodeGen/avx512bw-builtins.c @@ -594,154 +594,62 @@ __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-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: @llvm.x86.avx512.mask.padds.b.512 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-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); + // CHECK: @llvm.x86.avx512.mask.padds.b.512 + 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-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> %{{.*}} + // CHECK: @llvm.x86.avx512.mask.padds.b.512 return _mm512_maskz_adds_epi8(__U,__A,__B); } __m512i test_mm512_adds_epi16(__m512i __A, __m512i __B) { // CHECK-LABEL: @test_mm512_adds_epi16 - // 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); + // CHECK: @llvm.x86.avx512.mask.padds.w.512 + 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-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> %{{.*}} + // CHECK: @llvm.x86.avx512.mask.padds.w.512 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-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); + // CHECK: @llvm.x86.avx512.mask.padds.w.512 + return _mm512_maskz_adds_epi16(__U,__A,__B); } __m512i test_mm512_adds_epu8(__m512i __A, __m512i __B) { // CHECK-LABEL: @test_mm512_adds_epu8 - // 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: @llvm.x86.avx512.mask.paddus.b.512 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-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> %{{.*}} + // CHECK: @llvm.x86.avx512.mask.paddus.b.512 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-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> %{{.*}} + // CHECK: @llvm.x86.avx512.mask.paddus.b.512 return _mm512_maskz_adds_epu8(__U,__A,__B); } __m512i test_mm512_adds_epu16(__m512i __A, __m512i __B) { // CHECK-LABEL: @test_mm512_adds_epu16 - // 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: @llvm.x86.avx512.mask.paddus.w.512 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-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> %{{.*}} + // CHECK: @llvm.x86.avx512.mask.paddus.w.512 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-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> %{{.*}} + // CHECK: @llvm.x86.avx512.mask.paddus.w.512 return _mm512_maskz_adds_epu16(__U,__A,__B); } __m512i test_mm512_avg_epu8(__m512i __A, __m512i __B) { @@ -995,137 +903,63 @@ __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-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); + // CHECK: @llvm.x86.avx512.mask.psubs.b.512 + 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-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); + // CHECK: @llvm.x86.avx512.mask.psubs.b.512 + 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-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); + // CHECK: @llvm.x86.avx512.mask.psubs.b.512 + return _mm512_maskz_subs_epi8(__U,__A,__B); } __m512i test_mm512_subs_epi16(__m512i __A, __m512i __B) { // CHECK-LABEL: @test_mm512_subs_epi16 - // 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); + // CHECK: @llvm.x86.avx512.mask.psubs.w.512 + 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-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); + // CHECK: @llvm.x86.avx512.mask.psubs.w.512 + 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-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); + // CHECK: @llvm.x86.avx512.mask.psubs.w.512 + return _mm512_maskz_subs_epi16(__U,__A,__B); } __m512i test_mm512_subs_epu8(__m512i __A, __m512i __B) { // CHECK-LABEL: @test_mm512_subs_epu8 - // 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); + // CHECK: @llvm.x86.avx512.mask.psubus.b.512 + 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-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); + // CHECK: @llvm.x86.avx512.mask.psubus.b.512 + 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-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); + // CHECK: @llvm.x86.avx512.mask.psubus.b.512 + return _mm512_maskz_subs_epu8(__U,__A,__B); } __m512i test_mm512_subs_epu16(__m512i __A, __m512i __B) { // CHECK-LABEL: @test_mm512_subs_epu16 - // 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); + // CHECK: @llvm.x86.avx512.mask.psubus.w.512 + 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-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); + // CHECK: @llvm.x86.avx512.mask.psubus.w.512 + 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-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); + // CHECK: @llvm.x86.avx512.mask.psubus.w.512 + 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 a41a2efd25..7adc50c231 100644 --- a/test/CodeGen/avx512vlbw-builtins.c +++ b/test/CodeGen/avx512vlbw-builtins.c @@ -1075,211 +1075,97 @@ __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-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: @llvm.x86.sse2.padds.b // 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-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: @llvm.x86.sse2.padds.b // 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-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: @llvm.x86.avx2.padds.b // 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-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: @llvm.x86.avx2.padds.b // 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-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: @llvm.x86.sse2.padds.w // 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-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: @llvm.x86.sse2.padds.w // 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-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: @llvm.x86.avx2.padds.w // 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-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: @llvm.x86.avx2.padds.w // 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-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: @llvm.x86.sse2.paddus.b // 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-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: @llvm.x86.sse2.paddus.b // 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-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: @llvm.x86.avx2.paddus.b // 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-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: @llvm.x86.avx2.paddus.b // 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-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: @llvm.x86.sse2.paddus.w // 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-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: @llvm.x86.sse2.paddus.w // 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-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: @llvm.x86.avx2.paddus.w // 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-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: @llvm.x86.avx2.paddus.w // CHECK: select <16 x i1> %{{.*}}, <16 x i16> %{{.*}}, <16 x i16> %{{.*}} return _mm256_maskz_adds_epu16(__U,__A,__B); } @@ -1633,191 +1519,102 @@ __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-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: @llvm.x86.sse2.psubs.b // 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-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: @llvm.x86.sse2.psubs.b // 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-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: @llvm.x86.avx2.psubs.b // 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-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: @llvm.x86.avx2.psubs.b // 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-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: @llvm.x86.sse2.psubs.w // 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-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: @llvm.x86.sse2.psubs.w // 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-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: @llvm.x86.avx2.psubs.w // 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-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: @llvm.x86.avx2.psubs.w // 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-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: @llvm.x86.sse2.psubus.b // 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-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: @llvm.x86.sse2.psubus.b // 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-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: @llvm.x86.avx2.psubus.b // 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-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: @llvm.x86.avx2.psubus.b // 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-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: @llvm.x86.sse2.psubus.w // 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-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: @llvm.x86.sse2.psubus.w // 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-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: @llvm.x86.avx2.psubus.w // 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-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: @llvm.x86.avx2.psubus.w // 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 26fc939b91..4ddb121ad1 100644 --- a/test/CodeGen/sse2-builtins.c +++ b/test/CodeGen/sse2-builtins.c @@ -47,53 +47,25 @@ __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-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> + // CHECK: call <16 x i8> @llvm.x86.sse2.padds.b(<16 x i8> %{{.*}}, <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-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> + // CHECK: call <8 x i16> @llvm.x86.sse2.padds.w(<8 x i16> %{{.*}}, <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-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> + // CHECK: call <16 x i8> @llvm.x86.sse2.paddus.b(<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-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> + // CHECK: call <8 x i16> @llvm.x86.sse2.paddus.w(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) return _mm_adds_epu16(A, B); } @@ -1444,47 +1416,25 @@ __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-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> + // CHECK: call <16 x i8> @llvm.x86.sse2.psubs.b(<16 x i8> %{{.*}}, <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-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> + // CHECK: call <8 x i16> @llvm.x86.sse2.psubs.w(<8 x i16> %{{.*}}, <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-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> {{.*}}, {{.*}} + // CHECK: call <16 x i8> @llvm.x86.sse2.psubus.b(<16 x i8> %{{.*}}, <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-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> {{.*}}, {{.*}} + // CHECK: call <8 x i16> @llvm.x86.sse2.psubus.w(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) return _mm_subs_epu16(A, B); }