[DAGCombine] Transform (fadd A, (fmul B, -2.0)) -> (fsub A, (fadd B, B)).

[mcrosier]

Summary

PTAL

Chad

[efriedma]

I would guess we should prefer fmul as the canonical form, for the same reason we prefer "shl %x, 1" over "add %x, %x": we optimize instructions where hasOneUse() is true more aggressively. I guess it doesn't make a big difference either way, though.

Either way, please add a testcase for "fadd %x, %x", to confirm that we canonicalize both fadd and fmul to the same form.

[mcrosier]

-Add test case to check fadd X, X is canonical form, per Eli's request.

[mcrosier]

FWIW, I could also fix this in the DAG combiner. The particular case I care about looks like 'a * b - 2.0 * c', but the expression is transformed to 'a * c + -2.0 * c' before we hit the DAG Combine of interest (which only expects a +2.0).

[efriedma]

Another data-point: reassociate currently prefers to canonicalize "fadd %x, %x", to "fmul %x, 2". We don't want to fight back and forth in IR.

[mcrosier]

In D32596#740344, @efriedma wrote:

Another data-point: reassociate currently prefers to canonicalize "fadd %x, %x", to "fmul %x, 2". We don't want to fight back and forth in IR.

Thanks, Eli. I'll work on extending the DAG combine in that case. Does that sound reasonable?

[mcrosier]

-Rewrite as a DAG combine.

[efriedma]

Not sure if we need a target hook for this...? Replacing one instruction with two might not always be a good idea.

Otherwise looks fine.

[arsenm]

This is worse for AMDGPU because it requires a larger instruction encoding for f16/f32. For f64 this is better

[arsenm]

In D32596#743761, @arsenm wrote:

This is worse for AMDGPU because it requires a larger instruction encoding for f16/f32. For f64 this is better

Specifically if the user has a neg source modifier. Otherwise it is always worse

[RKSimon]

lib/CodeGen/SelectionDAG/DAGCombiner.cpp

9583 ↗

