Add FNeg support to InstructionSimplify

[cameron.mcinally]

Summary

This is the last chunk separated from the larger D61419...

Add FNeg support to InstructionSimplify. There is only one xform included in this patch:

fneg (fneg X) -> X

I took a liberty with the added test and will comment inline so that it's clear for review purposes.

[cameron.mcinally]

llvm/test/Analysis/ConstantFolding/fneg.ll

2

I'm thinking that changing the pass to -instsimplify will save creating another file for the new xform. InstSimplify will exercise the ConstantExpr folding as well, so coverage will remain the same.

Does anyone feel strongly against this?

[cameron.mcinally]

Fix a typo in a comment.

[cameron.mcinally]

Fix bad copy-and-paste. Misunderstood the purpose of SimplifyUnOp(...).

[spatel]

llvm/test/Analysis/ConstantFolding/fneg.ll

2

I don't like having a test for a pass out of its named directory. That makes it hard to find.

This test can be added into:
test/Transforms/InstSimplify/floating-point-arithmetic.ll

[cameron.mcinally]

llvm/test/Analysis/ConstantFolding/fneg.ll

2

Good idea. Thanks.

I originally was looking at cast-vector.ll in test/Analysis/ConstantFolding, which is an -instsimplify test, so that's probably misplaced too. Just a heads up...

[cameron.mcinally]

Move tests as @spatel suggested.

[spatel]

LGTM

llvm/lib/Analysis/InstructionSimplify.cpp

54–56

Nit: we will never converge if we favor old code formatting over the current formatting spec ('camelCase'), so I'd rather have the right formatting in this patch and then update everything that's wrong with an NFC change or vice-versa. At least for the static functions, that shouldn't be too disruptive?

[cameron.mcinally]

Use camelCase for static functions, as @spatel suggested.

llvm/include/llvm/Analysis/InstructionSimplify.h

SimplifyQuery getWithInstruction(Instruction *I) const {
     return Copy;
   }
 };
 
 // NOTE: the explicit multiple argument versions of these functions are
 // deprecated.
 // Please use the SimplifyQuery versions in new code.
 
+/// Given operand for an FNeg, fold the result or return null.
+Value *SimplifyFNegInst(Value *Op, FastMathFlags FMF,
+                        const SimplifyQuery &Q);
+
 /// Given operands for an Add, fold the result or return null.
 Value *SimplifyAddInst(Value *LHS, Value *RHS, bool isNSW, bool isNUW,
                        const SimplifyQuery &Q);
 
 /// Given operands for a Sub, fold the result or return null.
 Value *SimplifySubInst(Value *LHS, Value *RHS, bool isNSW, bool isNUW,
                        const SimplifyQuery &Q);
 
Value *SimplifyShuffleVectorInst(Value *Op0, Value *Op1, Constant *Mask,
                                  Type *RetTy, const SimplifyQuery &Q);
 
 //=== Helper functions for higher up the class hierarchy.
 
 /// Given operands for a CmpInst, fold the result or return null.
 Value *SimplifyCmpInst(unsigned Predicate, Value *LHS, Value *RHS,
                        const SimplifyQuery &Q);
 
