[ConstantFolding] fold abs intrinsic

[spatel]

Summary

The handling for minimum value is similar to cttz/ctlz with 0 just above this case.

[aqjune]

llvm/test/Analysis/ConstantFolding/abs.ll

46

(a silly question) abs with a vector input is optimized here, but this patch is about non-vector integers; do you have any idea which part of ConstantFolding.cpp is responsible for this?

[spatel]

llvm/lib/Analysis/ConstantFolding.cpp

2858

Vector types are handled by calling the scalar fold for each element.

llvm/test/Analysis/ConstantFolding/abs.ll

46

Not silly - I used the vector test to reduce the number of tests needed, and it's not obvious from just this patch how that works. :)
I put an inline comment at the place where vectors get expanded. So this test is sequentially calling into the scalar code 8 times (once for each element of the vector).

[aqjune]

LGTM

llvm/test/Analysis/ConstantFolding/abs.ll

46

Thank you for the kind explanation! :)

llvm/lib/Analysis/ConstantFolding.cpp

bool llvm::canConstantFoldCallTo(const CallBase *Call, const Function *F) {
   case Intrinsic::ctpop:
   case Intrinsic::ctlz:
   case Intrinsic::cttz:
   case Intrinsic::fshl:
   case Intrinsic::fshr:
   case Intrinsic::launder_invariant_group:
   case Intrinsic::strip_invariant_group:
   case Intrinsic::masked_load:
+  case Intrinsic::abs:
   case Intrinsic::smax:
   case Intrinsic::smin:
   case Intrinsic::umax:
   case Intrinsic::umin:
   case Intrinsic::sadd_with_overflow:
   case Intrinsic::uadd_with_overflow:
   case Intrinsic::ssub_with_overflow:
   case Intrinsic::usub_with_overflow:
case Intrinsic::ctlz:
       if (C1->isOneValue() && (!C0 || C0->isNullValue()))
         return UndefValue::get(Ty);
       if (!C0)
         return Constant::getNullValue(Ty);
       if (IntrinsicID == Intrinsic::cttz)
         return ConstantInt::get(Ty, C0->countTrailingZeros());
       else
         return ConstantInt::get(Ty, C0->countLeadingZeros());
+
+    case Intrinsic::abs:
+      // Undef or minimum val operand with poison min --> undef
+      assert(C1 && "Must be constant int");
+      if (C1->isOneValue() && (!C0 || C0->isMinSignedValue()))
+        return UndefValue::get(Ty);
+
+      // Undef operand with no poison min --> 0 (sign bit must be clear)
+      if (C1->isNullValue() && !C0)
+        return Constant::getNullValue(Ty);
+
+      return ConstantInt::get(Ty, C0->abs());
     }
 
     return nullptr;
   }
 
   // Support ConstantVector in case we have an Undef in the top.
   if ((isa<ConstantVector>(Operands[0]) ||
        isa<ConstantDataVector>(Operands[0])) &&
for (unsigned J = 0, JE = Operands.size(); J != JE; ++J) {
 
       Constant *Agg = Operands[J]->getAggregateElement(I);
       if (!Agg)
         return nullptr;
 
       Lane[J] = Agg;
     }
 
     // Use the regular scalar folding to simplify this column.
     Constant *Folded =
         ConstantFoldScalarCall(Name, IntrinsicID, Ty, Lane, TLI, Call);
     if (!Folded)
       return nullptr;
     Result[I] = Folded;
   }
 
   return ConstantVector::get(Result);

llvm/test/Analysis/ConstantFolding/abs.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt < %s -constprop -S | FileCheck %s
 
 declare i8 @llvm.abs.i8(i8, i1)
 declare <8 x i8> @llvm.abs.v8i8(<8 x i8>, i1)
 
 define i8 @undef_val_min_poison() {
 ; CHECK-LABEL: @undef_val_min_poison(
-; CHECK-NEXT:    [[R:%.*]] = call i8 @llvm.abs.i8(i8 undef, i1 true)
-; CHECK-NEXT:    ret i8 [[R]]
+; CHECK-NEXT:    ret i8 undef
 ;
   %r = call i8 @llvm.abs.i8(i8 undef, i1 true)
   ret i8 %r
 }
 
 define i8 @undef_val_min_not_poison() {
 ; CHECK-LABEL: @undef_val_min_not_poison(
-; CHECK-NEXT:    [[R:%.*]] = call i8 @llvm.abs.i8(i8 undef, i1 false)
-; CHECK-NEXT:    ret i8 [[R]]
+; CHECK-NEXT:    ret i8 0
 ;
   %r = call i8 @llvm.abs.i8(i8 undef, i1 false)
   ret i8 %r
 }
 
 define i8 @min_val_min_poison() {
 ; CHECK-LABEL: @min_val_min_poison(
-; CHECK-NEXT:    [[R:%.*]] = call i8 @llvm.abs.i8(i8 -128, i1 true)
-; CHECK-NEXT:    ret i8 [[R]]
+; CHECK-NEXT:    ret i8 undef
 ;
   %r = call i8 @llvm.abs.i8(i8 -128, i1 true)
   ret i8 %r
 }
 
 define i8 @min_val_min_not_poison() {
 ; CHECK-LABEL: @min_val_min_not_poison(
-; CHECK-NEXT:    [[R:%.*]] = call i8 @llvm.abs.i8(i8 -128, i1 false)
-; CHECK-NEXT:    ret i8 [[R]]
+; CHECK-NEXT:    ret i8 -128
 ;
   %r = call i8 @llvm.abs.i8(i8 -128, i1 false)
   ret i8 %r
 }
 
 define <8 x i8> @vec_const() {
 ; CHECK-LABEL: @vec_const(
-; CHECK-NEXT:    [[R:%.*]] = call <8 x i8> @llvm.abs.v8i8(<8 x i8> <i8 -127, i8 -126, i8 -42, i8 -1, i8 0, i8 1, i8 42, i8 127>, i1 true)
-; CHECK-NEXT:    ret <8 x i8> [[R]]
+; CHECK-NEXT:    ret <8 x i8> <i8 127, i8 126, i8 42, i8 1, i8 0, i8 1, i8 42, i8 127>
 ;
   %r = call <8 x i8> @llvm.abs.v8i8(<8 x i8> <i8 -127, i8 -126, i8 -42, i8 -1, i8 0, i8 1, i8 42, i8 127>, i1 1)
   ret <8 x i8> %r
 }