(On Diff #97131)

Only do this if isFNegFree()?

[spatel]

test/CodeGen/X86/fmul-combines.ll

21–22 ↗

(On Diff #97131)

What we don't see in this check, but you probably know or can infer: x86 doesn't have an 'fneg' op for SSE/AVX (they ran out of transistors?).

So we load the 128-bit sign-bit mask from memory:

xorps	LCPI1_0(%rip), %xmm0

It's also true that the mul version would load a '2.0', but this adds an extra op, and I don't think that's good for any x86 target.

There's one other reason this may not be good: there are actually CPUs (hello, Jaguar!) that have faster FP multiplies than FP adds.

[mcrosier]

Address reviewers feedback by narrowing transform so that the negation is "free".

@efriedma: This transform now replaces 2 instruction for 2 instruction in the worst case. For AArch64 it's actually replaces 3 for 2 because we now avoid materializing the -2.0. Probably true for other targets.
@arsenm: I don't believe this new version causes the instruction encoding to change in size, but please correct me if I'm wrong.
@spatel: This should addresses your comment w.r.t. X86. If you wish, I can add a target-hook to predicate this transform if the target supports fast multiplication. Please let me know if that's still a concern.

Thank you everyone for your feedback. Very much appreciated.

[arsenm]

In D32596#744882, @mcrosier wrote:

@arsenm: I don't believe this new version causes the instruction encoding to change in size, but please correct me if I'm wrong.

Yes, this is always better if it's really an fsub since the user then doesn't matter

[mcrosier]

In D32596#744944, @arsenm wrote:

In D32596#744882, @mcrosier wrote:

@arsenm: I don't believe this new version causes the instruction encoding to change in size, but please correct me if I'm wrong.

Yes, this is always better if it's really an fsub since the user then doesn't matter

Great. I'll wait for other's feedback before committing.

[efriedma]

lib/CodeGen/SelectionDAG/DAGCombiner.cpp

9468 ↗

(On Diff #97667)

hasOneUse()?

[mcrosier]

lib/CodeGen/SelectionDAG/DAGCombiner.cpp

9468 ↗

(On Diff #97667)

Very good point! One second.

[mcrosier]

-Check for a single use, so that we know the fmul will be folded away.

[efriedma]

LGTM.

[gberry]

My only comment is that you may be missing additional cases where the fneg could be folded away, but perhaps those can be fixed in a follow up change.

[mcrosier]

In D32596#745247, @gberry wrote:

My only comment is that you may be missing additional cases where the fneg could be folded away, but perhaps those can be fixed in a follow up change.

Yes, I'll investigate once this patch lands.

[spatel]

In D32596#745262, @mcrosier wrote:

In D32596#745247, @gberry wrote:

My only comment is that you may be missing additional cases where the fneg could be folded away, but perhaps those can be fixed in a follow up change.

Yes, I'll investigate once this patch lands.

Seems like isNegatibleForFree() would be the place to recognize patterns like this, and then we'd have a corresponding special case for -2.0 in GetNegatedExpression().

As written, this transform should be good for all x86 because it removes a constant load, so no objections, but...
I'm confused about our handling of FP folds. We're saying that this is a universally good (all targets and no relaxed FP needed) codegen fold, but we don't want it in IR/InstCombine because we prefer constants there.

Some tests to think about below. We'll fold the first 3 in DAGCombiner after this patch (universally afaict), but InstCombine does nothing with those. Should InstCombine fold fnegs into constants and fsub -> fadd?

The last case is transformed partially in InstCombine (div -> mul), but DAGCombiner does nothing with that. It's ok to not have a DAG fold for that because nothing this late is producing an fdiv?

define float @add_mul_neg2(float %a, float %b) {
  %mul = fmul float %b, -2.0
  %add = fadd float %a, %mul
  ret float %add
}

define float @sub_mul_neg2(float %a, float %b) {
  %mul = fmul float %b, -2.0
  %sub = fsub float %a, %mul
  ret float %sub
}

define float @mul_mul_neg2(float %a, float %b) {
  %mul = fmul float %b, -2.0
  %neg = fsub float -0.0, %a
  %mul2 = fmul float %neg, %mul
  ret float %mul2
}

define float @sub_div_neghalf(float %a, float %b) {
  %div = fdiv float %b, -0.5
  %sub = fsub float %a, %div
  ret float %sub
}

[mcrosier]

In D32596#745330, @spatel wrote:

Seems like isNegatibleForFree() would be the place to recognize patterns like this, and then we'd have a corresponding special case for -2.0 in GetNegatedExpression().

I'll investigate this suggestion. Thanks.

As written, this transform should be good for all x86 because it removes a constant load, so no objections, but...

Okay, good.

I'm confused about our handling of FP folds. We're saying that this is a universally good (all targets and no relaxed FP needed) codegen fold, but we don't want it in IR/InstCombine because we prefer constants there.

As Eli pointed out, the reassociation pass prefers the fmul with constant (to expose additional factoring opportunities, IIRC). He also pointed out that we should prefer fmul X, 2.0 as the canonical form, for the same reason we prefer "shl %x, 1" over "add %x, %x": we optimize instructions where hasOneUse() is true more aggressively. Given these two implications I went ahead and implemented this as a DAG combine. However, I think it might make sense to have InstCombine canonicalize to the mul with constant form as well.

Some tests to think about below. We'll fold the first 3 in DAGCombiner after this patch (universally afaict), but InstCombine does nothing with those. Should InstCombine fold fnegs into constants and fsub -> fadd?

The last case is transformed partially in InstCombine (div -> mul), but DAGCombiner does nothing with that. It's ok to not have a DAG fold for that because nothing this late is producing an fdiv?

While InstCombine does nothing, the reassociation pass will canonicalize to

(fsub A, (fmul/fdiv B, -C)) -> (fadd A, (fmul/fdiv B, C))
(fadd A, (fmul/fdiv B, -C)) -> (fsub A, (fmul/fdiv B, C))

where C is a constant and

(fsub A, (fdiv b, -0.5)) -> (fadd A, (fmul b, 2.0))

for the last test.

We could make InstCombine prefer these forms as well and that might make a difference, but it might not. My guess is it probably doesn't matter, but I'll experiment.

[spatel]

In D32596#746288, @mcrosier wrote:

While InstCombine does nothing, the reassociation pass will canonicalize to

(fsub A, (fmul/fdiv B, -C)) -> (fadd A, (fmul/fdiv B, C))
(fadd A, (fmul/fdiv B, -C)) -> (fsub A, (fmul/fdiv B, C))

Thanks for checking those out. I haven't looked at the reassociation pass very much. I'm surprised to see it flip a constant's sign and create an fsub rather than fadd. Any ideas why that is a good thing to do?

[mcrosier]

In D32596#746314, @spatel wrote:

In D32596#746288, @mcrosier wrote:

While InstCombine does nothing, the reassociation pass will canonicalize to

(fsub A, (fmul/fdiv B, -C)) -> (fadd A, (fmul/fdiv B, C))
(fadd A, (fmul/fdiv B, -C)) -> (fsub A, (fmul/fdiv B, C))

Thanks for checking those out. I haven't looked at the reassociation pass very much. I'm surprised to see it flip a constant's sign and create an fsub rather than fadd. Any ideas why that is a good thing to do?

AFAICT reassociation is trying to force all constants to be positive so it can increase the opportunities for factorization. This should also allows CSE and GVN to eliminate more duplicate expressions (per D4904 and D5363).

[mcrosier]

In D32596#745247, @gberry wrote:

My only comment is that you may be missing additional cases where the fneg could be folded away, but perhaps those can be fixed in a follow up change.

Here's at least one case we're missing: https://bugs.llvm.org/show_bug.cgi?id=32939

lib/Transforms/InstCombine/InstCombineMulDivRem.cpp

if (isa<Constant>(Op1)) {
     // (fmul X, -1.0) --> (fsub -0.0, X)
     if (match(Op1, m_SpecificFP(-1.0))) {
       Constant *NegZero = ConstantFP::getNegativeZero(Op1->getType());
       Instruction *RI = BinaryOperator::CreateFSub(NegZero, Op0);
       RI->copyFastMathFlags(&I);
       return RI;
     }
 
+    // (fmul X, 2.0) --> (fadd X, X)
+    if (match(Op1, m_SpecificFP(+2.0))) {
+      Instruction *RI = BinaryOperator::CreateFAdd(Op0, Op0);
+      RI->copyFastMathFlags(&I);
+      return RI;
+    }
+
     Constant *C = cast<Constant>(Op1);
     if (AllowReassociate && isFiniteNonZeroFp(C)) {
       // Let MDC denote an expression in one of these forms:
       // X * C, C/X, X/C, where C is a constant.
       //
       // Try to simplify "MDC * Constant"
       if (isFMulOrFDivWithConstant(Op0))
         if (Value *V = foldFMulConst(cast<Instruction>(Op0), C, &I))

test/Transforms/InstCombine/fast-math.ll

 ; CHECK: fdiv fast float 1.200000e+07, %f1
 }
 
 ; X/C1 * C2 => X * (C2/C1) is disabled if X/C1 has multiple uses
 @fmul2_external = external global float
 define float @fmul2_disable(float %f1) {
   %div = fdiv fast float 1.000000e+00, %f1
   store float %div, float* @fmul2_external
-  %mul = fmul fast float %div, 2.000000e+00
+  %mul = fmul fast float %div, 3.000000e+00
   ret float %mul
 ; CHECK-LABEL: @fmul2_disable
 ; CHECK: store
 ; CHECK: fmul fast
 }
 
 ; X/C1 * C2 => X * (C2/C1) (if C2/C1 is normal Fp)
 define float @fmul3(float %f1, float %f2) {

test/Transforms/InstCombine/fmul.ll

define float @test11(float %x, float %y) {
   %b = fadd fast float %y, 2.0
   %c = fadd fast float %a, %b
   ret float %c
 ; CHECK-LABEL: @test11(
 ; CHECK-NOT: fadd float
 ; CHECK: fadd fast float
 }
 
+; X * 2.0 => X + X
+define float @test12(float %x) {
+  %mul = fmul float %x, 2.0
+  ret float %mul
+
+; CHECK-LABEL: @test12(
+; CHECK: fadd float %x, %x
+; CHECK: ret
+}
+
+; X * 2.0 => X + X (w/fast flag)
+define float @test13(float %x) {
+  %mul = fmul fast float %x, 2.0
+  ret float %mul
+
+; CHECK-LABEL: @test13(
+; CHECK: fadd fast float %x, %x
+; CHECK: ret
+}
+
+; Check to make sure fadd X, X is the canonical form.
+define float @test14(float %x) {
+  %add = fadd float %x, %x
+  ret float %add
+
+; CHECK-LABEL: @test14(
+; CHECK: fadd float %x, %x
+; CHECK: ret
+}
+
 ; PR21126: http://llvm.org/bugs/show_bug.cgi?id=21126
 ; With unsafe/fast math, sqrt(X) * sqrt(X) is just X.
 declare double @llvm.sqrt.f64(double)
 
 define double @sqrt_squared1(double %f) {
   %sqrt = call double @llvm.sqrt.f64(double %f)
   %mul = fmul fast double %sqrt, %sqrt
   ret double %mul

test/Transforms/InstCombine/fold-fops-into-selects.ll

 ; CHECK-LABEL: @test3(
 ; CHECK: [[OP:%.*]] = fsub float 2.000000e+00, %B
 ; CHECK: select i1 %A, float 1.000000e+00, float [[OP]]
 }
 
 define float @test4(i1 %A, float %B) {
 EntryBlock:
   %cf = select i1 %A, float 1.000000e+00, float %B
-  %op = fmul float 2.000000e+00, %cf
+  %op = fmul float 3.000000e+00, %cf
   ret float %op
 ; CHECK-LABEL: @test4(
-; CHECK: [[OP:%.*]] = fmul float %B, 2.000000e+00
-; CHECK: select i1 %A, float 2.000000e+00, float [[OP]]
+; CHECK: [[OP:%.*]] = fmul float %B, 3.000000e+00
+; CHECK: select i1 %A, float 3.000000e+00, float [[OP]]
 }
 
 define float @test5(i1 %A, float %B) {
 EntryBlock:
   %cf = select i1 %A, float 1.000000e+00, float %B
   %op = fdiv float 2.000000e+00, %cf
   ret float %op
 ; CHECK-LABEL: @test5(