[Float2Int] Add support for unary FNeg to Float2Int

[cameron.mcinally]

Summary

I'm not that familiar with ConstantRange or F2I, so a thorough review will be appreciated.

Note that I chose to fake a binary FNeg for ConstantRange purposes. I think this is safe and should limit regressions. Opposing views welcome...

[jmolloy]

LGTM with one simplification. Thanks!

llvm/lib/Transforms/Scalar/Float2Int.cpp

250 ↗

(On Diff #207090)

I would just use:

return Zero.sub(Ops[0]);

llvm/trunk/lib/Transforms/Scalar/Float2Int.cpp

case Instruction::SIToFP: {
       // the analysis.
       unsigned BW = I->getOperand(0)->getType()->getPrimitiveSizeInBits();
       auto Input = ConstantRange::getFull(BW);
       auto CastOp = (Instruction::CastOps)I->getOpcode();
       seen(I, validateRange(Input.castOp(CastOp, MaxIntegerBW+1)));
       continue;
     }
 
+    case Instruction::FNeg:
     case Instruction::FAdd:
     case Instruction::FSub:
     case Instruction::FMul:
     case Instruction::FPToUI:
     case Instruction::FPToSI:
     case Instruction::FCmp:
       seen(I, unknownRange());
       break;
for (auto &It : reverse(SeenInsts)) {
     std::function<ConstantRange(ArrayRef<ConstantRange>)> Op;
     switch (I->getOpcode()) {
       // FIXME: Handle select and phi nodes.
     default:
     case Instruction::UIToFP:
     case Instruction::SIToFP:
       llvm_unreachable("Should have been handled in walkForwards!");
 
+    case Instruction::FNeg:
+      Op = [](ArrayRef<ConstantRange> Ops) {
+        assert(Ops.size() == 1 && "FNeg is a unary operator!");
+        unsigned Size = Ops[0].getBitWidth();
+        auto Zero = ConstantRange(APInt::getNullValue(Size));
+        return Zero.sub(Ops[0]);
+      };
+      break;
+
     case Instruction::FAdd:
     case Instruction::FSub:
     case Instruction::FMul:
       Op = [I](ArrayRef<ConstantRange> Ops) {
         assert(Ops.size() == 2 && "its a binary operator!");
         auto BinOp = (Instruction::BinaryOps) I->getOpcode();
         return Ops[0].binaryOp(BinOp, Ops[1]);
       };
Value *Float2IntPass::convert(Instruction *I, Type *ToTy) {
   case Instruction::UIToFP:
     NewV = IRB.CreateZExtOrTrunc(NewOperands[0], ToTy);
     break;
 
   case Instruction::SIToFP:
     NewV = IRB.CreateSExtOrTrunc(NewOperands[0], ToTy);
     break;
 
+  case Instruction::FNeg:
+    NewV = IRB.CreateNeg(NewOperands[0], I->getName());
+    break;
+
   case Instruction::FAdd:
   case Instruction::FSub:
   case Instruction::FMul:
     NewV = IRB.CreateBinOp(mapBinOpcode(I->getOpcode()),
                            NewOperands[0], NewOperands[1],
                            I->getName());
     break;
   }

llvm/trunk/test/Transforms/Float2Int/basic.ll

define i32 @simple5(i8 %a, i8 %b) {
   %2 = uitofp i8 %b to float
   %3 = fadd float %1, 1.0
   %4 = fmul float %3, %2
   %5 = fptoui float %4 to i32
   ret i32 %5
 }
 
 ; CHECK-LABEL: @simple6
-; CHECK:  %1 = uitofp i8 %a to float
-; CHECK:  %2 = uitofp i8 %b to float
-; CHECK:  %3 = fneg float %1
-; CHECK:  %4 = fmul float %3, %2
-; CHECK:  %5 = fptoui float %4 to i32
-; CHECK:  ret i32 %5
+; CHECK:  %1 = zext i8 %a to i32
+; CHECK:  %2 = zext i8 %b to i32
+; CHECK:  %3 = sub i32 0, %1
+; CHECK:  %4 = mul i32 %3, %2
+; CHECK:  ret i32 %4
 define i32 @simple6(i8 %a, i8 %b) {
   %1 = uitofp i8 %a to float
   %2 = uitofp i8 %b to float
   %3 = fneg float %1
   %4 = fmul float %3, %2
   %5 = fptoui float %4 to i32
   ret i32 %5
 }

 define i32 @simple_negative(i8 %call) {
   %conv1 = sitofp i8 %call to float
   %mul = fmul float %conv1, -3.000000e+00
   %conv2 = fptosi float %mul to i8
   %conv3 = sext i8 %conv2 to i32
   ret i32 %conv3
 }
 
+; CHECK-LABEL: @simple_fneg
+; CHECK:  %1 = zext i8 %a to i32
+; CHECK:  %2 = sub i32 0, %1
+; CHECK:  %3 = trunc i32 %2 to i16
+; CHECK:  ret i16 %3
+define i16 @simple_fneg(i8 %a) {
+  %1 = uitofp i8 %a to float
+  %2 = fneg fast float %1
+  %3 = fptoui float %2 to i16
+  ret i16 %3
+}
+
 ;
 ; Negative tests
 ;
 
 ; CHECK-LABEL: @neg_multi1
 ; CHECK:  %fa = uitofp i8 %a to float
 ; CHECK:  %fc = uitofp i8 %c to float
 ; CHECK:  %x = fadd float %fa, %fc