Skip to content

Commit d9a5aa8

Browse files
nikicnikic
authored
[PatternMatch] Do not accept undef elements in m_AllOnes() and friends (#88217)
Change all the cstval_pred_ty based PatternMatch helpers (things like m_AllOnes and m_Zero) to only allow poison elements inside vector splats, not undef elements. Historically, we used to represent non-demanded elements in vectors using undef. Nowadays, we use poison instead. As such, I believe that support for undef in vector splats is no longer useful. At the same time, while poison splat elements are pretty much always safe to ignore, this is not generally the case for undef elements. We have existing miscompiles in our tests due to this (see the masked-merge-*.ll tests changed here) and it's easy to miss such cases in the future, now that we write tests using poison instead of undef elements. I think overall, keeping support for undef elements no longer makes sense, and we should drop it. Once this is done consistently, I think we may also consider allowing poison in m_APInt by default, as doing that change is much less risky than doing the same with undef. This change involves a substantial amount of test changes. For most tests, I've just replaced undef with poison, as I don't think there is value in retaining both. For some tests (where the distinction between undef and poison is important), I've duplicated tests.
1 parent a16bb07 commit d9a5aa8

File tree

158 files changed

+2042
-1839
lines changed

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

158 files changed

+2042
-1839
lines changed

‎llvm/include/llvm/IR/PatternMatch.h

Lines changed: 5 additions & 30 deletions
Original file line numberDiff line numberDiff line change
@@ -345,7 +345,7 @@ template <int64_t Val> inline constantint_match<Val> m_ConstantInt() {
345345

346346
/// This helper class is used to match constant scalars, vector splats,
347347
/// and fixed width vectors that satisfy a specified predicate.
348-
/// For fixed width vector constants, undefined elements are ignored.
348+
/// For fixed width vector constants, poison elements are ignored.
349349
template <typename Predicate, typename ConstantVal>
350350
struct cstval_pred_ty : public Predicate {
351351
template <typename ITy> bool match(ITy *V) {
@@ -364,19 +364,19 @@ struct cstval_pred_ty : public Predicate {
364364
// Non-splat vector constant: check each element for a match.
365365
unsigned NumElts = FVTy->getNumElements();
366366
assert(NumElts != 0 && "Constant vector with no elements?");
367-
bool HasNonUndefElements = false;
367+
bool HasNonPoisonElements = false;
368368
for (unsigned i = 0; i != NumElts; ++i) {
369369
Constant *Elt = C->getAggregateElement(i);
370370
if (!Elt)
371371
return false;
372-
if (isa<UndefValue>(Elt))
372+
if (isa<PoisonValue>(Elt))
373373
continue;
374374
auto *CV = dyn_cast<ConstantVal>(Elt);
375375
if (!CV || !this->isValue(CV->getValue()))
376376
return false;
377-
HasNonUndefElements = true;
377+
HasNonPoisonElements = true;
378378
}
379-
return HasNonUndefElements;
379+
return HasNonPoisonElements;
380380
}
381381
}
382382
return false;
@@ -2587,31 +2587,6 @@ m_Not(const ValTy &V) {
25872587
return m_c_Xor(m_AllOnes(), V);
25882588
}
25892589

2590-
template <typename ValTy> struct NotForbidUndef_match {
2591-
ValTy Val;
2592-
NotForbidUndef_match(const ValTy &V) : Val(V) {}
2593-
2594-
template <typename OpTy> bool match(OpTy *V) {
2595-
// We do not use m_c_Xor because that could match an arbitrary APInt that is
2596-
// not -1 as C and then fail to match the other operand if it is -1.
2597-
// This code should still work even when both operands are constants.
2598-
Value *X;
2599-
const APInt *C;
2600-
if (m_Xor(m_Value(X), m_APIntForbidUndef(C)).match(V) && C->isAllOnes())
2601-
return Val.match(X);
2602-
if (m_Xor(m_APIntForbidUndef(C), m_Value(X)).match(V) && C->isAllOnes())
2603-
return Val.match(X);
2604-
return false;
2605-
}
2606-
};
2607-
2608-
/// Matches a bitwise 'not' as 'xor V, -1' or 'xor -1, V'. For vectors, the
2609-
/// constant value must be composed of only -1 scalar elements.
2610-
template <typename ValTy>
2611-
inline NotForbidUndef_match<ValTy> m_NotForbidUndef(const ValTy &V) {
2612-
return NotForbidUndef_match<ValTy>(V);
2613-
}
2614-
26152590
/// Matches an SMin with LHS and RHS in either order.
26162591
template <typename LHS, typename RHS>
26172592
inline MaxMin_match<ICmpInst, LHS, RHS, smin_pred_ty, true>

‎llvm/lib/Analysis/InstructionSimplify.cpp

Lines changed: 10 additions & 13 deletions
Original file line numberDiff line numberDiff line change
@@ -1513,7 +1513,7 @@ static Value *simplifyAShrInst(Value *Op0, Value *Op1, bool IsExact,
15131513

15141514
// -1 >>a X --> -1
15151515
// (-1 << X) a>> X --> -1
1516-
// Do not return Op0 because it may contain undef elements if it's a vector.
1516+
// We could return the original -1 constant to preserve poison elements.
15171517
if (match(Op0, m_AllOnes()) ||
15181518
match(Op0, m_Shl(m_AllOnes(), m_Specific(Op1))))
15191519
return Constant::getAllOnesValue(Op0->getType());
@@ -2281,7 +2281,7 @@ static Value *simplifyOrLogic(Value *X, Value *Y) {
22812281
// (B ^ ~A) | (A & B) --> B ^ ~A
22822282
// (~A ^ B) | (B & A) --> ~A ^ B
22832283
// (B ^ ~A) | (B & A) --> B ^ ~A
2284-
if (match(X, m_c_Xor(m_NotForbidUndef(m_Value(A)), m_Value(B))) &&
2284+
if (match(X, m_c_Xor(m_Not(m_Value(A)), m_Value(B))) &&
22852285
match(Y, m_c_And(m_Specific(A), m_Specific(B))))
22862286
return X;
22872287

@@ -2298,31 +2298,29 @@ static Value *simplifyOrLogic(Value *X, Value *Y) {
22982298
// (B & ~A) | ~(A | B) --> ~A
22992299
// (B & ~A) | ~(B | A) --> ~A
23002300
Value *NotA;
2301-
if (match(X,
2302-
m_c_And(m_CombineAnd(m_Value(NotA), m_NotForbidUndef(m_Value(A))),
2303-
m_Value(B))) &&
2301+
if (match(X, m_c_And(m_CombineAnd(m_Value(NotA), m_Not(m_Value(A))),
2302+
m_Value(B))) &&
23042303
match(Y, m_Not(m_c_Or(m_Specific(A), m_Specific(B)))))
23052304
return NotA;
23062305
// The same is true of Logical And
23072306
// TODO: This could share the logic of the version above if there was a
23082307
// version of LogicalAnd that allowed more than just i1 types.
2309-
if (match(X, m_c_LogicalAnd(
2310-
m_CombineAnd(m_Value(NotA), m_NotForbidUndef(m_Value(A))),
2311-
m_Value(B))) &&
2308+
if (match(X, m_c_LogicalAnd(m_CombineAnd(m_Value(NotA), m_Not(m_Value(A))),
2309+
m_Value(B))) &&
23122310
match(Y, m_Not(m_c_LogicalOr(m_Specific(A), m_Specific(B)))))
23132311
return NotA;
23142312

23152313
// ~(A ^ B) | (A & B) --> ~(A ^ B)
23162314
// ~(A ^ B) | (B & A) --> ~(A ^ B)
23172315
Value *NotAB;
2318-
if (match(X, m_CombineAnd(m_NotForbidUndef(m_Xor(m_Value(A), m_Value(B))),
2316+
if (match(X, m_CombineAnd(m_Not(m_Xor(m_Value(A), m_Value(B))),
23192317
m_Value(NotAB))) &&
23202318
match(Y, m_c_And(m_Specific(A), m_Specific(B))))
23212319
return NotAB;
23222320

23232321
// ~(A & B) | (A ^ B) --> ~(A & B)
23242322
// ~(A & B) | (B ^ A) --> ~(A & B)
2325-
if (match(X, m_CombineAnd(m_NotForbidUndef(m_And(m_Value(A), m_Value(B))),
2323+
if (match(X, m_CombineAnd(m_Not(m_And(m_Value(A), m_Value(B))),
23262324
m_Value(NotAB))) &&
23272325
match(Y, m_c_Xor(m_Specific(A), m_Specific(B))))
23282326
return NotAB;
@@ -2552,9 +2550,8 @@ static Value *simplifyXorInst(Value *Op0, Value *Op1, const SimplifyQuery &Q,
25522550
// The 'not' op must contain a complete -1 operand (no undef elements for
25532551
// vector) for the transform to be safe.
25542552
Value *NotA;
2555-
if (match(X,
2556-
m_c_Or(m_CombineAnd(m_NotForbidUndef(m_Value(A)), m_Value(NotA)),
2557-
m_Value(B))) &&
2553+
if (match(X, m_c_Or(m_CombineAnd(m_Not(m_Value(A)), m_Value(NotA)),
2554+
m_Value(B))) &&
25582555
match(Y, m_c_And(m_Specific(A), m_Specific(B))))
25592556
return NotA;
25602557

‎llvm/lib/IR/Constants.cpp

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -316,7 +316,7 @@ bool Constant::isElementWiseEqual(Value *Y) const {
316316
Constant *C0 = ConstantExpr::getBitCast(const_cast<Constant *>(this), IntTy);
317317
Constant *C1 = ConstantExpr::getBitCast(cast<Constant>(Y), IntTy);
318318
Constant *CmpEq = ConstantExpr::getICmp(ICmpInst::ICMP_EQ, C0, C1);
319-
return isa<UndefValue>(CmpEq) || match(CmpEq, m_One());
319+
return isa<PoisonValue>(CmpEq) || match(CmpEq, m_One());
320320
}
321321

322322
static bool

‎llvm/lib/Transforms/InstCombine/InstCombineAndOrXor.cpp

Lines changed: 3 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -2538,6 +2538,8 @@ Instruction *InstCombinerImpl::visitAnd(BinaryOperator &I) {
25382538
}
25392539
}
25402540

2541+
// and(shl(zext(X), Y), SignMask) -> and(sext(X), SignMask)
2542+
// where Y is a valid shift amount.
25412543
if (match(&I, m_And(m_OneUse(m_Shl(m_ZExt(m_Value(X)), m_Value(Y))),
25422544
m_SignMask())) &&
25432545
match(Y, m_SpecificInt_ICMP(
@@ -2546,15 +2548,7 @@ Instruction *InstCombinerImpl::visitAnd(BinaryOperator &I) {
25462548
Ty->getScalarSizeInBits() -
25472549
X->getType()->getScalarSizeInBits())))) {
25482550
auto *SExt = Builder.CreateSExt(X, Ty, X->getName() + ".signext");
2549-
auto *SanitizedSignMask = cast<Constant>(Op1);
2550-
// We must be careful with the undef elements of the sign bit mask, however:
2551-
// the mask elt can be undef iff the shift amount for that lane was undef,
2552-
// otherwise we need to sanitize undef masks to zero.
2553-
SanitizedSignMask = Constant::replaceUndefsWith(
2554-
SanitizedSignMask, ConstantInt::getNullValue(Ty->getScalarType()));
2555-
SanitizedSignMask =
2556-
Constant::mergeUndefsWith(SanitizedSignMask, cast<Constant>(Y));
2557-
return BinaryOperator::CreateAnd(SExt, SanitizedSignMask);
2551+
return BinaryOperator::CreateAnd(SExt, Op1);
25582552
}
25592553

25602554
if (Instruction *Z = narrowMaskedBinOp(I))

‎llvm/test/Transforms/InstCombine/X86/x86-vector-shifts.ll

Lines changed: 15 additions & 15 deletions
Original file line numberDiff line numberDiff line change
@@ -2032,23 +2032,23 @@ define <4 x i64> @avx2_psrlv_q_256_allbig(<4 x i64> %v) {
20322032
ret <4 x i64> %1
20332033
}
20342034

2035-
; The shift amount is 0 (the undef lane could be 0), so we return the unshifted input.
2035+
; The shift amount is 0 (the poison lane could be 0), so we return the unshifted input.
20362036

2037-
define <2 x i64> @avx2_psrlv_q_128_undef(<2 x i64> %v) {
2038-
; CHECK-LABEL: @avx2_psrlv_q_128_undef(
2037+
define <2 x i64> @avx2_psrlv_q_128_poison(<2 x i64> %v) {
2038+
; CHECK-LABEL: @avx2_psrlv_q_128_poison(
20392039
; CHECK-NEXT: ret <2 x i64> [[V:%.*]]
20402040
;
2041-
%1 = insertelement <2 x i64> <i64 0, i64 8>, i64 undef, i64 1
2041+
%1 = insertelement <2 x i64> <i64 0, i64 8>, i64 poison, i64 1
20422042
%2 = tail call <2 x i64> @llvm.x86.avx2.psrlv.q(<2 x i64> %v, <2 x i64> %1)
20432043
ret <2 x i64> %2
20442044
}
20452045

2046-
define <4 x i64> @avx2_psrlv_q_256_undef(<4 x i64> %v) {
2047-
; CHECK-LABEL: @avx2_psrlv_q_256_undef(
2048-
; CHECK-NEXT: [[TMP1:%.*]] = lshr <4 x i64> [[V:%.*]], <i64 undef, i64 8, i64 16, i64 31>
2046+
define <4 x i64> @avx2_psrlv_q_256_poison(<4 x i64> %v) {
2047+
; CHECK-LABEL: @avx2_psrlv_q_256_poison(
2048+
; CHECK-NEXT: [[TMP1:%.*]] = lshr <4 x i64> [[V:%.*]], <i64 poison, i64 8, i64 16, i64 31>
20492049
; CHECK-NEXT: ret <4 x i64> [[TMP1]]
20502050
;
2051-
%1 = insertelement <4 x i64> <i64 0, i64 8, i64 16, i64 31>, i64 undef, i64 0
2051+
%1 = insertelement <4 x i64> <i64 0, i64 8, i64 16, i64 31>, i64 poison, i64 0
20522052
%2 = tail call <4 x i64> @llvm.x86.avx2.psrlv.q.256(<4 x i64> %v, <4 x i64> %1)
20532053
ret <4 x i64> %2
20542054
}
@@ -2435,21 +2435,21 @@ define <4 x i64> @avx2_psllv_q_256_allbig(<4 x i64> %v) {
24352435

24362436
; The shift amount is 0 (the undef lane could be 0), so we return the unshifted input.
24372437

2438-
define <2 x i64> @avx2_psllv_q_128_undef(<2 x i64> %v) {
2439-
; CHECK-LABEL: @avx2_psllv_q_128_undef(
2438+
define <2 x i64> @avx2_psllv_q_128_poison(<2 x i64> %v) {
2439+
; CHECK-LABEL: @avx2_psllv_q_128_poison(
24402440
; CHECK-NEXT: ret <2 x i64> [[V:%.*]]
24412441
;
2442-
%1 = insertelement <2 x i64> <i64 0, i64 8>, i64 undef, i64 1
2442+
%1 = insertelement <2 x i64> <i64 0, i64 8>, i64 poison, i64 1
24432443
%2 = tail call <2 x i64> @llvm.x86.avx2.psllv.q(<2 x i64> %v, <2 x i64> %1)
24442444
ret <2 x i64> %2
24452445
}
24462446

2447-
define <4 x i64> @avx2_psllv_q_256_undef(<4 x i64> %v) {
2448-
; CHECK-LABEL: @avx2_psllv_q_256_undef(
2449-
; CHECK-NEXT: [[TMP1:%.*]] = shl <4 x i64> [[V:%.*]], <i64 undef, i64 8, i64 16, i64 31>
2447+
define <4 x i64> @avx2_psllv_q_256_poison(<4 x i64> %v) {
2448+
; CHECK-LABEL: @avx2_psllv_q_256_poison(
2449+
; CHECK-NEXT: [[TMP1:%.*]] = shl <4 x i64> [[V:%.*]], <i64 poison, i64 8, i64 16, i64 31>
24502450
; CHECK-NEXT: ret <4 x i64> [[TMP1]]
24512451
;
2452-
%1 = insertelement <4 x i64> <i64 0, i64 8, i64 16, i64 31>, i64 undef, i64 0
2452+
%1 = insertelement <4 x i64> <i64 0, i64 8, i64 16, i64 31>, i64 poison, i64 0
24532453
%2 = tail call <4 x i64> @llvm.x86.avx2.psllv.q.256(<4 x i64> %v, <4 x i64> %1)
24542454
ret <4 x i64> %2
24552455
}

‎llvm/test/Transforms/InstCombine/abs-1.ll

Lines changed: 8 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -63,14 +63,14 @@ define <2 x i8> @abs_canonical_2(<2 x i8> %x) {
6363
ret <2 x i8> %abs
6464
}
6565

66-
; Even if a constant has undef elements.
66+
; Even if a constant has poison elements.
6767

68-
define <2 x i8> @abs_canonical_2_vec_undef_elts(<2 x i8> %x) {
69-
; CHECK-LABEL: @abs_canonical_2_vec_undef_elts(
68+
define <2 x i8> @abs_canonical_2_vec_poison_elts(<2 x i8> %x) {
69+
; CHECK-LABEL: @abs_canonical_2_vec_poison_elts(
7070
; CHECK-NEXT: [[ABS:%.*]] = call <2 x i8> @llvm.abs.v2i8(<2 x i8> [[X:%.*]], i1 false)
7171
; CHECK-NEXT: ret <2 x i8> [[ABS]]
7272
;
73-
%cmp = icmp sgt <2 x i8> %x, <i8 undef, i8 -1>
73+
%cmp = icmp sgt <2 x i8> %x, <i8 poison, i8 -1>
7474
%neg = sub <2 x i8> zeroinitializer, %x
7575
%abs = select <2 x i1> %cmp, <2 x i8> %x, <2 x i8> %neg
7676
ret <2 x i8> %abs
@@ -208,15 +208,15 @@ define <2 x i8> @nabs_canonical_2(<2 x i8> %x) {
208208
ret <2 x i8> %abs
209209
}
210210

211-
; Even if a constant has undef elements.
211+
; Even if a constant has poison elements.
212212

213-
define <2 x i8> @nabs_canonical_2_vec_undef_elts(<2 x i8> %x) {
214-
; CHECK-LABEL: @nabs_canonical_2_vec_undef_elts(
213+
define <2 x i8> @nabs_canonical_2_vec_poison_elts(<2 x i8> %x) {
214+
; CHECK-LABEL: @nabs_canonical_2_vec_poison_elts(
215215
; CHECK-NEXT: [[TMP1:%.*]] = call <2 x i8> @llvm.abs.v2i8(<2 x i8> [[X:%.*]], i1 false)
216216
; CHECK-NEXT: [[ABS:%.*]] = sub <2 x i8> zeroinitializer, [[TMP1]]
217217
; CHECK-NEXT: ret <2 x i8> [[ABS]]
218218
;
219-
%cmp = icmp sgt <2 x i8> %x, <i8 -1, i8 undef>
219+
%cmp = icmp sgt <2 x i8> %x, <i8 -1, i8 poison>
220220
%neg = sub <2 x i8> zeroinitializer, %x
221221
%abs = select <2 x i1> %cmp, <2 x i8> %neg, <2 x i8> %x
222222
ret <2 x i8> %abs

‎llvm/test/Transforms/InstCombine/add-mask-neg.ll

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -89,16 +89,16 @@ define <2 x i32> @dec_mask_neg_v2i32(<2 x i32> %X) {
8989
ret <2 x i32> %dec
9090
}
9191

92-
define <2 x i32> @dec_mask_neg_v2i32_undef(<2 x i32> %X) {
93-
; CHECK-LABEL: @dec_mask_neg_v2i32_undef(
92+
define <2 x i32> @dec_mask_neg_v2i32_poison(<2 x i32> %X) {
93+
; CHECK-LABEL: @dec_mask_neg_v2i32_poison(
9494
; CHECK-NEXT: [[TMP1:%.*]] = add <2 x i32> [[X:%.*]], <i32 -1, i32 -1>
9595
; CHECK-NEXT: [[TMP2:%.*]] = xor <2 x i32> [[X]], <i32 -1, i32 -1>
9696
; CHECK-NEXT: [[DEC:%.*]] = and <2 x i32> [[TMP1]], [[TMP2]]
9797
; CHECK-NEXT: ret <2 x i32> [[DEC]]
9898
;
9999
%neg = sub <2 x i32> zeroinitializer, %X
100100
%mask = and <2 x i32> %neg, %X
101-
%dec = add <2 x i32> %mask, <i32 -1, i32 undef>
101+
%dec = add <2 x i32> %mask, <i32 -1, i32 poison>
102102
ret <2 x i32> %dec
103103
}
104104

‎llvm/test/Transforms/InstCombine/add.ll

Lines changed: 14 additions & 14 deletions
Original file line numberDiff line numberDiff line change
@@ -150,24 +150,24 @@ define i32 @test5_add_nsw(i32 %A, i32 %B) {
150150
ret i32 %D
151151
}
152152

153-
define <2 x i8> @neg_op0_vec_undef_elt(<2 x i8> %a, <2 x i8> %b) {
154-
; CHECK-LABEL: @neg_op0_vec_undef_elt(
153+
define <2 x i8> @neg_op0_vec_poison_elt(<2 x i8> %a, <2 x i8> %b) {
154+
; CHECK-LABEL: @neg_op0_vec_poison_elt(
155155
; CHECK-NEXT: [[R:%.*]] = sub <2 x i8> [[B:%.*]], [[A:%.*]]
156156
; CHECK-NEXT: ret <2 x i8> [[R]]
157157
;
158-
%nega = sub <2 x i8> <i8 0, i8 undef>, %a
158+
%nega = sub <2 x i8> <i8 0, i8 poison>, %a
159159
%r = add <2 x i8> %nega, %b
160160
ret <2 x i8> %r
161161
}
162162

163-
define <2 x i8> @neg_neg_vec_undef_elt(<2 x i8> %a, <2 x i8> %b) {
164-
; CHECK-LABEL: @neg_neg_vec_undef_elt(
163+
define <2 x i8> @neg_neg_vec_poison_elt(<2 x i8> %a, <2 x i8> %b) {
164+
; CHECK-LABEL: @neg_neg_vec_poison_elt(
165165
; CHECK-NEXT: [[TMP1:%.*]] = add <2 x i8> [[A:%.*]], [[B:%.*]]
166166
; CHECK-NEXT: [[R:%.*]] = sub <2 x i8> zeroinitializer, [[TMP1]]
167167
; CHECK-NEXT: ret <2 x i8> [[R]]
168168
;
169-
%nega = sub <2 x i8> <i8 undef, i8 0>, %a
170-
%negb = sub <2 x i8> <i8 undef, i8 0>, %b
169+
%nega = sub <2 x i8> <i8 poison, i8 0>, %a
170+
%negb = sub <2 x i8> <i8 poison, i8 0>, %b
171171
%r = add <2 x i8> %nega, %negb
172172
ret <2 x i8> %r
173173
}
@@ -1196,14 +1196,14 @@ define <2 x i32> @test44_vec_non_matching(<2 x i32> %A) {
11961196
ret <2 x i32> %C
11971197
}
11981198

1199-
define <2 x i32> @test44_vec_undef(<2 x i32> %A) {
1200-
; CHECK-LABEL: @test44_vec_undef(
1201-
; CHECK-NEXT: [[B:%.*]] = or <2 x i32> [[A:%.*]], <i32 123, i32 undef>
1202-
; CHECK-NEXT: [[C:%.*]] = add <2 x i32> [[B]], <i32 -123, i32 undef>
1199+
define <2 x i32> @test44_vec_poison(<2 x i32> %A) {
1200+
; CHECK-LABEL: @test44_vec_poison(
1201+
; CHECK-NEXT: [[B:%.*]] = or <2 x i32> [[A:%.*]], <i32 123, i32 poison>
1202+
; CHECK-NEXT: [[C:%.*]] = add nsw <2 x i32> [[B]], <i32 -123, i32 poison>
12031203
; CHECK-NEXT: ret <2 x i32> [[C]]
12041204
;
1205-
%B = or <2 x i32> %A, <i32 123, i32 undef>
1206-
%C = add <2 x i32> %B, <i32 -123, i32 undef>
1205+
%B = or <2 x i32> %A, <i32 123, i32 poison>
1206+
%C = add <2 x i32> %B, <i32 -123, i32 poison>
12071207
ret <2 x i32> %C
12081208
}
12091209

@@ -2983,7 +2983,7 @@ define i8 @signum_i8_i8_use3(i8 %x) {
29832983
ret i8 %r
29842984
}
29852985

2986-
; poison/undef is ok to propagate in shift amount
2986+
; poison is ok to propagate in shift amount
29872987
; complexity canonicalization guarantees that shift is op0 of add
29882988

29892989
define <2 x i5> @signum_v2i5_v2i5(<2 x i5> %x) {

0 commit comments

Comments
 (0)