Exclude bitcast and ext/trunc signbit optimization on ppc_fp128

[echristo]

Summary

Revision a1c05fe removed bitcast from the list of problematic transformations, however:

%97 = fptrunc ppc_fp128 %2 to double            // we need to check ppc_fp128 here to prevent the transformation
%98 = bitcast double %97 to i64                 // a1c05fe checks ppc_fp128 at here
%99 = icmp slt i64 %98, 0
%100 = zext i1 %99 to i8
store i8 %100, i8* %7, align 1

so this patch does that. I'm also disabling it in the presence of extend just in case.

I verified separately that the hash of -std::infinity and std::infinity don't match now.

[spatel]

LGTM. I had convinced myself that the problem was only the fpext variant, but that’s clearly wrong.

llvm/lib/Transforms/InstCombine/InstCombineCompares.cpp

if (match(BCSrcOp, m_UIToFP(m_Value(X))))
         return new ICmpInst(Pred, X, ConstantInt::getNullValue(X->getType()));
 
     // If this is a sign-bit test of a bitcast of a casted FP value, eliminate
     // the FP extend/truncate because that cast does not change the sign-bit.
     // This is true for all standard IEEE-754 types and the X86 80-bit type.
     // The sign-bit is always the most significant bit in those types.
     const APInt *C;
     bool TrueIfSigned;
-    if (!BCSrcOp->getType()->isPPC_FP128Ty() && match(Op1, m_APInt(C)) &&
-        Bitcast->hasOneUse() && isSignBitCheck(Pred, *C, TrueIfSigned)) {
+    if (match(Op1, m_APInt(C)) && Bitcast->hasOneUse() &&
+        isSignBitCheck(Pred, *C, TrueIfSigned)) {
       if (match(BCSrcOp, m_FPExt(m_Value(X))) ||
           match(BCSrcOp, m_FPTrunc(m_Value(X)))) {
         // (bitcast (fpext/fptrunc X)) to iX) < 0 --> (bitcast X to iY) < 0
         // (bitcast (fpext/fptrunc X)) to iX) > -1 --> (bitcast X to iY) > -1
         Type *XType = X->getType();
+
+        // We can't currently handle Power style floating point operations here.
+        if (!(XType->isPPC_FP128Ty() || BCSrcOp->getType()->isPPC_FP128Ty())) {
+
           Type *NewType = Builder.getIntNTy(XType->getScalarSizeInBits());
           if (auto *XVTy = dyn_cast<VectorType>(XType))
             NewType = VectorType::get(NewType, XVTy->getNumElements());
           Value *NewBitcast = Builder.CreateBitCast(X, NewType);
           if (TrueIfSigned)
             return new ICmpInst(ICmpInst::ICMP_SLT, NewBitcast,
                                 ConstantInt::getNullValue(NewType));
           else
             return new ICmpInst(ICmpInst::ICMP_SGT, NewBitcast,
                                 ConstantInt::getAllOnesValue(NewType));
         }
       }
     }
+  }
 
   // Test to see if the operands of the icmp are casted versions of other
   // values. If the ptr->ptr cast can be stripped off both arguments, do so.
   if (Bitcast->getType()->isPointerTy() &&
       (isa<Constant>(Op1) || isa<BitCastInst>(Op1))) {
     // If operand #1 is a bitcast instruction, it must also be a ptr->ptr cast
     // so eliminate it as well.
     if (auto *BC2 = dyn_cast<BitCastInst>(Op1))

llvm/test/Transforms/InstCombine/icmp.ll

;
   %s2 = fpext float %x to ppc_fp128
   %s3 = bitcast ppc_fp128 %s2 to i128
   %s4 = icmp slt i128 %s3, 0
   ret i1 %s4
 }
 
 define i1 @signbit_bitcast_fptrunc_ppc_fp128(ppc_fp128 %x) {
 ; CHECK-LABEL: @signbit_bitcast_fptrunc_ppc_fp128(
-; CHECK-NEXT:    [[TMP1:%.*]] = bitcast ppc_fp128 [[X:%.*]] to i128
-; CHECK-NEXT:    [[S4:%.*]] = icmp slt i128 [[TMP1]], 0
+; CHECK-NEXT:    [[S2:%.*]] = fptrunc ppc_fp128 [[X:%.*]] to float
+; CHECK-NEXT:    [[S3:%.*]] = bitcast float [[S2]] to i32
+; CHECK-NEXT:    [[S4:%.*]] = icmp slt i32 [[S3]], 0
 ; CHECK-NEXT:    ret i1 [[S4]]
 ;
   %s2 = fptrunc ppc_fp128 %x to float
   %s3 = bitcast float %s2 to i32
   %s4 = icmp slt i32 %s3, 0
   ret i1 %s4
 }