[SCCP] Replace valuestate.isConstant with helper isConstant

[StephenFan]

Summary

With this patch, simplifyBinOp in visitBinaryInst may return
PoisonValue. So this patch also introduce a poison tag to ValueLattice
to handle poison constant.

[nikic]

This only makes a difference when the binop returns a poison result, right? I think it's unfortunate that this ends up replacing that with an undef value.

I think it would be good to introduce a new lattice value for poison, which allows us to explicitly represent this and avoid refining poison to undef. Especially in conjunction with D153718, which is kind of weird in we claim no undefs but the result is represented as undef.

[StephenFan]

In D153717#4447064, @nikic wrote:

This only makes a difference when the binop returns a poison result, right? I think it's unfortunate that this ends up replacing that with an undef value.

Exactly. Replace a poison value with an undef value is not a good idea, because As LangRef says, PoisonValue is stronger than UndefValue, it enables more optimizations. But actually, I really don't understand that, or in other words, I can't find an example to convince myself. Do you @nikic know that or do you mind telling me the answer? :)

I think it would be good to introduce a new lattice value for poison, which allows us to explicitly represent this and avoid refining poison to undef. Especially in conjunction with D153718, which is kind of weird in we claim no undefs but the result is represented as under.

This is a good idea. Or I also had an idea that we don't need the undef enum in ValueLattice, because no matter UndefValue or PoisonValue, they are all constant. And when we visit instructions in SCCPSolver, we should do instructionsimplify for instructions that one of their operands is constant. If we want to judge if a valuelattice is undef, we can just judge like isa<UndefValue>(ConstVal). What's your @nikic opinion?

[nikic]

In D153717#4447859, @StephenFan wrote:

In D153717#4447064, @nikic wrote:

This only makes a difference when the binop returns a poison result, right? I think it's unfortunate that this ends up replacing that with an undef value.

Exactly. Replace a poison value with an undef value is not a good idea, because As LangRef says, PoisonValue is stronger than UndefValue, it enables more optimizations. But actually, I really don't understand that, or in other words, I can't find an example to convince myself. Do you @nikic know that or do you mind telling me the answer? :)

For example and i32 %x, poison is poison, but and i32 %x, undef is not undef (it would be folded to i32 0).

I think it would be good to introduce a new lattice value for poison, which allows us to explicitly represent this and avoid refining poison to undef. Especially in conjunction with D153718, which is kind of weird in we claim no undefs but the result is represented as under.

This is a good idea. Or I also had an idea that we don't need the undef enum in ValueLattice, because no matter UndefValue or PoisonValue, they are all constant. And when we visit instructions in SCCPSolver, we should do instructionsimplify for instructions that one of their operands is constant. If we want to judge if a valuelattice is undef, we can just judge like isa<UndefValue>(ConstVal). What's your @nikic opinion?

I think the reason for the separate undef state is to make sure it does not accidentally get treated like a constant. The core problem is that SCCP allows a lattice transition undef -> C (which basically only exists to support phi nodes with undef operands). So if you initially folded some operation using undef as op(undef) = C2 (which makes an implicit choice of undef) and then transition undef -> C, then op(C) = C3 where possibly C2 != C3. This would violate the lattice structure.

[StephenFan]

Introduce poison tag to ValueLattice.

[StephenFan]

In D153717#4451441, @nikic wrote:

In D153717#4447859, @StephenFan wrote:

In D153717#4447064, @nikic wrote:

This only makes a difference when the binop returns a poison result, right? I think it's unfortunate that this ends up replacing that with an undef value.

Exactly. Replace a poison value with an undef value is not a good idea, because As LangRef says, PoisonValue is stronger than UndefValue, it enables more optimizations. But actually, I really don't understand that, or in other words, I can't find an example to convince myself. Do you @nikic know that or do you mind telling me the answer? :)

For example and i32 %x, poison is poison, but and i32 %x, undef is not undef (it would be folded to i32 0).

Thanks for your detailed explanation!

I think it would be good to introduce a new lattice value for poison, which allows us to explicitly represent this and avoid refining poison to undef. Especially in conjunction with D153718, which is kind of weird in we claim no undefs but the result is represented as under.

This is a good idea. Or I also had an idea that we don't need the undef enum in ValueLattice, because no matter UndefValue or PoisonValue, they are all constant. And when we visit instructions in SCCPSolver, we should do instructionsimplify for instructions that one of their operands is constant. If we want to judge if a valuelattice is undef, we can just judge like isa<UndefValue>(ConstVal). What's your @nikic opinion?

I think the reason for the separate undef state is to make sure it does not accidentally get treated like a constant. The core problem is that SCCP allows a lattice transition undef -> C (which basically only exists to support phi nodes with undef operands). So if you initially folded some operation using undef as op(undef) = C2 (which makes an implicit choice of undef) and then transition undef -> C, then op(C) = C3 where possibly C2 != C3. This would violate the lattice structure.

This is indeed the problem. Maybe we can use SimplifyQuery(DL).getWithoutUndef() as a query wrapper to avoid this situation.

[StephenFan]

Ping. :)

[nikic]

llvm/lib/Transforms/Utils/SCCPSolver.cpp

1235

Shouldn't we propagate poison here and in similar cases (by going through the Constant path)?

[StephenFan]

llvm/lib/Transforms/Utils/SCCPSolver.cpp

1235

Yes. But currently SCCPSolver::getConstant(ValueLatticeElement) doesn't support get undef or poison constant values. And undef or poison are represented in SCCPSolver just by the enum tags which don't have the type information to construct UndefValue or PoisonValue. To support this, we should record the undef or poison in ConstVal instead of just representing it by tags.

[nikic]

llvm/lib/Transforms/Utils/SCCPSolver.cpp

1235

Since recently getConstant() also takes the type, so you can materialize a PoisonValue with the correct type there.

[StephenFan]

Rebase.

llvm/include/llvm/Analysis/ValueLattice.h

enum ValueLatticeElementTy {
     /// can be merged with constants (or single element constant ranges),
     /// assuming all uses of the result will be replaced.
     /// Transition allowed to the following states:
     ///  constant
     ///  constantrange_including_undef
     ///  overdefined
     undef,
 
+    /// The same as undef state except it is an PoisonValue constant or produces
+    /// poison.
+    poison,
+
     /// This Value has a specific constant value.  The constant cannot be undef.
     /// (For constant integers, constantrange is used instead. Integer typed
     /// constantexprs can appear as constant.) Note that the constant state
     /// can be reached by merging undef & constant states.
     /// Transition allowed to the following states:
     ///  overdefined
     constant,
 
class ValueLatticeElement {
   };
 
