InstSimplify: Constant fold some canonicalizes

[arsenm]

Summary

+/-0 is obviously foldable. Other non-special, non-subnormal
values are also probably OK.

Also folds undef to 0, even though based on the users it
may make more sense to fold to 1 (e.g. fmul fast x, canonicalize(undef))

[arsenm]

ping

[arsenm]

ping

[arsenm]

ping

[arsenm]

New and improved version in D137858

include/llvm/IR/Constants.h

public:
 
   /// This returns a ConstantFP, or a vector containing a splat of a ConstantFP,
   /// for the specified value in the specified type. This should only be used
   /// for simple constant values like 2.0/1.0 etc, that are known-valid both as
   /// host double and as the target format.
   static Constant *get(Type* Ty, double V);
   static Constant *get(Type* Ty, StringRef Str);
   static ConstantFP *get(LLVMContext &Context, const APFloat &V);
+  static Constant *get(Type *Ty, const APFloat &V);
   static Constant *getNaN(Type *Ty, bool Negative = false, unsigned type = 0);
   static Constant *getNegativeZero(Type *Ty);
   static Constant *getInfinity(Type *Ty, bool Negative = false);
 
   /// Return true if Ty is big enough to represent V.
   static bool isValueValidForType(Type *Ty, const APFloat &V);
   inline const APFloat &getValueAPF() const { return Val; }
 

lib/Analysis/InstructionSimplify.cpp

for (unsigned I = 0, E = ConstMask->getType()->getVectorNumElements(); I != E;
     if (auto *MaskElt = ConstMask->getAggregateElement(I))
       if (MaskElt->isNullValue() || isa<UndefValue>(MaskElt))
         continue;
     return false;
   }
   return true;
 }
 
+static Value *simplifyCanonicalize(Value *Src) {
+  // Any bit value is necessarily a valid canonical value, but 0 is always
+  // canonical.
+  if (isa<UndefValue>(Src))
+    return ConstantFP::get(Src->getType(), 0.0);
+
+  const APFloat *C;
+
+  if (!match(Src, m_APFloat(C)))
+    return nullptr;
+
+  // Zero is always canonical and the sign must be preserved.
+  if (C->isZero())
+    return ConstantFP::get(Src->getType(), *C);
+
+  // Denorms and special values may have special rules, but it should be OK to
+  // fold a totally average number.
+  if (C->isNormal())
+    return ConstantFP::get(Src->getType(), *C);
+
+  return nullptr;
+}
+
 template <typename IterTy>
 static Value *SimplifyIntrinsic(Function *F, IterTy ArgBegin, IterTy ArgEnd,
                                 const SimplifyQuery &Q, unsigned MaxRecurse) {
   Intrinsic::ID IID = F->getIntrinsicID();
   unsigned NumOperands = std::distance(ArgBegin, ArgEnd);
 
   // Unary Ops
   if (NumOperands == 1) {
     // Perform idempotent optimizations
     if (IsIdempotent(IID)) {
       if (IntrinsicInst *II = dyn_cast<IntrinsicInst>(*ArgBegin)) {
         if (II->getIntrinsicID() == IID)
           return II;
       }
     }
 
     switch (IID) {
     case Intrinsic::fabs: {
       if (SignBitMustBeZero(*ArgBegin, Q.TLI))
         return *ArgBegin;
       return nullptr;
     }
+    case Intrinsic::canonicalize:
+      return simplifyCanonicalize(*ArgBegin);
     default:
       return nullptr;
     }
   }
 
   // Binary Ops
   if (NumOperands == 2) {
     Value *LHS = *ArgBegin;

lib/IR/Constants.cpp

else {
       Ty = Type::getPPC_FP128Ty(Context);
     }
     Slot.reset(new ConstantFP(Ty, V));
   }
 
   return Slot.get();
 }
 
+Constant* ConstantFP::get(Type *Ty, const APFloat& V) {
+  ConstantFP *C = get(Ty->getContext(), V);
+
+  if (VectorType *VTy = dyn_cast<VectorType>(Ty))
+    return ConstantVector::getSplat(VTy->getNumElements(), C);
+
+  return C;
+}
+
 Constant *ConstantFP::getInfinity(Type *Ty, bool Negative) {
   const fltSemantics &Semantics = *TypeToFloatSemantics(Ty->getScalarType());
   Constant *C = get(Ty->getContext(), APFloat::getInf(Semantics, Negative));
 
   if (VectorType *VTy = dyn_cast<VectorType>(Ty))
     return ConstantVector::getSplat(VTy->getNumElements(), C);
 
   return C;

test/Transforms/InstCombine/maxnum.ll

 ; CHECK-NEXT: %1 = call float @llvm.canonicalize.f32(float %x)
 ; CHECK-NEXT: ret float %1
 define float @maxnum_f32_val_nan(float %x) #0 {
   %y = call float @llvm.maxnum.f32(float %x, float 0x7FF8000000000000) #0
   ret float %y
 }
 
 ; CHECK-LABEL: @fold_maxnum_f32_undef_undef
-; CHECK-NEXT: %1 = call float @llvm.canonicalize.f32(float undef)
-; CHECK-NEXT: ret float %1
+; CHECK-NEXT: ret float 0.000000e+00
 define float @fold_maxnum_f32_undef_undef() nounwind {
   %val = call float @llvm.maxnum.f32(float undef, float undef) #0
   ret float %val
 }
 
 ; CHECK-LABEL: @fold_maxnum_f32_val_undef
 ; CHECK-NEXT: %1 = call float @llvm.canonicalize.f32(float %x)
 ; CHECK-NEXT: ret float %1

