InstCombine: Recognize fabs as bitcasted integer

[arsenm]

Summary

In the past we sort of pretended float might be implementable
as a non-IEEE type but that never realistically would work. Exotic
FP types would need to be added to the IR. Turning these
into FP operations enables FP tracking optimizations.

[arsenm]

Check noimplicitfloat

[efriedma]

LGTM

(For future reference, most of the discussion happened on https://reviews.llvm.org/D151934 .)

[arsenm]

5c0da5839de1bdc08f411a04305a9bdadf538ad5

[bjope]

Having some problems understanding how this interacts with -fdenormal-fp-math. Our target is using preserve-sign. And the fabs is lowered into a floating point instructions that would that has flushed the result to zero.

So a test case that is doing

float input = -0x1.fffffcp-127 + 0.0f;

int main() {
  union {
    float f;
    ui32_t i;
  } rep;
  rep.f = input;

  const ui32_t aInt = rep.i;
  const ui32_t aAbs = aInt & 0x7ffffffful;

  if (aAbs == 0) {
    printf("masked %f is zero\n", input);
  } else {
    printf("masked %f is not zero\n", input);
  }
  ...
}

used to result in "masked -0.000000 is not zero" being printed (since the store to rep.f is storing a denormal number to memory).

But with this patch the compiler introduces a fabs operation. And then our backend picks an floating point instruction that has flushed the result to zero. So with this patch it starts printing "masked -0.000000 is zero" instead.

So is this transform bad when denormal-fp-math isn't set to ieee?
Or is it something with the frontend (or test program) that is bad here. What should happen when storing that denormal literal to memory. Should that involve a flush-to-zero as well?

[arsenm]

In D151937#4638331, @bjope wrote:

And the fabs is lowered into a floating point instructions that would that has flushed the result to zero.

Your fabs is incorrectly implemented then. fabs is defined as a non-canonicalizing bit operation. You can only use this instruction when used in a context where the result is used in a canonicalizing context

[bjope]

In D151937#4638337, @arsenm wrote:

In D151937#4638331, @bjope wrote:

And the fabs is lowered into a floating point instructions that would that has flushed the result to zero.

Your fabs is incorrectly implemented then. fabs is defined as a non-canonicalizing bit operation. You can only use this instruction when used in a context where the result is used in a canonicalizing context

Ok. I see. Thanks!

llvm/lib/Transforms/InstCombine/InstCombineAndOrXor.cpp

if (C3->isPowerOf2()) {
           Value *Cmp = Builder.CreateICmpEQ(X, CmpC);
           return SelectInst::Create(Cmp, ConstantInt::get(Ty, *C3),
                                     ConstantInt::getNullValue(Ty));
         }
       }
     }
   }
 
