1 files changed, 3 insertions, 49 deletions

diff --git a/llvm/lib/Analysis/ValueTracking.cpp b/llvm/lib/Analysis/ValueTracking.cpp
index cd7c029ce12..d2d8b160ce2 100644
--- a/llvm/lib/Analysis/ValueTracking.cpp
+++ b/llvm/lib/Analysis/ValueTracking.cpp
@@ -3816,6 +3816,9 @@ bool llvm::propagatesFullPoison(const Instruction *I) {
   case Instruction::Trunc:
   case Instruction::BitCast:
   case Instruction::AddrSpaceCast:
+  case Instruction::Mul:
+  case Instruction::Shl:
+  case Instruction::GetElementPtr:
     // These operations all propagate poison unconditionally. Note that poison
     // is not any particular value, so xor or subtraction of poison with
     // itself still yields poison, not zero.
@@ -3827,60 +3830,11 @@ bool llvm::propagatesFullPoison(const Instruction *I) {
     // multiple output bits. A replicated poison bit is still poison.
     return true;
 
-  case Instruction::Shl: {
-    // Left shift *by* a poison value is poison. The number of
-    // positions to shift is unsigned, so no negative values are
-    // possible there. Left shift by zero places preserves poison. So
-    // it only remains to consider left shift of poison by a positive
-    // number of places.
-    //
-    // A left shift by a positive number of places leaves the lowest order bit
-    // non-poisoned. However, if such a shift has a no-wrap flag, then we can
-    // make the poison operand violate that flag, yielding a fresh full-poison
-    // value.
-    auto *OBO = cast<OverflowingBinaryOperator>(I);
-    return OBO->hasNoUnsignedWrap() || OBO->hasNoSignedWrap();
-  }
-
-  case Instruction::Mul: {
-    // A multiplication by zero yields a non-poison zero result, so we need to
-    // rule out zero as an operand. Conservatively, multiplication by a
-    // non-zero constant is not multiplication by zero.
-    //
-    // Multiplication by a non-zero constant can leave some bits
-    // non-poisoned. For example, a multiplication by 2 leaves the lowest
-    // order bit unpoisoned. So we need to consider that.
-    //
-    // Multiplication by 1 preserves poison. If the multiplication has a
-    // no-wrap flag, then we can make the poison operand violate that flag
-    // when multiplied by any integer other than 0 and 1.
-    auto *OBO = cast<OverflowingBinaryOperator>(I);
-    if (OBO->hasNoUnsignedWrap() || OBO->hasNoSignedWrap()) {
-      for (Value *V : OBO->operands()) {
-        if (auto *CI = dyn_cast<ConstantInt>(V)) {
-          // A ConstantInt cannot yield poison, so we can assume that it is
-          // the other operand that is poison.
-          return !CI->isZero();
-        }
-      }
-    }
-    return false;
-  }
-
   case Instruction::ICmp:
     // Comparing poison with any value yields poison.  This is why, for
     // instance, x s< (x +nsw 1) can be folded to true.
     return true;
 
-  case Instruction::GetElementPtr:
-    // A GEP implicitly represents a sequence of additions, subtractions,
-    // truncations, sign extensions and multiplications. The multiplications
-    // are by the non-zero sizes of some set of types, so we do not have to be
-    // concerned with multiplication by zero. If the GEP is in-bounds, then
-    // these operations are implicitly no-signed-wrap so poison is propagated
-    // by the arguments above for Add, Sub, Trunc, SExt and Mul.
-    return cast<GEPOperator>(I)->isInBounds();
-
   default:
     return false;
   }