[clang] [CIR][CodeGen] Emit cir.fmuladd for FP-contracted mul+add/sub (PR #215382)
via cfe-commits
cfe-commits at lists.llvm.org
Mon Aug 10 13:11:09 PDT 2026
llvmorg-github-actions[bot] wrote:
<!--LLVM PR SUMMARY COMMENT-->
@llvm/pr-subscribers-clangir
Author: Konstantinos Parasyris (koparasy)
<details>
<summary>Changes</summary>
Ports the FP-contraction fusion from classic CodeGen (`tryEmitFMulAdd` /
`buildFMulAdd`) to CIRGen. Under `-ffp-contract=on / fast`, `a * b + c` and
`a * b - c` fuse into `cir.fmuladd` (with the addend negated for the sub
form) instead of separate `cir.fmul` + `cir.fadd/fsub`.
Depends on the cir.fmuladd op added in #<!-- -->215329 .
Fusion is gated on `FPOptions::allowFPContractWithinStatement()` and only
fires when the multiply feeds the add/sub exclusively.
Some differences from classic CodeGen, we have a "single fmul check".
OG matches both a plain fmul BinaryOperator and experimental_constrained_fmul
(two branches). In CIR the constrained mode is an `fenv` attribute on cir.fmul, so one
`FMulOp` check covers both; the fenv is carried onto `cir.fmuladd` via `getConstrainedFPAttr()`.
---
Patch is 21.89 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/215382.diff
4 Files Affected:
- (modified) clang/lib/CIR/CodeGen/CIRGenExprScalar.cpp (+89)
- (added) clang/test/CIR/CodeGen/fp-contract-on-pragma.cpp (+122)
- (added) clang/test/CIR/CodeGen/fp-contract-pragma.cpp (+258)
- (added) clang/test/CIR/CodeGen/fp-contract.c (+86)
``````````diff
diff --git a/clang/lib/CIR/CodeGen/CIRGenExprScalar.cpp b/clang/lib/CIR/CodeGen/CIRGenExprScalar.cpp
index 8d660a0a2c721..7e2c057c142b4 100644
--- a/clang/lib/CIR/CodeGen/CIRGenExprScalar.cpp
+++ b/clang/lib/CIR/CodeGen/CIRGenExprScalar.cpp
@@ -1948,6 +1948,89 @@ static bool isIntegerVectorBinOp(mlir::Type ty) {
return vecTy && mlir::isa<cir::IntType>(vecTy.getElementType());
}
+// Construct a cir.fmuladd op to represent a fused mul-add of `mulOp` and
+// `addend`. Use negMul and negAdd to negate the first operand of the mul or
+// the addend respectively. This allows fmuladd to represent a*b-c, or c-a*b.
+// Patterns in LLVM should catch the negated forms and translate them to
+// efficient operations.
+static mlir::Value buildFMulAdd(cir::FMulOp mulOp, mlir::Value addend,
+ CIRGenBuilderTy &builder, bool negMul,
+ bool negAdd) {
+ const mlir::Location loc = mulOp.getLoc();
+ mlir::Value mulOp0 = mulOp.getLhs();
+ mlir::Value mulOp1 = mulOp.getRhs();
+ if (negMul)
+ mulOp0 = builder.createFNeg(loc, mulOp0);
+ if (negAdd)
+ addend = builder.createFNeg(loc, addend);
+
+ mlir::Value fmuladd =
+ cir::FMulAddOp::create(builder, loc, addend.getType(), mulOp0, mulOp1,
+ addend, builder.getConstrainedFPAttr());
+ mulOp.erase();
+ return fmuladd;
+}
+
+// Check whether it would be legal to emit a cir.fmuladd op to represent op
+// and if so, build it.
+//
+// Checks that (a) the operation is fusable, and (b) -ffp-contract=on.
+// Does NOT check the type of the operation - it's assumed that this function
+// will be called from contexts where it's known that the type is contractable.
+static mlir::Value tryEmitFMulAdd(const BinOpInfo &op,
+ CIRGenBuilderTy &builder, bool isSub = false) {
+ assert((op.opcode == BO_Add || op.opcode == BO_AddAssign ||
+ op.opcode == BO_Sub || op.opcode == BO_SubAssign) &&
+ "Only fadd/fsub can be the root of an fmuladd.");
+
+ // Check whether this op is marked as fusable.
+ if (!op.fpFeatures.allowFPContractWithinStatement())
+ return nullptr;
+
+ mlir::Value lhs = op.lhs;
+ mlir::Value rhs = op.rhs;
+
+ // Peek through fneg to look for fmul. Make sure the fneg has no other users,
+ // and that it is the only use of its operand.
+ bool negLHS = false;
+ if (auto lhsNeg = lhs.getDefiningOp<cir::FNegOp>()) {
+ if (lhsNeg.getResult().use_empty() && lhsNeg.getInput().hasOneUse()) {
+ lhs = lhsNeg.getInput();
+ negLHS = true;
+ }
+ }
+
+ bool negRHS = false;
+ if (auto rhsNeg = rhs.getDefiningOp<cir::FNegOp>()) {
+ if (rhsNeg.getResult().use_empty() && rhsNeg.getInput().hasOneUse()) {
+ rhs = rhsNeg.getInput();
+ negRHS = true;
+ }
+ }
+
+ // We have a potentially fusable op. Look for a mul on one of the operands.
+ // Also make sure that the mul result isn't used directly. In that case,
+ // there's no point creating a muladd operation.
+ if (auto lhsMul = lhs.getDefiningOp<cir::FMulOp>()) {
+ if (lhsMul.getResult().use_empty() || negLHS) {
+ // If we looked through fneg, erase it.
+ if (negLHS)
+ op.lhs.getDefiningOp<cir::FNegOp>().erase();
+ return buildFMulAdd(lhsMul, op.rhs, builder, negLHS, isSub);
+ }
+ }
+ if (auto rhsMul = rhs.getDefiningOp<cir::FMulOp>()) {
+ if (rhsMul.getResult().use_empty() || negRHS) {
+ // If we looked through fneg, erase it.
+ if (negRHS)
+ op.rhs.getDefiningOp<cir::FNegOp>().erase();
+ return buildFMulAdd(rhsMul, op.lhs, builder, isSub ^ negRHS, false);
+ }
+ }
+
+ return nullptr;
+}
+
mlir::Value ScalarExprEmitter::emitMul(const BinOpInfo &ops) {
const mlir::Location loc = cgf.getLoc(ops.loc);
if (!isIntegerVectorBinOp(ops.lhs.getType()) &&
@@ -2047,6 +2130,9 @@ mlir::Value ScalarExprEmitter::emitAdd(const BinOpInfo &ops) {
if (cir::isFPOrVectorOfFPType(ops.lhs.getType())) {
CIRGenFunction::CIRGenFPOptionsRAII FPOptsRAII(cgf, ops.fpFeatures);
+ // Try to form an fmuladd.
+ if (mlir::Value fmuladd = tryEmitFMulAdd(ops, builder))
+ return fmuladd;
return builder.createFAdd(loc, ops.lhs, ops.rhs);
}
@@ -2095,6 +2181,9 @@ mlir::Value ScalarExprEmitter::emitSub(const BinOpInfo &ops) {
if (cir::isFPOrVectorOfFPType(ops.lhs.getType())) {
CIRGenFunction::CIRGenFPOptionsRAII FPOptsRAII(cgf, ops.fpFeatures);
+ // Try to form an fmuladd.
+ if (mlir::Value fmuladd = tryEmitFMulAdd(ops, builder, /*isSub=*/true))
+ return fmuladd;
return builder.createFSub(loc, ops.lhs, ops.rhs);
}
diff --git a/clang/test/CIR/CodeGen/fp-contract-on-pragma.cpp b/clang/test/CIR/CodeGen/fp-contract-on-pragma.cpp
new file mode 100644
index 0000000000000..2c04dcfd6afc3
--- /dev/null
+++ b/clang/test/CIR/CodeGen/fp-contract-on-pragma.cpp
@@ -0,0 +1,122 @@
+// ClangIR port of clang/test/CodeGen/fp-contract-on-pragma.cpp.
+
+// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -std=c++11 -Wno-unused-value -fclangir -emit-cir %s -o %t.cir
+// RUN: FileCheck --input-file=%t.cir %s -check-prefix=CIR
+// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -std=c++11 -Wno-unused-value -fclangir -emit-llvm %s -o %t.ll
+// RUN: FileCheck --input-file=%t.ll %s -check-prefix=LLVM
+// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -std=c++11 -Wno-unused-value -emit-llvm %s -o %t-ogcg.ll
+// RUN: FileCheck --input-file=%t-ogcg.ll %s -check-prefix=OGCG
+
+// Is FP_CONTRACT honored in a simple case?
+float fp_contract_1(float a, float b, float c) {
+#pragma clang fp contract(on)
+ return a * b + c;
+}
+// CIR-LABEL: cir.func {{.*}}@_Z13fp_contract_1fff
+// CIR: cir.fmuladd %{{.*}}, %{{.*}}, %{{.*}} : !cir.float
+// CIR-NOT: cir.fmul
+// LLVM-LABEL: @_Z13fp_contract_1fff
+// LLVM: call float @llvm.fmuladd.f32
+// OGCG-LABEL: @_Z13fp_contract_1fff
+// OGCG: call float @llvm.fmuladd.f32
+
+// Is FP_CONTRACT state cleared on exiting compound statements?
+float fp_contract_2(float a, float b, float c) {
+ {
+#pragma clang fp contract(on)
+ }
+ return a * b + c;
+}
+// CIR-LABEL: cir.func {{.*}}@_Z13fp_contract_2fff
+// CIR: cir.fmul %{{.*}}, %{{.*}} : !cir.float
+// CIR: cir.fadd %{{.*}}, %{{.*}} : !cir.float
+// CIR-NOT: cir.fmuladd
+// LLVM-LABEL: @_Z13fp_contract_2fff
+// LLVM: %[[M:.*]] = fmul float
+// LLVM: fadd float %[[M]],
+// OGCG-LABEL: @_Z13fp_contract_2fff
+// OGCG: %[[M:.*]] = fmul float
+// OGCG: fadd float %[[M]],
+
+// Does FP_CONTRACT survive template instantiation?
+class Foo {};
+Foo operator+(Foo, Foo);
+
+template <typename T>
+T template_muladd(T a, T b, T c) {
+#pragma clang fp contract(on)
+ return a * b + c;
+}
+// CIR-LABEL: cir.func {{.*}}@_Z15template_muladdIfET_S0_S0_S0_
+// CIR: cir.fmuladd %{{.*}}, %{{.*}}, %{{.*}} : !cir.float
+// LLVM-LABEL: @_Z15template_muladdIfET_S0_S0_S0_
+// LLVM: call float @llvm.fmuladd.f32
+// OGCG-LABEL: @_Z15template_muladdIfET_S0_S0_S0_
+// OGCG: call {{.*}}float @llvm.fmuladd.f32
+
+// fp_contract_3 is just a caller; the fused op lives in the instantiated
+// template_muladd checked above. It is emitted in a different order under the
+// classic CodeGen path, so it carries no checks of its own here.
+float fp_contract_3(float a, float b, float c) {
+ return template_muladd<float>(a, b, c);
+}
+
+template <typename T>
+class fp_contract_4 {
+ float method(float a, float b, float c) {
+#pragma clang fp contract(on)
+ return a * b + c;
+ }
+};
+template class fp_contract_4<int>;
+// CIR-LABEL: cir.func {{.*}}@_ZN13fp_contract_4IiE6methodEfff
+// CIR: cir.fmuladd %{{.*}}, %{{.*}}, %{{.*}} : !cir.float
+// LLVM-LABEL: @_ZN13fp_contract_4IiE6methodEfff
+// LLVM: call float @llvm.fmuladd.f32
+// OGCG-LABEL: @_ZN13fp_contract_4IiE6methodEfff
+// OGCG: call float @llvm.fmuladd.f32
+
+// Check file-scoped FP_CONTRACT
+#pragma clang fp contract(on)
+float fp_contract_5(float a, float b, float c) {
+ return a * b + c;
+}
+// CIR-LABEL: cir.func {{.*}}@_Z13fp_contract_5fff
+// CIR: cir.fmuladd %{{.*}}, %{{.*}}, %{{.*}} : !cir.float
+// LLVM-LABEL: @_Z13fp_contract_5fff
+// LLVM: call float @llvm.fmuladd.f32
+// OGCG-LABEL: @_Z13fp_contract_5fff
+// OGCG: call float @llvm.fmuladd.f32
+
+#pragma clang fp contract(off)
+float fp_contract_6(float a, float b, float c) {
+ return a * b + c;
+}
+// CIR-LABEL: cir.func {{.*}}@_Z13fp_contract_6fff
+// CIR: cir.fmul %{{.*}}, %{{.*}} : !cir.float
+// CIR: cir.fadd %{{.*}}, %{{.*}} : !cir.float
+// CIR-NOT: cir.fmuladd
+// LLVM-LABEL: @_Z13fp_contract_6fff
+// LLVM: %[[M:.*]] = fmul float
+// LLVM: fadd float %[[M]],
+// OGCG-LABEL: @_Z13fp_contract_6fff
+// OGCG: %[[M:.*]] = fmul float
+// OGCG: fadd float %[[M]],
+
+// If the multiply has multiple uses, don't produce fmuladd.
+// This used to assert (PR25719):
+// https://llvm.org/bugs/show_bug.cgi?id=25719
+float fp_contract_7(float a, float b, float c) {
+#pragma clang fp contract(on)
+ return (a = 2 * b) - c;
+}
+// CIR-LABEL: cir.func {{.*}}@_Z13fp_contract_7fff
+// CIR: cir.fmul %{{.*}}, %{{.*}} : !cir.float
+// CIR: cir.fsub %{{.*}}, %{{.*}} : !cir.float
+// CIR-NOT: cir.fmuladd
+// LLVM-LABEL: @_Z13fp_contract_7fff
+// LLVM: %[[M:.*]] = fmul float
+// LLVM: fsub float %[[M]],
+// OGCG-LABEL: @_Z13fp_contract_7fff
+// OGCG: %[[M:.*]] = fmul float
+// OGCG: fsub float %[[M]],
diff --git a/clang/test/CIR/CodeGen/fp-contract-pragma.cpp b/clang/test/CIR/CodeGen/fp-contract-pragma.cpp
new file mode 100644
index 0000000000000..6819f150205fe
--- /dev/null
+++ b/clang/test/CIR/CodeGen/fp-contract-pragma.cpp
@@ -0,0 +1,258 @@
+// ClangIR port of clang/test/CodeGen/fp-contract-pragma.cpp.
+
+// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -std=c++11 -Wno-unused-value -fclangir -emit-cir %s -o %t.cir
+// RUN: FileCheck --input-file=%t.cir %s -check-prefix=CIR
+// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -std=c++11 -Wno-unused-value -fclangir -emit-llvm %s -o %t.ll
+// RUN: FileCheck --input-file=%t.ll %s -check-prefix=LLVM
+// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -std=c++11 -Wno-unused-value -emit-llvm %s -o %t-ogcg.ll
+// RUN: FileCheck --input-file=%t-ogcg.ll %s -check-prefix=OGCG
+
+// Is FP_CONTRACT honored in a simple case?
+float fp_contract_1(float a, float b, float c) {
+ #pragma STDC FP_CONTRACT ON
+ return a * b + c;
+}
+// CIR-LABEL: cir.func {{.*}}@_Z13fp_contract_1fff
+// CIR: cir.fmuladd %{{.*}}, %{{.*}}, %{{.*}} : !cir.float
+// CIR-NOT: cir.fmul
+// LLVM-LABEL: @_Z13fp_contract_1fff
+// LLVM: call float @llvm.fmuladd.f32
+// OGCG-LABEL: @_Z13fp_contract_1fff
+// OGCG: call float @llvm.fmuladd.f32
+
+// Is FP_CONTRACT state cleared on exiting compound statements?
+float fp_contract_2(float a, float b, float c) {
+ {
+ #pragma STDC FP_CONTRACT ON
+ }
+ return a * b + c;
+}
+// CIR-LABEL: cir.func {{.*}}@_Z13fp_contract_2fff
+// CIR: cir.fmul %{{.*}}, %{{.*}} : !cir.float
+// CIR: cir.fadd %{{.*}}, %{{.*}} : !cir.float
+// CIR-NOT: cir.fmuladd
+// LLVM-LABEL: @_Z13fp_contract_2fff
+// LLVM: %[[M:.*]] = fmul float
+// LLVM: fadd float %[[M]],
+// OGCG-LABEL: @_Z13fp_contract_2fff
+// OGCG: %[[M:.*]] = fmul float
+// OGCG: fadd float %[[M]],
+
+// Does FP_CONTRACT survive template instantiation?
+class Foo {};
+Foo operator+(Foo, Foo);
+
+template <typename T>
+T template_muladd(T a, T b, T c) {
+ #pragma STDC FP_CONTRACT ON
+ return a * b + c;
+}
+// The fmuladd is emitted in the instantiated template body.
+// CIR-LABEL: cir.func {{.*}}@_Z15template_muladdIfET_S0_S0_S0_
+// CIR: cir.fmuladd %{{.*}}, %{{.*}}, %{{.*}} : !cir.float
+// LLVM-LABEL: @_Z15template_muladdIfET_S0_S0_S0_
+// LLVM: call float @llvm.fmuladd.f32
+// OGCG-LABEL: @_Z15template_muladdIfET_S0_S0_S0_
+// OGCG: call {{.*}}float @llvm.fmuladd.f32
+
+// fp_contract_3 is just a caller; the fused op lives in the instantiated
+// template_muladd checked above. It is emitted in a different order under the
+// classic CodeGen path, so it carries no checks of its own here.
+float fp_contract_3(float a, float b, float c) {
+ return template_muladd<float>(a, b, c);
+}
+
+template<typename T> class fp_contract_4 {
+ float method(float a, float b, float c) {
+ #pragma STDC FP_CONTRACT ON
+ return a * b + c;
+ }
+};
+template class fp_contract_4<int>;
+// CIR-LABEL: cir.func {{.*}}@_ZN13fp_contract_4IiE6methodEfff
+// CIR: cir.fmuladd %{{.*}}, %{{.*}}, %{{.*}} : !cir.float
+// LLVM-LABEL: @_ZN13fp_contract_4IiE6methodEfff
+// LLVM: call float @llvm.fmuladd.f32
+// OGCG-LABEL: @_ZN13fp_contract_4IiE6methodEfff
+// OGCG: call float @llvm.fmuladd.f32
+
+// Check file-scoped FP_CONTRACT
+#pragma STDC FP_CONTRACT ON
+float fp_contract_5(float a, float b, float c) {
+ return a * b + c;
+}
+// CIR-LABEL: cir.func {{.*}}@_Z13fp_contract_5fff
+// CIR: cir.fmuladd %{{.*}}, %{{.*}}, %{{.*}} : !cir.float
+// LLVM-LABEL: @_Z13fp_contract_5fff
+// LLVM: call float @llvm.fmuladd.f32
+// OGCG-LABEL: @_Z13fp_contract_5fff
+// OGCG: call float @llvm.fmuladd.f32
+
+#pragma STDC FP_CONTRACT OFF
+float fp_contract_6(float a, float b, float c) {
+ return a * b + c;
+}
+// CIR-LABEL: cir.func {{.*}}@_Z13fp_contract_6fff
+// CIR: cir.fmul %{{.*}}, %{{.*}} : !cir.float
+// CIR: cir.fadd %{{.*}}, %{{.*}} : !cir.float
+// CIR-NOT: cir.fmuladd
+// LLVM-LABEL: @_Z13fp_contract_6fff
+// LLVM: %[[M:.*]] = fmul float
+// LLVM: fadd float %[[M]],
+// OGCG-LABEL: @_Z13fp_contract_6fff
+// OGCG: %[[M:.*]] = fmul float
+// OGCG: fadd float %[[M]],
+
+// If the multiply has multiple uses, don't produce fmuladd.
+// This used to assert (PR25719):
+// https://llvm.org/bugs/show_bug.cgi?id=25719
+float fp_contract_7(float a, float b, float c) {
+ #pragma STDC FP_CONTRACT ON
+ return (a = 2 * b) - c;
+}
+// CIR-LABEL: cir.func {{.*}}@_Z13fp_contract_7fff
+// CIR: cir.fmul %{{.*}}, %{{.*}} : !cir.float
+// CIR: cir.fsub %{{.*}}, %{{.*}} : !cir.float
+// CIR-NOT: cir.fmuladd
+// LLVM-LABEL: @_Z13fp_contract_7fff
+// LLVM: %[[M:.*]] = fmul float
+// LLVM: fsub float %[[M]],
+// OGCG-LABEL: @_Z13fp_contract_7fff
+// OGCG: %[[M:.*]] = fmul float
+// OGCG: fsub float %[[M]],
+
+// a * b - c => fmuladd(a, b, -c)
+float fp_contract_8(float a, float b, float c) {
+ #pragma STDC FP_CONTRACT ON
+ return a * b - c;
+}
+// CIR-LABEL: cir.func {{.*}}@_Z13fp_contract_8fff
+// CIR: cir.fneg %{{.*}} : !cir.float
+// CIR: cir.fmuladd %{{.*}}, %{{.*}}, %{{.*}} : !cir.float
+// LLVM-LABEL: @_Z13fp_contract_8fff
+// LLVM: fneg float
+// LLVM: call float @llvm.fmuladd.f32
+// OGCG-LABEL: @_Z13fp_contract_8fff
+// OGCG: fneg float
+// OGCG: call float @llvm.fmuladd.f32
+
+// c - a * b => fmuladd(-a, b, c) (mul on the RHS of a subtraction)
+float fp_contract_9(float a, float b, float c) {
+ #pragma STDC FP_CONTRACT ON
+ return c - a * b;
+}
+// CIR-LABEL: cir.func {{.*}}@_Z13fp_contract_9fff
+// CIR: cir.fneg %{{.*}} : !cir.float
+// CIR: cir.fmuladd %{{.*}}, %{{.*}}, %{{.*}} : !cir.float
+// LLVM-LABEL: @_Z13fp_contract_9fff
+// LLVM: fneg float
+// LLVM: call float @llvm.fmuladd.f32
+// OGCG-LABEL: @_Z13fp_contract_9fff
+// OGCG: fneg float
+// OGCG: call float @llvm.fmuladd.f32
+
+// -(a * b) + c => fmuladd(-a, b, c) (peek through fneg on the LHS)
+float fp_contract_10(float a, float b, float c) {
+ #pragma STDC FP_CONTRACT ON
+ return -(a * b) + c;
+}
+// CIR-LABEL: cir.func {{.*}}@_Z14fp_contract_10fff
+// CIR: cir.fneg %{{.*}} : !cir.float
+// CIR: cir.fmuladd %{{.*}}, %{{.*}}, %{{.*}} : !cir.float
+// CIR-NOT: cir.fadd
+// LLVM-LABEL: @_Z14fp_contract_10fff
+// LLVM: fneg float
+// LLVM: call float @llvm.fmuladd.f32
+// OGCG-LABEL: @_Z14fp_contract_10fff
+// OGCG: fneg float
+// OGCG: call float @llvm.fmuladd.f32
+
+// -(a * b) - c => fmuladd(-a, b, -c) (fneg both the mul operand and addend)
+float fp_contract_11(float a, float b, float c) {
+ #pragma STDC FP_CONTRACT ON
+ return -(a * b) - c;
+}
+// CIR-LABEL: cir.func {{.*}}@_Z14fp_contract_11fff
+// CIR: cir.fneg %{{.*}} : !cir.float
+// CIR: cir.fneg %{{.*}} : !cir.float
+// CIR: cir.fmuladd %{{.*}}, %{{.*}}, %{{.*}} : !cir.float
+// LLVM-LABEL: @_Z14fp_contract_11fff
+// LLVM: fneg float
+// LLVM: fneg float
+// LLVM: call float @llvm.fmuladd.f32
+// OGCG-LABEL: @_Z14fp_contract_11fff
+// OGCG: fneg float
+// OGCG: fneg float
+// OGCG: call float @llvm.fmuladd.f32
+
+// c + -(a * b) => fmuladd(-a, b, c) (peek through fneg on the RHS)
+float fp_contract_12(float a, float b, float c) {
+ #pragma STDC FP_CONTRACT ON
+ return c + -(a * b);
+}
+// CIR-LABEL: cir.func {{.*}}@_Z14fp_contract_12fff
+// CIR: cir.fneg %{{.*}} : !cir.float
+// CIR: cir.fmuladd %{{.*}}, %{{.*}}, %{{.*}} : !cir.float
+// CIR-NOT: cir.fadd
+// LLVM-LABEL: @_Z14fp_contract_12fff
+// LLVM: fneg float
+// LLVM: call float @llvm.fmuladd.f32
+// OGCG-LABEL: @_Z14fp_contract_12fff
+// OGCG: fneg float
+// OGCG: call float @llvm.fmuladd.f32
+
+// c - -(a * b) => fmuladd(a, b, c) (the two negations cancel; no fneg)
+float fp_contract_13(float a, float b, float c) {
+ #pragma STDC FP_CONTRACT ON
+ return c - -(a * b);
+}
+// CIR-LABEL: cir.func {{.*}}@_Z14fp_contract_13fff
+// CIR-NOT: cir.fneg
+// CIR: cir.fmuladd %{{.*}}, %{{.*}}, %{{.*}} : !cir.float
+// LLVM-LABEL: @_Z14fp_contract_13fff
+// LLVM-NOT: fneg float
+// LLVM: call float @llvm.fmuladd.f32
+// OGCG-LABEL: @_Z14fp_contract_13fff
+// OGCG-NOT: fneg float
+// OGCG: call float @llvm.fmuladd.f32
+
+// Mul reused by the assignment, so no fusion. At -O0 the negation stays an
+// fneg+fadd instead of the fsub the -O3 original test expects.
+float fp_contract_14(float a, float b, float c) {
+ #pragma STDC FP_CONTRACT ON
+ float d;
+ return (d = -(a * b)) + c;
+}
+// CIR-LABEL: cir.func {{.*}}@_Z14fp_contract_14fff
+// CIR: cir.fmul %{{.*}}, %{{.*}} : !cir.float
+// CIR: cir.fneg %{{.*}} : !cir.float
+// CIR: cir.fadd %{{.*}}, %{{.*}} : !cir.float
+// CIR-NOT: cir.fmuladd
+// LLVM-LABEL: @_Z14fp_contract_14fff
+// LLVM: fmul float
+// LLVM: fneg float
+// LLVM: fadd float
+// OGCG-LABEL: @_Z14fp_contract_14fff
+// OGCG: fmul float
+// OGCG: fneg float
+// OGCG: fadd float
+
+// Same as above, with the negation applied to the assignment result.
+float fp_contract_15(float a, float b, float c) {
+ #pragma STDC FP_CONTRACT ON
+ float d;
+ return -(d = (a * b)) + c;
+}
+// CIR-LABEL: cir.func {{.*}}@_Z14fp_contract_15fff
+// CIR: cir.fmul %{{.*}}, %{{.*}} : !cir.float
+// CIR: cir.fneg %{{.*}} : !cir.float
+// CIR: cir.fadd %{{.*}}, %{{.*}} : !cir.float
+// CIR-NOT: cir.fmuladd
+// LLVM-LABEL: @_Z14fp_contract_15fff
+// LLVM: fmul float
+// LLVM: fneg float
+// LLVM: fadd float
+// OGCG-LABEL: @_Z14fp_contract_15fff
+// OGCG: fmul float
+// OGCG: fneg float
+// OGCG: fadd float
diff --git a/clang/test/CIR/CodeGen/fp-contract.c b/clang/test/CIR/CodeGen/fp-contract.c
new file mode 100644
index 0000000000000..a27ead3d127d3
--- /dev/null
+++ b/clang/test/CIR/CodeGen/fp-contract.c
@@ -0,0 +1,86 @@
+// Test that -ffp-contract=on fuses a*b+c / a*b-c into cir.fmuladd and that
+// -ffp-contract=off does not.
+
+// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -Wno-unused-value -fclangir -ffp-contract=on -emit-cir %s -o %t.cir
+// RUN: FileCheck --input-file=%t.cir %s -check-prefix=CIR-ON
+// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -Wno-unused-value -fclangir -ffp-contract=off -emit-cir %s -o %t-off.cir
+// RUN: FileCheck --input-file=%t-off.cir %s -check-prefix=CIR-OFF
+
+// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -Wno-unused-value -fclangir -ffp-contract=on -emit-llvm %s -o %t.ll
+// RUN: FileCheck --input-file=%t.ll %s -check-prefix=LLVM-ON
+// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -Wno-unused-value -fclangir -ffp-contract=off -emit-llvm %s -o %t-off.ll
+// RUN: FileCheck --input-file=%t-off.ll %s -check-prefix=LLVM-OFF
+
+// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -Wno-unused-value -ffp-contract=on -emit-llvm %s -o %t.ll
+// RUN: FileCheck --input-file=%t.ll %s -check-prefix=OGCG-ON
+// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -Wno-unused-value -ffp-contract=off -emit-llvm %s -o %t-off.ll
+// RUN: FileCheck --input-file=%t-off.ll %s -check-prefix=OGCG-OFF
+
+// a * b + c => fmuladd(a, b, c)
+float fmuladd_add(float a, float b, float c) {
+ return a * b + c;
+}
+// CIR-ON-LABEL: cir.func {{.*}}@fmuladd_add
+// CIR-ON: cir.fmuladd %{{.*}}, %{{.*}}, %{{.*}} : !cir.float
+// CIR-ON-NOT: cir.fmul
+
+// CIR-OFF-LABEL: cir.func {{.*}}@fmuladd_add
+// CIR-OFF: cir.fmul %{{.*}}, %{{.*}} : !cir.floa...
[truncated]
``````````
</details>
https://github.com/llvm/llvm-project/pull/215382
More information about the cfe-commits
mailing list