Return undef on conversions that overflow (PR21330).

[spatel]

Summary

The LLVM Lang Ref states for signed/unsigned int to float conversions:
"If the value cannot fit in the floating point value, the results are undefined."

And for FP to signed/unsigned int:
"If the value cannot fit in ty2, the results are undefined."

This matches the C definitions.

The existing behavior pins to infinity or a max int value, but that may just lead to more confusion as seen in:
http://llvm.org/bugs/show_bug.cgi?id=21130

Returning undef will hopefully lead to a less silent failure.

[hfinkel]

I suppose the real question here is: Should we provide "best effort", and can we define what that means? What does common hardware do?

Can you explain how making this undef will help the test case from the PR(s)?

[spatel]

In D5603#4, @hfinkel wrote:

I suppose the real question here is: Should we provide "best effort", and can we define what that means? What does common hardware do?
Can you explain how making this undef will help the test case from the PR(s)?

In http://llvm.org/bugs/show_bug.cgi?id=21130, our best effort based on the current behavior was to saturate to the max signed int value (127 for an i8). But this result was considered wrong by the customer. They expected the unsigned 8-bit value (0x9c) to be generated and then be interpreted as a signed value -100.

I'm not sure how we'd pick a winner based on that, so I would hope that an undef return would eventually generate something obviously wrong (like a zero instruction on PPC or a ud2 on x86)? I haven't traced undef codegen through the backend yet.

As for HW behavior, it's a mixed bag. Start with float -> (un)signed int: PPC and x86 don't have instructions for unsigned conversions AFAICT. Their signed conversions try to saturate to the max value...but that doesn't make sense if the conversion was supposed to be unsigned in the high-level language. ARMv8 does have instructions for both signed and unsigned conversions, and it appears to try to saturate in all cases. Int -> float can't overflow for any HW that I see because there's no HW with big enough ints yet. :) So that's just a software problem, and so I'd again take the Lang Ref at its word and return undef.

[hfinkel]

Okay; fair enough. LGTM.

[spatel]

Closed by commit rL219542 (authored by @spatel).

llvm/trunk/lib/IR/ConstantFold.cpp

case Instruction::FPExt:
     return nullptr; // Can't fold.
   case Instruction::FPToUI: 
   case Instruction::FPToSI:
     if (ConstantFP *FPC = dyn_cast<ConstantFP>(V)) {
       const APFloat &V = FPC->getValueAPF();
       bool ignored;
       uint64_t x[2]; 
       uint32_t DestBitWidth = cast<IntegerType>(DestTy)->getBitWidth();
-      (void) V.convertToInteger(x, DestBitWidth, opc==Instruction::FPToSI,
-                                APFloat::rmTowardZero, &ignored);
+      if (APFloat::opInvalidOp ==
+          V.convertToInteger(x, DestBitWidth, opc==Instruction::FPToSI,
+                             APFloat::rmTowardZero, &ignored)) {
+        // Undefined behavior invoked - the destination type can't represent
+        // the input constant.
+        return UndefValue::get(DestTy);
+      }
       APInt Val(DestBitWidth, x);
       return ConstantInt::get(FPC->getContext(), Val);
     }
     return nullptr; // Can't fold.
   case Instruction::IntToPtr:   //always treated as unsigned
     if (V->isNullValue())       // Is it an integral null value?
       return ConstantPointerNull::get(cast<PointerType>(DestTy));
     return nullptr;                   // Other pointer types cannot be casted
case Instruction::PtrToInt:   // always treated as unsigned
     // Other pointer types cannot be casted
     return nullptr;
   case Instruction::UIToFP:
   case Instruction::SIToFP:
     if (ConstantInt *CI = dyn_cast<ConstantInt>(V)) {
       APInt api = CI->getValue();
       APFloat apf(DestTy->getFltSemantics(),
                   APInt::getNullValue(DestTy->getPrimitiveSizeInBits()));
-      (void)apf.convertFromAPInt(api, 
-                                 opc==Instruction::SIToFP,
-                                 APFloat::rmNearestTiesToEven);
+      if (APFloat::opOverflow &
+          apf.convertFromAPInt(api, opc==Instruction::SIToFP,
+                              APFloat::rmNearestTiesToEven)) {
+        // Undefined behavior invoked - the destination type can't represent
+        // the input constant.
+        return UndefValue::get(DestTy);
+      }
       return ConstantFP::get(V->getContext(), apf);
     }
     return nullptr;
   case Instruction::ZExt:
     if (ConstantInt *CI = dyn_cast<ConstantInt>(V)) {
       uint32_t BitWidth = cast<IntegerType>(DestTy)->getBitWidth();
       return ConstantInt::get(V->getContext(),
                               CI->getValue().zext(BitWidth));

llvm/trunk/test/Transforms/InstCombine/cast.ll

define i8 @test85(i32 %a) {
   %trunc = trunc i32 %shr to i8
   ret i8 %trunc
 
 ; CHECK-LABEL: @test85(
 ; CHECK: [[ADD:%.*]] = add i32 %a, 2130706432
 ; CHECK: [[SHR:%.*]] = lshr exact i32 [[ADD]], 23
 ; CHECK: [[CST:%.*]] = trunc i32 [[SHR]] to i8
 }
+
+; Overflow on a float to int or int to float conversion is undefined (PR21130).
+
+define i8 @overflow_fptosi() {
+  %i = fptosi double 1.56e+02 to i8
+  ret i8 %i
+; CHECK-LABEL: @overflow_fptosi(
+; CHECK-NEXT: ret i8 undef 
+}
+
+define i8 @overflow_fptoui() {
+  %i = fptoui double 2.56e+02 to i8
+  ret i8 %i
+; CHECK-LABEL: @overflow_fptoui(
+; CHECK-NEXT: ret i8 undef 
+}
+
+; The maximum float is approximately 2 ** 128 which is 3.4E38. 
+; The constant below is 4E38. Use a 130 bit integer to hold that
+; number; 129-bits for the value + 1 bit for the sign.
+define float @overflow_uitofp() {
+  %i = uitofp i130 400000000000000000000000000000000000000 to float
+  ret float %i
+; CHECK-LABEL: @overflow_uitofp(
+; CHECK-NEXT: ret float undef 
+}
+
+define float @overflow_sitofp() {
+  %i = sitofp i130 400000000000000000000000000000000000000 to float
+  ret float %i
+; CHECK-LABEL: @overflow_sitofp(
+; CHECK-NEXT: ret float undef 
+}
+