[InstSimplify] Add more poison folding optimizations

[aqjune]

Summary

This adds more poison folding optimizations to InstSimplify.

Since all binary operators propagate poison, these are fine.

Also, the precondition of select cond, undef, x -> x is relaxed to allow the case when x is undef.

[nikic]

llvm/lib/Analysis/InstructionSimplify.cpp

749

I'd prefer the PoisonValue checks to happen independently of the isUndefValue checks, because these are valid even if undef value folding is disabled (folding poison does not create an assumption for a specific undef value).

[aqjune]

llvm/lib/Analysis/InstructionSimplify.cpp

749

That is correct. I was concerned about whether independently dealing with it might confuse people or not.
Anyway, since it allows more optimization, I'll update this patch to do so.

[aqjune]

• Make poison check independent from Q.isUndefValue query calls
• Remove xor poison, X -> poison folding to avoid xor poison, poison -> poison as mentioned in D104648

[nikic]

LGTM

llvm/test/Transforms/InstCombine/select-binop-cmp.ll

1270

While you're in the area: poisong -> poison

llvm/lib/Analysis/InstructionSimplify.cpp

 
 /// Given operands for a Sub, see if we can fold the result.
 /// If not, this returns null.
 static Value *SimplifySubInst(Value *Op0, Value *Op1, bool isNSW, bool isNUW,
                               const SimplifyQuery &Q, unsigned MaxRecurse) {
   if (Constant *C = foldOrCommuteConstant(Instruction::Sub, Op0, Op1, Q))
     return C;
 
+  // X - poison -> poison
+  // poison - X -> poison
+  if (isa<PoisonValue>(Op0) || isa<PoisonValue>(Op1))
+    return PoisonValue::get(Op0->getType());
+
   // X - undef -> undef
   // undef - X -> undef
   if (Q.isUndefValue(Op0) || Q.isUndefValue(Op1))
     return UndefValue::get(Op0->getType());
 
   // X - 0 -> X
   if (match(Op1, m_Zero()))
     return Op0;
 
   // X - X -> 0
   if (Op0 == Op1)
     return Constant::getNullValue(Op0->getType());
 
   // Is this a negation?
   if (match(Op0, m_Zero())) {
     // 0 - X -> 0 if the sub is NUW.

 
 /// Given operands for a Mul, see if we can fold the result.
 /// If not, this returns null.
 static Value *SimplifyMulInst(Value *Op0, Value *Op1, const SimplifyQuery &Q,
                               unsigned MaxRecurse) {
   if (Constant *C = foldOrCommuteConstant(Instruction::Mul, Op0, Op1, Q))
     return C;
 
+  // X * poison -> poison
+  if (isa<PoisonValue>(Op1))
+    return Op1;
+
   // X * undef -> 0
   // X * 0 -> 0
   if (Q.isUndefValue(Op1) || match(Op1, m_Zero()))
     return Constant::getNullValue(Op0->getType());
 
   // X * 1 -> X
   if (match(Op1, m_One()))
     return Op0;
if (Op1C && VTy) {
     unsigned NumElts = VTy->getNumElements();
     for (unsigned i = 0; i != NumElts; ++i) {
       Constant *Elt = Op1C->getAggregateElement(i);
       if (Elt && (Elt->isNullValue() || Q.isUndefValue(Elt)))
         return PoisonValue::get(Ty);
     }
   }
 
+  // poison / X -> poison
+  // poison % X -> poison
+  if (isa<PoisonValue>(Op0))
+    return Op0;
+
   // undef / X -> 0
   // undef % X -> 0
   if (Q.isUndefValue(Op0))
     return Constant::getNullValue(Ty);
 
   // 0 / X -> 0
   // 0 % X -> 0
   if (match(Op0, m_Zero()))

 /// Given operands for an Shl, LShr or AShr, see if we can fold the result.
 /// If not, this returns null.
 static Value *SimplifyShift(Instruction::BinaryOps Opcode, Value *Op0,
                             Value *Op1, bool IsNSW, const SimplifyQuery &Q,
                             unsigned MaxRecurse) {
   if (Constant *C = foldOrCommuteConstant(Opcode, Op0, Op1, Q))
     return C;
 
+  // poison shift by X -> poison
+  if (isa<PoisonValue>(Op0))
+    return Op0;
+
   // 0 shift by X -> 0
   if (match(Op0, m_Zero()))
     return Constant::getNullValue(Op0->getType());
 
   // X shift by 0 -> X
   // Shift-by-sign-extended bool must be shift-by-0 because shift-by-all-ones
   // would be poison.
   Value *X;

 
 /// Given operands for an And, see if we can fold the result.
 /// If not, this returns null.
 static Value *SimplifyAndInst(Value *Op0, Value *Op1, const SimplifyQuery &Q,
                               unsigned MaxRecurse) {
   if (Constant *C = foldOrCommuteConstant(Instruction::And, Op0, Op1, Q))
     return C;
 
+  // X & poison -> poison
+  if (isa<PoisonValue>(Op1))
+    return Op1;
+
   // X & undef -> 0
   if (Q.isUndefValue(Op1))
     return Constant::getNullValue(Op0->getType());
 
   // X & X = X
   if (Op0 == Op1)
     return Op0;
 

 
 /// Given operands for an Or, see if we can fold the result.
 /// If not, this returns null.
 static Value *SimplifyOrInst(Value *Op0, Value *Op1, const SimplifyQuery &Q,
                              unsigned MaxRecurse) {
   if (Constant *C = foldOrCommuteConstant(Instruction::Or, Op0, Op1, Q))
     return C;
 
+  // X | poison -> poison
+  if (isa<PoisonValue>(Op1))
+    return Op1;
+
   // X | undef -> -1
   // X | -1 = -1
   // Do not return Op1 because it may contain undef elements if it's a vector.
   if (Q.isUndefValue(Op1) || match(Op1, m_AllOnes()))
     return Constant::getAllOnesValue(Op0->getType());
 
   // X | X = X
   // X | 0 = X
if (FMF.noNaNs() ||
       return ConstantInt::get(RetTy, Pred == FCmpInst::FCMP_ORD);
 
   // NaN is unordered; NaN is not ordered.
   assert((FCmpInst::isOrdered(Pred) || FCmpInst::isUnordered(Pred)) &&
          "Comparison must be either ordered or unordered");
   if (match(RHS, m_NaN()))
     return ConstantInt::get(RetTy, CmpInst::isUnordered(Pred));
 
+  // fcmp pred x, poison and  fcmp pred poison, x
+  // fold to poison
+  if (isa<PoisonValue>(LHS) || isa<PoisonValue>(RHS))
+    return PoisonValue::get(RetTy);
+
   // fcmp pred x, undef  and  fcmp pred undef, x
   // fold to true if unordered, false if ordered
   if (Q.isUndefValue(LHS) || Q.isUndefValue(RHS)) {
     // Choosing NaN for the undef will always make unordered comparison succeed
     // and ordered comparison fail.
     return ConstantInt::get(RetTy, CmpInst::isUnordered(Pred));
   }
 

 /// If not, this returns null.
 static Value *SimplifySelectInst(Value *Cond, Value *TrueVal, Value *FalseVal,
                                  const SimplifyQuery &Q, unsigned MaxRecurse) {
   if (auto *CondC = dyn_cast<Constant>(Cond)) {
     if (auto *TrueC = dyn_cast<Constant>(TrueVal))
       if (auto *FalseC = dyn_cast<Constant>(FalseVal))
         return ConstantFoldSelectInstruction(CondC, TrueC, FalseC);
 
+    // select poison, X, Y -> poison
+    if (isa<PoisonValue>(CondC))
+      return PoisonValue::get(TrueVal->getType());
+
     // select undef, X, Y -> X or Y
     if (Q.isUndefValue(CondC))
       return isa<Constant>(FalseVal) ? FalseVal : TrueVal;
 
     // select true,  X, Y --> X
     // select false, X, Y --> Y
     // For vectors, allow undef/poison elements in the condition to match the
     // defined elements, so we can eliminate the select.
static Value *SimplifySelectInst(Value *Cond, Value *TrueVal, Value *FalseVal,
   if (Cond->getType() == TrueVal->getType() &&
       match(TrueVal, m_One()) && match(FalseVal, m_ZeroInt()))
     return Cond;
 
   // select ?, X, X -> X
   if (TrueVal == FalseVal)
     return TrueVal;
 
+  // If the true or false value is poison, we can fold to the other value.
   // If the true or false value is undef, we can fold to the other value as
   // long as the other value isn't poison.
-  // select ?, undef, X -> X
-  if (Q.isUndefValue(TrueVal) &&
-      isGuaranteedNotToBeUndefOrPoison(FalseVal, Q.AC, Q.CxtI, Q.DT))
+  // select ?, poison, X -> X
+  // select ?, undef,  X -> X
+  if (isa<PoisonValue>(TrueVal) ||
+      (Q.isUndefValue(TrueVal) &&
+       isGuaranteedNotToBePoison(FalseVal, Q.AC, Q.CxtI, Q.DT)))
     return FalseVal;
-  // select ?, X, undef -> X
-  if (Q.isUndefValue(FalseVal) &&
-      isGuaranteedNotToBeUndefOrPoison(TrueVal, Q.AC, Q.CxtI, Q.DT))
+  // select ?, X, poison -> X
+  // select ?, X, undef  -> X
+  if (isa<PoisonValue>(FalseVal) ||
+      (Q.isUndefValue(FalseVal) &&
+       isGuaranteedNotToBePoison(TrueVal, Q.AC, Q.CxtI, Q.DT)))
     return TrueVal;
 
   // Deal with partial undef vector constants: select ?, VecC, VecC' --> VecC''
   Constant *TrueC, *FalseC;
   if (isa<FixedVectorType>(TrueVal->getType()) &&
       match(TrueVal, m_Constant(TrueC)) &&
       match(FalseVal, m_Constant(FalseC))) {
     unsigned NumElts =
         cast<FixedVectorType>(TrueC->getType())->getNumElements();
     SmallVector<Constant *, 16> NewC;
     for (unsigned i = 0; i != NumElts; ++i) {
       // Bail out on incomplete vector constants.
       Constant *TEltC = TrueC->getAggregateElement(i);
       Constant *FEltC = FalseC->getAggregateElement(i);
       if (!TEltC || !FEltC)
         break;
 
       // If the elements match (undef or not), that value is the result. If only
       // one element is undef, choose the defined element as the safe result.
       if (TEltC == FEltC)
         NewC.push_back(TEltC);
-      else if (Q.isUndefValue(TEltC) &&
-               isGuaranteedNotToBeUndefOrPoison(FEltC))
+      else if (isa<PoisonValue>(TEltC) ||
+               (Q.isUndefValue(TEltC) && isGuaranteedNotToBePoison(FEltC)))
         NewC.push_back(FEltC);
-      else if (Q.isUndefValue(FEltC) &&
-               isGuaranteedNotToBeUndefOrPoison(TEltC))
+      else if (isa<PoisonValue>(FEltC) ||
+               (Q.isUndefValue(FEltC) && isGuaranteedNotToBePoison(TEltC)))
         NewC.push_back(TEltC);
       else
         break;
     }
     if (NewC.size() == NumElts)
       return ConstantVector::get(NewC);
   }
 

llvm/test/Transforms/InstCombine/and-narrow.ll

;
   %z = zext <2 x i8> %x to <2 x i16>
   %b = lshr <2 x i16> %z, <i16 4, i16 8>
   %r = and <2 x i16> %b, %z
   ret <2 x i16> %r
 }
 
 define <2 x i16> @zext_lshr_vec_undef(<2 x i8> %x) {
 ; CHECK-LABEL: @zext_lshr_vec_undef(
-; CHECK-NEXT:    ret <2 x i16> zeroinitializer
+; CHECK-NEXT:    ret <2 x i16> poison
 ;
   %z = zext <2 x i8> %x to <2 x i16>
   %b = lshr <2 x i16> %z, undef
   %r = and <2 x i16> %b, %z
   ret <2 x i16> %r
 }
 
 ; Don't create poison by narrowing a shift below the shift amount.
 
 define <2 x i16> @zext_shl_vec_overshift(<2 x i8> %x) {
 ; CHECK-LABEL: @zext_shl_vec_overshift(
 ; CHECK-NEXT:    [[Z:%.*]] = zext <2 x i8> [[X:%.*]] to <2 x i16>
 ; CHECK-NEXT:    [[B:%.*]] = shl <2 x i16> [[Z]], <i16 8, i16 2>
 ; CHECK-NEXT:    [[R:%.*]] = and <2 x i16> [[B]], [[Z]]
 ; CHECK-NEXT:    ret <2 x i16> [[R]]
 ;
   %z = zext <2 x i8> %x to <2 x i16>
   %b = shl <2 x i16> %z, <i16 8, i16 2>
   %r = and <2 x i16> %b, %z
   ret <2 x i16> %r
 }
 
 define <2 x i16> @zext_shl_vec_undef(<2 x i8> %x) {
 ; CHECK-LABEL: @zext_shl_vec_undef(
-; CHECK-NEXT:    ret <2 x i16> zeroinitializer
+; CHECK-NEXT:    ret <2 x i16> poison
 ;
   %z = zext <2 x i8> %x to <2 x i16>
   %b = shl <2 x i16> %z, undef
   %r = and <2 x i16> %b, %z
   ret <2 x i16> %r
 }
 

llvm/test/Transforms/InstCombine/select-binop-cmp.ll

;
   %B = xor i32 %x, %z
   %C = select i1 %A, i32 %y, i32 %B
   ret i32 %C
 }
 
 define i32 @select_xor_icmp_meta(i32 %x, i32 %y, i32 %z) {
 ; CHECK-LABEL: @select_xor_icmp_meta(
 ; CHECK-NEXT:    [[A:%.*]] = icmp eq i32 [[X:%.*]], 0
-; CHECK-NEXT:    [[C:%.*]] = select i1 [[A]], i32 [[Z:%.*]], i32 [[Y:%.*]], !prof !0
+; CHECK-NEXT:    [[C:%.*]] = select i1 [[A]], i32 [[Z:%.*]], i32 [[Y:%.*]], !prof [[PROF0:![0-9]+]]
 ; CHECK-NEXT:    ret i32 [[C]]
 ;
   %A = icmp eq i32 %x, 0
   %B = xor i32 %x, %z
   %C = select i1 %A, i32 %B, i32 %y, !prof !0
   ret i32 %C
 }
 

 ;
   %c = icmp eq i32 %x, 2
   %div = udiv i32 %y, %x
   %s = select i1 %c, i32 %div, i32 %y
   ret i32 %s
 }
 
 ; We can't replace %x by 0 here, because that would cause UB. However,
 ; replacing the udiv result by poisong is fine.
 define i32 @select_replace_udiv_non_speculatable(i32 %x, i32 %y) {
 ; CHECK-LABEL: @select_replace_udiv_non_speculatable(
-; CHECK-NEXT:    [[C:%.*]] = icmp eq i32 [[X:%.*]], 0
-; CHECK-NEXT:    [[S:%.*]] = select i1 [[C]], i32 poison, i32 [[Y:%.*]]
-; CHECK-NEXT:    ret i32 [[S]]
+; CHECK-NEXT:    ret i32 [[Y:%.*]]
 ;
   %c = icmp eq i32 %x, 0
   %div = udiv i32 %y, %x
   %s = select i1 %c, i32 %div, i32 %y
   ret i32 %s
 }
 
 ; We can't replace %i in the phi node here, because it refers to %i from

llvm/test/Transforms/InstSimplify/ConstProp/poison.ll

;
   %i1 = icmp eq i8 poison, 1
   %i2 = fcmp oeq float poison, 1.0
   %i3 = select i1 poison, i8 1, i8 2
   %i4 = select i1 true, i8 poison, i8 %x
   call void (...) @use(i1 %i1, i1 %i2, i8 %i3, i8 %i4, i8* getelementptr (i8, i8* poison, i64 1), i8* getelementptr inbounds (i8, i8* undef, i64 1))
   ret void
 }
 
-; TODO: these must be folded into poison; D92270
 define void @logicalops_i1(i1 %x) {
 ; CHECK-LABEL: @logicalops_i1(
-; CHECK-NEXT:    call void (...) @use(i1 true, i1 false)
+; CHECK-NEXT:    call void (...) @use(i1 poison, i1 poison)
 ; CHECK-NEXT:    ret void
 ;
   %i1 = or i1 %x, poison
   %i2 = and i1 %x, poison
   call void (...) @use(i1 %i1, i1 %i2)
   ret void
 }

llvm/test/Transforms/InstSimplify/and.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt < %s -instsimplify -S | FileCheck %s
 
-; TODO: this should be poison
-
 define i32 @poison(i32 %x) {
 ; CHECK-LABEL: @poison(
-; CHECK-NEXT:    ret i32 0
+; CHECK-NEXT:    ret i32 poison
 ;
   %v = and i32 %x, poison
   ret i32 %v
 }

llvm/test/Transforms/InstSimplify/fcmp.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt < %s -instsimplify -S | FileCheck %s
 
-; TODO: these should be poison
 define i1 @poison(float %x) {
 ; CHECK-LABEL: @poison(
-; CHECK-NEXT:    ret i1 false
+; CHECK-NEXT:    ret i1 poison
 ;
   %v = fcmp oeq float %x, poison
   ret i1 %v
 }
 
 define i1 @poison2(float %x) {
 ; CHECK-LABEL: @poison2(
-; CHECK-NEXT:    ret i1 true
+; CHECK-NEXT:    ret i1 poison
 ;
   %v = fcmp ueq float %x, poison
   ret i1 %v
 }

llvm/test/Transforms/InstSimplify/mul.ll

 define <2 x i8> @mul_by_0_vec_undef_elt(<2 x i8> %a) {
 ; CHECK-LABEL: @mul_by_0_vec_undef_elt(
 ; CHECK-NEXT:    ret <2 x i8> zeroinitializer
 ;
   %b = mul <2 x i8> %a, <i8 undef, i8 0>
   ret <2 x i8> %b
 }
 
-; TODO: this should be poison
-
 define i32 @poison(i32 %x) {
 ; CHECK-LABEL: @poison(
-; CHECK-NEXT:    ret i32 0
+; CHECK-NEXT:    ret i32 poison
 ;
   %v = mul i32 %x, poison
   ret i32 %v
 }

llvm/test/Transforms/InstSimplify/or.ll

 ; CHECK-NEXT:    ret <2 x i1> <i1 true, i1 true>
 ;
   %ab = and <2 x i1> %b, %a
   %not = xor <2 x i1> %ab, <i1 -1, i1 undef>
   %r = or <2 x i1> %not, %a
   ret <2 x i1> %r
 }
 
-; TODO: this should be poison
-
 define i32 @poison(i32 %x) {
 ; CHECK-LABEL: @poison(
-; CHECK-NEXT:    ret i32 -1
+; CHECK-NEXT:    ret i32 poison
 ;
   %v = or i32 %x, poison
   ret i32 %v
 }
 
 declare void @use(i32)
 
 define i32 @and_or_not_or(i32 %A, i32 %B) {

llvm/test/Transforms/InstSimplify/select-inseltpoison.ll

 ; CHECK-NEXT:    [[S:%.*]] = select <vscale x 2 x i1> [[COND:%.*]], <vscale x 2 x i1> undef, <vscale x 2 x i1> insertelement (<vscale x 2 x i1> poison, i1 true, i32 0)
 ; CHECK-NEXT:    ret <vscale x 2 x i1> [[S]]
 ;
   %vec = insertelement <vscale x 2 x i1> poison, i1 true, i32 0
   %s = select <vscale x 2 x i1> %cond, <vscale x 2 x i1> undef, <vscale x 2 x i1> %vec
   ret <vscale x 2 x i1> %s
 }
 
-; TODO: these can be optimized more
-
 define i32 @poison(i32 %x, i32 %y) {
 ; CHECK-LABEL: @poison(
 ; CHECK-NEXT:    ret i32 [[X:%.*]]
 ;
   %v = select i1 undef, i32 %x, i32 %y
   ret i32 %v
 }
 
 define i32 @poison2(i1 %cond, i32 %x) {
 ; CHECK-LABEL: @poison2(
-; CHECK-NEXT:    [[V:%.*]] = select i1 [[COND:%.*]], i32 poison, i32 [[X:%.*]]
-; CHECK-NEXT:    ret i32 [[V]]
+; CHECK-NEXT:    ret i32 [[X:%.*]]
 ;
   %v = select i1 %cond, i32 poison, i32 %x
   ret i32 %v
 }
 
 define i32 @poison3(i1 %cond, i32 %x) {
 ; CHECK-LABEL: @poison3(
-; CHECK-NEXT:    [[V:%.*]] = select i1 [[COND:%.*]], i32 [[X:%.*]], i32 poison
-; CHECK-NEXT:    ret i32 [[V]]
+; CHECK-NEXT:    ret i32 [[X:%.*]]
 ;
   %v = select i1 %cond, i32 %x, i32 poison
   ret i32 %v
 }
 
 define <2 x i32> @poison4(<2 x i1> %cond, <2 x i32> %x) {
 ; CHECK-LABEL: @poison4(
-; CHECK-NEXT:    [[V:%.*]] = select <2 x i1> [[COND:%.*]], <2 x i32> [[X:%.*]], <2 x i32> poison
-; CHECK-NEXT:    ret <2 x i32> [[V]]
+; CHECK-NEXT:    ret <2 x i32> [[X:%.*]]
 ;
   %v = select <2 x i1> %cond, <2 x i32> %x, <2 x i32> poison
   ret <2 x i32> %v
 }

llvm/test/Transforms/InstSimplify/select.ll

;
   %r1.sroa.0.1 = select i1 %cmp, i32 0, i32 %shifted
   ret i32 %r1.sroa.0.1
 }
 declare i32 @llvm.cttz.i32(i32, i1 immarg)
 
 ; Partial undef scalable vectors should be ignored.
 define <vscale x 2 x i1> @ignore_scalable_undef(<vscale x 2 x i1> %cond) {
 ; CHECK-LABEL: @ignore_scalable_undef(
-; CHECK-NEXT:    [[S:%.*]] = select <vscale x 2 x i1> [[COND:%.*]], <vscale x 2 x i1> undef, <vscale x 2 x i1> insertelement (<vscale x 2 x i1> undef, i1 true, i32 0)
-; CHECK-NEXT:    ret <vscale x 2 x i1> [[S]]
+; CHECK-NEXT:    ret <vscale x 2 x i1> insertelement (<vscale x 2 x i1> undef, i1 true, i32 0)
 ;
   %vec = insertelement <vscale x 2 x i1> undef, i1 true, i32 0
   %s = select <vscale x 2 x i1> %cond, <vscale x 2 x i1> undef, <vscale x 2 x i1> %vec
   ret <vscale x 2 x i1> %s
 }
 
 define i32 @select_neutral_add_rhs(i32 %x, i32 %y) {
 ; CHECK-LABEL: @select_neutral_add_rhs(

 ; CHECK-NEXT:    ret <2 x i32> [[S]]
 ;
   %x10 = shufflevector <2 x i32> %x, <2 x i32> undef, <2 x i32> <i32 1, i32 0>
   %cond = icmp eq <2 x i32> %x, zeroinitializer
   %s = select <2 x i1> %cond, <2 x i32> %x10, <2 x i32> zeroinitializer
   ret <2 x i32> %s
 }
 
-; TODO: these can be optimized more
-
 define i32 @poison(i32 %x, i32 %y) {
 ; CHECK-LABEL: @poison(
 ; CHECK-NEXT:    ret i32 [[X:%.*]]
 ;
   %v = select i1 undef, i32 %x, i32 %y
   ret i32 %v
 }
 
 define i32 @poison2(i1 %cond, i32 %x) {
 ; CHECK-LABEL: @poison2(
-; CHECK-NEXT:    [[V:%.*]] = select i1 [[COND:%.*]], i32 poison, i32 [[X:%.*]]
-; CHECK-NEXT:    ret i32 [[V]]
+; CHECK-NEXT:    ret i32 [[X:%.*]]
 ;
   %v = select i1 %cond, i32 poison, i32 %x
   ret i32 %v
 }
 
 define i32 @poison3(i1 %cond, i32 %x) {
 ; CHECK-LABEL: @poison3(
-; CHECK-NEXT:    [[V:%.*]] = select i1 [[COND:%.*]], i32 [[X:%.*]], i32 poison
-; CHECK-NEXT:    ret i32 [[V]]
+; CHECK-NEXT:    ret i32 [[X:%.*]]
 ;
   %v = select i1 %cond, i32 %x, i32 poison
   ret i32 %v
 }
 
 define <2 x i32> @poison4(<2 x i1> %cond, <2 x i32> %x) {
 ; CHECK-LABEL: @poison4(
-; CHECK-NEXT:    [[V:%.*]] = select <2 x i1> [[COND:%.*]], <2 x i32> [[X:%.*]], <2 x i32> poison
-; CHECK-NEXT:    ret <2 x i32> [[V]]
+; CHECK-NEXT:    ret <2 x i32> [[X:%.*]]
 ;
   %v = select <2 x i1> %cond, <2 x i32> %x, <2 x i32> poison
   ret <2 x i32> %v
 }

llvm/test/Transforms/InstSimplify/shift.ll

 define i32 @poison3(i32 %x) {
 ; CHECK-LABEL: @poison3(
 ; CHECK-NEXT:    ret i32 poison
 ;
   %v = shl i32 %x, poison
   ret i32 %v
 }
 
-; TODO: these should be poison
-
 define i32 @poison4(i32 %x) {
 ; CHECK-LABEL: @poison4(
-; CHECK-NEXT:    ret i32 0
+; CHECK-NEXT:    ret i32 poison
 ;
   %v = lshr i32 poison, %x
   ret i32 %v
 }
 
 define i32 @poison5(i32 %x) {
 ; CHECK-LABEL: @poison5(
-; CHECK-NEXT:    ret i32 0
+; CHECK-NEXT:    ret i32 poison
 ;
   %v = ashr i32 poison, %x
   ret i32 %v
 }
 
 define i32 @poison6(i32 %x) {
 ; CHECK-LABEL: @poison6(
-; CHECK-NEXT:    ret i32 0
+; CHECK-NEXT:    ret i32 poison
 ;
   %v = shl i32 poison, %x
   ret i32 %v
 }

llvm/test/Transforms/InstSimplify/sub.ll

 ; CHECK-LABEL: @neg_neg_vec(
 ; CHECK-NEXT:    ret <2 x i32> [[A:%.*]]
 ;
   %B = sub <2 x i32> <i32 0, i32 undef>, %A
   %C = sub <2 x i32> <i32 0, i32 undef>, %B
   ret <2 x i32> %C
 }
 
-; TODO: these should be poison
-
 define i32 @poison1(i32 %x) {
 ; CHECK-LABEL: @poison1(
-; CHECK-NEXT:    ret i32 undef
+; CHECK-NEXT:    ret i32 poison
 ;
   %v = sub i32 %x, poison
   ret i32 %v
 }
 
 define i32 @poison2(i32 %x) {
 ; CHECK-LABEL: @poison2(
-; CHECK-NEXT:    ret i32 undef
+; CHECK-NEXT:    ret i32 poison
 ;
   %v = sub i32 poison, %x
   ret i32 %v
 }