[LVI] Don't compute range on not guaranteed not to be undef condition in SelectInst

[StephenFan]

Summary

Fixes:https://github.com/llvm/llvm-project/issues/62901

[Allen]

llvm/test/Transforms/CorrelatedValuePropagation/select.ll

268

could it freeze the operand instead ? https://alive2.llvm.org/ce/z/xfwAJ2

[nikic]

LGTM

[StephenFan]

llvm/test/Transforms/CorrelatedValuePropagation/select.ll

268

Yes, we can do this. But LazyValueInfo is an analysis pass, we can not freeze it in it.

llvm/lib/Analysis/LazyValueInfo.cpp

if (SPR.Flavor == SPF_NABS) {
             Zero.sub(FalseCR.abs()), FalseVal.isConstantRangeIncludingUndef());
     }
   }
 
   // Can we constrain the facts about the true and false values by using the
   // condition itself?  This shows up with idioms like e.g. select(a > 5, a, 5).
   // TODO: We could potentially refine an overdefined true value above.
   Value *Cond = SI->getCondition();
+  // If the value is undef, a different value may be chosen in
+  // the select condition.
+  if (isGuaranteedNotToBeUndefOrPoison(Cond, AC)) {
     TrueVal = intersect(TrueVal,
                         getValueFromCondition(SI->getTrueValue(), Cond, true));
-  FalseVal = intersect(FalseVal,
-                       getValueFromCondition(SI->getFalseValue(), Cond, false));
+    FalseVal = intersect(
+        FalseVal, getValueFromCondition(SI->getFalseValue(), Cond, false));
+  }
 
   ValueLatticeElement Result = TrueVal;
   Result.mergeIn(FalseVal);
   return Result;
 }
 
 std::optional<ConstantRange>
 LazyValueInfoImpl::getRangeFor(Value *V, Instruction *CxtI, BasicBlock *BB) {

llvm/test/Transforms/CorrelatedValuePropagation/basic.ll

;
   %assume = icmp ult i32 %b, 42
   call void @llvm.assume(i1 %assume)
   %cmp = icmp uge i32 %a, %b
   %sel = select i1 %cmp, i32 %b, i32 %a
   %cmp2 = icmp ult i32 %sel, 42
   ret i1 %cmp2
 }
 
