From 42208a201eb56931ec89793dd61a751765c86800 Mon Sep 17 00:00:00 2001 From: XChy Date: Tue, 12 Aug 2025 03:01:19 +0800 Subject: [PATCH 1/4] [VectorCombine] Precisely calculate the cost in foldInstExtBinop and avoid infinite loop --- .../Transforms/Vectorize/VectorCombine.cpp | 9 +++++++++ .../VectorCombine/binop-scalarize.ll | 19 +++++++++++++++++++ 2 files changed, 28 insertions(+) diff --git a/llvm/lib/Transforms/Vectorize/VectorCombine.cpp b/llvm/lib/Transforms/Vectorize/VectorCombine.cpp index 6345b18b809a6..31c8320bd4933 100644 --- a/llvm/lib/Transforms/Vectorize/VectorCombine.cpp +++ b/llvm/lib/Transforms/Vectorize/VectorCombine.cpp @@ -769,6 +769,11 @@ bool VectorCombine::foldInsExtBinop(Instruction &I) { if (!ResultTy) return false; + // Avoid splitting the unfoldable constant expression binop(x,y), otherwise + // binop(insert(x,a,idx),insert(y,b,idx)) may be folded back and forth. + if (match(VecBinOp, m_BinOp(m_Constant(), m_Constant()))) + return false; + // TODO: Attempt to detect m_ExtractElt for scalar operands and convert to // shuffle? @@ -1250,6 +1255,10 @@ bool VectorCombine::scalarizeOpOrCmp(Instruction &I) { InstructionCost NewCost = ScalarOpCost + TTI.getVectorInstrCost(Instruction::InsertElement, VecTy, CostKind, *Index, NewVecC); + // Additional cost for unfoldable constant expression. + if (!NewVecC) + NewCost += VectorOpCost; + for (auto [Idx, Op, VecC, Scalar] : enumerate(Ops, VecCs, ScalarOps)) { if (!Scalar || (II && isVectorIntrinsicWithScalarOpAtArg( II->getIntrinsicID(), Idx, &TTI))) diff --git a/llvm/test/Transforms/VectorCombine/binop-scalarize.ll b/llvm/test/Transforms/VectorCombine/binop-scalarize.ll index 52a706a0b59a7..bc07f8b086496 100644 --- a/llvm/test/Transforms/VectorCombine/binop-scalarize.ll +++ b/llvm/test/Transforms/VectorCombine/binop-scalarize.ll @@ -20,3 +20,22 @@ define <4 x i8> @udiv_ub(i8 %x, i8 %y) { %v = udiv <4 x i8> %x.insert, %y.insert ret <4 x i8> %v } + + +; Unfoldable constant expression may cause infinite loop between +; scalarizing insertelement and folding binop(insert(x,a,idx),insert(y,b,idx)) +@val = external hidden global ptr, align 8 + +define <2 x i64> @pr153012(i64 %idx) #0 { +; CHECK-LABEL: define <2 x i64> @pr153012( +; CHECK-SAME: i64 [[IDX:%.*]]) { +; CHECK-NEXT: [[ENTRY:.*:]] +; CHECK-NEXT: [[A:%.*]] = insertelement <2 x i64> , i64 [[IDX]], i32 0 +; CHECK-NEXT: [[B:%.*]] = or disjoint <2 x i64> splat (i64 2), [[A]] +; CHECK-NEXT: ret <2 x i64> [[B]] +; +entry: + %a = insertelement <2 x i64> , i64 %idx, i32 0 + %b = or disjoint <2 x i64> splat (i64 2), %a + ret <2 x i64> %b +} From 6a5666b3ca96b7cc823d42f717682e86dc78f4a8 Mon Sep 17 00:00:00 2001 From: XChy Date: Tue, 12 Aug 2025 12:49:38 +0800 Subject: [PATCH 2/4] fix testcases --- .../VectorCombine/X86/intrinsic-scalarize.ll | 22 +++++------- .../VectorCombine/intrinsic-scalarize.ll | 35 ++++++++----------- 2 files changed, 22 insertions(+), 35 deletions(-) diff --git a/llvm/test/Transforms/VectorCombine/X86/intrinsic-scalarize.ll b/llvm/test/Transforms/VectorCombine/X86/intrinsic-scalarize.ll index 5f3229398792a..17545bf768a64 100644 --- a/llvm/test/Transforms/VectorCombine/X86/intrinsic-scalarize.ll +++ b/llvm/test/Transforms/VectorCombine/X86/intrinsic-scalarize.ll @@ -3,19 +3,12 @@ ; RUN: opt < %s -S -p vector-combine -mtriple=x86_64 -mattr=avx2 | FileCheck %s --check-prefixes=CHECK,AVX2 define <2 x float> @maxnum(float %x, float %y) { -; SSE2-LABEL: define <2 x float> @maxnum( -; SSE2-SAME: float [[X:%.*]], float [[Y:%.*]]) #[[ATTR0:[0-9]+]] { -; SSE2-NEXT: [[X_INSERT:%.*]] = insertelement <2 x float> poison, float [[X]], i32 0 -; SSE2-NEXT: [[Y_INSERT:%.*]] = insertelement <2 x float> poison, float [[Y]], i32 0 -; SSE2-NEXT: [[V:%.*]] = call <2 x float> @llvm.maxnum.v2f32(<2 x float> [[X_INSERT]], <2 x float> [[Y_INSERT]]) -; SSE2-NEXT: ret <2 x float> [[V]] -; -; AVX2-LABEL: define <2 x float> @maxnum( -; AVX2-SAME: float [[X:%.*]], float [[Y:%.*]]) #[[ATTR0:[0-9]+]] { -; AVX2-NEXT: [[V_SCALAR:%.*]] = call float @llvm.maxnum.f32(float [[X]], float [[Y]]) -; AVX2-NEXT: [[TMP1:%.*]] = call <2 x float> @llvm.maxnum.v2f32(<2 x float> poison, <2 x float> poison) -; AVX2-NEXT: [[V:%.*]] = insertelement <2 x float> [[TMP1]], float [[V_SCALAR]], i64 0 -; AVX2-NEXT: ret <2 x float> [[V]] +; CHECK-LABEL: define <2 x float> @maxnum( +; CHECK-SAME: float [[X:%.*]], float [[Y:%.*]]) #[[ATTR0:[0-9]+]] { +; CHECK-NEXT: [[X_INSERT:%.*]] = insertelement <2 x float> poison, float [[X]], i32 0 +; CHECK-NEXT: [[Y_INSERT:%.*]] = insertelement <2 x float> poison, float [[Y]], i32 0 +; CHECK-NEXT: [[V:%.*]] = call <2 x float> @llvm.maxnum.v2f32(<2 x float> [[X_INSERT]], <2 x float> [[Y_INSERT]]) +; CHECK-NEXT: ret <2 x float> [[V]] ; %x.insert = insertelement <2 x float> poison, float %x, i32 0 %y.insert = insertelement <2 x float> poison, float %y, i32 0 @@ -23,4 +16,5 @@ define <2 x float> @maxnum(float %x, float %y) { ret <2 x float> %v } ;; NOTE: These prefixes are unused and the list is autogenerated. Do not add tests below this line: -; CHECK: {{.*}} +; AVX2: {{.*}} +; SSE2: {{.*}} diff --git a/llvm/test/Transforms/VectorCombine/intrinsic-scalarize.ll b/llvm/test/Transforms/VectorCombine/intrinsic-scalarize.ll index 9e43a28bf1e59..775f7ebf7a55f 100644 --- a/llvm/test/Transforms/VectorCombine/intrinsic-scalarize.ll +++ b/llvm/test/Transforms/VectorCombine/intrinsic-scalarize.ll @@ -32,9 +32,8 @@ define @umax_scalable(i32 %x, i32 %y) { define <4 x i32> @umax_fixed_lhs_const(i32 %x) { ; CHECK-LABEL: define <4 x i32> @umax_fixed_lhs_const( ; CHECK-SAME: i32 [[X:%.*]]) { -; CHECK-NEXT: [[V_SCALAR:%.*]] = call i32 @llvm.umax.i32(i32 1, i32 [[X]]) -; CHECK-NEXT: [[TMP1:%.*]] = call <4 x i32> @llvm.umax.v4i32(<4 x i32> , <4 x i32> poison) -; CHECK-NEXT: [[V:%.*]] = insertelement <4 x i32> [[TMP1]], i32 [[V_SCALAR]], i64 0 +; CHECK-NEXT: [[X_INSERT:%.*]] = insertelement <4 x i32> poison, i32 [[X]], i32 0 +; CHECK-NEXT: [[V:%.*]] = call <4 x i32> @llvm.umax.v4i32(<4 x i32> , <4 x i32> [[X_INSERT]]) ; CHECK-NEXT: ret <4 x i32> [[V]] ; %x.insert = insertelement <4 x i32> poison, i32 %x, i32 0 @@ -45,9 +44,8 @@ define <4 x i32> @umax_fixed_lhs_const(i32 %x) { define <4 x i32> @umax_fixed_rhs_const(i32 %x) { ; CHECK-LABEL: define <4 x i32> @umax_fixed_rhs_const( ; CHECK-SAME: i32 [[X:%.*]]) { -; CHECK-NEXT: [[V_SCALAR:%.*]] = call i32 @llvm.umax.i32(i32 [[X]], i32 1) -; CHECK-NEXT: [[TMP1:%.*]] = call <4 x i32> @llvm.umax.v4i32(<4 x i32> poison, <4 x i32> ) -; CHECK-NEXT: [[V:%.*]] = insertelement <4 x i32> [[TMP1]], i32 [[V_SCALAR]], i64 0 +; CHECK-NEXT: [[X_INSERT:%.*]] = insertelement <4 x i32> poison, i32 [[X]], i32 0 +; CHECK-NEXT: [[V:%.*]] = call <4 x i32> @llvm.umax.v4i32(<4 x i32> [[X_INSERT]], <4 x i32> ) ; CHECK-NEXT: ret <4 x i32> [[V]] ; %x.insert = insertelement <4 x i32> poison, i32 %x, i32 0 @@ -58,9 +56,8 @@ define <4 x i32> @umax_fixed_rhs_const(i32 %x) { define @umax_scalable_lhs_const(i32 %x) { ; CHECK-LABEL: define @umax_scalable_lhs_const( ; CHECK-SAME: i32 [[X:%.*]]) { -; CHECK-NEXT: [[V_SCALAR:%.*]] = call i32 @llvm.umax.i32(i32 42, i32 [[X]]) -; CHECK-NEXT: [[TMP1:%.*]] = call @llvm.umax.nxv4i32( splat (i32 42), poison) -; CHECK-NEXT: [[V:%.*]] = insertelement [[TMP1]], i32 [[V_SCALAR]], i64 0 +; CHECK-NEXT: [[X_INSERT:%.*]] = insertelement poison, i32 [[X]], i32 0 +; CHECK-NEXT: [[V:%.*]] = call @llvm.umax.nxv4i32( splat (i32 42), [[X_INSERT]]) ; CHECK-NEXT: ret [[V]] ; %x.insert = insertelement poison, i32 %x, i32 0 @@ -71,9 +68,8 @@ define @umax_scalable_lhs_const(i32 %x) { define @umax_scalable_rhs_const(i32 %x) { ; CHECK-LABEL: define @umax_scalable_rhs_const( ; CHECK-SAME: i32 [[X:%.*]]) { -; CHECK-NEXT: [[V_SCALAR:%.*]] = call i32 @llvm.umax.i32(i32 [[X]], i32 42) -; CHECK-NEXT: [[TMP1:%.*]] = call @llvm.umax.nxv4i32( poison, splat (i32 42)) -; CHECK-NEXT: [[V:%.*]] = insertelement [[TMP1]], i32 [[V_SCALAR]], i64 0 +; CHECK-NEXT: [[X_INSERT:%.*]] = insertelement poison, i32 [[X]], i32 0 +; CHECK-NEXT: [[V:%.*]] = call @llvm.umax.nxv4i32( [[X_INSERT]], splat (i32 42)) ; CHECK-NEXT: ret [[V]] ; %x.insert = insertelement poison, i32 %x, i32 0 @@ -99,9 +95,8 @@ define <4 x i32> @non_trivially_vectorizable(i32 %x, i32 %y) { define <4 x float> @fabs_fixed(float %x) { ; CHECK-LABEL: define <4 x float> @fabs_fixed( ; CHECK-SAME: float [[X:%.*]]) { -; CHECK-NEXT: [[V_SCALAR:%.*]] = call float @llvm.fabs.f32(float [[X]]) -; CHECK-NEXT: [[TMP1:%.*]] = call <4 x float> @llvm.fabs.v4f32(<4 x float> poison) -; CHECK-NEXT: [[V:%.*]] = insertelement <4 x float> [[TMP1]], float [[V_SCALAR]], i64 0 +; CHECK-NEXT: [[X_INSERT:%.*]] = insertelement <4 x float> poison, float [[X]], i32 0 +; CHECK-NEXT: [[V:%.*]] = call <4 x float> @llvm.fabs.v4f32(<4 x float> [[X_INSERT]]) ; CHECK-NEXT: ret <4 x float> [[V]] ; %x.insert = insertelement <4 x float> poison, float %x, i32 0 @@ -112,9 +107,8 @@ define <4 x float> @fabs_fixed(float %x) { define @fabs_scalable(float %x) { ; CHECK-LABEL: define @fabs_scalable( ; CHECK-SAME: float [[X:%.*]]) { -; CHECK-NEXT: [[V_SCALAR:%.*]] = call float @llvm.fabs.f32(float [[X]]) -; CHECK-NEXT: [[TMP1:%.*]] = call @llvm.fabs.nxv4f32( poison) -; CHECK-NEXT: [[V:%.*]] = insertelement [[TMP1]], float [[V_SCALAR]], i64 0 +; CHECK-NEXT: [[X_INSERT:%.*]] = insertelement poison, float [[X]], i32 0 +; CHECK-NEXT: [[V:%.*]] = call @llvm.fabs.nxv4f32( [[X_INSERT]]) ; CHECK-NEXT: ret [[V]] ; %x.insert = insertelement poison, float %x, i32 0 @@ -155,9 +149,8 @@ define @fma_scalable(float %x, float %y, float %z) { define <4 x float> @scalar_argument(float %x) { ; CHECK-LABEL: define <4 x float> @scalar_argument( ; CHECK-SAME: float [[X:%.*]]) { -; CHECK-NEXT: [[V_SCALAR:%.*]] = call float @llvm.powi.f32.i32(float [[X]], i32 42) -; CHECK-NEXT: [[TMP1:%.*]] = call <4 x float> @llvm.powi.v4f32.i32(<4 x float> poison, i32 42) -; CHECK-NEXT: [[V:%.*]] = insertelement <4 x float> [[TMP1]], float [[V_SCALAR]], i64 0 +; CHECK-NEXT: [[X_INSERT:%.*]] = insertelement <4 x float> poison, float [[X]], i32 0 +; CHECK-NEXT: [[V:%.*]] = call <4 x float> @llvm.powi.v4f32.i32(<4 x float> [[X_INSERT]], i32 42) ; CHECK-NEXT: ret <4 x float> [[V]] ; %x.insert = insertelement <4 x float> poison, float %x, i32 0 From 716a5b1cdb8c466c7a0692cd3c86a0329371ee05 Mon Sep 17 00:00:00 2001 From: XChy Date: Fri, 15 Aug 2025 02:32:07 +0800 Subject: [PATCH 3/4] fix comment and testcase --- llvm/lib/Transforms/Vectorize/VectorCombine.cpp | 3 ++- .../Transforms/VectorCombine/X86/intrinsic-scalarize.ll | 7 ++----- 2 files changed, 4 insertions(+), 6 deletions(-) diff --git a/llvm/lib/Transforms/Vectorize/VectorCombine.cpp b/llvm/lib/Transforms/Vectorize/VectorCombine.cpp index 31c8320bd4933..74cccc950ae78 100644 --- a/llvm/lib/Transforms/Vectorize/VectorCombine.cpp +++ b/llvm/lib/Transforms/Vectorize/VectorCombine.cpp @@ -770,7 +770,8 @@ bool VectorCombine::foldInsExtBinop(Instruction &I) { return false; // Avoid splitting the unfoldable constant expression binop(x,y), otherwise - // binop(insert(x,a,idx),insert(y,b,idx)) may be folded back and forth. + // binop(insert(x,a,idx),insert(y,b,idx)) may be folded back and forth due to + // the possible cost table mismatch. if (match(VecBinOp, m_BinOp(m_Constant(), m_Constant()))) return false; diff --git a/llvm/test/Transforms/VectorCombine/X86/intrinsic-scalarize.ll b/llvm/test/Transforms/VectorCombine/X86/intrinsic-scalarize.ll index 17545bf768a64..ba62913c574f5 100644 --- a/llvm/test/Transforms/VectorCombine/X86/intrinsic-scalarize.ll +++ b/llvm/test/Transforms/VectorCombine/X86/intrinsic-scalarize.ll @@ -1,6 +1,6 @@ ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --version 5 -; RUN: opt < %s -S -p vector-combine -mtriple=x86_64 -mattr=sse2 | FileCheck %s --check-prefixes=CHECK,SSE2 -; RUN: opt < %s -S -p vector-combine -mtriple=x86_64 -mattr=avx2 | FileCheck %s --check-prefixes=CHECK,AVX2 +; RUN: opt < %s -S -p vector-combine -mtriple=x86_64 -mattr=sse2 | FileCheck %s +; RUN: opt < %s -S -p vector-combine -mtriple=x86_64 -mattr=avx2 | FileCheck %s define <2 x float> @maxnum(float %x, float %y) { ; CHECK-LABEL: define <2 x float> @maxnum( @@ -15,6 +15,3 @@ define <2 x float> @maxnum(float %x, float %y) { %v = call <2 x float> @llvm.maxnum(<2 x float> %x.insert, <2 x float> %y.insert) ret <2 x float> %v } -;; NOTE: These prefixes are unused and the list is autogenerated. Do not add tests below this line: -; AVX2: {{.*}} -; SSE2: {{.*}} From 2f15724315ff394eb79f02ab83705230b64a02f7 Mon Sep 17 00:00:00 2001 From: XChy Date: Fri, 15 Aug 2025 18:19:42 +0800 Subject: [PATCH 4/4] Use InstSimplify --- .../Transforms/Vectorize/VectorCombine.cpp | 36 +++++------------ .../VectorCombine/X86/intrinsic-scalarize.ll | 24 +++++++---- .../VectorCombine/intrinsic-scalarize.ll | 40 +++++++++---------- 3 files changed, 44 insertions(+), 56 deletions(-) diff --git a/llvm/lib/Transforms/Vectorize/VectorCombine.cpp b/llvm/lib/Transforms/Vectorize/VectorCombine.cpp index 74cccc950ae78..f551216d994ca 100644 --- a/llvm/lib/Transforms/Vectorize/VectorCombine.cpp +++ b/llvm/lib/Transforms/Vectorize/VectorCombine.cpp @@ -74,7 +74,7 @@ class VectorCombine { const DataLayout *DL, TTI::TargetCostKind CostKind, bool TryEarlyFoldsOnly) : F(F), Builder(F.getContext(), InstSimplifyFolder(*DL)), TTI(TTI), - DT(DT), AA(AA), AC(AC), DL(DL), CostKind(CostKind), + DT(DT), AA(AA), AC(AC), DL(DL), CostKind(CostKind), SQ(*DL), TryEarlyFoldsOnly(TryEarlyFoldsOnly) {} bool run(); @@ -88,6 +88,7 @@ class VectorCombine { AssumptionCache &AC; const DataLayout *DL; TTI::TargetCostKind CostKind; + const SimplifyQuery SQ; /// If true, only perform beneficial early IR transforms. Do not introduce new /// vector operations. @@ -769,12 +770,6 @@ bool VectorCombine::foldInsExtBinop(Instruction &I) { if (!ResultTy) return false; - // Avoid splitting the unfoldable constant expression binop(x,y), otherwise - // binop(insert(x,a,idx),insert(y,b,idx)) may be folded back and forth due to - // the possible cost table mismatch. - if (match(VecBinOp, m_BinOp(m_Constant(), m_Constant()))) - return false; - // TODO: Attempt to detect m_ExtractElt for scalar operands and convert to // shuffle? @@ -1238,17 +1233,18 @@ bool VectorCombine::scalarizeOpOrCmp(Instruction &I) { // Fold the vector constants in the original vectors into a new base vector to // get more accurate cost modelling. Value *NewVecC = nullptr; - TargetFolder Folder(*DL); if (CI) - NewVecC = Folder.FoldCmp(CI->getPredicate(), VecCs[0], VecCs[1]); + NewVecC = simplifyCmpInst(CI->getPredicate(), VecCs[0], VecCs[1], SQ); else if (UO) NewVecC = - Folder.FoldUnOpFMF(UO->getOpcode(), VecCs[0], UO->getFastMathFlags()); + simplifyUnOp(UO->getOpcode(), VecCs[0], UO->getFastMathFlags(), SQ); else if (BO) - NewVecC = Folder.FoldBinOp(BO->getOpcode(), VecCs[0], VecCs[1]); - else if (II->arg_size() == 2) - NewVecC = Folder.FoldBinaryIntrinsic(II->getIntrinsicID(), VecCs[0], - VecCs[1], II->getType(), &I); + NewVecC = simplifyBinOp(BO->getOpcode(), VecCs[0], VecCs[1], SQ); + else if (II) + NewVecC = simplifyCall(II, II->getCalledOperand(), VecCs, SQ); + + if (!NewVecC) + return false; // Get cost estimate for the insert element. This cost will factor into // both sequences. @@ -1256,9 +1252,6 @@ bool VectorCombine::scalarizeOpOrCmp(Instruction &I) { InstructionCost NewCost = ScalarOpCost + TTI.getVectorInstrCost(Instruction::InsertElement, VecTy, CostKind, *Index, NewVecC); - // Additional cost for unfoldable constant expression. - if (!NewVecC) - NewCost += VectorOpCost; for (auto [Idx, Op, VecC, Scalar] : enumerate(Ops, VecCs, ScalarOps)) { if (!Scalar || (II && isVectorIntrinsicWithScalarOpAtArg( @@ -1304,15 +1297,6 @@ bool VectorCombine::scalarizeOpOrCmp(Instruction &I) { if (auto *ScalarInst = dyn_cast(Scalar)) ScalarInst->copyIRFlags(&I); - // Create a new base vector if the constant folding failed. - if (!NewVecC) { - if (CI) - NewVecC = Builder.CreateCmp(CI->getPredicate(), VecCs[0], VecCs[1]); - else if (UO || BO) - NewVecC = Builder.CreateNAryOp(Opcode, VecCs); - else - NewVecC = Builder.CreateIntrinsic(VecTy, II->getIntrinsicID(), VecCs); - } Value *Insert = Builder.CreateInsertElement(NewVecC, Scalar, *Index); replaceValue(I, *Insert); return true; diff --git a/llvm/test/Transforms/VectorCombine/X86/intrinsic-scalarize.ll b/llvm/test/Transforms/VectorCombine/X86/intrinsic-scalarize.ll index ba62913c574f5..ad5f5a7107c2b 100644 --- a/llvm/test/Transforms/VectorCombine/X86/intrinsic-scalarize.ll +++ b/llvm/test/Transforms/VectorCombine/X86/intrinsic-scalarize.ll @@ -1,17 +1,25 @@ ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --version 5 -; RUN: opt < %s -S -p vector-combine -mtriple=x86_64 -mattr=sse2 | FileCheck %s -; RUN: opt < %s -S -p vector-combine -mtriple=x86_64 -mattr=avx2 | FileCheck %s +; RUN: opt < %s -S -p vector-combine -mtriple=x86_64 -mattr=sse2 | FileCheck %s --check-prefixes=CHECK,SSE2 +; RUN: opt < %s -S -p vector-combine -mtriple=x86_64 -mattr=avx2 | FileCheck %s --check-prefixes=CHECK,AVX2 define <2 x float> @maxnum(float %x, float %y) { -; CHECK-LABEL: define <2 x float> @maxnum( -; CHECK-SAME: float [[X:%.*]], float [[Y:%.*]]) #[[ATTR0:[0-9]+]] { -; CHECK-NEXT: [[X_INSERT:%.*]] = insertelement <2 x float> poison, float [[X]], i32 0 -; CHECK-NEXT: [[Y_INSERT:%.*]] = insertelement <2 x float> poison, float [[Y]], i32 0 -; CHECK-NEXT: [[V:%.*]] = call <2 x float> @llvm.maxnum.v2f32(<2 x float> [[X_INSERT]], <2 x float> [[Y_INSERT]]) -; CHECK-NEXT: ret <2 x float> [[V]] +; SSE2-LABEL: define <2 x float> @maxnum( +; SSE2-SAME: float [[X:%.*]], float [[Y:%.*]]) #[[ATTR0:[0-9]+]] { +; SSE2-NEXT: [[X_INSERT:%.*]] = insertelement <2 x float> poison, float [[X]], i32 0 +; SSE2-NEXT: [[Y_INSERT:%.*]] = insertelement <2 x float> poison, float [[Y]], i32 0 +; SSE2-NEXT: [[V:%.*]] = call <2 x float> @llvm.maxnum.v2f32(<2 x float> [[X_INSERT]], <2 x float> [[Y_INSERT]]) +; SSE2-NEXT: ret <2 x float> [[V]] +; +; AVX2-LABEL: define <2 x float> @maxnum( +; AVX2-SAME: float [[X:%.*]], float [[Y:%.*]]) #[[ATTR0:[0-9]+]] { +; AVX2-NEXT: [[V_SCALAR:%.*]] = call float @llvm.maxnum.f32(float [[X]], float [[Y]]) +; AVX2-NEXT: [[V:%.*]] = insertelement <2 x float> poison, float [[V_SCALAR]], i64 0 +; AVX2-NEXT: ret <2 x float> [[V]] ; %x.insert = insertelement <2 x float> poison, float %x, i32 0 %y.insert = insertelement <2 x float> poison, float %y, i32 0 %v = call <2 x float> @llvm.maxnum(<2 x float> %x.insert, <2 x float> %y.insert) ret <2 x float> %v } +;; NOTE: These prefixes are unused and the list is autogenerated. Do not add tests below this line: +; CHECK: {{.*}} diff --git a/llvm/test/Transforms/VectorCombine/intrinsic-scalarize.ll b/llvm/test/Transforms/VectorCombine/intrinsic-scalarize.ll index 775f7ebf7a55f..abd98a4dc64b8 100644 --- a/llvm/test/Transforms/VectorCombine/intrinsic-scalarize.ll +++ b/llvm/test/Transforms/VectorCombine/intrinsic-scalarize.ll @@ -5,8 +5,7 @@ define <4 x i32> @umax_fixed(i32 %x, i32 %y) { ; CHECK-LABEL: define <4 x i32> @umax_fixed( ; CHECK-SAME: i32 [[X:%.*]], i32 [[Y:%.*]]) { ; CHECK-NEXT: [[V_SCALAR:%.*]] = call i32 @llvm.umax.i32(i32 [[X]], i32 [[Y]]) -; CHECK-NEXT: [[TMP1:%.*]] = call <4 x i32> @llvm.umax.v4i32(<4 x i32> poison, <4 x i32> poison) -; CHECK-NEXT: [[V:%.*]] = insertelement <4 x i32> [[TMP1]], i32 [[V_SCALAR]], i64 0 +; CHECK-NEXT: [[V:%.*]] = insertelement <4 x i32> poison, i32 [[V_SCALAR]], i64 0 ; CHECK-NEXT: ret <4 x i32> [[V]] ; %x.insert = insertelement <4 x i32> poison, i32 %x, i32 0 @@ -19,8 +18,7 @@ define @umax_scalable(i32 %x, i32 %y) { ; CHECK-LABEL: define @umax_scalable( ; CHECK-SAME: i32 [[X:%.*]], i32 [[Y:%.*]]) { ; CHECK-NEXT: [[V_SCALAR:%.*]] = call i32 @llvm.umax.i32(i32 [[X]], i32 [[Y]]) -; CHECK-NEXT: [[TMP1:%.*]] = call @llvm.umax.nxv4i32( poison, poison) -; CHECK-NEXT: [[V:%.*]] = insertelement [[TMP1]], i32 [[V_SCALAR]], i64 0 +; CHECK-NEXT: [[V:%.*]] = insertelement poison, i32 [[V_SCALAR]], i64 0 ; CHECK-NEXT: ret [[V]] ; %x.insert = insertelement poison, i32 %x, i32 0 @@ -32,8 +30,8 @@ define @umax_scalable(i32 %x, i32 %y) { define <4 x i32> @umax_fixed_lhs_const(i32 %x) { ; CHECK-LABEL: define <4 x i32> @umax_fixed_lhs_const( ; CHECK-SAME: i32 [[X:%.*]]) { -; CHECK-NEXT: [[X_INSERT:%.*]] = insertelement <4 x i32> poison, i32 [[X]], i32 0 -; CHECK-NEXT: [[V:%.*]] = call <4 x i32> @llvm.umax.v4i32(<4 x i32> , <4 x i32> [[X_INSERT]]) +; CHECK-NEXT: [[V_SCALAR:%.*]] = call i32 @llvm.umax.i32(i32 1, i32 [[X]]) +; CHECK-NEXT: [[V:%.*]] = insertelement <4 x i32> poison, i32 [[V_SCALAR]], i64 0 ; CHECK-NEXT: ret <4 x i32> [[V]] ; %x.insert = insertelement <4 x i32> poison, i32 %x, i32 0 @@ -44,8 +42,8 @@ define <4 x i32> @umax_fixed_lhs_const(i32 %x) { define <4 x i32> @umax_fixed_rhs_const(i32 %x) { ; CHECK-LABEL: define <4 x i32> @umax_fixed_rhs_const( ; CHECK-SAME: i32 [[X:%.*]]) { -; CHECK-NEXT: [[X_INSERT:%.*]] = insertelement <4 x i32> poison, i32 [[X]], i32 0 -; CHECK-NEXT: [[V:%.*]] = call <4 x i32> @llvm.umax.v4i32(<4 x i32> [[X_INSERT]], <4 x i32> ) +; CHECK-NEXT: [[V_SCALAR:%.*]] = call i32 @llvm.umax.i32(i32 [[X]], i32 1) +; CHECK-NEXT: [[V:%.*]] = insertelement <4 x i32> poison, i32 [[V_SCALAR]], i64 0 ; CHECK-NEXT: ret <4 x i32> [[V]] ; %x.insert = insertelement <4 x i32> poison, i32 %x, i32 0 @@ -56,8 +54,8 @@ define <4 x i32> @umax_fixed_rhs_const(i32 %x) { define @umax_scalable_lhs_const(i32 %x) { ; CHECK-LABEL: define @umax_scalable_lhs_const( ; CHECK-SAME: i32 [[X:%.*]]) { -; CHECK-NEXT: [[X_INSERT:%.*]] = insertelement poison, i32 [[X]], i32 0 -; CHECK-NEXT: [[V:%.*]] = call @llvm.umax.nxv4i32( splat (i32 42), [[X_INSERT]]) +; CHECK-NEXT: [[V_SCALAR:%.*]] = call i32 @llvm.umax.i32(i32 42, i32 [[X]]) +; CHECK-NEXT: [[V:%.*]] = insertelement poison, i32 [[V_SCALAR]], i64 0 ; CHECK-NEXT: ret [[V]] ; %x.insert = insertelement poison, i32 %x, i32 0 @@ -68,8 +66,8 @@ define @umax_scalable_lhs_const(i32 %x) { define @umax_scalable_rhs_const(i32 %x) { ; CHECK-LABEL: define @umax_scalable_rhs_const( ; CHECK-SAME: i32 [[X:%.*]]) { -; CHECK-NEXT: [[X_INSERT:%.*]] = insertelement poison, i32 [[X]], i32 0 -; CHECK-NEXT: [[V:%.*]] = call @llvm.umax.nxv4i32( [[X_INSERT]], splat (i32 42)) +; CHECK-NEXT: [[V_SCALAR:%.*]] = call i32 @llvm.umax.i32(i32 [[X]], i32 42) +; CHECK-NEXT: [[V:%.*]] = insertelement poison, i32 [[V_SCALAR]], i64 0 ; CHECK-NEXT: ret [[V]] ; %x.insert = insertelement poison, i32 %x, i32 0 @@ -95,8 +93,8 @@ define <4 x i32> @non_trivially_vectorizable(i32 %x, i32 %y) { define <4 x float> @fabs_fixed(float %x) { ; CHECK-LABEL: define <4 x float> @fabs_fixed( ; CHECK-SAME: float [[X:%.*]]) { -; CHECK-NEXT: [[X_INSERT:%.*]] = insertelement <4 x float> poison, float [[X]], i32 0 -; CHECK-NEXT: [[V:%.*]] = call <4 x float> @llvm.fabs.v4f32(<4 x float> [[X_INSERT]]) +; CHECK-NEXT: [[V_SCALAR:%.*]] = call float @llvm.fabs.f32(float [[X]]) +; CHECK-NEXT: [[V:%.*]] = insertelement <4 x float> poison, float [[V_SCALAR]], i64 0 ; CHECK-NEXT: ret <4 x float> [[V]] ; %x.insert = insertelement <4 x float> poison, float %x, i32 0 @@ -107,8 +105,8 @@ define <4 x float> @fabs_fixed(float %x) { define @fabs_scalable(float %x) { ; CHECK-LABEL: define @fabs_scalable( ; CHECK-SAME: float [[X:%.*]]) { -; CHECK-NEXT: [[X_INSERT:%.*]] = insertelement poison, float [[X]], i32 0 -; CHECK-NEXT: [[V:%.*]] = call @llvm.fabs.nxv4f32( [[X_INSERT]]) +; CHECK-NEXT: [[V_SCALAR:%.*]] = call float @llvm.fabs.f32(float [[X]]) +; CHECK-NEXT: [[V:%.*]] = insertelement poison, float [[V_SCALAR]], i64 0 ; CHECK-NEXT: ret [[V]] ; %x.insert = insertelement poison, float %x, i32 0 @@ -120,8 +118,7 @@ define <4 x float> @fma_fixed(float %x, float %y, float %z) { ; CHECK-LABEL: define <4 x float> @fma_fixed( ; CHECK-SAME: float [[X:%.*]], float [[Y:%.*]], float [[Z:%.*]]) { ; CHECK-NEXT: [[V_SCALAR:%.*]] = call float @llvm.fma.f32(float [[X]], float [[Y]], float [[Z]]) -; CHECK-NEXT: [[TMP1:%.*]] = call <4 x float> @llvm.fma.v4f32(<4 x float> poison, <4 x float> poison, <4 x float> poison) -; CHECK-NEXT: [[V:%.*]] = insertelement <4 x float> [[TMP1]], float [[V_SCALAR]], i64 0 +; CHECK-NEXT: [[V:%.*]] = insertelement <4 x float> poison, float [[V_SCALAR]], i64 0 ; CHECK-NEXT: ret <4 x float> [[V]] ; %x.insert = insertelement <4 x float> poison, float %x, i32 0 @@ -135,8 +132,7 @@ define @fma_scalable(float %x, float %y, float %z) { ; CHECK-LABEL: define @fma_scalable( ; CHECK-SAME: float [[X:%.*]], float [[Y:%.*]], float [[Z:%.*]]) { ; CHECK-NEXT: [[V_SCALAR:%.*]] = call float @llvm.fma.f32(float [[X]], float [[Y]], float [[Z]]) -; CHECK-NEXT: [[TMP1:%.*]] = call @llvm.fma.nxv4f32( poison, poison, poison) -; CHECK-NEXT: [[V:%.*]] = insertelement [[TMP1]], float [[V_SCALAR]], i64 0 +; CHECK-NEXT: [[V:%.*]] = insertelement poison, float [[V_SCALAR]], i64 0 ; CHECK-NEXT: ret [[V]] ; %x.insert = insertelement poison, float %x, i32 0 @@ -149,8 +145,8 @@ define @fma_scalable(float %x, float %y, float %z) { define <4 x float> @scalar_argument(float %x) { ; CHECK-LABEL: define <4 x float> @scalar_argument( ; CHECK-SAME: float [[X:%.*]]) { -; CHECK-NEXT: [[X_INSERT:%.*]] = insertelement <4 x float> poison, float [[X]], i32 0 -; CHECK-NEXT: [[V:%.*]] = call <4 x float> @llvm.powi.v4f32.i32(<4 x float> [[X_INSERT]], i32 42) +; CHECK-NEXT: [[V_SCALAR:%.*]] = call float @llvm.powi.f32.i32(float [[X]], i32 42) +; CHECK-NEXT: [[V:%.*]] = insertelement <4 x float> poison, float [[V_SCALAR]], i64 0 ; CHECK-NEXT: ret <4 x float> [[V]] ; %x.insert = insertelement <4 x float> poison, float %x, i32 0