[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

I would just use:

return Zero.sub(Ops[0]);

llvm/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 = [I](ArrayRef<ConstantRange> Ops) {
+        assert(Ops.size() == 1 && "its a unary operator!");
+        auto BinOp = (Instruction::BinaryOps) Instruction::FSub;
+        unsigned Size = Ops[0].getBitWidth();
+        auto Zero = ConstantRange(APInt::getNullValue(Size));
+        return Zero.binaryOp(BinOp, 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/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
 }