This is an archive of the discontinued LLVM Phabricator instance.

Differential D105984

[PowerPC] Restore FastMathFlags of Builder for Vector FDiv Builtins
ClosedPublic

Authored by quinnp on Jul 14 2021, 7:38 AM.

Details

Reviewers
nemanjai
stefanp
Group Reviewers
Restricted Project
Commits
rGfd855c24c72c: [PowerPC] Restore FastMathFlags of Builder for Vector FDiv Builtins
Summary

This patch fixes __builtin_ppc_recipdivf, __builtin_ppc_recipdivd,
__builtin_ppc_rsqrtf, and __builtin_ppc_rsqrtd. FastMathFlags are
set to fast immediately before emitting these builtins. Now the flags
are restored to their previous values after the builtins are emitted.

Diff Detail

Event Timeline

quinnp created this revision.Jul 14 2021, 7:38 AM
Herald added subscribers: shchenz, kbarton, nemanjai. · View Herald TranscriptJul 14 2021, 7:38 AM
quinnp requested review of this revision.Jul 14 2021, 7:38 AM
Herald added a project: Restricted Project. · View Herald TranscriptJul 14 2021, 7:38 AM
Herald added a subscriber: cfe-commits. · View Herald Transcript
quinnp retitled this revision from [PowerPC] Vec Div Builtins Restore FMF of Builder to [PowerPC] Restore FastMathFlags of Builder for Vec Div Builtins .Jul 14 2021, 7:39 AM
quinnp added reviewers: nemanjai, Restricted Project, stefanp.
quinnp retitled this revision from [PowerPC] Restore FastMathFlags of Builder for Vec Div Builtins to [PowerPC] Restore FastMathFlags of Builder for Vector FDiv Builtins .
quinnp updated this revision to Diff 358613.Jul 14 2021, 8:18 AM
quinnp retitled this revision from [PowerPC] Restore FastMathFlags of Builder for Vector FDiv Builtins to [PowerPC] Restore FastMathFlags of Builder for Vector FDiv Builtins.

Fixing indentation.

Harbormaster completed remote builds in B113988: Diff 358613.Jul 14 2021, 10:51 AM
qiucf added a subscriber: qiucf.Jul 14 2021, 7:31 PM
qiucf added inline comments.
clang/lib/CodeGen/CGBuiltin.cpp
15292
quinnp updated this revision to Diff 359093.Jul 15 2021, 12:43 PM
quinnp marked an inline comment as done.

Adressing review comment.

quinnp updated this revision to Diff 359116.EditedJul 15 2021, 1:43 PM

Adding REQUIRES: powerpc-registered target to front end test case.

quinnp updated this revision to Diff 359118.Jul 15 2021, 1:48 PM

Removing a newline.

Harbormaster completed remote builds in B114347: Diff 359118.Jul 15 2021, 5:48 PM
nemanjai accepted this revision.Jul 16 2021, 4:34 AM

LGTM. Thanks for fixing this.

This revision is now accepted and ready to land.Jul 16 2021, 4:34 AM
quinnp updated this revision to Diff 359338.Jul 16 2021, 8:54 AM

Removing entry checks from front end test and renaming a variable.

Harbormaster completed remote builds in B114512: Diff 359338.Jul 16 2021, 9:30 AM
This revision was landed with ongoing or failed builds.Jul 20 2021, 7:41 AM
Closed by commit rGfd855c24c72c: [PowerPC] Restore FastMathFlags of Builder for Vector FDiv Builtins (authored by quinnp, committed by kamaub). · Explain Why
This revision was automatically updated to reflect the committed changes.
kamaub added a commit: rGfd855c24c72c: [PowerPC] Restore FastMathFlags of Builder for Vector FDiv Builtins.

Revision Contents

PathSize
clang/
lib/
CodeGen/
9 lines
test/
CodeGen/
70 lines

Diff 360129