-define i1 @clamp_low1(i32 %a) {
+define i1 @clamp_low1(i32 noundef %a) {
 ; CHECK-LABEL: @clamp_low1(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[CMP:%.*]] = icmp sge i32 [[A:%.*]], 5
 ; CHECK-NEXT:    br i1 [[CMP]], label [[A_GUARD:%.*]], label [[OUT:%.*]]
 ; CHECK:       a_guard:
 ; CHECK-NEXT:    [[SEL_CMP:%.*]] = icmp eq i32 [[A]], 5
 ; CHECK-NEXT:    [[ADD:%.*]] = add nsw i32 [[A]], -1
 ; CHECK-NEXT:    [[SEL:%.*]] = select i1 [[SEL_CMP]], i32 5, i32 [[ADD]]
a_guard:
   %add = add i32 %a, -1
   %sel = select i1 %sel_cmp, i32 5, i32 %add
   %res = icmp eq i32 %sel, 4
   ret i1 %res
 out:
   ret i1 false
 }
 
-define i1 @clamp_low2(i32 %a) {
+define i1 @clamp_low2(i32 noundef %a) {
 ; CHECK-LABEL: @clamp_low2(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[CMP:%.*]] = icmp sge i32 [[A:%.*]], 5
 ; CHECK-NEXT:    br i1 [[CMP]], label [[A_GUARD:%.*]], label [[OUT:%.*]]
 ; CHECK:       a_guard:
 ; CHECK-NEXT:    [[SEL_CMP:%.*]] = icmp ne i32 [[A]], 5
 ; CHECK-NEXT:    [[ADD:%.*]] = add nsw i32 [[A]], -1
 ; CHECK-NEXT:    [[SEL:%.*]] = select i1 [[SEL_CMP]], i32 [[ADD]], i32 5
a_guard:
   %add = add i32 %a, -1
   %sel = select i1 %sel_cmp, i32 %add, i32 5
   %res = icmp eq i32 %sel, 4
   ret i1 %res
 out:
   ret i1 false
 }
 
-define i1 @clamp_low3(i32 %a) {
+define i1 @clamp_low3(i32 noundef %a) {
 ; CHECK-LABEL: @clamp_low3(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[CMP:%.*]] = icmp sge i32 [[A:%.*]], 5
 ; CHECK-NEXT:    br i1 [[CMP]], label [[A_GUARD:%.*]], label [[OUT:%.*]]
 ; CHECK:       a_guard:
 ; CHECK-NEXT:    [[SEL_CMP:%.*]] = icmp ugt i32 [[A]], 5
 ; CHECK-NEXT:    [[ADD:%.*]] = add nsw i32 [[A]], -1
 ; CHECK-NEXT:    [[SEL:%.*]] = select i1 [[SEL_CMP]], i32 [[ADD]], i32 5
a_guard:
   %add = add i32 %a, -1
   %sel = select i1 %sel_cmp, i32 %add, i32 5
   %res = icmp eq i32 %sel, 4
   ret i1 %res
 out:
   ret i1 false
 }
 
-define i1 @clamp_low4(i32 %a) {
+define i1 @clamp_low4(i32 noundef %a) {
 ; CHECK-LABEL: @clamp_low4(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[CMP:%.*]] = icmp sge i32 [[A:%.*]], 5
 ; CHECK-NEXT:    br i1 [[CMP]], label [[A_GUARD:%.*]], label [[OUT:%.*]]
 ; CHECK:       a_guard:
 ; CHECK-NEXT:    [[SEL_CMP:%.*]] = icmp ule i32 [[A]], 5
 ; CHECK-NEXT:    [[ADD:%.*]] = add nsw i32 [[A]], -1
 ; CHECK-NEXT:    [[SEL:%.*]] = select i1 [[SEL_CMP]], i32 5, i32 [[ADD]]
a_guard:
   %add = add i32 %a, -1
   %sel = select i1 %sel_cmp, i32 5, i32 %add
   %res = icmp eq i32 %sel, 4
   ret i1 %res
 out:
   ret i1 false
 }
 
-define i1 @clamp_high1(i32 %a) {
+define i1 @clamp_high1(i32 noundef %a) {
 ; CHECK-LABEL: @clamp_high1(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[CMP:%.*]] = icmp sle i32 [[A:%.*]], 5
 ; CHECK-NEXT:    br i1 [[CMP]], label [[A_GUARD:%.*]], label [[OUT:%.*]]
 ; CHECK:       a_guard:
 ; CHECK-NEXT:    [[SEL_CMP:%.*]] = icmp eq i32 [[A]], 5
 ; CHECK-NEXT:    [[ADD:%.*]] = add nsw i32 [[A]], 1
 ; CHECK-NEXT:    [[SEL:%.*]] = select i1 [[SEL_CMP]], i32 5, i32 [[ADD]]
a_guard:
   %add = add i32 %a, 1
   %sel = select i1 %sel_cmp, i32 5, i32 %add
   %res = icmp eq i32 %sel, 6
   ret i1 %res
 out:
   ret i1 false
 }
 
-define i1 @clamp_high2(i32 %a) {
+define i1 @clamp_high2(i32 noundef %a) {
 ; CHECK-LABEL: @clamp_high2(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[CMP:%.*]] = icmp sle i32 [[A:%.*]], 5
 ; CHECK-NEXT:    br i1 [[CMP]], label [[A_GUARD:%.*]], label [[OUT:%.*]]
 ; CHECK:       a_guard:
 ; CHECK-NEXT:    [[SEL_CMP:%.*]] = icmp ne i32 [[A]], 5
 ; CHECK-NEXT:    [[ADD:%.*]] = add nsw i32 [[A]], 1
 ; CHECK-NEXT:    [[SEL:%.*]] = select i1 [[SEL_CMP]], i32 [[ADD]], i32 5
a_guard:
   %add = add i32 %a, 1
   %sel = select i1 %sel_cmp, i32 %add, i32 5
   %res = icmp eq i32 %sel, 6
   ret i1 %res
 out:
   ret i1 false
 }
 
-define i1 @clamp_high3(i32 %a) {
+define i1 @clamp_high3(i32 noundef %a) {
 ; CHECK-LABEL: @clamp_high3(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[CMP:%.*]] = icmp sle i32 [[A:%.*]], 5
 ; CHECK-NEXT:    br i1 [[CMP]], label [[A_GUARD:%.*]], label [[OUT:%.*]]
 ; CHECK:       a_guard:
 ; CHECK-NEXT:    [[SEL_CMP:%.*]] = icmp slt i32 [[A]], 5
 ; CHECK-NEXT:    [[ADD:%.*]] = add nsw i32 [[A]], 1
 ; CHECK-NEXT:    [[SEL:%.*]] = select i1 [[SEL_CMP]], i32 [[ADD]], i32 5
a_guard:
   %add = add i32 %a, 1
   %sel = select i1 %sel_cmp, i32 %add, i32 5
   %res = icmp eq i32 %sel, 6
   ret i1 %res
 out:
   ret i1 false
 }
 
-define i1 @clamp_high4(i32 %a) {
+define i1 @clamp_high4(i32 noundef %a) {
 ; CHECK-LABEL: @clamp_high4(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[CMP:%.*]] = icmp sle i32 [[A:%.*]], 5
 ; CHECK-NEXT:    br i1 [[CMP]], label [[A_GUARD:%.*]], label [[OUT:%.*]]
 ; CHECK:       a_guard:
 ; CHECK-NEXT:    [[SEL_CMP:%.*]] = icmp sge i32 [[A]], 5
 ; CHECK-NEXT:    [[ADD:%.*]] = add nsw i32 [[A]], 1
 ; CHECK-NEXT:    [[SEL:%.*]] = select i1 [[SEL_CMP]], i32 5, i32 [[ADD]]
a_guard:
   %sel = select i1 %sel_cmp, i32 5, i32 %add
   %res = icmp eq i32 %sel, 6
   ret i1 %res
 out:
   ret i1 false
 }
 
 ; Just showing arbitrary constants work, not really a clamp
-define i1 @not_clamp_high(i32 %a) {
+define i1 @not_clamp_high(i32 noundef %a) {
 ; CHECK-LABEL: @not_clamp_high(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[CMP:%.*]] = icmp sle i32 [[A:%.*]], 5
 ; CHECK-NEXT:    br i1 [[CMP]], label [[A_GUARD:%.*]], label [[OUT:%.*]]
 ; CHECK:       a_guard:
 ; CHECK-NEXT:    [[SEL_CMP:%.*]] = icmp ne i32 [[A]], 5
 ; CHECK-NEXT:    [[ADD:%.*]] = add nsw i32 [[A]], 100
 ; CHECK-NEXT:    [[SEL:%.*]] = select i1 [[SEL_CMP]], i32 [[ADD]], i32 5

llvm/test/Transforms/CorrelatedValuePropagation/select.ll

 ; CHECK-NEXT:    br i1 [[CMP1]], label [[NEXT:%.*]], label [[EXIT:%.*]]
 ; CHECK:       next:
 ; CHECK-NEXT:    [[COND:%.*]] = icmp sgt i32 [[PVAL]], 0
 ; CHECK-NEXT:    [[MIN:%.*]] = select i1 [[COND]], i32 [[PVAL]], i32 5
 ; CHECK-NEXT:    ret i1 false
 ; CHECK:       exit:
 ; CHECK-NEXT:    ret i1 true
 ;
-  %pval = load i32, i32* %p
+  %pval = load i32, i32* %p, !noundef !0
   %cmp1 = icmp slt i32 %pval, 255
   br i1 %cmp1, label %next, label %exit
 
 next:
   %cond = icmp sgt i32 %pval, 0
   %min = select i1 %cond, i32 %pval, i32 5
   %res = icmp eq i32 %min, -1
   ret i1 %res

 ; CHECK-NEXT:    br i1 [[CMP1]], label [[NEXT:%.*]], label [[EXIT:%.*]]
 ; CHECK:       next:
 ; CHECK-NEXT:    [[COND:%.*]] = icmp ne i32 [[PVAL]], 254
 ; CHECK-NEXT:    [[SEL:%.*]] = select i1 [[COND]], i32 [[PVAL]], i32 1
 ; CHECK-NEXT:    ret i1 true
 ; CHECK:       exit:
 ; CHECK-NEXT:    ret i1 true
 ;
-  %pval = load i32, i32* %p
+  %pval = load i32, i32* %p, !noundef !0
   %cmp1 = icmp ult i32 %pval, 255
   br i1 %cmp1, label %next, label %exit
 
 next:
   %cond = icmp ne i32 %pval, 254
   %sel = select i1 %cond, i32 %pval, i32 1
   %res = icmp slt i32 %sel, 254
   ret i1 %res
 
 exit:
   ret i1 true
 }
+
+define i64 @select_cond_may_undef(i32 %a) {
+; CHECK-LABEL: @select_cond_may_undef(
+; CHECK-NEXT:    [[IS_A_NONNEGATIVE:%.*]] = icmp sgt i32 [[A:%.*]], 1
+; CHECK-NEXT:    [[NARROW:%.*]] = select i1 [[IS_A_NONNEGATIVE]], i32 [[A]], i32 0
+; CHECK-NEXT:    [[MAX:%.*]] = sext i32 [[NARROW]] to i64
+; CHECK-NEXT:    ret i64 [[MAX]]
+;
+  %is_a_nonnegative = icmp sgt i32 %a, 1
+  %narrow = select i1 %is_a_nonnegative, i32 %a, i32 0
+  %max = sext i32 %narrow to i64
+  ret i64 %max
+}
+
+!0 = !{}