[InstCombine] Handle -(X-Y) --> (Y-X) for unary fneg when NSZ

[cameron.mcinally]

@jyknight

I'd be open to opinions on if this optimization should be throttled for NaNs too. My understanding is that IEEE-754 does not specify the sign of NaN results for FSub, so it doesn't matter if an FNeg is performed on the result or not.

That said, in practice, whether this combine is performed or not could change the sign of a NaN....

[cameron.mcinally]

Ping.

[spatel]

This matches the existing fold with 2 fsubs, and I agree with the comment in the description regarding IEEE-754 - fsub doesn't need to preserve the sign bit of a NaN. LGTM.

llvm/trunk/lib/Transforms/InstCombine/InstCombineAddSub.cpp

static Instruction *foldFNegIntoConstant(Instruction &I) {
   // -(C / X) --> (-C) / X
   if (match(&I, m_FNeg(m_OneUse(m_FDiv(m_Constant(C), m_Value(X))))))
     return BinaryOperator::CreateFDivFMF(ConstantExpr::getFNeg(C), X, &I);
 
   return nullptr;
 }
 
 Instruction *InstCombiner::visitFNeg(UnaryOperator &I) {
-  if (Value *V = SimplifyFNegInst(I.getOperand(0), I.getFastMathFlags(),
+  Value *Op = I.getOperand(0);
+
+  if (Value *V = SimplifyFNegInst(Op, I.getFastMathFlags(),
                                   SQ.getWithInstruction(&I)))
     return replaceInstUsesWith(I, V);
 
   if (Instruction *X = foldFNegIntoConstant(I))
     return X;
 
+  Value *X, *Y;
+
+  // If we can ignore the sign of zeros: -(X - Y) --> (Y - X)
+  if (I.hasNoSignedZeros() &&
+      match(Op, m_OneUse(m_FSub(m_Value(X), m_Value(Y)))))
+    return BinaryOperator::CreateFSubFMF(Y, X, &I);
+
   return nullptr;
 }
 
 Instruction *InstCombiner::visitFSub(BinaryOperator &I) {
   if (Value *V = SimplifyFSubInst(I.getOperand(0), I.getOperand(1),
                                   I.getFastMathFlags(),
                                   SQ.getWithInstruction(&I)))
     return replaceInstUsesWith(I, V);

llvm/trunk/test/Transforms/InstCombine/fsub.ll

 ; CHECK-NEXT:    [[TMP1:%.*]] = fsub nsz float [[Y:%.*]], [[X:%.*]]
 ; CHECK-NEXT:    ret float [[TMP1]]
 ;
   %t1 = fsub float %x, %y
   %t2 = fsub nsz float -0.0, %t1
   ret float %t2
 }
 
-; FIXME: This combine isn't working.
 define float @unary_neg_sub_nsz(float %x, float %y) {
 ; CHECK-LABEL: @unary_neg_sub_nsz(
-; CHECK-NEXT:    [[T1:%.*]] = fsub float [[X:%.*]], [[Y:%.*]]
-; CHECK-NEXT:    [[T2:%.*]] = fneg nsz float [[T1]]
+; CHECK-NEXT:    [[T2:%.*]] = fsub nsz float [[Y:%.*]], [[X:%.*]]
 ; CHECK-NEXT:    ret float [[T2]]
 ;
   %t1 = fsub float %x, %y
   %t2 = fneg nsz float %t1
   ret float %t2
 }
 
 ; If the subtract has another use, we don't do the transform (even though it