   /// Destroy contents of lattice value, without destructing the object.
   void destroy() {
     switch (Tag) {
     case overdefined:
     case unknown:
     case undef:
+    case poison:
     case constant:
     case notconstant:
       break;
     case constantrange_including_undef:
     case constantrange:
       Range.~ConstantRange();
       break;
     };
case constantrange_including_undef:
       break;
     case constant:
     case notconstant:
       ConstVal = Other.ConstVal;
       break;
     case overdefined:
     case unknown:
     case undef:
+    case poison:
       break;
     }
   }
 
   ValueLatticeElement(ValueLatticeElement &&Other)
       : Tag(Other.Tag), NumRangeExtensions(0) {
     switch (Other.Tag) {
     case constantrange:
     case constantrange_including_undef:
       new (&Range) ConstantRange(std::move(Other.Range));
       NumRangeExtensions = Other.NumRangeExtensions;
       break;
     case constant:
     case notconstant:
       ConstVal = Other.ConstVal;
       break;
     case overdefined:
     case unknown:
     case undef:
+    case poison:
       break;
     }
     Other.Tag = unknown;
   }
 
   ValueLatticeElement &operator=(const ValueLatticeElement &Other) {
     destroy();
     new (this) ValueLatticeElement(Other);
public:
   }
   static ValueLatticeElement getOverdefined() {
     ValueLatticeElement Res;
     Res.markOverdefined();
     return Res;
   }
 
   bool isUndef() const { return Tag == undef; }
+  bool isPoison() const { return Tag == poison; }
   bool isUnknown() const { return Tag == unknown; }
-  bool isUnknownOrUndef() const { return Tag == unknown || Tag == undef; }
+  bool isUnknownOrUndefOrPoison() const {
+    return Tag == unknown || Tag == undef || Tag == poison;
+  }
   bool isConstant() const { return Tag == constant; }
   bool isNotConstant() const { return Tag == notconstant; }
   bool isConstantRangeIncludingUndef() const {
     return Tag == constantrange_including_undef;
   }
   /// Returns true if this value is a constant range. Use \p UndefAllowed to
   /// exclude non-singleton constant ranges that may also be undef. Note that
   /// this function also returns true if the range may include undef, but only
public:
   bool markOverdefined() {
     if (isOverdefined())
       return false;
     destroy();
     Tag = overdefined;
     return true;
   }
 