+/// Given operand for a UnaryOperator, fold the result or return null.
+Value *SimplifyUnOp(unsigned Opcode, Value *Op, const SimplifyQuery &Q);
+
+/// Given operand for an FP UnaryOperator, fold the result or return null.
+/// In contrast to SimplifyBinOp, try to use FastMathFlag when folding the
+/// result. In case we don't need FastMathFlags, simply fall to SimplifyBinOp.
+Value *SimplifyFPUnOp(unsigned Opcode, Value *Op, FastMathFlags FMF,
+                      const SimplifyQuery &Q);
+
 /// Given operands for a BinaryOperator, fold the result or return null.
 Value *SimplifyBinOp(unsigned Opcode, Value *LHS, Value *RHS,
                      const SimplifyQuery &Q);
 
 /// Given operands for an FP BinaryOperator, fold the result or return null.
 /// In contrast to SimplifyBinOp, try to use FastMathFlag when folding the
 /// result. In case we don't need FastMathFlags, simply fall to SimplifyBinOp.
 Value *SimplifyFPBinOp(unsigned Opcode, Value *LHS, Value *RHS,

llvm/lib/Analysis/InstructionSimplify.cpp

 #define DEBUG_TYPE "instsimplify"
 
 enum { RecursionLimit = 3 };
 
 STATISTIC(NumExpand,  "Number of expansions");
 STATISTIC(NumReassoc, "Number of reassociations");
 
 static Value *SimplifyAndInst(Value *, Value *, const SimplifyQuery &, unsigned);
+static Value *SimplifyUnOp(unsigned, Value *, const SimplifyQuery &, unsigned);
+static Value *SimplifyFPUnOp(unsigned, Value *, const FastMathFlags &,
+                             const SimplifyQuery &, unsigned);
 static Value *SimplifyBinOp(unsigned, Value *, Value *, const SimplifyQuery &,
                             unsigned);
 static Value *SimplifyFPBinOp(unsigned, Value *, Value *, const FastMathFlags &,
                               const SimplifyQuery &, unsigned);
 static Value *SimplifyCmpInst(unsigned, Value *, Value *, const SimplifyQuery &,
                               unsigned);
 static Value *SimplifyICmpInst(unsigned Predicate, Value *LHS, Value *RHS,
                                const SimplifyQuery &Q, unsigned MaxRecurse);

 }
 
 /// Given operands for a ShuffleVectorInst, fold the result or return null.
 Value *llvm::SimplifyShuffleVectorInst(Value *Op0, Value *Op1, Constant *Mask,
                                        Type *RetTy, const SimplifyQuery &Q) {
   return ::SimplifyShuffleVectorInst(Op0, Op1, Mask, RetTy, Q, RecursionLimit);
 }
 
