missed fold: (X * 0.0) * constant => X * 0.0

[zhengyang92]

https://alive2.llvm.org/ce/z/bKDTJd
https://godbolt.org/z/v1qYrb5Ka

define float @src(float %0) {
entry:
  %1 = fmul float %0, 0.000000e+00
  %2 = fmul float %1, 3.000000e+00
  ret float %2
}

define float @tgt(float %0) {
entry:
  %1 = fmul float %0, 0.000000e+00
  ret float %1
}

@jayfoad @regehr

[dtcxzyw]

It also holds for -0: https://alive2.llvm.org/ce/z/zzp6r9.

[llvmbot]

Hi!

This issue may be a good introductory issue for people new to working on LLVM. If you would like to work on this issue, your first steps are:

1. In the comments of the issue, request for it to be assigned to you.
2. Fix the issue locally.
3. Run the test suite locally. Remember that the subdirectories under test/ create fine-grained testing targets, so you can e.g. use make check-clang-ast to only run Clang's AST tests.
4. Create a Git commit.
5. Run git clang-format HEAD~1 to format your changes.
6. Open a pull request to the upstream repository on GitHub. Detailed instructions can be found in GitHub's documentation.

If you have any further questions about this issue, don't hesitate to ask via a comment in the thread below.

[llvmbot]

@llvm/issue-subscribers-good-first-issue

Author: Zhengyang Liu (zhengyang92)

https://alive2.llvm.org/ce/z/bKDTJd https://godbolt.org/z/v1qYrb5Ka

define float @<!-- -->src(float %0) {
entry:
  %1 = fmul float %0, 0.000000e+00
  %2 = fmul float %1, 3.000000e+00
  ret float %2
}

define float @<!-- -->tgt(float %0) {
entry:
  %1 = fmul float %0, 0.000000e+00
  ret float %1
}

@jayfoad @regehr

[RKSimon]

What are the constraints on the constants? sign mismatches have to be handled correctly of course:

----------------------------------------
define float @src(float %0) {
entry:
  %1 = fmul float %0, 0.000000
  %2 = fmul float %1, -1.000000
  ret float %2
}
=>
define float @tgt(float %0) {
entry:
  %1 = fmul float %0, -0.000000
  ret float %1
}
Transformation seems to be correct!

[dtcxzyw]

What are the constraints on the constants? sign mismatches have to be handled correctly of course:

----------------------------------------
define float @src(float %0) {
entry:
  %1 = fmul float %0, 0.000000
  %2 = fmul float %1, -1.000000
  ret float %2
}
=>
define float @tgt(float %0) {
entry:
  %1 = fmul float %0, -0.000000
  ret float %1
}
Transformation seems to be correct!

Generalized proof: https://alive2.llvm.org/ce/z/3UZo2z

[jayfoad]

X * Y --> X if:

• X is +/- 0
• sign bit of Y is zero
• Y is not inf or nan

Similarly X * Y --> -X if the sign bit of Y is 1.

Note that neither X nor Y needs to be a constant to implement this optimization.

[SahilPatidar]

@dtcxzyw, I would like to take this one.

[arsenm]

This is a specific case of #64967 (or at least closely related)

[SahilPatidar]

@dtcxzyw Can we use @llvm.copysign.f32 to set the sign bit in this transformation?

[dtcxzyw]

@dtcxzyw Can we use @llvm.copysign.f32 to set the sign bit in this transformation?

It is not necessary. You can use ConstantFP::getZero(Type, <sign of zero> ^ <sign of constant>).
BTW, would you like to handle generalized cases as described in #64967?