[Instcombine] Try to get select's FMFs from its operands

[mnadeem]

Summary

This tries to tackle https://bugs.llvm.org/show_bug.cgi?id=52259

Intersect the FMF of the select's operands. If the operand is not a FPMathOperator e.g. an argument then try to take the flag from the function's attributes.

[spatel]

Using function attributes is what we're trying to get away from by having instruction-level FMF, so this would have to be clearly labeled as a hack or temporary fix.

That said, I don't think anyone is working on a real fix that would apply FMF to all FP values. That was a comment I made in:
https://llvm.org/PR35607
...but it might lead to another question about how that works with type-less memory (I don't know the answer to that one).

I think that's also the root cause for the failure in the motivating bug/test for this patch:
https://llvm.org/PR52259
That is, I don't think we can blame SROA for not propagating FMF when creating a phi - the FMF weren't on the loaded values used to form that phi in the first place.

This fabs example is worth posting to llvm-dev for wider discussion. I think we do need to do something to optimize that code, but there's no clear fix that I know of.
Note that this example is really only about 'nsz':
https://godbolt.org/z/1zW6hK1qK

[lebedev.ri]

This review seems to be stuck/dead, consider abandoning if no longer relevant.

llvm/include/llvm/IR/Operator.h

 
 #ifndef LLVM_IR_OPERATOR_H
 #define LLVM_IR_OPERATOR_H
 
 #include "llvm/ADT/MapVector.h"
 #include "llvm/ADT/None.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/IR/Constants.h"
+#include "llvm/IR/Function.h"
 #include "llvm/IR/Instruction.h"
 #include "llvm/IR/Type.h"
 #include "llvm/IR/Value.h"
 #include "llvm/Support/Casting.h"
 #include <cstddef>
 
 namespace llvm {
 
public:
   FastMathFlags() = default;
 
   static FastMathFlags getFast() {
     FastMathFlags FMF;
     FMF.setFast();
     return FMF;
   }
 
+  static FastMathFlags getFromFuncAttr(Function *F) {
+    FastMathFlags FMF;
+    if (F->hasFnAttribute("unsafe-fp-math")) {
+      bool UnsafeMath = F->getFnAttribute("unsafe-fp-math").getValueAsBool();
+      FMF.setAllowReassoc(UnsafeMath);
+      FMF.setAllowReciprocal(UnsafeMath);
+    }
+    if (F->hasFnAttribute("no-nans-fp-math"))
+      FMF.setNoNaNs(F->getFnAttribute("no-nans-fp-math").getValueAsBool());
+    if (F->hasFnAttribute("no-signed-zeros-fp-math"))
+      FMF.setNoSignedZeros(
+          F->getFnAttribute("no-signed-zeros-fp-math").getValueAsBool());
+    if (F->hasFnAttribute("no-infs-fp-math"))
+      FMF.setNoInfs(F->getFnAttribute("no-infs-fp-math").getValueAsBool());
+    if (F->hasFnAttribute("approx-func-fp-math"))
+      FMF.setApproxFunc(
+          F->getFnAttribute("approx-func-fp-math").getValueAsBool());
+    return FMF;
+  }
+
   bool any() const { return Flags != 0; }
   bool none() const { return Flags == 0; }
   bool all() const { return Flags == ~0U; }
 
   void clear() { Flags = 0; }
   void set()   { Flags = ~0U; }
 
   /// Flag queries

llvm/lib/Transforms/InstCombine/InstCombineSelect.cpp

if (*Res == true) {
     else
       // select op, true, (select cond, A, B) => select op, true, B
       // or     op, (select cond, A, B)       => select op, true, B
       //   if op = false implies condval = false.
       return SelectInst::Create(Op, One, B);
   }
 }
 
+static FastMathFlags getFMFforSel(SelectInst &SI) {
+  Value *TrueVal = SI.getTrueValue();
+  Value *FalseVal = SI.getFalseValue();
+  FastMathFlags FMF;
+  FMF.set();
+
+  if (auto *V = dyn_cast<FPMathOperator>(TrueVal))
+    FMF &= V->getFastMathFlags();
+  else
+    FMF &= FastMathFlags::getFromFuncAttr(SI.getFunction());
+
+  if (auto *V = dyn_cast<FPMathOperator>(FalseVal))
+    FMF &= V->getFastMathFlags();
+  else
+    FMF &= FastMathFlags::getFromFuncAttr(SI.getFunction());
+
+  // This is probably not needed.
+  // Value *CondVal = SI.getCondition();
+  // if (auto *V = dyn_cast<FPMathOperator>(CondVal))
+  //   FMF &= V->getFastMathFlags();
+  // else
+  //   FMF &= FastMathFlags::getFromFuncAttr(SI.getFunction());
+
+  return FMF;
+}
+
 Instruction *InstCombinerImpl::visitSelectInst(SelectInst &SI) {
   Value *CondVal = SI.getCondition();
   Value *TrueVal = SI.getTrueValue();
   Value *FalseVal = SI.getFalseValue();
   Type *SelType = SI.getType();
 
   // FIXME: Remove this workaround when freeze related patches are done.
   // For select with undef operand which feeds into an equality comparison,
if (Value *V = SimplifySelectInst(CondVal, TrueVal, FalseVal,
     return replaceInstUsesWith(SI, V);
 
   if (Instruction *I = canonicalizeSelectToShuffle(SI))
     return I;
 
   if (Instruction *I = canonicalizeScalarSelectOfVecs(SI, *this))
     return I;
 
+  // If the select does not have any FMFs then use the intersection
+  // of it's operand's FMFs.
+  if (isa<FPMathOperator>(SI) && SI.getFastMathFlags().none()) {
+    FastMathFlags FMF = getFMFforSel(SI);
+    if (FMF.any()) {
+      SI.setFastMathFlags(getFMFforSel(SI));
+      return &SI;
+    }
+  }
+
   CmpInst::Predicate Pred;
 
   // Avoid potential infinite loops by checking for non-constant condition.
   // TODO: Can we assert instead by improving canonicalizeSelectToShuffle()?
   //       Scalar select must have simplified?
   if (SelType->isIntOrIntVectorTy(1) && !isa<Constant>(CondVal) &&
       TrueVal->getType() == CondVal->getType()) {
     // Folding select to and/or i1 isn't poison safe in general. impliesPoison

llvm/test/Transforms/InstCombine/minmax-fold.ll

 
 define float @not_min_of_min(i8 %i, float %x) {
 ; CHECK-LABEL: @not_min_of_min(
 ; CHECK-NEXT:    [[CMP1_INV:%.*]] = fcmp fast oge float [[X:%.*]], 1.000000e+00
 ; CHECK-NEXT:    [[TMP1:%.*]] = select fast i1 [[CMP1_INV]], float 1.000000e+00, float [[X]]
 ; CHECK-NEXT:    [[CMP2_INV:%.*]] = fcmp fast oge float [[X]], 2.000000e+00
 ; CHECK-NEXT:    [[TMP2:%.*]] = select fast i1 [[CMP2_INV]], float 2.000000e+00, float [[X]]
 ; CHECK-NEXT:    [[CMP3:%.*]] = icmp ult i8 [[I:%.*]], 16
-; CHECK-NEXT:    [[R:%.*]] = select i1 [[CMP3]], float [[TMP1]], float [[TMP2]]
+; CHECK-NEXT:    [[R:%.*]] = select fast i1 [[CMP3]], float [[TMP1]], float [[TMP2]]
 ; CHECK-NEXT:    ret float [[R]]
 ;
   %cmp1 = fcmp fast ult float %x, 1.0
   %min1 = select i1 %cmp1, float %x, float 1.0
   %cmp2 = fcmp fast ult float %x, 2.0
   %min2 = select i1 %cmp2, float %x, float 2.0
   %cmp3 = icmp ult i8 %i, 16
   %r = select i1 %cmp3, float %min1, float %min2
;
   ret i37 %r
 }
 
 ; Negative test
 ; TODO: assert that instsimplify always gets this?
 
 define i37 @add_umax_simplify(i37 %x) {
 ; CHECK-LABEL: @add_umax_simplify(
-; CHECK-NEXT:    [[A:%.*]] = add nuw i37 [[X:%.*]], 42
-; CHECK-NEXT:    ret i37 [[A]]
+; CHECK-NEXT:    [[R:%.*]] = add nuw i37 [[X:%.*]], 42
+; CHECK-NEXT:    ret i37 [[R]]
 ;
   %a = add nuw i37 %x, 42
   %c = icmp ugt i37 %a, 42
   %r = select i1 %c, i37 %a, i37 42
   ret i37 %r
 }
 
 ; Negative test

llvm/test/Transforms/PhaseOrdering/fmf-select-abs.ll

+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
+; RUN: opt < %s -S -O1 | FileCheck %s
+
+
+; Function Attrs: mustprogress nounwind uwtable
+define dso_local double @foo(double %x) #0 {
+; CHECK-LABEL: @foo(
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    [[TMP0:%.*]] = call reassoc nnan ninf nsz arcp afn double @llvm.fabs.f64(double [[X:%.*]])
+; CHECK-NEXT:    ret double [[TMP0]]
+;
+entry:
+  %retval = alloca double, align 8
+  %x.addr = alloca double, align 8
+  store double %x, double* %x.addr, align 8
+  %0 = load double, double* %x.addr, align 8
+  %cmp = fcmp fast olt double %0, 0.000000e+00
+  br i1 %cmp, label %if.then, label %if.else
+
+if.then:                                          ; preds = %entry
+  %1 = load double, double* %x.addr, align 8
+  %fneg = fneg fast double %1
+  store double %fneg, double* %retval, align 8
+  br label %return
+
+if.else:                                          ; preds = %entry
+  %2 = load double, double* %x.addr, align 8
+  store double %2, double* %retval, align 8
+  br label %return
+
+return:                                           ; preds = %if.else, %if.then
+  %3 = load double, double* %retval, align 8
+  ret double %3
+}
+
+
+attributes #0 = { mustprogress nounwind uwtable "approx-func-fp-math"="true" "frame-pointer"="non-leaf" "min-legal-vector-width"="0" "no-infs-fp-math"="true" "no-nans-fp-math"="true" "no-signed-zeros-fp-math"="true" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="cortex-a76" "unsafe-fp-math"="true" }