[SCCP] try to convert sitofp to uitofp

[spatel]

Summary

https://alive2.llvm.org/ce/z/tDmLfs

This is another small extension of the signed->unsigned logic. This can enable subsequent FP folds because it eliminates negative FP values. Example:
https://alive2.llvm.org/ce/z/tnwfVk

Codegen can invert the transform if it can see that the input signbit is clear.

There was a comment on a test saying not to try this, but I don't see a reason to avoid it. I adjusted one of the existing tests to show that we are not miscompiling when the range includes a negative value.

[nikic]

LGTM

[efriedma]

uitofp is significantly more expensive than sitofp on many targets. I'm not sure we want to do this if we're not confident we can reverse the transform.

[spatel]

In D134975#3828062, @efriedma wrote:

uitofp is significantly more expensive than sitofp on many targets. I'm not sure we want to do this if we're not confident we can reverse the transform.

Yes, this has potential to find transforms that SDAG can't recover since it's looking across blocks.
I don't have a real example where this comes into play; just noticed that we'd need an extra condition for signed cast with an fmul fold as in the example.
SDAG already tries to convert these in both directions after testing legality, so that's probably good enough. I'll put a code comment in SCCP and abandon this patch.

llvm/lib/Transforms/Scalar/SCCP.cpp

auto isNonNegative = [&Solver](Value *V) {
     }
     const ValueLatticeElement &IV = Solver.getLatticeValueFor(V);
     return IV.isConstantRange(/*UndefAllowed=*/false) &&
            IV.getConstantRange().isAllNonNegative();
   };
 
   Instruction *NewInst = nullptr;
   switch (Inst.getOpcode()) {
-  case Instruction::SExt: {
-    // If the source value is not negative, this is a zext.
+  case Instruction::SExt:
+  case Instruction::SIToFP: {
+    // If the source value is not negative, this is an unsigned cast.
     Value *Op0 = Inst.getOperand(0);
-    if (isa<Constant>(Op0) || InsertedValues.count(Op0) || !isNonNegative(Op0))
+    if (InsertedValues.count(Op0) || !isNonNegative(Op0))
       return false;
-    NewInst = new ZExtInst(Op0, Inst.getType(), "", &Inst);
+    auto NewOpcode = Inst.getOpcode() == Inst.SExt ? Inst.ZExt : Inst.UIToFP;
+    NewInst = CastInst::Create(NewOpcode, Op0, Inst.getType(), "", &Inst);
     break;
   }
   case Instruction::AShr: {
     // If the shifted value is not negative, this is a logical shift right.
     Value *Op0 = Inst.getOperand(0);
     if (InsertedValues.count(Op0) || !isNonNegative(Op0))
       return false;
     NewInst = BinaryOperator::CreateLShr(Op0, Inst.getOperand(1), "", &Inst);

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

 ; CHECK-NEXT:    ret i1 [[RES]]
 ;
   %call.1 = tail call i1 @f.sext(i32 100, i32 -120)
   %call.2 = tail call i1 @f.sext(i32 300, i32 900)
   %res = and i1 %call.1, %call.2
   ret i1 %res
 }
 
-; There's nothing we can do besides going to the full range or overdefined.
+; The initial cast is known to only be used with positive values, so it becomes unsigned.
+
 define internal i1 @f.fptosi(i32 %x) {
 ; CHECK-LABEL: @f.fptosi(
-; CHECK-NEXT:    [[TO_DOUBLE:%.*]] = sitofp i32 [[X:%.*]] to double
+; CHECK-NEXT:    [[TO_DOUBLE:%.*]] = uitofp i32 [[X:%.*]] to double
 ; CHECK-NEXT:    [[ADD:%.*]] = fadd double 0.000000e+00, [[TO_DOUBLE]]
 ; CHECK-NEXT:    [[TO_I32:%.*]] = fptosi double [[ADD]] to i32
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp sgt i32 [[TO_I32]], 300
 ; CHECK-NEXT:    [[C_2:%.*]] = icmp sgt i32 [[TO_I32]], 299
 ; CHECK-NEXT:    [[C_3:%.*]] = icmp slt i32 [[TO_I32]], 100
 ; CHECK-NEXT:    [[C_4:%.*]] = icmp slt i32 [[TO_I32]], 101
 ; CHECK-NEXT:    [[RES_1:%.*]] = add i1 [[C_1]], [[C_2]]
 ; CHECK-NEXT:    [[RES_2:%.*]] = add i1 [[RES_1]], [[C_3]]

 ;
   %call.1 = tail call i1 @f.fptosi(i32 100)
   %call.2 = tail call i1 @f.fptosi(i32 300)
   %res = and i1 %call.1, %call.2
   ret i1 %res
 }
 
 ; There's nothing we can do besides going to the full range or overdefined.
+; The initial cast is used with both positive and negative values,
+; so it must remain signed.
+
 define internal i1 @f.fpext(i16 %x) {
 ; CHECK-LABEL: @f.fpext(
 ; CHECK-NEXT:    [[TO_FLOAT:%.*]] = sitofp i16 [[X:%.*]] to float
 ; CHECK-NEXT:    [[TO_DOUBLE:%.*]] = fpext float [[TO_FLOAT]] to double
 ; CHECK-NEXT:    [[TO_I64:%.*]] = fptoui float [[TO_FLOAT]] to i64
 ; CHECK-NEXT:    [[C_1:%.*]] = icmp sgt i64 [[TO_I64]], 300
 ; CHECK-NEXT:    [[C_2:%.*]] = icmp sgt i64 [[TO_I64]], 299
 ; CHECK-NEXT:    [[C_3:%.*]] = icmp slt i64 [[TO_I64]], 100
;
   %res.2 = add i1 %res.1, %c.3
   %res.3 = add i1 %res.2, %c.4
   ret i1 %res.3
 }
 
 ; There's nothing we can do besides going to the full range or overdefined.
 define i1 @caller.fpext() {
 ; CHECK-LABEL: @caller.fpext(
-; CHECK-NEXT:    [[CALL_1:%.*]] = tail call i1 @f.fpext(i16 100)
+; CHECK-NEXT:    [[CALL_1:%.*]] = tail call i1 @f.fpext(i16 -100)
 ; CHECK-NEXT:    [[CALL_2:%.*]] = tail call i1 @f.fpext(i16 300)
 ; CHECK-NEXT:    [[RES:%.*]] = and i1 [[CALL_1]], [[CALL_2]]
 ; CHECK-NEXT:    ret i1 [[RES]]
 ;
-  %call.1 = tail call i1 @f.fpext(i16 100)
+  %call.1 = tail call i1 @f.fpext(i16 -100)
   %call.2 = tail call i1 @f.fpext(i16 300)
   %res = and i1 %call.1, %call.2
   ret i1 %res
 }
 
 ; There's nothing we can do besides going to the full range or overdefined.
 define internal i1 @f.inttoptr.ptrtoint(i64 %x) {
 ; CHECK-LABEL: @f.inttoptr.ptrtoint(

 ; CHECK-NEXT:    ret i1 [[RES]]
 ;
   %call.1 = tail call i1 @f.inttoptr.ptrtoint(i64 100)
   %call.2 = tail call i1 @f.inttoptr.ptrtoint(i64 300)
   %res = and i1 %call.1, %call.2
   ret i1 %res
 }
 
-; Make sure we do not create constant ranges for int to fp casts.
 define i1 @int_range_to_double_cast(i32 %a) {
 ; CHECK-LABEL: @int_range_to_double_cast(
 ; CHECK-NEXT:    [[R:%.*]] = and i32 [[A:%.*]], 255
-; CHECK-NEXT:    [[T4:%.*]] = sitofp i32 [[R]] to double
+; CHECK-NEXT:    [[T4:%.*]] = uitofp i32 [[R]] to double
 ; CHECK-NEXT:    [[T10:%.*]] = fadd double 0.000000e+00, [[T4]]
 ; CHECK-NEXT:    [[T11:%.*]] = fcmp olt double [[T4]], [[T10]]
 ; CHECK-NEXT:    ret i1 [[T11]]
 ;
   %r = and i32 %a, 255
   %t4 = sitofp i32 %r to double
   %t10 = fadd double 0.000000e+00, %t4
   %t11 = fcmp olt double %t4, %t10

llvm/test/Transforms/SCCP/sitofp.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt -passes=ipsccp -S < %s | FileCheck %s
 
 define float @sitofp_and(i8 %x) {
 ; CHECK-LABEL: @sitofp_and(
 ; CHECK-NEXT:    [[PX:%.*]] = and i8 [[X:%.*]], 127
-; CHECK-NEXT:    [[R:%.*]] = sitofp i8 [[PX]] to float
+; CHECK-NEXT:    [[R:%.*]] = uitofp i8 [[PX]] to float
 ; CHECK-NEXT:    ret float [[R]]
 ;
   %px = and i8 %x, 127
   %r = sitofp i8 %px to float
   ret float %r
 }
 
 define half @sitofp_const(i8 %x) {
 ; CHECK-LABEL: @sitofp_const(
 ; CHECK-NEXT:    ret half 0xH5140
 ;
   %r = sitofp i8 42 to half
   ret half %r
 }
 
 define double @sitofp_zext(i7 %x) {
 ; CHECK-LABEL: @sitofp_zext(
 ; CHECK-NEXT:    [[PX:%.*]] = zext i7 [[X:%.*]] to i8
-; CHECK-NEXT:    [[R:%.*]] = sitofp i8 [[PX]] to double
+; CHECK-NEXT:    [[R:%.*]] = uitofp i8 [[PX]] to double
 ; CHECK-NEXT:    ret double [[R]]
 ;
   %px = zext i7 %x to i8
   %r = sitofp i8 %px to double
   ret double %r
 }
 
 ; negative test

 ; x is known non-negative in t block
 
 define float @dominating_condition(i32 %x) {
 ; CHECK-LABEL: @dominating_condition(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[CMP:%.*]] = icmp sge i32 [[X:%.*]], 0
 ; CHECK-NEXT:    br i1 [[CMP]], label [[T:%.*]], label [[F:%.*]]
 ; CHECK:       t:
-; CHECK-NEXT:    [[A:%.*]] = sitofp i32 [[X]] to float
+; CHECK-NEXT:    [[A:%.*]] = uitofp i32 [[X]] to float
 ; CHECK-NEXT:    br label [[EXIT:%.*]]
 ; CHECK:       f:
 ; CHECK-NEXT:    br label [[EXIT]]
 ; CHECK:       exit:
 ; CHECK-NEXT:    [[COND:%.*]] = phi float [ [[A]], [[T]] ], [ 4.200000e+01, [[F]] ]
 ; CHECK-NEXT:    ret float [[COND]]
 ;
 entry:

 define float @dominating_condition_alt(i32 %x) {
 ; CHECK-LABEL: @dominating_condition_alt(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[CMP:%.*]] = icmp ugt i32 [[X:%.*]], 2000000000
 ; CHECK-NEXT:    br i1 [[CMP]], label [[T:%.*]], label [[F:%.*]]
 ; CHECK:       t:
 ; CHECK-NEXT:    br label [[EXIT:%.*]]
 ; CHECK:       f:
-; CHECK-NEXT:    [[A:%.*]] = sitofp i32 [[X]] to float
+; CHECK-NEXT:    [[A:%.*]] = uitofp i32 [[X]] to float
 ; CHECK-NEXT:    br label [[EXIT]]
 ; CHECK:       exit:
 ; CHECK-NEXT:    [[COND:%.*]] = phi float [ -4.200000e+01, [[T]] ], [ [[A]], [[F]] ]
 ; CHECK-NEXT:    ret float [[COND]]
 ;
 entry:
   %cmp = icmp ugt i32 %x, 2000000000
   br i1 %cmp, label %t, label %f