[InlineCost] Add support for unary fneg.

This adds support for unary fneg based on the implementation of BinaryOperator without the soft float FP cost.

Previously we would just delegate to visitUnaryInstruction. I think the only real change is that we will pass the FastMath flags to SimplifyFNeg now.

Differential Revision: https://reviews.llvm.org/D62699

llvm-svn: 362732

diff --git a/llvm/lib/Analysis/InlineCost.cpp b/llvm/lib/Analysis/InlineCost.cpp
index a332a439007163b744f59714d0e3a6a771173d9d..3cb56f8cccf59c7184f3be7b3a60e1969df2c7fb 100644 (file)
--- a/llvm/lib/Analysis/InlineCost.cpp
+++ b/llvm/lib/Analysis/InlineCost.cpp
@@ -273,6 +273,7 @@ class CallAnalyzer : public InstVisitor<CallAnalyzer, bool> {
   bool visitCmpInst(CmpInst &I);
   bool visitSub(BinaryOperator &I);
   bool visitBinaryOperator(BinaryOperator &I);
+  bool visitFNeg(UnaryOperator &I);
   bool visitLoad(LoadInst &I);
   bool visitStore(StoreInst &I);
   bool visitExtractValue(ExtractValueInst &I);
@@ -1106,6 +1107,28 @@ bool CallAnalyzer::visitBinaryOperator(BinaryOperator &I) {
   return false;
 }
 
+bool CallAnalyzer::visitFNeg(UnaryOperator &I) {
+  Value *Op = I.getOperand(0);
+  Constant *COp = dyn_cast<Constant>(Op);
+  if (!COp)
+    COp = SimplifiedValues.lookup(Op);
+
+  Value *SimpleV = SimplifyFNegInst(COp ? COp : Op,
+                                    cast<FPMathOperator>(I).getFastMathFlags(),
+                                    DL);
+
+  if (Constant *C = dyn_cast_or_null<Constant>(SimpleV))
+    SimplifiedValues[&I] = C;
+
+  if (SimpleV)
+    return true;
+
+  // Disable any SROA on arguments to arbitrary, unsimplified fneg.
+  disableSROA(Op);
+
+  return false;
+}
+
 bool CallAnalyzer::visitLoad(LoadInst &I) {
   Value *SROAArg;
   DenseMap<Value *, int>::iterator CostIt;

diff --git a/llvm/test/Transforms/Inline/inline_constprop.ll b/llvm/test/Transforms/Inline/inline_constprop.ll
index b07ec03d7d67de0102e1debca8b6dfe71f70e8e1..276c72cd3bd237da62e2253bb685487e184edd25 100644 (file)
--- a/llvm/test/Transforms/Inline/inline_constprop.ll
+++ b/llvm/test/Transforms/Inline/inline_constprop.ll
@@ -345,3 +345,34 @@ bb1:
 ; CHECK-LABEL: define void @caller7(
 ; CHECK: %call = call i16 @caller7.external(i16 1)
 ; CHECK-NEXT: ret void
+
+define float @caller8(float %y) {
+; Check that we can constant-prop through fneg instructions
+;
+; CHECK-LABEL: @caller8(
+; CHECK-NOT: call
+; CHECK: ret
+  %x = call float @callee8(float -42.0, float %y)
+  ret float %x
+}
+
+define float @callee8(float %x, float %y) {
+  %neg = fneg float %x
+  %icmp = fcmp ugt float %neg, 42.0
+  br i1 %icmp, label %bb.true, label %bb.false
+
+bb.true:
+  ; This block musn't be counted in the inline cost.
+  %y1 = fadd float %y, 1.0
+  %y2 = fadd float %y1, 1.0
+  %y3 = fadd float %y2, 1.0
+  %y4 = fadd float %y3, 1.0
+  %y5 = fadd float %y4, 1.0
+  %y6 = fadd float %y5, 1.0
+  %y7 = fadd float %y6, 1.0
+  %y8 = fadd float %y7, 1.0
+  ret float %y8
+
+bb.false:
+  ret float %x
+}