+static Constant *foldConstant(Instruction::UnaryOps Opcode,
+                              Value *&Op, const SimplifyQuery &Q) {
+  if (auto *C = dyn_cast<Constant>(Op))
+    return ConstantFoldUnaryOpOperand(Opcode, C, Q.DL);
+  return nullptr;
+}
+
+/// Given the operand for an FNeg, see if we can fold the result.  If not, this
+/// returns null.
+static Value *SimplifyFNegInst(Value *Op, FastMathFlags FMF,
+                               const SimplifyQuery &Q, unsigned MaxRecurse) {
+  if (Constant *C = foldConstant(Instruction::FNeg, Op, Q))
+    return C;
+
+  Value *X;
+  // fneg (fneg X) ==> X
+  if (match(Op, m_FNeg(m_Value(X))))
+    return X;
+
+  return nullptr;
+}
+
+Value *llvm::SimplifyFNegInst(Value *Op, FastMathFlags FMF,
+                              const SimplifyQuery &Q) {
+  return ::SimplifyFNegInst(Op, FMF, Q, RecursionLimit);
+}
+
 static Constant *propagateNaN(Constant *In) {
   // If the input is a vector with undef elements, just return a default NaN.
   if (!In->isNaN())
     return ConstantFP::getNaN(In->getType());
 
   // Propagate the existing NaN constant when possible.
   // TODO: Should we quiet a signaling NaN?
   return In;

 
 Value *llvm::SimplifyFRemInst(Value *Op0, Value *Op1, FastMathFlags FMF,
                               const SimplifyQuery &Q) {
   return ::SimplifyFRemInst(Op0, Op1, FMF, Q, RecursionLimit);
 }
 
 //=== Helper functions for higher up the class hierarchy.
 
+/// Given the operand for a UnaryOperator, see if we can fold the result.
+/// If not, this returns null.
+/// TODO: Stubbed out for future non-FP UnaryOperators.
+static Value *SimplifyUnOp(unsigned Opcode, Value *Op, const SimplifyQuery &Q,
+                           unsigned MaxRecurse) {
+  switch (Opcode) {
+  default:
+    llvm_unreachable("Unexpected opcode");
+  }
+}
+
+/// Given the operand for a UnaryOperator, see if we can fold the result.
+/// If not, this returns null.
+/// In contrast to SimplifyUnOp, try to use FastMathFlag when folding the
+/// result. In case we don't need FastMathFlags, simply fall to SimplifyUnOp.
+static Value *SimplifyFPUnOp(unsigned Opcode, Value *Op,
+                             const FastMathFlags &FMF,
+                             const SimplifyQuery &Q, unsigned MaxRecurse) {
+  switch (Opcode) {
+  case Instruction::FNeg:
+    return SimplifyFNegInst(Op, FMF, Q, MaxRecurse);
+  default:
+    return SimplifyUnOp(Opcode, Op, Q, MaxRecurse);
+  }
+}
+
+Value *llvm::SimplifyFPUnOp(unsigned Opcode, Value *Op, FastMathFlags FMF,
+                            const SimplifyQuery &Q) {
+  return ::SimplifyFPUnOp(Opcode, Op, FMF, Q, RecursionLimit);
+}
+
 /// Given operands for a BinaryOperator, see if we can fold the result.
 /// If not, this returns null.
 static Value *SimplifyBinOp(unsigned Opcode, Value *LHS, Value *RHS,
                             const SimplifyQuery &Q, unsigned MaxRecurse) {
   switch (Opcode) {
   case Instruction::Add:
     return SimplifyAddInst(LHS, RHS, false, false, Q, MaxRecurse);
   case Instruction::Sub:
Value *llvm::SimplifyInstruction(Instruction *I, const SimplifyQuery &SQ,
                                  OptimizationRemarkEmitter *ORE) {
   const SimplifyQuery Q = SQ.CxtI ? SQ : SQ.getWithInstruction(I);
   Value *Result;
 
   switch (I->getOpcode()) {
   default:
     Result = ConstantFoldInstruction(I, Q.DL, Q.TLI);
     break;
+  case Instruction::FNeg:
+    Result = SimplifyFNegInst(I->getOperand(0), I->getFastMathFlags(), Q);
+    break;
   case Instruction::FAdd:
     Result = SimplifyFAddInst(I->getOperand(0), I->getOperand(1),
                               I->getFastMathFlags(), Q);
     break;
   case Instruction::Add:
     Result =
         SimplifyAddInst(I->getOperand(0), I->getOperand(1),
                         Q.IIQ.hasNoSignedWrap(cast<BinaryOperator>(I)),

llvm/test/Analysis/ConstantFolding/fneg.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt < %s -constprop -S | FileCheck %s
+; RUN: opt < %s -instsimplify -S | FileCheck %s
 
 define float @fneg_constant() {
 ; CHECK-LABEL: @fneg_constant(
 ; CHECK-NEXT:    ret float 0.000000e+00
 ;
   %r = fneg float -0.0
   ret float %r
 }
 
 define float @fneg_undef() {
 ; CHECK-LABEL: @fneg_undef(
 ; CHECK-NEXT:    ret float undef
 ;
   %r = fneg float undef
   ret float %r
 }
 
 define float @fneg_fneg_var(float %a) {
 ; CHECK-LABEL: @fneg_fneg_var(
-; CHECK-NEXT:    [[R:%.*]] = fneg float [[A:%.*]]
-; CHECK-NEXT:    [[R1:%.*]] = fneg float [[R]]
-; CHECK-NEXT:    ret float [[R1]]
+; CHECK-NEXT:    ret float [[A:%.*]]
 ;
   %r  = fneg float %a
   %r1 = fneg float %r
   ret float %r1
 }
 
 define <4 x float> @fneg_constant_elts_v4f32() {
 ; CHECK-LABEL: @fneg_constant_elts_v4f32(