Optimization for powi(x, y) * x

[k-arrows]

Consider the following:

#include <cmath>

double f1(double x)
{
    return pow(x, 3) * pow(x, 1);
}

double f2(double x)
{
    return pow(x, 4);
}

(X86) https://godbolt.org/z/nd3ME13Po
(ARM) https://godbolt.org/z/z5vjnPhrK

On X86, if -Ofast is specified, GCC just calculates x * x * x * x for f1 with two mulsd, but Clang performs mulsd three times. There is no such difference on ARM.

[llvmbot]

@llvm/issue-subscribers-backend-x86

Author: None (k-arrows)

Consider the following: ```cpp #include <cmath>

double f1(double x)
{
return pow(x, 3) * pow(x, 1);
}

double f2(double x)
{
return pow(x, 4);
}

(X86) https://godbolt.org/z/nd3ME13Po
(ARM) https://godbolt.org/z/z5vjnPhrK

On X86, if `-Ofast` is specified, GCC just calculates `x * x * x * x` for `f1` with two `mulsd`, but Clang performs `mulsd` three times. There is no such difference on ARM.
</details>

[dtcxzyw]

llvm-project/llvm/lib/Transforms/InstCombine/InstCombineMulDivRem.cpp

Lines 708 to 717 in a63dc79

	// pow(X, Y) * X --> pow(X, Y+1)
	// X * pow(X, Y) --> pow(X, Y+1)
	if (match(&I, m_c_FMul(m_OneUse(m_Intrinsic<Intrinsic::pow>(m_Value(X),
	m_Value(Y))),
	m_Deferred(X)))) {
	Value *Y1 =
	Builder.CreateFAddFMF(Y, ConstantFP::get(I.getType(), 1.0), &I);
	Value *Pow = Builder.CreateBinaryIntrinsic(Intrinsic::pow, X, Y1, &I);
	return replaceInstUsesWith(I, Pow);
	}

powi(X, Y) * X --> powi(X, Y + 1) also works.
@vfdff I guess you are interested in this optimization :)

[vfdff]

• related IR test: https://gcc.godbolt.org/z/rMK1884Yh

define double @f1(double noundef %x) {
  %p1 = tail call fast double @llvm.powi.f64.i32(double %x, i32 3)
  %mul = fmul fast double %p1, %x
  ret double %mul
}

declare double @llvm.powi.f64.i32(double, i32)

• arm64: clang --target=aarch64 -march=armv8.3-a+sve -O3 -Ofast

f1: // @f1
  fmul d1, d0, d0
  fmul d1, d0, d1
  fmul d0, d1, d0
  ret