[SCEV] Use SCEVUnknown(poison) instead of SCEVUnknown(undef).

[fhahn]

Summary

Use poison instead of undef for SCEVUnkown of unreachable values.
This should be in line with the movement to replace undef with poison
when possible.

Suggested in D114650.

[nikic]

llvm/lib/Analysis/ScalarEvolution.cpp

7199

This change is fine, but I don't think the containsUndef -> containsPoison change makes sense. We can still have SCEVUnknown of UndefValue (from other places), and I believe current containsUndef() callers do want to check for those as well.

[fhahn]

llvm/lib/Analysis/ScalarEvolution.cpp

7199

I suppose we would need to check for both undef & poison, which is achieved by just checking for UndefVal (because PoisonValue inherits from UndefValue)?

[fhahn]

Undo changes to containsUndefs.

[nikic]

LGTM

llvm/lib/Analysis/ScalarEvolution.cpp

7199

Yes, exactly.

llvm/lib/Analysis/ScalarEvolution.cpp

if (!isSCEVable(V->getType()))
     return getUnknown(V);
 
   if (Instruction *I = dyn_cast<Instruction>(V)) {
     // Don't attempt to analyze instructions in blocks that aren't
     // reachable. Such instructions don't matter, and they aren't required
     // to obey basic rules for definitions dominating uses which this
     // analysis depends on.
     if (!DT.isReachableFromEntry(I->getParent()))
-      return getUnknown(UndefValue::get(V->getType()));
+      return getUnknown(PoisonValue::get(V->getType()));
   } else if (ConstantInt *CI = dyn_cast<ConstantInt>(V))
     return getConstant(CI);
   else if (GlobalAlias *GA = dyn_cast<GlobalAlias>(V))
     return GA->isInterposable() ? getUnknown(V) : getSCEV(GA->getAliasee());
   else if (!isa<ConstantExpr>(V))
     return getUnknown(V);
 
   const SCEV *LHS;

llvm/test/Analysis/ScalarEvolution/shift-recurrences.ll

 }
 
 ; Corner case where phi is not in a loop because it is in unreachable
 ; code (which loopinfo ignores, but simple recurrence matching does not).
 define void @unreachable_phi() {
 ; CHECK-LABEL: 'unreachable_phi'
 ; CHECK-NEXT:  Classifying expressions for: @unreachable_phi
 ; CHECK-NEXT:    %p_58.addr.1 = phi i32 [ undef, %unreachable1 ], [ %sub2629, %unreachable2 ]
-; CHECK-NEXT:    --> undef U: full-set S: full-set
+; CHECK-NEXT:    --> poison U: full-set S: full-set
 ; CHECK-NEXT:    %sub2629 = sub i32 %p_58.addr.1, 1
-; CHECK-NEXT:    --> undef U: full-set S: full-set
+; CHECK-NEXT:    --> poison U: full-set S: full-set
 ; CHECK-NEXT:  Determining loop execution counts for: @unreachable_phi
 ;
 entry:
   ret void
 
 unreachable1:
   br label %unreachable_nonloop
 unreachable2:
   br label %unreachable_nonloop
 unreachable_nonloop:
   %p_58.addr.1 = phi i32 [ undef, %unreachable1 ], [ %sub2629, %unreachable2 ]
   %sub2629 = sub i32 %p_58.addr.1, 1
   unreachable
 }
 
 ; Corner case where phi is not in loop header because binop is in unreachable
 ; code (which loopinfo ignores, but simple recurrence matching does not).
 define void @unreachable_binop() {
 ; CHECK-LABEL: 'unreachable_binop'
 ; CHECK-NEXT:  Classifying expressions for: @unreachable_binop
 ; CHECK-NEXT:    %p_58.addr.1 = phi i32 [ undef, %header ], [ %sub2629, %unreachable ]
 ; CHECK-NEXT:    --> %p_58.addr.1 U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %header: Variant }
 ; CHECK-NEXT:    %sub2629 = sub i32 %p_58.addr.1, 1
-; CHECK-NEXT:    --> undef U: full-set S: full-set
+; CHECK-NEXT:    --> poison U: full-set S: full-set
 ; CHECK-NEXT:  Determining loop execution counts for: @unreachable_binop
 ; CHECK-NEXT:  Loop %header: Unpredictable backedge-taken count.
 ; CHECK-NEXT:  Loop %header: Unpredictable max backedge-taken count.
 ; CHECK-NEXT:  Loop %header: Unpredictable predicated backedge-taken count.
 ;
 entry:
   br label %header
 

llvm/test/Analysis/ScalarEvolution/unreachable-code.ll

 ; RUN: opt < %s -disable-output "-passes=print<scalar-evolution>" 2>&1 | FileCheck %s
 
 ; CHECK: %t = add i64 %t, 1
-; CHECK: -->  undef
+; CHECK: -->  poison
 
 define void @foo() {
 entry:
   ret void
 
 dead:
   %t = add i64 %t, 1
   ret void
 }