+  bool markPoison() {
+    if (isPoison())
+      return false;
+
+    assert(isUnknown());
+    Tag = poison;
+    return true;
+  }
+
   bool markUndef() {
     if (isUndef())
       return false;
 
     assert(isUnknown());
     Tag = undef;
     return true;
   }
 
   bool markConstant(Constant *V, bool MayIncludeUndef = false) {
+    if (isa<PoisonValue>(V))
+      return markPoison();
+
     if (isa<UndefValue>(V))
       return markUndef();
 
     if (isConstant()) {
       assert(getConstant() == V && "Marking constant with different value");
       return false;
     }
 
if (isConstantRange()) {
         return markOverdefined();
 
       assert(NewR.contains(getConstantRange()) &&
              "Existing range must be a subset of NewR");
       Range = std::move(NewR);
       return true;
     }
 
-    assert(isUnknown() || isUndef());
+    assert(isUnknownOrUndefOrPoison());
 
     NumRangeExtensions = 0;
     Tag = NewTag;
     new (&Range) ConstantRange(std::move(NewR));
     return true;
   }
 
   /// Updates this object to approximate both this object and RHS. Returns
   /// true if this object has been changed.
   bool mergeIn(const ValueLatticeElement &RHS,
                MergeOptions Opts = MergeOptions()) {
     if (RHS.isUnknown() || isOverdefined())
       return false;
     if (RHS.isOverdefined()) {
       markOverdefined();
       return true;
     }
 
-    if (isUndef()) {
+    if (isUndef() || isPoison()) {
       assert(!RHS.isUnknown());
-      if (RHS.isUndef())
+      if (isPoison() && RHS.isUndef())
+        return markUndef();
+      if (RHS.isUndef() || RHS.isPoison())
         return false;
       if (RHS.isConstant())
         return markConstant(RHS.getConstant(), true);
       if (RHS.isConstantRange())
         return markConstantRange(RHS.getConstantRange(true),
                                  Opts.setMayIncludeUndef());
       return markOverdefined();
     }

llvm/lib/Analysis/ValueLattice.cpp

ValueLatticeElement::getCompare(CmpInst::Predicate Pred, Type *Ty,
   return nullptr;
 }
 
 raw_ostream &operator<<(raw_ostream &OS, const ValueLatticeElement &Val) {
   if (Val.isUnknown())
     return OS << "unknown";
   if (Val.isUndef())
     return OS << "undef";
+  if (Val.isPoison())
+    return OS << "poison";
   if (Val.isOverdefined())
     return OS << "overdefined";
 
   if (Val.isNotConstant())
     return OS << "notconstant<" << *Val.getNotConstant() << ">";
 
   if (Val.isConstantRangeIncludingUndef())
     return OS << "constantrange incl. undef <"

llvm/lib/Transforms/IPO/SCCP.cpp

if (ReturnValue.isConstantRange() &&
             ConstantAsMetadata::get(ConstantInt::get(Context, CR.getLower())),
             ConstantAsMetadata::get(ConstantInt::get(Context, CR.getUpper()))};
         CB->setMetadata(LLVMContext::MD_range, MDNode::get(Context, RangeMD));
       }
       continue;
     }
     if (F->getReturnType()->isVoidTy())
       continue;
-    if (SCCPSolver::isConstant(ReturnValue) || ReturnValue.isUnknownOrUndef())
+    if (SCCPSolver::isConstant(ReturnValue) ||
+        ReturnValue.isUnknownOrUndefOrPoison())
       findReturnsToZap(*F, ReturnsToZap, Solver);
   }
 
   for (auto *F : Solver.getMRVFunctionsTracked()) {
     assert(F->getReturnType()->isStructTy() &&
            "The return type should be a struct");
     StructType *STy = cast<StructType>(F->getReturnType());
     if (Solver.isStructLatticeConstant(F, STy))

llvm/lib/Transforms/Utils/SCCPSolver.cpp

static ConstantRange getConstantRange(const ValueLatticeElement &LV, Type *Ty,
   if (LV.isConstantRange(UndefAllowed))
     return LV.getConstantRange();
   return ConstantRange::getFull(Ty->getScalarSizeInBits());
 }
 
 namespace llvm {
 
 bool SCCPSolver::isConstant(const ValueLatticeElement &LV) {
-  return LV.isConstant() ||
+  return LV.isConstant() || LV.isPoison() || LV.isUndef() ||
          (LV.isConstantRange() && LV.getConstantRange().isSingleElement());
 }
 
 bool SCCPSolver::isOverdefined(const ValueLatticeElement &LV) {
-  return !LV.isUnknownOrUndef() && !SCCPSolver::isConstant(LV);
+  return !LV.isUnknownOrUndefOrPoison() && !SCCPSolver::isConstant(LV);
 }
 
 static bool canRemoveInstruction(Instruction *I) {
   if (wouldInstructionBeTriviallyDead(I))
     return true;
 
   // Some instructions can be handled but are rejected above. Catch
   // those cases by falling through to here.
for (unsigned i = 0, e = STy->getNumElements(); i != e; ++i) {
     if (!SCCPSolver::isConstant(LV))
       return false;
   }
   return true;
 }
 
 Constant *SCCPInstVisitor::getConstant(const ValueLatticeElement &LV,
                                        Type *Ty) const {
+  if (LV.isPoison())
+    return PoisonValue::get(Ty);
+
+  if (LV.isUndef())
+    return UndefValue::get(Ty);
+
   if (LV.isConstant()) {
     Constant *C = LV.getConstant();
     assert(C->getType() == Ty && "Type mismatch");
     return C;
   }
 
   if (LV.isConstantRange()) {
     const auto &CR = LV.getConstantRange();
if (BI->isUnconditional()) {
       return;
     }
 
     ValueLatticeElement BCValue = getValueState(BI->getCondition());
     ConstantInt *CI = getConstantInt(BCValue, BI->getCondition()->getType());
     if (!CI) {
       // Overdefined condition variables, and branches on unfoldable constant
       // conditions, mean the branch could go either way.
-      if (!BCValue.isUnknownOrUndef())
+      if (!BCValue.isUnknownOrUndefOrPoison())
         Succs[0] = Succs[1] = true;
       return;
     }
 
     // Constant condition variables mean the branch can only go a single way.
     Succs[CI->isZero()] = true;
     return;
   }
if (SCValue.isConstantRange(/*UndefAllowed=*/false)) {
       }
 
       // TODO: Determine whether default case is reachable.
       Succs[SI->case_default()->getSuccessorIndex()] = true;
       return;
     }
 
     // Overdefined or unknown condition? All destinations are executable!
-    if (!SCValue.isUnknownOrUndef())
+    if (!SCValue.isUnknownOrUndefOrPoison())
       Succs.assign(TI.getNumSuccessors(), true);
     return;
   }
 
   // In case of indirect branch and its address is a blockaddress, we mark
   // the target as executable.
   if (auto *IBR = dyn_cast<IndirectBrInst>(&TI)) {
     // Casts are folded by visitCastInst.
     ValueLatticeElement IBRValue = getValueState(IBR->getAddress());
     BlockAddress *Addr = dyn_cast_or_null<BlockAddress>(
         getConstant(IBRValue, IBR->getAddress()->getType()));
     if (!Addr) { // Overdefined or unknown condition?
       // All destinations are executable!
-      if (!IBRValue.isUnknownOrUndef())
+      if (!IBRValue.isUnknownOrUndefOrPoison())
         Succs.assign(TI.getNumSuccessors(), true);
       return;
     }
 
     BasicBlock *T = Addr->getBasicBlock();
     assert(Addr->getFunction() == T->getParent() &&
            "Block address of a different function ?");
     for (unsigned i = 0; i < IBR->getNumSuccessors(); ++i) {

 
 void SCCPInstVisitor::visitCastInst(CastInst &I) {
   // ResolvedUndefsIn might mark I as overdefined. Bail out, even if we would
   // discover a concrete value later.
   if (ValueState[&I].isOverdefined())
     return;
 
   ValueLatticeElement OpSt = getValueState(I.getOperand(0));
-  if (OpSt.isUnknownOrUndef())
+  if (OpSt.isUnknown())
     return;
 
   if (Constant *OpC = getConstant(OpSt, I.getOperand(0)->getType())) {
     // Fold the constant as we build.
     Constant *C = ConstantFoldCastOperand(I.getOpcode(), OpC, I.getType(), DL);
     markConstant(&I, C);
   } else if (I.getDestTy()->isIntegerTy() &&
              I.getSrcTy()->isIntOrIntVectorTy()) {

 void SCCPInstVisitor::handleExtractOfWithOverflow(ExtractValueInst &EVI,
                                                   const WithOverflowInst *WO,
                                                   unsigned Idx) {
   Value *LHS = WO->getLHS(), *RHS = WO->getRHS();
   ValueLatticeElement L = getValueState(LHS);
   ValueLatticeElement R = getValueState(RHS);
   addAdditionalUser(LHS, &EVI);
   addAdditionalUser(RHS, &EVI);
-  if (L.isUnknownOrUndef() || R.isUnknownOrUndef())
+  if (L.isUnknownOrUndefOrPoison() || R.isUnknownOrUndefOrPoison())
     return; // Wait to resolve.
 
   Type *Ty = LHS->getType();
   ConstantRange LR = getConstantRange(L, Ty);
   ConstantRange RR = getConstantRange(R, Ty);
   if (Idx == 0) {
     ConstantRange Res = LR.binaryOp(WO->getBinaryOp(), RR);
     mergeInValue(&EVI, ValueLatticeElement::getRange(Res));
if (I.getType()->isStructTy())
     return (void)markOverdefined(&I);
 
   // resolvedUndefsIn might mark I as overdefined. Bail out, even if we would
   // discover a concrete value later.
   if (ValueState[&I].isOverdefined())
     return (void)markOverdefined(&I);
 
   ValueLatticeElement CondValue = getValueState(I.getCondition());
-  if (CondValue.isUnknownOrUndef())
+  if (CondValue.isUnknownOrUndefOrPoison())
     return;
 
   if (ConstantInt *CondCB =
           getConstantInt(CondValue, I.getCondition()->getType())) {
     Value *OpVal = CondCB->isZero() ? I.getFalseValue() : I.getTrueValue();
     mergeInValue(&I, getValueState(OpVal));
     return;
   }
void SCCPInstVisitor::visitUnaryOperator(Instruction &I) {
 
   ValueLatticeElement &IV = ValueState[&I];
   // resolvedUndefsIn might mark I as overdefined. Bail out, even if we would
   // discover a concrete value later.
   if (SCCPSolver::isOverdefined(IV))
     return (void)markOverdefined(&I);
 
   // If something is unknown/undef, wait for it to resolve.
-  if (V0State.isUnknownOrUndef())
+  if (V0State.isUnknown())
     return;
 
   if (SCCPSolver::isConstant(V0State))
     if (Constant *C = ConstantFoldUnaryOpOperand(
             I.getOpcode(), getConstant(V0State, I.getType()), DL))
       return (void)markConstant(IV, &I, C);
 
   markOverdefined(&I);
 }
 
 void SCCPInstVisitor::visitFreezeInst(FreezeInst &I) {
   // If this freeze returns a struct, just mark the result overdefined.
   // TODO: We could do a lot better than this.
   if (I.getType()->isStructTy())
     return (void)markOverdefined(&I);
 
   ValueLatticeElement V0State = getValueState(I.getOperand(0));
   ValueLatticeElement &IV = ValueState[&I];
   // resolvedUndefsIn might mark I as overdefined. Bail out, even if we would
   // discover a concrete value later.
   if (SCCPSolver::isOverdefined(IV))
     return (void)markOverdefined(&I);
 
   // If something is unknown/undef, wait for it to resolve.
-  if (V0State.isUnknownOrUndef())
+  if (V0State.isUnknownOrUndefOrPoison())
     return;
 
   if (SCCPSolver::isConstant(V0State) &&
       isGuaranteedNotToBeUndefOrPoison(getConstant(V0State, I.getType())))
     return (void)markConstant(IV, &I, getConstant(V0State, I.getType()));
 
   markOverdefined(&I);
 }
 
 // Handle Binary Operators.
 void SCCPInstVisitor::visitBinaryOperator(Instruction &I) {
   ValueLatticeElement V1State = getValueState(I.getOperand(0));
   ValueLatticeElement V2State = getValueState(I.getOperand(1));
 
   ValueLatticeElement &IV = ValueState[&I];
   if (IV.isOverdefined())
     return;
 
   // If something is undef, wait for it to resolve.
-  if (V1State.isUnknownOrUndef() || V2State.isUnknownOrUndef())
+  if (V1State.isUnknownOrUndefOrPoison() || V2State.isUnknownOrUndefOrPoison())
     return;
 
   if (V1State.isOverdefined() && V2State.isOverdefined())
     return (void)markOverdefined(&I);
 
   // If either of the operands is a constant, try to fold it to a constant.
   // TODO: Use information from notconstant better.
-  if ((V1State.isConstant() || V2State.isConstant())) {
+  if ((SCCPSolver::isConstant(V1State) || SCCPSolver::isConstant(V2State))) {
     Value *V1 = SCCPSolver::isConstant(V1State)
                     ? getConstant(V1State, I.getOperand(0)->getType())
                     : I.getOperand(0);
     Value *V2 = SCCPSolver::isConstant(V2State)
                     ? getConstant(V2State, I.getOperand(1)->getType())
                     : I.getOperand(1);
     Value *R = simplifyBinOp(I.getOpcode(), V1, V2, SimplifyQuery(DL));
     auto *C = dyn_cast_or_null<Constant>(R);
void SCCPInstVisitor::visitCmpInst(CmpInst &I) {
   if (C) {
     ValueLatticeElement CV;
     CV.markConstant(C);
     mergeInValue(&I, CV);
     return;
   }
 
   // If operands are still unknown, wait for it to resolve.
-  if ((V1State.isUnknownOrUndef() || V2State.isUnknownOrUndef()) &&
+  if ((V1State.isUnknownOrUndefOrPoison() ||
+       V2State.isUnknownOrUndefOrPoison()) &&
       !SCCPSolver::isConstant(ValueState[&I]))
     return;
 
   markOverdefined(&I);
 }
 
 // Handle getelementptr instructions.  If all operands are constants then we
 // can turn this into a getelementptr ConstantExpr.
 void SCCPInstVisitor::visitGetElementPtrInst(GetElementPtrInst &I) {
   if (SCCPSolver::isOverdefined(ValueState[&I]))
     return (void)markOverdefined(&I);
 
   SmallVector<Constant *, 8> Operands;
   Operands.reserve(I.getNumOperands());
 
   for (unsigned i = 0, e = I.getNumOperands(); i != e; ++i) {
     ValueLatticeElement State = getValueState(I.getOperand(i));
-    if (State.isUnknownOrUndef())
+    if (State.isUnknownOrUndefOrPoison())
       return; // Operands are not resolved yet.
 
     if (SCCPSolver::isOverdefined(State))
       return (void)markOverdefined(&I);
 
     if (Constant *C = getConstant(State, I.getOperand(i)->getType())) {
       Operands.push_back(C);
       continue;
if (I.getType()->isStructTy() || I.isVolatile())
     return (void)markOverdefined(&I);
 
   // resolvedUndefsIn might mark I as overdefined. Bail out, even if we would
   // discover a concrete value later.
   if (ValueState[&I].isOverdefined())
     return (void)markOverdefined(&I);
 
   ValueLatticeElement PtrVal = getValueState(I.getOperand(0));
-  if (PtrVal.isUnknownOrUndef())
+  if (PtrVal.isUnknownOrUndefOrPoison())
     return; // The pointer is not resolved yet!
 
   ValueLatticeElement &IV = ValueState[&I];
 
   if (SCCPSolver::isConstant(PtrVal)) {
     Constant *Ptr = getConstant(PtrVal, I.getOperand(0)->getType());
 
     // load null is undefined.
if (F && F->isDeclaration() && canConstantFoldCallTo(&CB, F)) {
     SmallVector<Constant *, 8> Operands;
     for (const Use &A : CB.args()) {
       if (A.get()->getType()->isStructTy())
         return markOverdefined(&CB); // Can't handle struct args.
       if (A.get()->getType()->isMetadataTy())
         continue;                    // Carried in CB, not allowed in Operands.
       ValueLatticeElement State = getValueState(A);
 
-      if (State.isUnknownOrUndef())
+      if (State.isUnknownOrUndefOrPoison())
         return; // Operands are not resolved yet.
       if (SCCPSolver::isOverdefined(State))
         return (void)markOverdefined(&CB);
       assert(SCCPSolver::isConstant(State) && "Unknown state!");
       Operands.push_back(getConstant(State, A->getType()));
     }
 
     if (SCCPSolver::isOverdefined(getValueState(&CB)))
if (auto *II = dyn_cast<IntrinsicInst>(&CB)) {
 
     if (ConstantRange::isIntrinsicSupported(II->getIntrinsicID())) {
       // Compute result range for intrinsics supported by ConstantRange.
       // Do this even if we don't know a range for all operands, as we may
       // still know something about the result range, e.g. of abs(x).
       SmallVector<ConstantRange, 2> OpRanges;
       for (Value *Op : II->args()) {
         const ValueLatticeElement &State = getValueState(Op);
-        if (State.isUnknownOrUndef())
+        if (State.isUnknownOrUndefOrPoison())
           return;
         OpRanges.push_back(getConstantRange(State, Op->getType()));
       }
 
       ConstantRange Result =
           ConstantRange::intrinsic(II->getIntrinsicID(), OpRanges);
       return (void)mergeInValue(II, ValueLatticeElement::getRange(Result));
     }

llvm/test/Transforms/SCCP/PR16052.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --scrub-attributes
 ; RUN: opt < %s -S -passes=ipsccp | FileCheck %s
 
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 define i64 @fn2() {
-; CHECK-LABEL: define {{[^@]+}}@fn2()
+; CHECK-LABEL: define {{[^@]+}}@fn2() {
 ; CHECK-NEXT:  entry:
-; CHECK-NEXT:    [[CONV:%.*]] = sext i32 undef to i64
-; CHECK-NEXT:    [[DIV:%.*]] = sdiv i64 8, [[CONV]]
-; CHECK-NEXT:    [[CALL2:%.*]] = call i64 @fn1(i64 [[DIV]])
+; CHECK-NEXT:    [[CALL2:%.*]] = call i64 @fn1(i64 poison)
 ; CHECK-NEXT:    ret i64 [[CALL2]]
 ;
 entry:
   %conv = sext i32 undef to i64
   %div = sdiv i64 8, %conv
   %call2 = call i64 @fn1(i64 %div)
   ret i64 %call2
 }
 
 define internal i64 @fn1(i64 %p1) {
 ; CHECK-LABEL: define {{[^@]+}}@fn1
-; CHECK-SAME: (i64 [[P1:%.*]])
+; CHECK-SAME: (i64 [[P1:%.*]]) {
 ; CHECK-NEXT:  entry:
-; CHECK-NEXT:    [[TOBOOL:%.*]] = icmp ne i64 [[P1]], 0
-; CHECK-NEXT:    [[COND:%.*]] = select i1 [[TOBOOL]], i64 [[P1]], i64 [[P1]]
+; CHECK-NEXT:    [[TOBOOL:%.*]] = icmp ne i64 poison, 0
+; CHECK-NEXT:    [[COND:%.*]] = select i1 [[TOBOOL]], i64 poison, i64 poison
 ; CHECK-NEXT:    ret i64 [[COND]]
 ;
 entry:
   %tobool = icmp ne i64 %p1, 0
   %cond = select i1 %tobool, i64 %p1, i64 %p1
   ret i64 %cond
 }

llvm/test/Transforms/SCCP/binaryops-range-special-cases.ll

 }
 
 define void @urem_cmp_constants() {
 ; CHECK-LABEL: @urem_cmp_constants(
 ; CHECK-NEXT:    call void @use(i1 true)
 ; CHECK-NEXT:    call void @use(i1 false)
 ; CHECK-NEXT:    call void @use(i1 true)
 ; CHECK-NEXT:    call void @use(i1 false)
-; CHECK-NEXT:    [[UREM_3:%.*]] = urem i16 12704, 0
-; CHECK-NEXT:    [[C_5:%.*]] = icmp eq i16 [[UREM_3]], 1
+; CHECK-NEXT:    [[C_5:%.*]] = icmp eq i16 poison, 1
 ; CHECK-NEXT:    call void @use(i1 [[C_5]])
 ; CHECK-NEXT:    ret void
 ;
   %sel = select i1 false, i16 0, i16 12704
   %urem.1 = urem i16 %sel, 12704
   %c.1 = icmp eq i16 %urem.1, 0
   call void @use(i1 %c.1)
   %c.2 = icmp eq i16 %urem.1, 1

 }
 
 define void @srem_cmp_constants() {
 ; CHECK-LABEL: @srem_cmp_constants(
 ; CHECK-NEXT:    call void @use(i1 true)
 ; CHECK-NEXT:    call void @use(i1 false)
 ; CHECK-NEXT:    call void @use(i1 true)
 ; CHECK-NEXT:    call void @use(i1 false)
-; CHECK-NEXT:    [[SREM_3:%.*]] = urem i16 12704, 0
-; CHECK-NEXT:    [[C_5:%.*]] = icmp eq i16 [[SREM_3]], 1
+; CHECK-NEXT:    [[C_5:%.*]] = icmp eq i16 poison, 1
 ; CHECK-NEXT:    call void @use(i1 [[C_5]])
 ; CHECK-NEXT:    ret void
 ;
   %sel = select i1 false, i16 0, i16 12704
   %srem.1 = srem i16 %sel, 12704
   %c.1 = icmp eq i16 %srem.1, 0
   call void @use(i1 %c.1)
   %c.2 = icmp eq i16 %srem.1, 1

llvm/test/Transforms/SCCP/ip-ranges-phis.ll

 ; CHECK-NEXT:    [[P:%.*]] = phi i32 [ [[X]], [[ENTRY:%.*]] ], [ [[Y]], [[IF_TRUE_1]] ], [ [[Z]], [[IF_TRUE_2]] ]
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp sgt i32 [[P]], 5
 ; CHECK-NEXT:    [[C_2:%.*]] = icmp eq i32 [[P]], 0
 ; CHECK-NEXT:    [[C_3:%.*]] = icmp slt i32 [[P]], 0
 ; CHECK-NEXT:    [[V_1:%.*]] = select i1 [[C_1]], i32 10, i32 100
 ; CHECK-NEXT:    [[V_2:%.*]] = select i1 [[C_2]], i32 20, i32 200
 ; CHECK-NEXT:    [[V_3:%.*]] = select i1 [[C_3]], i32 30, i32 300
 ; CHECK-NEXT:    [[R_1:%.*]] = add nuw nsw i32 [[V_1]], [[V_2]]
-; CHECK-NEXT:    [[R_2:%.*]] = add nuw nsw i32 [[R_1]], [[V_3]]
-; CHECK-NEXT:    [[R_3:%.*]] = add nuw nsw i32 [[R_2]], 400
-; CHECK-NEXT:    [[R_4:%.*]] = add nuw nsw i32 [[R_3]], 50
-; CHECK-NEXT:    [[R_5:%.*]] = add nuw nsw i32 [[R_4]], 60
-; CHECK-NEXT:    [[R_6:%.*]] = add nuw nsw i32 [[R_4]], 700
+; CHECK-NEXT:    [[R_2:%.*]] = add i32 [[R_1]], [[V_3]]
+; CHECK-NEXT:    [[R_3:%.*]] = add i32 [[R_2]], 400
+; CHECK-NEXT:    [[R_4:%.*]] = add i32 [[R_3]], 50
+; CHECK-NEXT:    [[R_5:%.*]] = add i32 [[R_4]], 60
+; CHECK-NEXT:    [[R_6:%.*]] = add i32 [[R_4]], 700
 ; CHECK-NEXT:    ret i32 [[R_6]]
 ;
 
 
 
 entry:
   br i1 %cmp.1, label %if.true.1, label %end
 

 ; CHECK-LABEL: define {{[^@]+}}@caller3
 ; CHECK-SAME: (i32 [[Y:%.*]], i1 [[CMP_1:%.*]]) {
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    br i1 [[CMP_1]], label [[IF_TRUE:%.*]], label [[END:%.*]]
 ; CHECK:       if.true:
 ; CHECK-NEXT:    br label [[END]]
 ; CHECK:       end:
 ; CHECK-NEXT:    [[P1:%.*]] = phi i32 [ 0, [[ENTRY:%.*]] ], [ 5, [[IF_TRUE]] ]
-; CHECK-NEXT:    [[CALL1:%.*]] = tail call i32 @f3(i32 [[P1]], i32 [[Y]], i1 [[CMP_1]])
+; CHECK-NEXT:    [[CALL1:%.*]] = tail call i32 @f3(i32 [[P1]], i32 [[Y]], i1 [[CMP_1]]), !range [[RNG0:![0-9]+]]
 ; CHECK-NEXT:    ret i32 [[CALL1]]
 ;
 
 
 entry:
   br i1 %cmp.1, label %if.true, label %end
 
 if.true:
   br label %end
 
 end:
   %p1 = phi i32 [ 0, %entry], [ 5, %if.true ]
   %call1 = tail call i32 @f3(i32 %p1, i32 %y, i1 %cmp.1)
   ret i32 %call1
 }

llvm/test/Transforms/SCCP/ipsccp-cycles.ll

 
 bb.false:
   ret i32 0
 }
 
 define i32 @test3b(i32 %a) {
 ; CHECK-LABEL: @test3b(
 ; CHECK-NEXT:  entry:
-; CHECK-NEXT:    [[V1:%.*]] = call i32 @test3a(i32 0)
+; CHECK-NEXT:    [[V1:%.*]] = call i32 @test3a(i32 0), !range [[RNG0:![0-9]+]]
 ; CHECK-NEXT:    br label [[LOOP:%.*]]
 ; CHECK:       loop:
-; CHECK-NEXT:    [[V2:%.*]] = call i32 @test3a(i32 [[V1]])
+; CHECK-NEXT:    [[V2:%.*]] = call i32 @test3a(i32 [[V1]]), !range [[RNG0]]
 ; CHECK-NEXT:    [[V3:%.*]] = add i32 [[V2]], 1
-; CHECK-NEXT:    [[V4:%.*]] = call i32 @test3a(i32 [[V3]])
+; CHECK-NEXT:    [[V4:%.*]] = call i32 @test3a(i32 [[V3]]), !range [[RNG0]]
 ; CHECK-NEXT:    [[C:%.*]] = icmp eq i32 [[V4]], [[A:%.*]]
 ; CHECK-NEXT:    br i1 [[C]], label [[EXIT:%.*]], label [[LOOP]]
 ; CHECK:       exit:
 ; CHECK-NEXT:    ret i32 [[V4]]
 ;
 entry:
   %v1 = call i32 @test3a(i32 0)
   br label %loop
exit:
   ret i32 %v4
 }
 
 %struct.S = type { i32, i32 }
 
 ; Check for a range extension cycle through a  struct argument.
 define internal i32 @test4a(%struct.S %s) {
 ; CHECK-LABEL: @test4a(
-; CHECK-NEXT:    [[A:%.*]] = extractvalue [[STRUCT_S:%.*]] %s, 0
-; CHECK-NEXT:    [[B:%.*]] = extractvalue [[STRUCT_S]] %s, 1
+; CHECK-NEXT:    [[A:%.*]] = extractvalue [[STRUCT_S:%.*]] [[S:%.*]], 0
+; CHECK-NEXT:    [[B:%.*]] = extractvalue [[STRUCT_S]] [[S]], 1
 ; CHECK-NEXT:    [[X:%.*]] = add i32 [[A]], 1
 ; CHECK-NEXT:    [[C:%.*]] = icmp eq i32 [[X]], [[B]]
 ; CHECK-NEXT:    br i1 [[C]], label [[BB_TRUE:%.*]], label [[BB_FALSE:%.*]]
 ; CHECK:       bb.true:
-; CHECK-NEXT:    [[S2:%.*]] = insertvalue [[STRUCT_S]] %s, i32 [[X]], 0
-; CHECK-NEXT:    [[R:%.*]] = call i32 @test4a(%struct.S [[S2]])
+; CHECK-NEXT:    [[S2:%.*]] = insertvalue [[STRUCT_S]] [[S]], i32 [[X]], 0
+; CHECK-NEXT:    [[R:%.*]] = call i32 @test4a([[STRUCT_S]] [[S2]])
 ; CHECK-NEXT:    ret i32 [[R]]
 ; CHECK:       bb.false:
 ; CHECK-NEXT:    ret i32 [[A]]
 ;
   %a = extractvalue %struct.S %s, 0
   %b = extractvalue %struct.S %s, 1
 
   %x = add i32 %a, 1
   %c = icmp eq i32 %x, %b
   br i1 %c, label %bb.true, label %bb.false
 
 bb.true:
   %s2 = insertvalue %struct.S %s, i32 %x, 0
   %r = call i32 @test4a(%struct.S %s2)
   ret i32 %r
 
 bb.false:
   ret i32 %a
 }
 
 define i32 @test4b(i32 %b) {
 ; CHECK-LABEL: @test4b(
 ; CHECK-NEXT:    [[S2:%.*]] = insertvalue [[STRUCT_S:%.*]] { i32 17, i32 undef }, i32 [[B:%.*]], 1
-; CHECK-NEXT:    [[X:%.*]] = call i32 @test4a(%struct.S [[S2]])
+; CHECK-NEXT:    [[X:%.*]] = call i32 @test4a([[STRUCT_S]] [[S2]])
 ; CHECK-NEXT:    ret i32 [[X]]
 ;
   %s1 = insertvalue %struct.S undef, i32 17, 0
   %s2 = insertvalue %struct.S %s1, i32 %b, 1
   %X = call i32 @test4a(%struct.S %s2)
   ret i32 %X
 }
 

 
 define internal %struct @test6a(ptr %arg, i32 %arg1, i32 %arg2) {
 ; CHECK-LABEL: @test6a(
 ; CHECK-NEXT:  bb:
 ; CHECK-NEXT:    [[TMP:%.*]] = icmp eq ptr [[ARG:%.*]], null
 ; CHECK-NEXT:    br i1 [[TMP]], label [[BB6:%.*]], label [[BB3:%.*]]
 ; CHECK:       bb3:
 ; CHECK-NEXT:    [[S1:%.*]] = tail call [[STRUCT:%.*]] @test6a(ptr [[ARG]], i32 0, i32 -1)
-; CHECK-NEXT:    [[TMP4:%.*]] = extractvalue [[STRUCT]] %s1, 0
+; CHECK-NEXT:    [[TMP4:%.*]] = extractvalue [[STRUCT]] [[S1]], 0
 ; CHECK-NEXT:    [[TMP5:%.*]] = add nsw i32 [[TMP4]], -1
-; CHECK-NEXT:    [[S2:%.*]] = insertvalue [[STRUCT]] %s1, i32 [[TMP5]], 0
-; CHECK-NEXT:    ret [[STRUCT]] %s2
+; CHECK-NEXT:    [[S2:%.*]] = insertvalue [[STRUCT]] [[S1]], i32 [[TMP5]], 0
+; CHECK-NEXT:    ret [[STRUCT]] [[S2]]
 ; CHECK:       bb6:
 ; CHECK-NEXT:    ret [[STRUCT]] { i32 0, i32 undef }
 ;
 bb:
   %tmp = icmp eq ptr %arg, null
   br i1 %tmp, label %bb6, label %bb3
 
 bb3:                                              ; preds = %bb

llvm/test/Transforms/SCCP/loadtest2.ll

+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --version 2
 ; RUN: opt < %s -data-layout="E-p:32:32" -passes=ipsccp -S | FileCheck %s
 
 @j = internal global i32 undef, align 4
 
 ; Make sure we do not mark loads from undef as overdefined.
 define i32 @test5(i32 %b) {
-; CHECK-LABEL: define i32 @test5(i32 %b)
-; CHECK-NEXT:    %add = add nsw i32 undef, %b
-; CHECK-NEXT:    ret i32 %add
+; CHECK-LABEL: define i32 @test5
+; CHECK-SAME: (i32 [[B:%.*]]) {
+; CHECK-NEXT:    [[ADD:%.*]] = add nsw i32 undef, [[B]]
+; CHECK-NEXT:    ret i32 [[ADD]]
 ;
   %l = load i32, ptr @j, align 4
   %add = add nsw i32 %l, %b
   ret i32 %add
 }

llvm/test/Transforms/SCCP/overdefined-div.ll

 ;
   %tinkywinky = sdiv i32 0, %foo
   ret i32 %tinkywinky
 }
 
 define i32 @test3(i32 %foo) {
 ; CHECK-LABEL: define i32 @test3
 ; CHECK-SAME: (i32 [[FOO:%.*]]) {
-; CHECK-NEXT:    [[TINKYWINKY:%.*]] = udiv i32 [[FOO]], 0
-; CHECK-NEXT:    ret i32 [[TINKYWINKY]]
+; CHECK-NEXT:    ret i32 poison
 ;
   %tinkywinky = udiv i32 %foo, 0
   ret i32 %tinkywinky
 }
 
 define i32 @test4(i32 %foo) {
 ; CHECK-LABEL: define i32 @test4
 ; CHECK-SAME: (i32 [[FOO:%.*]]) {
-; CHECK-NEXT:    [[TINKYWINKY:%.*]] = sdiv i32 [[FOO]], 0
-; CHECK-NEXT:    ret i32 [[TINKYWINKY]]
+; CHECK-NEXT:    ret i32 poison
 ;
   %tinkywinky = sdiv i32 %foo, 0
   ret i32 %tinkywinky
 }

llvm/test/Transforms/SCCP/ub-shift.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt < %s -passes=sccp -S | FileCheck %s
 
 define void @shift_undef_64(ptr %p) {
 ; CHECK-LABEL: @shift_undef_64(
-; CHECK-NEXT:    store i64 0, ptr [[P:%.*]], align 4
-; CHECK-NEXT:    store i64 -1, ptr [[P]], align 4
-; CHECK-NEXT:    [[R3:%.*]] = shl nuw nsw i64 -1, 4294967298
-; CHECK-NEXT:    store i64 [[R3]], ptr [[P]], align 4
+; CHECK-NEXT:    store i64 poison, ptr [[P:%.*]], align 4
+; CHECK-NEXT:    store i64 poison, ptr [[P]], align 4
+; CHECK-NEXT:    store i64 poison, ptr [[P]], align 4
 ; CHECK-NEXT:    ret void
 ;
   %r1 = lshr i64 -1, 4294967296 ; 2^32
   store i64 %r1, ptr %p
 
   %r2 = ashr i64 -1, 4294967297 ; 2^32 + 1
   store i64 %r2, ptr %p
 
   %r3 = shl i64 -1, 4294967298 ; 2^32 + 2
   store i64 %r3, ptr %p
 
   ret void
 }
 
 define void @shift_undef_65(ptr %p) {
 ; CHECK-LABEL: @shift_undef_65(
-; CHECK-NEXT:    store i65 0, ptr [[P:%.*]], align 4
-; CHECK-NEXT:    store i65 0, ptr [[P]], align 4
-; CHECK-NEXT:    [[R3:%.*]] = shl nuw nsw i65 1, -18446744073709551615
-; CHECK-NEXT:    store i65 [[R3]], ptr [[P]], align 4
+; CHECK-NEXT:    store i65 poison, ptr [[P:%.*]], align 4
+; CHECK-NEXT:    store i65 poison, ptr [[P]], align 4
+; CHECK-NEXT:    store i65 poison, ptr [[P]], align 4
 ; CHECK-NEXT:    ret void
 ;
   %r1 = lshr i65 2, 18446744073709551617
   store i65 %r1, ptr %p
 
   %r2 = ashr i65 4, 18446744073709551617
   store i65 %r2, ptr %p
 
   %r3 = shl i65 1, 18446744073709551617
   store i65 %r3, ptr %p
 
   ret void
 }
 
 define void @shift_undef_256(ptr %p) {
 ; CHECK-LABEL: @shift_undef_256(
-; CHECK-NEXT:    store i256 0, ptr [[P:%.*]], align 4
-; CHECK-NEXT:    store i256 0, ptr [[P]], align 4
-; CHECK-NEXT:    [[R3:%.*]] = shl nuw nsw i256 1, 18446744073709551619
-; CHECK-NEXT:    store i256 [[R3]], ptr [[P]], align 4
+; CHECK-NEXT:    store i256 poison, ptr [[P:%.*]], align 4
+; CHECK-NEXT:    store i256 poison, ptr [[P]], align 4
+; CHECK-NEXT:    store i256 poison, ptr [[P]], align 4
 ; CHECK-NEXT:    ret void
 ;
   %r1 = lshr i256 2, 18446744073709551617
   store i256 %r1, ptr %p
 
   %r2 = ashr i256 4, 18446744073709551618
   store i256 %r2, ptr %p
 
   %r3 = shl i256 1, 18446744073709551619
   store i256 %r3, ptr %p
 
   ret void
 }
 
 define void @shift_undef_511(ptr %p) {
 ; CHECK-LABEL: @shift_undef_511(
-; CHECK-NEXT:    store i511 0, ptr [[P:%.*]], align 4
-; CHECK-NEXT:    store i511 -1, ptr [[P]], align 4
-; CHECK-NEXT:    [[R3:%.*]] = shl nuw nsw i511 -3, 1208925819614629174706180
-; CHECK-NEXT:    store i511 [[R3]], ptr [[P]], align 4
+; CHECK-NEXT:    store i511 poison, ptr [[P:%.*]], align 4
+; CHECK-NEXT:    store i511 poison, ptr [[P]], align 4
+; CHECK-NEXT:    store i511 poison, ptr [[P]], align 4
 ; CHECK-NEXT:    ret void
 ;
   %r1 = lshr i511 -1, 1208925819614629174706276 ; 2^80 + 100
   store i511 %r1, ptr %p
 
   %r2 = ashr i511 -2, 1208925819614629174706200
   store i511 %r2, ptr %p
 
   %r3 = shl i511 -3, 1208925819614629174706180
   store i511 %r3, ptr %p
 
   ret void
 }

llvm/test/Transforms/SCCP/undef-resolve.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt -passes=sccp -S < %s | FileCheck %s
 
 
 ; PR6940
 define double @test1() {
 ; CHECK-LABEL: @test1(
-; CHECK-NEXT:    [[T:%.*]] = sitofp i32 undef to double
-; CHECK-NEXT:    ret double [[T]]
+; CHECK-NEXT:    ret double 0.000000e+00
 ;
   %t = sitofp i32 undef to double
   ret double %t
 }
 
 
 ; rdar://7832370
 ; Check that lots of stuff doesn't get turned into undef.

 ;
   %t = fadd double %x, undef
   ret double %t
 }
 
 ; Make sure casts produce a possible value
 define i32 @test5() {
 ; CHECK-LABEL: @test5(
-; CHECK-NEXT:    [[T:%.*]] = sext i8 undef to i32
-; CHECK-NEXT:    ret i32 [[T]]
+; CHECK-NEXT:    ret i32 0
 ;
   %t = sext i8 undef to i32
   ret i32 %t
 }
 
 ; Make sure ashr produces a possible value
 define i32 @test6() {
 ; CHECK-LABEL: @test6(

 entry:
   %shr4 = ashr i32 undef, zext (i1 icmp eq (ptr @test11, ptr @GV) to i32)
   ret i32 %shr4
 }
 
 ; Test unary ops
 define double @test12(double %x) {
 ; CHECK-LABEL: @test12(
-; CHECK-NEXT:    [[T:%.*]] = fneg double undef
-; CHECK-NEXT:    ret double [[T]]
+; CHECK-NEXT:    ret double undef
 ;
   %t = fneg double undef
   ret double %t
 }

llvm/test/Transforms/SCCP/widening.ll

 }
 
 ; In the function below, the condition %c.1 results in a range [7, 6), which
 ; can be used as a widening bound. It does not fully contain the range we get
 ; from combining it with the information from %tmp12.
 define void @foo(ptr %arg) {
 ; SCCP-LABEL: @foo(
 ; SCCP-NEXT:  bb:
-; SCCP-NEXT:    [[TMP:%.*]] = zext i8 undef to i32
 ; SCCP-NEXT:    [[TMP2:%.*]] = load i64, ptr [[ARG:%.*]], align 8
-; SCCP-NEXT:    switch i32 [[TMP]], label [[BB20:%.*]] [
-; SCCP-NEXT:    i32 1, label [[BB3:%.*]]
-; SCCP-NEXT:    i32 2, label [[BB4:%.*]]
-; SCCP-NEXT:    i32 4, label [[BB19:%.*]]
-; SCCP-NEXT:    ]
-; SCCP:       bb3:
-; SCCP-NEXT:    unreachable
-; SCCP:       bb4:
-; SCCP-NEXT:    [[TMP5:%.*]] = add i64 [[TMP2]], 3
-; SCCP-NEXT:    [[TMP6:%.*]] = and i64 [[TMP5]], 3
-; SCCP-NEXT:    [[TMP7:%.*]] = sub nuw nsw i64 3, [[TMP6]]
-; SCCP-NEXT:    [[TMP8:%.*]] = shl nuw nsw i64 [[TMP7]], 1
-; SCCP-NEXT:    [[TMP9:%.*]] = trunc i64 [[TMP8]] to i32
-; SCCP-NEXT:    [[TMP10:%.*]] = zext i32 [[TMP9]] to i64
-; SCCP-NEXT:    br label [[BB11:%.*]]
-; SCCP:       bb11:
-; SCCP-NEXT:    [[TMP12:%.*]] = phi i64 [ [[TMP10]], [[BB4]] ], [ [[TMP17:%.*]], [[BB18:%.*]] ]
-; SCCP-NEXT:    br label [[BB13:%.*]]
-; SCCP:       bb13:
-; SCCP-NEXT:    [[C_1:%.*]] = icmp eq i64 [[TMP12]], 6
-; SCCP-NEXT:    br i1 [[C_1]], label [[BB15:%.*]], label [[BB16:%.*]]
-; SCCP:       bb15:
-; SCCP-NEXT:    unreachable
-; SCCP:       bb16:
-; SCCP-NEXT:    [[TMP17]] = add i64 [[TMP12]], 2
-; SCCP-NEXT:    br label [[BB18]]
-; SCCP:       bb18:
-; SCCP-NEXT:    br label [[BB11]]
-; SCCP:       bb19:
-; SCCP-NEXT:    unreachable
+; SCCP-NEXT:    br label [[BB20:%.*]]
 ; SCCP:       bb20:
 ; SCCP-NEXT:    ret void
 ;
 ; IPSCCP-LABEL: @foo(
 ; IPSCCP-NEXT:  bb:
-; IPSCCP-NEXT:    [[TMP:%.*]] = zext i8 undef to i32
 ; IPSCCP-NEXT:    [[TMP2:%.*]] = load i64, ptr [[ARG:%.*]], align 8
-; IPSCCP-NEXT:    switch i32 [[TMP]], label [[BB20:%.*]] [
-; IPSCCP-NEXT:    i32 1, label [[BB3:%.*]]
-; IPSCCP-NEXT:    i32 2, label [[BB4:%.*]]
-; IPSCCP-NEXT:    i32 4, label [[BB19:%.*]]
-; IPSCCP-NEXT:    ]
-; IPSCCP:       bb3:
-; IPSCCP-NEXT:    unreachable
-; IPSCCP:       bb4:
-; IPSCCP-NEXT:    [[TMP5:%.*]] = add i64 [[TMP2]], 3
-; IPSCCP-NEXT:    [[TMP6:%.*]] = and i64 [[TMP5]], 3
-; IPSCCP-NEXT:    [[TMP7:%.*]] = sub nuw nsw i64 3, [[TMP6]]
-; IPSCCP-NEXT:    [[TMP8:%.*]] = shl nuw nsw i64 [[TMP7]], 1
-; IPSCCP-NEXT:    [[TMP9:%.*]] = trunc i64 [[TMP8]] to i32
-; IPSCCP-NEXT:    [[TMP10:%.*]] = zext i32 [[TMP9]] to i64
-; IPSCCP-NEXT:    br label [[BB11:%.*]]
-; IPSCCP:       bb11:
-; IPSCCP-NEXT:    [[TMP12:%.*]] = phi i64 [ [[TMP10]], [[BB4]] ], [ [[TMP17:%.*]], [[BB18:%.*]] ]
-; IPSCCP-NEXT:    br label [[BB13:%.*]]
-; IPSCCP:       bb13:
-; IPSCCP-NEXT:    [[C_1:%.*]] = icmp eq i64 [[TMP12]], 6
-; IPSCCP-NEXT:    br i1 [[C_1]], label [[BB15:%.*]], label [[BB16:%.*]]
-; IPSCCP:       bb15:
-; IPSCCP-NEXT:    unreachable
-; IPSCCP:       bb16:
-; IPSCCP-NEXT:    [[TMP17]] = add i64 [[TMP12]], 2
-; IPSCCP-NEXT:    br label [[BB18]]
-; IPSCCP:       bb18:
-; IPSCCP-NEXT:    br label [[BB11]]
-; IPSCCP:       bb19:
-; IPSCCP-NEXT:    unreachable
+; IPSCCP-NEXT:    br label [[BB20:%.*]]
 ; IPSCCP:       bb20:
 ; IPSCCP-NEXT:    ret void
 ;
 bb:
   %tmp = zext i8 undef to i32
   %tmp2 = load i64, ptr %arg, align 8
   switch i32 %tmp, label %bb20 [
   i32 1, label %bb3