clang/lib/CodeGen/CGBuiltin.cpp

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 15,274 Lines • ▼ Show 20 Lines case PPC::BI__builtin_vsx_xvabssp: {
return Builder.CreateCall(F, X); return Builder.CreateCall(F, X);
} }
// Fastmath by default // Fastmath by default
case PPC::BI__builtin_ppc_recipdivf: case PPC::BI__builtin_ppc_recipdivf:
case PPC::BI__builtin_ppc_recipdivd: case PPC::BI__builtin_ppc_recipdivd:
case PPC::BI__builtin_ppc_rsqrtf: case PPC::BI__builtin_ppc_rsqrtf:
case PPC::BI__builtin_ppc_rsqrtd: { case PPC::BI__builtin_ppc_rsqrtd: {
FastMathFlags FMF = Builder.getFastMathFlags();
Builder.getFastMathFlags().setFast(); Builder.getFastMathFlags().setFast();
llvm::Type *ResultType = ConvertType(E->getType()); llvm::Type *ResultType = ConvertType(E->getType());
Value *X = EmitScalarExpr(E->getArg(0)); Value *X = EmitScalarExpr(E->getArg(0));
if (BuiltinID == PPC::BI__builtin_ppc_recipdivf || if (BuiltinID == PPC::BI__builtin_ppc_recipdivf ||
BuiltinID == PPC::BI__builtin_ppc_recipdivd) { BuiltinID == PPC::BI__builtin_ppc_recipdivd) {
Value *Y = EmitScalarExpr(E->getArg(1)); Value *Y = EmitScalarExpr(E->getArg(1));
return Builder.CreateFDiv(X, Y, "recipdiv"); Value *FDiv = Builder.CreateFDiv(X, Y, "recipdiv");
Builder.getFastMathFlags() &= (FMF);
qiucfUnsubmitted
Done
ReplyInline Actions
Value *fdiv = Builder.CreateFDiv(X, Y, "recipdiv");
- Builder.getFastMathFlags().operator&=(FMF);
+ Builder.getFastMathFlags() &= FMF;
return fdiv;
qiucf:
return FDiv;
} }
auto *One = ConstantFP::get(ResultType, 1.0); auto *One = ConstantFP::get(ResultType, 1.0);
llvm::Function *F = CGM.getIntrinsic(Intrinsic::sqrt, ResultType); llvm::Function *F = CGM.getIntrinsic(Intrinsic::sqrt, ResultType);
return Builder.CreateFDiv(One, Builder.CreateCall(F, X), "rsqrt"); Value *FDiv = Builder.CreateFDiv(One, Builder.CreateCall(F, X), "rsqrt");
Builder.getFastMathFlags() &= (FMF);
return FDiv;
} }
case PPC::BI__builtin_ppc_alignx: { case PPC::BI__builtin_ppc_alignx: {
ConstantInt *AlignmentCI = cast<ConstantInt>(Ops[0]); ConstantInt *AlignmentCI = cast<ConstantInt>(Ops[0]);
if (AlignmentCI->getValue().ugt(llvm::Value::MaximumAlignment)) if (AlignmentCI->getValue().ugt(llvm::Value::MaximumAlignment))
AlignmentCI = ConstantInt::get(AlignmentCI->getType(), AlignmentCI = ConstantInt::get(AlignmentCI->getType(),
llvm::Value::MaximumAlignment); llvm::Value::MaximumAlignment);
emitAlignmentAssumption(Ops[1], E->getArg(1), emitAlignmentAssumption(Ops[1], E->getArg(1),
▲ Show 20 Lines • Show All 2,977 Lines • Show Last 20 Lines

clang/test/CodeGen/builtins-ppc-fastmath.c

  • This file was added.
// REQUIRES: powerpc-registered-target
// RUN: %clang_cc1 -triple powerpc64-unknown-unknown \
// RUN: -emit-llvm %s -o - -target-cpu pwr7 | FileCheck %s
// RUN: %clang_cc1 -triple powerpc64le-unknown-unknown \
// RUN: -emit-llvm %s -o - -target-cpu pwr8 | FileCheck %s
// RUN: %clang_cc1 -triple powerpc64-unknown-aix \
// RUN: -emit-llvm %s -o - -target-cpu pwr7 | FileCheck %s
// RUN: %clang_cc1 -triple powerpc-unknown-aix \
// RUN: -emit-llvm %s -o - -target-cpu pwr7 | FileCheck %s
extern vector float a;
extern vector float b;
extern vector float c;
extern vector double d;
extern vector double e;
extern vector double f;
// CHECK-LABEL: @test_flags_recipdivf(
// CHECK: [[TMP0:%.*]] = load <4 x float>, <4 x float>* @a, align 16
// CHECK-NEXT: [[TMP1:%.*]] = load <4 x float>, <4 x float>* @b, align 16
// CHECK-NEXT: [[TMP2:%.*]] = load <4 x float>, <4 x float>* @a, align 16
// CHECK-NEXT: [[TMP3:%.*]] = load <4 x float>, <4 x float>* @b, align 16
// CHECK-NEXT: [[RECIPDIV:%.*]] = fdiv fast <4 x float> [[TMP2]], [[TMP3]]
// CHECK-NEXT: [[TMP4:%.*]] = load <4 x float>, <4 x float>* @c, align 16
// CHECK-NEXT: [[ADD:%.*]] = fadd <4 x float> [[RECIPDIV]], [[TMP4]]
// CHECK-NEXT: ret <4 x float> [[ADD]]
//
vector float test_flags_recipdivf() {
return __builtin_ppc_recipdivf(a, b) + c;
}
// CHECK-LABEL: @test_flags_recipdivd(
// CHECK: [[TMP0:%.*]] = load <2 x double>, <2 x double>* @d, align 16
// CHECK-NEXT: [[TMP1:%.*]] = load <2 x double>, <2 x double>* @e, align 16
// CHECK-NEXT: [[TMP2:%.*]] = load <2 x double>, <2 x double>* @d, align 16
// CHECK-NEXT: [[TMP3:%.*]] = load <2 x double>, <2 x double>* @e, align 16
// CHECK-NEXT: [[RECIPDIV:%.*]] = fdiv fast <2 x double> [[TMP2]], [[TMP3]]
// CHECK-NEXT: [[TMP4:%.*]] = load <2 x double>, <2 x double>* @f, align 16
// CHECK-NEXT: [[ADD:%.*]] = fadd <2 x double> [[RECIPDIV]], [[TMP4]]
// CHECK-NEXT: ret <2 x double> [[ADD]]
//
vector double test_flags_recipdivd() {
return __builtin_ppc_recipdivd(d, e) + f;
}
// CHECK-LABEL: @test_flags_rsqrtf(
// CHECK: [[TMP0:%.*]] = load <4 x float>, <4 x float>* @a, align 16
// CHECK-NEXT: [[TMP1:%.*]] = load <4 x float>, <4 x float>* @a, align 16
// CHECK-NEXT: [[TMP2:%.*]] = call fast <4 x float> @llvm.sqrt.v4f32(<4 x float> [[TMP1]])
// CHECK-NEXT: [[RSQRT:%.*]] = fdiv fast <4 x float> <float 1.000000e+00, float 1.000000e+00, float 1.000000e+00, float 1.000000e+00>, [[TMP2]]
// CHECK-NEXT: [[TMP3:%.*]] = load <4 x float>, <4 x float>* @b, align 16
// CHECK-NEXT: [[ADD:%.*]] = fadd <4 x float> [[RSQRT]], [[TMP3]]
// CHECK-NEXT: ret <4 x float> [[ADD]]
//
vector float test_flags_rsqrtf() {
return __builtin_ppc_rsqrtf(a) + b;
}
// CHECK-LABEL: @test_flags_rsqrtd(
// CHECK: [[TMP0:%.*]] = load <2 x double>, <2 x double>* @d, align 16
// CHECK-NEXT: [[TMP1:%.*]] = load <2 x double>, <2 x double>* @d, align 16
// CHECK-NEXT: [[TMP2:%.*]] = call fast <2 x double> @llvm.sqrt.v2f64(<2 x double> [[TMP1]])
// CHECK-NEXT: [[RSQRT:%.*]] = fdiv fast <2 x double> <double 1.000000e+00, double 1.000000e+00>, [[TMP2]]
// CHECK-NEXT: [[TMP3:%.*]] = load <2 x double>, <2 x double>* @e, align 16
// CHECK-NEXT: [[ADD:%.*]] = fadd <2 x double> [[RSQRT]], [[TMP3]]
// CHECK-NEXT: ret <2 x double> [[ADD]]
//
vector double test_flags_rsqrtd() {
return __builtin_ppc_rsqrtd(d) + e;
}