[InstCombine] fneg(X + C) --> -C - X

[spatel]

Summary

This is 1 of the potential folds uncovered by extending D72521.

We don't seem to do this in the backend either (unless I'm not seeing some target-specific transform).

icc and gcc (appears to be target-specific) do this transform.

[cameron.mcinally]

llvm/test/Transforms/InstCombine/fneg.ll

407

Nit: are lowercase variables the standard format for tests? I see that they're uppercase in the source comments.

[cameron.mcinally]

LGTM

[spatel]

llvm/test/Transforms/InstCombine/fneg.ll

407

There's no official standard for tests, but most IR tests seem to use lowercase. There are even (or at least used to be) tests that mixed variables that only differed in case (%x and %X), but that's obviously not good for scripts or humans.

Source code has a standard:
http://llvm.org/docs/CodingStandards.html#name-types-functions-variables-and-enumerators-properly
(there was a recent proposal for changing variable names to be lowerCamel, but seems to have died?)

Usually, I just copy the code comment to the test file for easier grepping, so I'm not sure why I changed it here. :)
If anyone has a preference, I can update to it.

llvm/lib/Transforms/InstCombine/InstCombineAddSub.cpp

if (match(&I, m_FNeg(m_OneUse(m_FMul(m_Value(X), m_Constant(C))))))
     return BinaryOperator::CreateFMulFMF(X, ConstantExpr::getFNeg(C), &I);
   // -(X / C) --> X / (-C)
   if (match(&I, m_FNeg(m_OneUse(m_FDiv(m_Value(X), m_Constant(C))))))
     return BinaryOperator::CreateFDivFMF(X, ConstantExpr::getFNeg(C), &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);
 
+  // With NSZ [ counter-example with -0.0: -(-0.0 + 0.0) != 0.0 + -0.0 ]:
+  // -(X + C) --> -X + -C --> -C - X
+  if (I.hasNoSignedZeros() &&
+      match(&I, m_FNeg(m_OneUse(m_FAdd(m_Value(X), m_Constant(C))))))
+    return BinaryOperator::CreateFSubFMF(ConstantExpr::getFNeg(C), X, &I);
+
   return nullptr;
 }
 
 static Instruction *hoistFNegAboveFMulFDiv(Instruction &I,
                                            InstCombiner::BuilderTy &Builder) {
   Value *FNeg;
   if (!match(&I, m_FNeg(m_Value(FNeg))))
     return nullptr;

llvm/test/Transforms/InstCombine/fneg.ll

;
   %n1 = fneg float %x
   call void @use(float %n1)
   %n2 = fneg float %y
   call void @use(float %n2)
   %sel = select i1 %cond, float %n1, float %n2
   ret float %sel
 }
 