test/Transforms/InstCombine/minnum.ll

 ; CHECK-NEXT: %1 = call float @llvm.canonicalize.f32(float %x)
 ; CHECK-NEXT: ret float %1
 define float @minnum_f32_val_nan(float %x) #0 {
   %y = call float @llvm.minnum.f32(float %x, float 0x7FF8000000000000) #0
   ret float %y
 }
 
 ; CHECK-LABEL: @fold_minnum_f32_undef_undef
-; CHECK-NEXT: %1 = call float @llvm.canonicalize.f32(float undef)
-; CHECK-NEXT: ret float %1
+; CHECK-NEXT: ret float 0.000000e+00
 define float @fold_minnum_f32_undef_undef() nounwind {
   %val = call float @llvm.minnum.f32(float undef, float undef) #0
   ret float %val
 }
 
 ; CHECK-LABEL: @fold_minnum_f32_val_undef
 ; CHECK-NEXT: %1 = call float @llvm.canonicalize.f32(float %x)
 ; CHECK-NEXT: ret float %1

test/Transforms/InstSimplify/canonicalize.ll

+; RUN: opt -instsimplify -S < %s | FileCheck %s
+
+declare float @llvm.canonicalize.f32(float)
+declare <2 x float> @llvm.canonicalize.v2f32(<2 x float>)
+
+; CHECK-LABEL: @fold_zero(
+; CHECK-NEXT: ret float 0.000000e+00
+define float @fold_zero() {
+  %ret = call float @llvm.canonicalize.f32(float 0.0)
+  ret float %ret
+}
+
+; CHECK-LABEL: @fold_negzero(
+; CHECK-NEXT: ret float -0.000000e+00
+define float @fold_negzero() {
+  %ret = call float @llvm.canonicalize.f32(float -0.0)
+  ret float %ret
+}
+
+; CHECK-LABEL: @fold_zero_vector(
+; CHECK-NEXT: ret <2 x float> zeroinitializer
+define <2 x float> @fold_zero_vector() {
+  %ret = call <2 x float> @llvm.canonicalize.v2f32(<2 x float> zeroinitializer)
+  ret <2 x float> %ret
+}
+
+; CHECK-LABEL: @fold_negzero_vector(
+; CHECK-NEXT: ret <2 x float> <float -0.000000e+00, float -0.000000e+00>
+define <2 x float> @fold_negzero_vector() {
+  %ret = call <2 x float> @llvm.canonicalize.v2f32(<2 x float> <float -0.0, float -0.0>)
+  ret <2 x float> %ret
+}
+
+; FIXME: Fold to -0.0 splat
+; CHECK-LABEL: @fold_negzero_vector_partialundef(
+; CHECK-NEXT: %ret = call <2 x float> @llvm.canonicalize.v2f32(<2 x float> <float -0.000000e+00, float undef>)
+; CHECK-NEXT: ret <2 x float> %ret
+define <2 x float> @fold_negzero_vector_partialundef() {
+  %ret = call <2 x float> @llvm.canonicalize.v2f32(<2 x float> <float -0.0, float undef>)
+  ret <2 x float> %ret
+}
+
+; CHECK-LABEL: @fold_undef(
+; CHECK-NEXT: ret float 0.000000e+00
+define float @fold_undef() {
+  %ret = call float @llvm.canonicalize.f32(float undef)
+  ret float %ret
+}
+
+; CHECK-LABEL: @fold_undef_vector(
+; CHECK-NEXT: ret <2 x float> zeroinitializer
+define <2 x float> @fold_undef_vector() {
+  %ret = call <2 x float> @llvm.canonicalize.v2f32(<2 x float> undef)
+  ret <2 x float> %ret
+}
+
+; CHECK-LABEL: @no_fold_denorm(
+; CHECK-NEXT: %ret = call float @llvm.canonicalize.f32(float 0x380FFFFFC0000000)
+; CHECK-NEXT: ret float %ret
+define float @no_fold_denorm() {
+  %ret = call float @llvm.canonicalize.f32(float bitcast (i32 8388607 to float))
+  ret float %ret
+}
+
+; CHECK-LABEL: @no_fold_inf(
+; CHECK-NEXT: %ret = call float @llvm.canonicalize.f32(float 0x7FF0000000000000)
+; CHECK-NEXT: ret float %ret
+define float @no_fold_inf() {
+  %ret = call float @llvm.canonicalize.f32(float 0x7FF0000000000000)
+  ret float %ret
+}
+
+; CHECK-LABEL: @no_fold_qnan(
+; CHECK-NEXT: %ret = call float @llvm.canonicalize.f32(float 0x7FF8000000000000)
+; CHECK-NEXT: ret float %ret
+define float @no_fold_qnan() {
+  %ret = call float @llvm.canonicalize.f32(float 0x7FF8000000000000)
+  ret float %ret
+}
+
+; CHECK-LABEL: @no_fold_snan(
+; CHECK-NEXT: %ret = call float @llvm.canonicalize.f32(float 0x7FF0000020000000)
+; CHECK-NEXT: ret float %ret
+define float @no_fold_snan() {
+  %ret = call float @llvm.canonicalize.f32(float bitcast (i32 2139095041 to float))
+  ret float %ret
+}
+
+; CHECK-LABEL: @fold_normal(
+; CHECK-NEXT: ret float 4.000000e+00
+define float @fold_normal() {
+  %ret = call float @llvm.canonicalize.f32(float 4.0)
+  ret float %ret
+}