[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

742

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

742

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 - undef -> undef
-  // undef - X -> undef
-  if (Q.isUndefValue(Op0) || Q.isUndefValue(Op1))
+  // X - undef  -> undef
+  // X - poison -> poison
+  // undef  - X -> undef
+  // poison - X -> poison
+  if (Q.isUndefValue(Op0) || Q.isUndefValue(Op1)) {
+    if (isa<PoisonValue>(Op0) || isa<PoisonValue>(Op1))
+      return PoisonValue::get(Op0->getType());
     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());

 
 /// 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
   // X * undef -> 0
+  if (Q.isUndefValue(Op1))
+    return isa<PoisonValue>(Op1) ? Op1 : Constant::getNullValue(Op0->getType());
+
   // X * 0 -> 0
-  if (Q.isUndefValue(Op1) || match(Op1, m_Zero()))
+  if (match(Op1, m_Zero()))
     return Constant::getNullValue(Op0->getType());
 
   // X * 1 -> X
   if (match(Op1, m_One()))
     return Op0;
 
   // (X / Y) * Y -> X if the division is exact.
   Value *X = nullptr;
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);
     }
   }
 
-  // undef / X -> 0
-  // undef % X -> 0
+  // undef  / X -> 0
+  // poison / X -> poison
+  // undef  % X -> 0
+  // poison % X -> poison
   if (Q.isUndefValue(Op0))
-    return Constant::getNullValue(Ty);
+    return isa<PoisonValue>(Op0) ? Op0 : Constant::getNullValue(Ty);
 
   // 0 / X -> 0
   // 0 % X -> 0
   if (match(Op0, m_Zero()))
     return Constant::getNullValue(Op0->getType());
 
   // X / X -> 1
   // X % X -> 0

 /// 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 (Q.isUndefValue(Op0) && 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 & undef -> 0
+  // X & poison -> poison
+  // X & undef  -> 0
   if (Q.isUndefValue(Op1))
-    return Constant::getNullValue(Op0->getType());
+    return isa<PoisonValue>(Op1) ? Op1 : Constant::getNullValue(Op0->getType());
 
   // X & X = X
   if (Op0 == Op1)
     return Op0;
 
   // X & 0 = 0
   if (match(Op1, m_Zero()))
     return Constant::getNullValue(Op0->getType());

 
 /// 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
   // X | undef -> -1
+  if (Q.isUndefValue(Op1))
+    return isa<PoisonValue>(Op1) ? Op1 :
+        Constant::getAllOnesValue(Op0->getType());
+
   // 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()))
+  if (match(Op1, m_AllOnes()))
     return Constant::getAllOnesValue(Op0->getType());
 
   // X | X = X
   // X | 0 = X
   if (Op0 == Op1 || match(Op1, m_Zero()))
     return Op0;
 
   // A | ~A  =  ~A | A  =  -1

 
 /// Given operands for a Xor, see if we can fold the result.
 /// If not, this returns null.
 static Value *SimplifyXorInst(Value *Op0, Value *Op1, const SimplifyQuery &Q,
                               unsigned MaxRecurse) {
   if (Constant *C = foldOrCommuteConstant(Instruction::Xor, Op0, Op1, Q))
     return C;
 
-  // A ^ undef -> undef
+  // A ^ poison -> poison
+  // A ^ undef  -> undef
   if (Q.isUndefValue(Op1))
     return Op1;
 
   // A ^ 0 = A
   if (match(Op1, m_Zero()))
     return Op0;
 
   // A ^ A = 0
static Value *SimplifyFCmpInst(unsigned Predicate, Value *LHS, Value *RHS,
   // 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, undef  and  fcmp pred undef, x
   // fold to true if unordered, false if ordered
+  // fcmp pred x, poison and  fcmp pred poison, x
+  // fold to poison
   if (Q.isUndefValue(LHS) || Q.isUndefValue(RHS)) {
+    if (isa<PoisonValue>(LHS) || isa<PoisonValue>(RHS))
+      return PoisonValue::get(RetTy);
+
     // Choosing NaN for the undef will always make unordered comparison succeed
     // and ordered comparison fail.
     return ConstantInt::get(RetTy, CmpInst::isUnordered(Pred));
   }
 
   // fcmp x,x -> true/false.  Not all compares are foldable.
   if (LHS == RHS) {
     if (CmpInst::isTrueWhenEqual(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 undef, X, Y -> X or Y
-    if (Q.isUndefValue(CondC))
+    // select poison, X, Y -> poison
+    // select undef,  X, Y -> X or Y
+    if (Q.isUndefValue(CondC)) {
+      if (isa<PoisonValue>(CondC))
+        return PoisonValue::get(TrueVal->getType());
       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.
     if (match(CondC, m_One()))
       return TrueVal;
     if (match(CondC, m_Zero()))
       return FalseVal;
   }
 
   // select i1 Cond, i1 true, i1 false --> i1 Cond
   assert(Cond->getType()->isIntOrIntVectorTy(1) &&
          "Select must have bool or bool vector condition");
   assert(TrueVal->getType() == FalseVal->getType() &&
          "Select must have same types for true/false ops");
   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
+  // select ?, poison, X -> X
+  // select ?, undef,  X -> X
   if (Q.isUndefValue(TrueVal) &&
-      isGuaranteedNotToBeUndefOrPoison(FalseVal, Q.AC, Q.CxtI, Q.DT))
+      (isa<PoisonValue>(TrueVal) ||
+       isGuaranteedNotToBePoison(FalseVal, Q.AC, Q.CxtI, Q.DT)))
       return FalseVal;
-  // select ?, X, undef -> X
+  // select ?, X, poison -> X
+  // select ?, X, undef  -> X
   if (Q.isUndefValue(FalseVal) &&
-      isGuaranteedNotToBeUndefOrPoison(TrueVal, Q.AC, Q.CxtI, Q.DT))
+      (isa<PoisonValue>(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))
+               (isa<PoisonValue>(TEltC) ||
+                isGuaranteedNotToBePoison(FEltC)))
         NewC.push_back(FEltC);
       else if (Q.isUndefValue(FEltC) &&
-               isGuaranteedNotToBeUndefOrPoison(TEltC))
+               (isa<PoisonValue>(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
 }