+; Negative test
+
 define float @fneg_fadd_constant(float %x) {
 ; CHECK-LABEL: @fneg_fadd_constant(
 ; CHECK-NEXT:    [[A:%.*]] = fadd float [[X:%.*]], 4.200000e+01
 ; CHECK-NEXT:    [[R:%.*]] = fneg float [[A]]
 ; CHECK-NEXT:    ret float [[R]]
 ;
   %a = fadd float %x, 42.0
   %r = fneg float %a
   ret float %r
 }
 
+; Negative test
+
 define float @fake_nsz_fadd_constant(float %x) {
 ; CHECK-LABEL: @fake_nsz_fadd_constant(
 ; CHECK-NEXT:    [[A:%.*]] = fadd float [[X:%.*]], 4.200000e+01
 ; CHECK-NEXT:    [[R:%.*]] = fsub float -0.000000e+00, [[A]]
 ; CHECK-NEXT:    ret float [[R]]
 ;
   %a = fadd float %x, 42.0
   %r = fsub float -0.0, %a
   ret float %r
 }
 
-; TODO: -(X + C) --> -C - X
+; -(X + C) --> -C - X
 
 define float @fneg_nsz_fadd_constant(float %x) {
 ; CHECK-LABEL: @fneg_nsz_fadd_constant(
-; CHECK-NEXT:    [[A:%.*]] = fadd float [[X:%.*]], 4.200000e+01
-; CHECK-NEXT:    [[R:%.*]] = fneg nsz float [[A]]
+; CHECK-NEXT:    [[R:%.*]] = fsub nsz float -4.200000e+01, [[X:%.*]]
 ; CHECK-NEXT:    ret float [[R]]
 ;
   %a = fadd float %x, 42.0
   %r = fneg nsz float %a
   ret float %r
 }
 
-; TODO: -(X + C) --> -C - X
+; -(X + C) --> -C - X
 
 define float @fake_fneg_nsz_fadd_constant(float %x) {
 ; CHECK-LABEL: @fake_fneg_nsz_fadd_constant(
-; CHECK-NEXT:    [[A:%.*]] = fadd float [[X:%.*]], 4.200000e+01
-; CHECK-NEXT:    [[R:%.*]] = fsub fast float -0.000000e+00, [[A]]
+; CHECK-NEXT:    [[R:%.*]] = fsub fast float -4.200000e+01, [[X:%.*]]
 ; CHECK-NEXT:    ret float [[R]]
 ;
   %a = fadd float %x, 42.0
   %r = fsub fast float -0.0, %a
   ret float %r
 }
 
+; Negative test
+
 define float @fneg_nsz_fadd_constant_extra_use(float %x) {
 ; CHECK-LABEL: @fneg_nsz_fadd_constant_extra_use(
 ; CHECK-NEXT:    [[A:%.*]] = fadd float [[X:%.*]], 4.200000e+01
 ; CHECK-NEXT:    call void @use(float [[A]])
 ; CHECK-NEXT:    [[R:%.*]] = fneg nsz float [[A]]
 ; CHECK-NEXT:    ret float [[R]]
 ;
   %a = fadd float %x, 42.0
   call void @use(float %a)
   %r = fneg nsz float %a
   ret float %r
 }
 
+; Negative test
+
 define float @fake_fneg_nsz_fadd_constant_extra_use(float %x) {
 ; CHECK-LABEL: @fake_fneg_nsz_fadd_constant_extra_use(
 ; CHECK-NEXT:    [[A:%.*]] = fadd float [[X:%.*]], 4.200000e+01
 ; CHECK-NEXT:    call void @use(float [[A]])
 ; CHECK-NEXT:    [[R:%.*]] = fsub fast float -0.000000e+00, [[A]]
 ; CHECK-NEXT:    ret float [[R]]
 ;
   %a = fadd float %x, 42.0
   call void @use(float %a)
   %r = fsub fast float -0.0, %a
   ret float %r
 }
 
-; TODO: -(X + C) --> -C - X
+; -(X + C) --> -C - X
 
 define <2 x float> @fneg_nsz_fadd_constant_vec(<2 x float> %x) {
 ; CHECK-LABEL: @fneg_nsz_fadd_constant_vec(
-; CHECK-NEXT:    [[A:%.*]] = fadd <2 x float> [[X:%.*]], <float 4.200000e+01, float 4.300000e+01>
-; CHECK-NEXT:    [[R:%.*]] = fneg reassoc nnan nsz <2 x float> [[A]]
+; CHECK-NEXT:    [[R:%.*]] = fsub reassoc nnan nsz <2 x float> <float -4.200000e+01, float -4.300000e+01>, [[X:%.*]]
 ; CHECK-NEXT:    ret <2 x float> [[R]]
 ;
   %a = fadd <2 x float> %x, <float 42.0, float 43.0>
   %r = fneg nsz nnan reassoc <2 x float> %a
   ret <2 x float> %r
 }
 
-; TODO: -(X + C) --> -C - X
+; -(X + C) --> -C - X
 
 define <2 x float> @fake_fneg_nsz_fadd_constant_vec(<2 x float> %x) {
 ; CHECK-LABEL: @fake_fneg_nsz_fadd_constant_vec(
-; CHECK-NEXT:    [[A:%.*]] = fadd <2 x float> [[X:%.*]], <float 4.200000e+01, float undef>
-; CHECK-NEXT:    [[R:%.*]] = fsub nsz <2 x float> <float undef, float -0.000000e+00>, [[A]]
+; CHECK-NEXT:    [[R:%.*]] = fsub nsz <2 x float> <float -4.200000e+01, float undef>, [[X:%.*]]
 ; CHECK-NEXT:    ret <2 x float> [[R]]
 ;
   %a = fadd <2 x float> %x, <float 42.0, float undef>
   %r = fsub nsz <2 x float> <float undef, float -0.0>, %a
   ret <2 x float> %r
 }
+
+@g = external global i16, align 1
+
+define float @fneg_nsz_fadd_constant_expr(float %x) {
+; CHECK-LABEL: @fneg_nsz_fadd_constant_expr(
+; CHECK-NEXT:    [[R:%.*]] = fsub nsz float fneg (float bitcast (i32 ptrtoint (i16* @g to i32) to float)), [[X:%.*]]
+; CHECK-NEXT:    ret float [[R]]
+;
+  %a = fadd float %x, bitcast (i32 ptrtoint (i16* @g to i32) to float)
+  %r = fneg nsz float %a
+  ret float %r
+}
+
+define float @fake_fneg_nsz_fadd_constant_expr(float %x) {
+; CHECK-LABEL: @fake_fneg_nsz_fadd_constant_expr(
+; CHECK-NEXT:    [[R:%.*]] = fsub nsz float fneg (float bitcast (i32 ptrtoint (i16* @g to i32) to float)), [[X:%.*]]
+; CHECK-NEXT:    ret float [[R]]
+;
+  %a = fadd float %x, bitcast (i32 ptrtoint (i16* @g to i32) to float)
+  %r = fsub nsz float -0.0, %a
+  ret float %r
+}