+  // If we are clearing the sign bit of a floating-point value, convert this to
+  // fabs, then cast back to integer.
+  //
+  // Assumes any IEEE-represented type has the sign bit in the high bit.
+  // TODO: Unify with APInt matcher. This version allows undef unlike m_APInt
+  Value *CastOp;
+  if (match(Op0, m_BitCast(m_Value(CastOp))) &&
+      match(Op1, m_MaxSignedValue()) &&
+      !Builder.GetInsertBlock()->getParent()->hasFnAttribute(
+        Attribute::NoImplicitFloat)) {
+    Type *EltTy = CastOp->getType()->getScalarType();
+    if (EltTy->isFloatingPointTy() && EltTy->isIEEE() &&
+        EltTy->getPrimitiveSizeInBits() ==
+        I.getType()->getScalarType()->getPrimitiveSizeInBits()) {
+      Value *FAbs = Builder.CreateUnaryIntrinsic(Intrinsic::fabs, CastOp);
+      return new BitCastInst(FAbs, I.getType());
+    }
+  }
+
   if (match(&I, m_And(m_OneUse(m_Shl(m_ZExt(m_Value(X)), m_Value(Y))),
                       m_SignMask())) &&
       match(Y, m_SpecificInt_ICMP(
                    ICmpInst::Predicate::ICMP_EQ,
                    APInt(Ty->getScalarSizeInBits(),
                          Ty->getScalarSizeInBits() -
                              X->getType()->getScalarSizeInBits())))) {
     auto *SExt = Builder.CreateSExt(X, Ty, X->getName() + ".signext");
if (match(Op1, m_APInt(RHSC))) {
       // TODO: We could handle 'ashr' here as well. That would be matching
       //       a 'not' op and moving it before the shift. Doing that requires
       //       preventing the inverse fold in canShiftBinOpWithConstantRHS().
     }
 
     // If we are XORing the sign bit of a floating-point value, convert
     // this to fneg, then cast back to integer.
     //
+    // This is generous interpretation of noimplicitfloat, this is not a true
+    // floating-point operation.
+    //
     // Assumes any IEEE-represented type has the sign bit in the high bit.
     // TODO: Unify with APInt matcher. This version allows undef unlike m_APInt
     Value *CastOp;
     if (match(Op0, m_BitCast(m_Value(CastOp))) && match(Op1, m_SignMask()) &&
         !Builder.GetInsertBlock()->getParent()->hasFnAttribute(
             Attribute::NoImplicitFloat)) {
       Type *EltTy = CastOp->getType()->getScalarType();
       if (EltTy->isFloatingPointTy() && EltTy->isIEEE() &&

llvm/test/Transforms/InstCombine/fabs-as-int.ll

;
   %bc = bitcast <2 x float> %x to <2 x i32>
   %and = and <2 x i32> %bc, <i32 2147483647, i32 2147483647>
   ret <2 x i32> %and
 }
 
 define float @fabs_as_int_f32_castback(float %val) {
 ; CHECK-LABEL: define float @fabs_as_int_f32_castback
 ; CHECK-SAME: (float [[VAL:%.*]]) {
-; CHECK-NEXT:    [[BITCAST:%.*]] = bitcast float [[VAL]] to i32
-; CHECK-NEXT:    [[AND:%.*]] = and i32 [[BITCAST]], 2147483647
-; CHECK-NEXT:    [[FABS:%.*]] = bitcast i32 [[AND]] to float
-; CHECK-NEXT:    ret float [[FABS]]
+; CHECK-NEXT:    [[TMP1:%.*]] = call float @llvm.fabs.f32(float [[VAL]])
+; CHECK-NEXT:    ret float [[TMP1]]
 ;
   %bitcast = bitcast float %val to i32
   %and = and i32 %bitcast, 2147483647
   %fabs = bitcast i32 %and to float
   ret float %fabs
 }
 
 define float @not_fabs_as_int_f32_castback_wrongconst(float %val) {
 ; CHECK-LABEL: define float @not_fabs_as_int_f32_castback_wrongconst
 ; CHECK-SAME: (float [[VAL:%.*]]) {
-; CHECK-NEXT:    [[BITCAST:%.*]] = bitcast float [[VAL]] to i32
-; CHECK-NEXT:    [[AND:%.*]] = and i32 [[BITCAST]], 2147483647
-; CHECK-NEXT:    [[FABS:%.*]] = bitcast i32 [[AND]] to float
-; CHECK-NEXT:    ret float [[FABS]]
+; CHECK-NEXT:    [[TMP1:%.*]] = call float @llvm.fabs.f32(float [[VAL]])
+; CHECK-NEXT:    ret float [[TMP1]]
 ;
   %bitcast = bitcast float %val to i32
   %and = and i32 %bitcast, 2147483647
   %fabs = bitcast i32 %and to float
   ret float %fabs
 }
 
 define float @fabs_as_int_f32_castback_multi_use(float %val, ptr %ptr) {
 ; CHECK-LABEL: define float @fabs_as_int_f32_castback_multi_use
 ; CHECK-SAME: (float [[VAL:%.*]], ptr [[PTR:%.*]]) {
-; CHECK-NEXT:    [[BITCAST:%.*]] = bitcast float [[VAL]] to i32
-; CHECK-NEXT:    [[AND:%.*]] = and i32 [[BITCAST]], 2147483647
-; CHECK-NEXT:    store i32 [[AND]], ptr [[PTR]], align 4
-; CHECK-NEXT:    [[FABS:%.*]] = bitcast i32 [[AND]] to float
-; CHECK-NEXT:    ret float [[FABS]]
+; CHECK-NEXT:    [[TMP1:%.*]] = call float @llvm.fabs.f32(float [[VAL]])
+; CHECK-NEXT:    store float [[TMP1]], ptr [[PTR]], align 4
+; CHECK-NEXT:    ret float [[TMP1]]
 ;
   %bitcast = bitcast float %val to i32
   %and = and i32 %bitcast, 2147483647
   store i32 %and, ptr %ptr
   %fabs = bitcast i32 %and to float
   ret float %fabs
 }
 
 define i64 @fabs_as_int_f64(double %x) {
 ; CHECK-LABEL: define i64 @fabs_as_int_f64
 ; CHECK-SAME: (double [[X:%.*]]) {
-; CHECK-NEXT:    [[BC:%.*]] = bitcast double [[X]] to i64
-; CHECK-NEXT:    [[AND:%.*]] = and i64 [[BC]], 9223372036854775807
+; CHECK-NEXT:    [[TMP1:%.*]] = call double @llvm.fabs.f64(double [[X]])
+; CHECK-NEXT:    [[AND:%.*]] = bitcast double [[TMP1]] to i64
 ; CHECK-NEXT:    ret i64 [[AND]]
 ;
   %bc = bitcast double %x to i64
   %and = and i64 %bc, 9223372036854775807
   ret i64 %and
 }
 
 define <2 x i64> @fabs_as_int_v2f64(<2 x double> %x) {
 ; CHECK-LABEL: define <2 x i64> @fabs_as_int_v2f64
 ; CHECK-SAME: (<2 x double> [[X:%.*]]) {
-; CHECK-NEXT:    [[BC:%.*]] = bitcast <2 x double> [[X]] to <2 x i64>
-; CHECK-NEXT:    [[AND:%.*]] = and <2 x i64> [[BC]], <i64 9223372036854775807, i64 9223372036854775807>
+; CHECK-NEXT:    [[TMP1:%.*]] = call <2 x double> @llvm.fabs.v2f64(<2 x double> [[X]])
+; CHECK-NEXT:    [[AND:%.*]] = bitcast <2 x double> [[TMP1]] to <2 x i64>
 ; CHECK-NEXT:    ret <2 x i64> [[AND]]
 ;
   %bc = bitcast <2 x double> %x to <2 x i64>
   %and = and <2 x i64> %bc, <i64 9223372036854775807, i64 9223372036854775807>
   ret <2 x i64> %and
 }
 
 define i64 @fabs_as_int_f64_swap(double %x) {
 ; CHECK-LABEL: define i64 @fabs_as_int_f64_swap
 ; CHECK-SAME: (double [[X:%.*]]) {
-; CHECK-NEXT:    [[BC:%.*]] = bitcast double [[X]] to i64
-; CHECK-NEXT:    [[AND:%.*]] = and i64 [[BC]], 9223372036854775807
+; CHECK-NEXT:    [[TMP1:%.*]] = call double @llvm.fabs.f64(double [[X]])
+; CHECK-NEXT:    [[AND:%.*]] = bitcast double [[TMP1]] to i64
 ; CHECK-NEXT:    ret i64 [[AND]]
 ;
   %bc = bitcast double %x to i64
   %and = and i64 9223372036854775807, %bc
   ret i64 %and
 }
 
 define i32 @fabs_as_int_f32(float %x) {
 ; CHECK-LABEL: define i32 @fabs_as_int_f32
 ; CHECK-SAME: (float [[X:%.*]]) {
-; CHECK-NEXT:    [[BC:%.*]] = bitcast float [[X]] to i32
-; CHECK-NEXT:    [[AND:%.*]] = and i32 [[BC]], 2147483647
+; CHECK-NEXT:    [[TMP1:%.*]] = call float @llvm.fabs.f32(float [[X]])
+; CHECK-NEXT:    [[AND:%.*]] = bitcast float [[TMP1]] to i32
 ; CHECK-NEXT:    ret i32 [[AND]]
 ;
   %bc = bitcast float %x to i32
   %and = and i32 %bc, 2147483647
   ret i32 %and
 }
 
 define <2 x i32> @fabs_as_int_v2f32(<2 x float> %x) {
 ; CHECK-LABEL: define <2 x i32> @fabs_as_int_v2f32
 ; CHECK-SAME: (<2 x float> [[X:%.*]]) {
-; CHECK-NEXT:    [[BC:%.*]] = bitcast <2 x float> [[X]] to <2 x i32>
-; CHECK-NEXT:    [[AND:%.*]] = and <2 x i32> [[BC]], <i32 2147483647, i32 2147483647>
+; CHECK-NEXT:    [[TMP1:%.*]] = call <2 x float> @llvm.fabs.v2f32(<2 x float> [[X]])
+; CHECK-NEXT:    [[AND:%.*]] = bitcast <2 x float> [[TMP1]] to <2 x i32>
 ; CHECK-NEXT:    ret <2 x i32> [[AND]]
 ;
   %bc = bitcast <2 x float> %x to <2 x i32>
   %and = and <2 x i32> %bc, <i32 2147483647, i32 2147483647>
   ret <2 x i32> %and
 }
 
 define <2 x i32> @not_fabs_as_int_v2f32_nonsplat(<2 x float> %x) {
 ; CHECK-LABEL: define <2 x i32> @not_fabs_as_int_v2f32_nonsplat
 ; CHECK-SAME: (<2 x float> [[X:%.*]]) {
 ; CHECK-NEXT:    [[BC:%.*]] = bitcast <2 x float> [[X]] to <2 x i32>
 ; CHECK-NEXT:    [[AND:%.*]] = and <2 x i32> [[BC]], <i32 2147483647, i32 2147483646>
 ; CHECK-NEXT:    ret <2 x i32> [[AND]]
 ;
   %bc = bitcast <2 x float> %x to <2 x i32>
   %and = and <2 x i32> %bc, <i32 2147483647, i32 2147483646>
   ret <2 x i32> %and
 }
 
 define <3 x i32> @fabs_as_int_v3f32_undef(<3 x float> %x) {
 ; CHECK-LABEL: define <3 x i32> @fabs_as_int_v3f32_undef
 ; CHECK-SAME: (<3 x float> [[X:%.*]]) {
-; CHECK-NEXT:    [[BC:%.*]] = bitcast <3 x float> [[X]] to <3 x i32>
-; CHECK-NEXT:    [[AND:%.*]] = and <3 x i32> [[BC]], <i32 2147483647, i32 undef, i32 2147483647>
+; CHECK-NEXT:    [[TMP1:%.*]] = call <3 x float> @llvm.fabs.v3f32(<3 x float> [[X]])
+; CHECK-NEXT:    [[AND:%.*]] = bitcast <3 x float> [[TMP1]] to <3 x i32>
 ; CHECK-NEXT:    ret <3 x i32> [[AND]]
 ;
   %bc = bitcast <3 x float> %x to <3 x i32>
   %and = and <3 x i32> %bc, <i32 2147483647, i32 undef, i32 2147483647>
   ret <3 x i32> %and
 }
 
 ; Make sure that only a bitcast is transformed.
;
   %and = and i32 %bitcast, 2147483647
   %fabs = bitcast i32 %and to float
   ret float %fabs
 }
 
 define i128 @fabs_as_int_fp128_f64_mask(fp128 %x) {
 ; CHECK-LABEL: define i128 @fabs_as_int_fp128_f64_mask
 ; CHECK-SAME: (fp128 [[X:%.*]]) {
-; CHECK-NEXT:    [[BC:%.*]] = bitcast fp128 [[X]] to i128
-; CHECK-NEXT:    [[AND:%.*]] = and i128 [[BC]], 170141183460469231731687303715884105727
+; CHECK-NEXT:    [[TMP1:%.*]] = call fp128 @llvm.fabs.f128(fp128 [[X]])
+; CHECK-NEXT:    [[AND:%.*]] = bitcast fp128 [[TMP1]] to i128
 ; CHECK-NEXT:    ret i128 [[AND]]
 ;
   %bc = bitcast fp128 %x to i128
   %and = and i128 %bc, 170141183460469231731687303715884105727
   ret i128 %and
 }
 
 define i128 @fabs_as_int_fp128_f128_mask(fp128 %x) {
 ; CHECK-LABEL: define i128 @fabs_as_int_fp128_f128_mask
 ; CHECK-SAME: (fp128 [[X:%.*]]) {
-; CHECK-NEXT:    [[BC:%.*]] = bitcast fp128 [[X]] to i128
-; CHECK-NEXT:    [[AND:%.*]] = and i128 [[BC]], 170141183460469231731687303715884105727
+; CHECK-NEXT:    [[TMP1:%.*]] = call fp128 @llvm.fabs.f128(fp128 [[X]])
+; CHECK-NEXT:    [[AND:%.*]] = bitcast fp128 [[TMP1]] to i128
 ; CHECK-NEXT:    ret i128 [[AND]]
 ;
   %bc = bitcast fp128 %x to i128
   %and = and i128 %bc, 170141183460469231731687303715884105727
   ret i128 %and
 }
 
 define i16 @fabs_as_int_f16(half %x) {
 ; CHECK-LABEL: define i16 @fabs_as_int_f16
 ; CHECK-SAME: (half [[X:%.*]]) {
-; CHECK-NEXT:    [[BC:%.*]] = bitcast half [[X]] to i16
-; CHECK-NEXT:    [[AND:%.*]] = and i16 [[BC]], 32767
+; CHECK-NEXT:    [[TMP1:%.*]] = call half @llvm.fabs.f16(half [[X]])
+; CHECK-NEXT:    [[AND:%.*]] = bitcast half [[TMP1]] to i16
 ; CHECK-NEXT:    ret i16 [[AND]]
 ;
   %bc = bitcast half %x to i16
   %and = and i16 %bc, 32767
   ret i16 %and
 }
 
 define <2 x i16> @fabs_as_int_v2f16(<2 x half> %x) {
 ; CHECK-LABEL: define <2 x i16> @fabs_as_int_v2f16
 ; CHECK-SAME: (<2 x half> [[X:%.*]]) {
-; CHECK-NEXT:    [[BC:%.*]] = bitcast <2 x half> [[X]] to <2 x i16>
-; CHECK-NEXT:    [[AND:%.*]] = and <2 x i16> [[BC]], <i16 32767, i16 32767>
+; CHECK-NEXT:    [[TMP1:%.*]] = call <2 x half> @llvm.fabs.v2f16(<2 x half> [[X]])
+; CHECK-NEXT:    [[AND:%.*]] = bitcast <2 x half> [[TMP1]] to <2 x i16>
 ; CHECK-NEXT:    ret <2 x i16> [[AND]]
 ;
   %bc = bitcast <2 x half> %x to <2 x i16>
   %and = and <2 x i16> %bc, <i16 32767, i16 32767>
   ret <2 x i16> %and
 }
 
 define i16 @fabs_as_int_bf16(bfloat %x) {
 ; CHECK-LABEL: define i16 @fabs_as_int_bf16
 ; CHECK-SAME: (bfloat [[X:%.*]]) {
-; CHECK-NEXT:    [[BC:%.*]] = bitcast bfloat [[X]] to i16
-; CHECK-NEXT:    [[AND:%.*]] = and i16 [[BC]], 32767
+; CHECK-NEXT:    [[TMP1:%.*]] = call bfloat @llvm.fabs.bf16(bfloat [[X]])
+; CHECK-NEXT:    [[AND:%.*]] = bitcast bfloat [[TMP1]] to i16
 ; CHECK-NEXT:    ret i16 [[AND]]
 ;
   %bc = bitcast bfloat %x to i16
   %and = and i16 %bc, 32767
   ret i16 %and
 }
 
 define <2 x i16> @fabs_as_int_v2bf16(<2 x bfloat> %x) {
 ; CHECK-LABEL: define <2 x i16> @fabs_as_int_v2bf16
 ; CHECK-SAME: (<2 x bfloat> [[X:%.*]]) {
-; CHECK-NEXT:    [[BC:%.*]] = bitcast <2 x bfloat> [[X]] to <2 x i16>
-; CHECK-NEXT:    [[AND:%.*]] = and <2 x i16> [[BC]], <i16 32767, i16 32767>
+; CHECK-NEXT:    [[TMP1:%.*]] = call <2 x bfloat> @llvm.fabs.v2bf16(<2 x bfloat> [[X]])
+; CHECK-NEXT:    [[AND:%.*]] = bitcast <2 x bfloat> [[TMP1]] to <2 x i16>
 ; CHECK-NEXT:    ret <2 x i16> [[AND]]
 ;
   %bc = bitcast <2 x bfloat> %x to <2 x i16>
   %and = and <2 x i16> %bc, <i16 32767, i16 32767>
   ret <2 x i16> %and
 }
 
 define i80 @fabs_as_int_x86_fp80_f64_mask(x86_fp80 %x) {

llvm/test/Transforms/InstCombine/fneg-fabs-as-int.ll

;
   %bc = bitcast <2 x float> %x to <2 x i32>
   %or = or <2 x i32> %bc, <i32 -2147483648, i32 -2147483648>
   ret <2 x i32> %or
 }
 
 define float @fneg_fabs_fabs_as_int_f32_and_or(float %val) {
 ; CHECK-LABEL: define float @fneg_fabs_fabs_as_int_f32_and_or
 ; CHECK-SAME: (float [[VAL:%.*]]) {
-; CHECK-NEXT:    [[BITCAST:%.*]] = bitcast float [[VAL]] to i32
-; CHECK-NEXT:    [[OR:%.*]] = or i32 [[BITCAST]], -2147483648
+; CHECK-NEXT:    [[TMP1:%.*]] = call float @llvm.fabs.f32(float [[VAL]])
+; CHECK-NEXT:    [[AND:%.*]] = bitcast float [[TMP1]] to i32
+; CHECK-NEXT:    [[OR:%.*]] = or i32 [[AND]], -2147483648
 ; CHECK-NEXT:    [[FNEG_FABS:%.*]] = bitcast i32 [[OR]] to float
 ; CHECK-NEXT:    ret float [[FNEG_FABS]]
 ;
   %bitcast = bitcast float %val to i32
   %and = and i32 %bitcast, 2147483647
   %or = or i32 %and, -2147483648
   %fneg.fabs = bitcast i32 %or to float
   ret float %fneg.fabs