From 6080387f136af5a51bbc310abb08c7158d7cd9d2 Mon Sep 17 00:00:00 2001 From: Sanjay Patel Date: Sun, 15 Dec 2019 09:32:03 -0500 Subject: [PATCH] [InstSimplify] fold splat of inserted constant to vector constant shuf (inselt ?, C, IndexC), undef, --> This is another missing shuffle fold pattern uncovered by the shuffle correctness fix from D70246. The problem was visible in the post-commit thread example, but we managed to overcome the limitation for that particular case with D71220. This is something like the inverse of the previous fix - there we didn't demand the inserted scalar, and here we are only demanding an inserted scalar. Differential Revision: https://reviews.llvm.org/D71488 --- llvm/lib/Analysis/InstructionSimplify.cpp | 24 ++++++++++++++++++++++ .../InstCombine/insert-extract-shuffle.ll | 3 +-- llvm/test/Transforms/InstSimplify/shufflevector.ll | 12 +++-------- 3 files changed, 28 insertions(+), 11 deletions(-) diff --git a/llvm/lib/Analysis/InstructionSimplify.cpp b/llvm/lib/Analysis/InstructionSimplify.cpp index fd67078..afcca2a 100644 --- a/llvm/lib/Analysis/InstructionSimplify.cpp +++ b/llvm/lib/Analysis/InstructionSimplify.cpp @@ -4452,6 +4452,30 @@ static Value *SimplifyShuffleVectorInst(Value *Op0, Value *Op1, Constant *Mask, ShuffleVectorInst::commuteShuffleMask(Indices, InVecNumElts); } + // A splat of an inserted scalar constant becomes a vector constant: + // shuf (inselt ?, C, IndexC), undef, --> + // NOTE: We may have commuted above, so analyze the updated Indices, not the + // original mask constant. + Constant *C; + ConstantInt *IndexC; + if (match(Op0, m_InsertElement(m_Value(), m_Constant(C), + m_ConstantInt(IndexC)))) { + // Match a splat shuffle mask of the insert index allowing undef elements. + int InsertIndex = IndexC->getZExtValue(); + if (all_of(Indices, [InsertIndex](int MaskElt) { + return MaskElt == InsertIndex || MaskElt == -1; + })) { + assert(isa(Op1) && "Expected undef operand 1 for splat"); + + // Shuffle mask undefs become undefined constant result elements. + SmallVector VecC(MaskNumElts, C); + for (unsigned i = 0; i != MaskNumElts; ++i) + if (Indices[i] == -1) + VecC[i] = UndefValue::get(C->getType()); + return ConstantVector::get(VecC); + } + } + // A shuffle of a splat is always the splat itself. Legal if the shuffle's // value type is same as the input vectors' type. if (auto *OpShuf = dyn_cast(Op0)) diff --git a/llvm/test/Transforms/InstCombine/insert-extract-shuffle.ll b/llvm/test/Transforms/InstCombine/insert-extract-shuffle.ll index 83fd7b6..d29bcc7 100644 --- a/llvm/test/Transforms/InstCombine/insert-extract-shuffle.ll +++ b/llvm/test/Transforms/InstCombine/insert-extract-shuffle.ll @@ -725,8 +725,7 @@ define <4 x float> @insert_demanded_element_op1(<4 x float> %x, <4 x float> %y) define <4 x float> @splat_constant(<4 x float> %x) { ; CHECK-LABEL: @splat_constant( ; CHECK-NEXT: [[INS3:%.*]] = insertelement <4 x float> [[X:%.*]], float 3.000000e+00, i32 3 -; CHECK-NEXT: [[SPLAT3:%.*]] = shufflevector <4 x float> [[INS3]], <4 x float> undef, <4 x i32> -; CHECK-NEXT: [[R:%.*]] = fadd <4 x float> [[INS3]], [[SPLAT3]] +; CHECK-NEXT: [[R:%.*]] = fadd <4 x float> [[INS3]], ; CHECK-NEXT: ret <4 x float> [[R]] ; %ins3 = insertelement <4 x float> %x, float 3.0, i32 3 diff --git a/llvm/test/Transforms/InstSimplify/shufflevector.ll b/llvm/test/Transforms/InstSimplify/shufflevector.ll index 38d605f..14c4205 100644 --- a/llvm/test/Transforms/InstSimplify/shufflevector.ll +++ b/llvm/test/Transforms/InstSimplify/shufflevector.ll @@ -250,9 +250,7 @@ define <2 x float> @PR32872(<2 x float> %x) { define <5 x i8> @splat_inserted_constant(<4 x i8> %x) { ; CHECK-LABEL: @splat_inserted_constant( -; CHECK-NEXT: [[INS3:%.*]] = insertelement <4 x i8> [[X:%.*]], i8 42, i64 3 -; CHECK-NEXT: [[SPLAT5:%.*]] = shufflevector <4 x i8> [[INS3]], <4 x i8> undef, <5 x i32> -; CHECK-NEXT: ret <5 x i8> [[SPLAT5]] +; CHECK-NEXT: ret <5 x i8> ; %ins3 = insertelement <4 x i8> %x, i8 42, i64 3 %splat5 = shufflevector <4 x i8> %ins3, <4 x i8> undef, <5 x i32> @@ -261,9 +259,7 @@ define <5 x i8> @splat_inserted_constant(<4 x i8> %x) { define <4 x float> @splat_inserted_constant_undef_elt(<4 x float> %x) { ; CHECK-LABEL: @splat_inserted_constant_undef_elt( -; CHECK-NEXT: [[INS1:%.*]] = insertelement <4 x float> [[X:%.*]], float 1.200000e+01, i32 1 -; CHECK-NEXT: [[SPLAT1:%.*]] = shufflevector <4 x float> [[INS1]], <4 x float> undef, <4 x i32> -; CHECK-NEXT: ret <4 x float> [[SPLAT1]] +; CHECK-NEXT: ret <4 x float> ; %ins1 = insertelement <4 x float> %x, float 12.0, i32 1 %splat1 = shufflevector <4 x float> %ins1, <4 x float> undef, <4 x i32> @@ -272,9 +268,7 @@ define <4 x float> @splat_inserted_constant_undef_elt(<4 x float> %x) { define <2 x i8> @splat_inserted_constant_not_canonical(<3 x i8> %x, <3 x i8> %y) { ; CHECK-LABEL: @splat_inserted_constant_not_canonical( -; CHECK-NEXT: [[INS2:%.*]] = insertelement <3 x i8> [[X:%.*]], i8 23, i7 2 -; CHECK-NEXT: [[SPLAT2:%.*]] = shufflevector <3 x i8> [[Y:%.*]], <3 x i8> [[INS2]], <2 x i32> -; CHECK-NEXT: ret <2 x i8> [[SPLAT2]] +; CHECK-NEXT: ret <2 x i8> ; %ins2 = insertelement <3 x i8> %x, i8 23, i7 2 %splat2 = shufflevector <3 x i8> %y, <3 x i8> %ins2, <2 x i32> -- 2.7.4