This is an archive of the discontinued LLVM Phabricator instance.

Differential D139309

InstCombine: Fold fabs (copysign x, y) -> fabs x
ClosedPublic

Authored by arsenm on Dec 5 2022, 5:09 AM.

Details

Reviewers
sepavloff
spatel
jcranmer-intel
nlopes
andrew.w.kaylor
kpn

Diff Detail

Event Timeline

arsenm created this revision.Dec 5 2022, 5:09 AM
Herald added a project: Restricted Project. · View Herald TranscriptDec 5 2022, 5:09 AM
Herald added a subscriber: hiraditya. · View Herald Transcript
arsenm requested review of this revision.Dec 5 2022, 5:09 AM
Herald added a project: Restricted Project. · View Herald TranscriptDec 5 2022, 5:09 AM
Herald added a subscriber: wdng. · View Herald Transcript
Harbormaster completed remote builds in B201078: Diff 480059.Dec 5 2022, 5:10 AM
arsenm added a child revision: D139310: InstCombine: Fold fneg (copysign x, y) -> copysign x, (fneg y).Dec 5 2022, 5:11 AM
kpn accepted this revision.Dec 5 2022, 11:20 AM

LGTM

llvm/include/llvm/IR/IRBuilder.h
946

This isn't used? Is it needed yet?

This revision is now accepted and ready to land.Dec 5 2022, 11:20 AM
arsenm added inline comments.Dec 5 2022, 11:22 AM
llvm/include/llvm/IR/IRBuilder.h
946

I have a stack of copysign patches it's used somewhere. I'll split this out to first use before pushing

arsenm closed this revision.Dec 6 2022, 5:29 AM
arsenm marked an inline comment as done.

e2f56debb3def1dc61552660ee5dd612ff269e47

Revision Contents

PathSize
llvm/
include/
llvm/
IR/
8 lines
6 lines
lib/
Transforms/
InstCombine/
10 lines
test/
Transforms/
InstCombine/
64 lines

Diff 480059

llvm/include/llvm/IR/IRBuilder.h

Show First 20 Lines • Show All 934 Lines • ▼ Show 20 Lines CallInst *CreateMinimum(Value *LHS, Value *RHS, const Twine &Name = "") {
return CreateBinaryIntrinsic(Intrinsic::minimum, LHS, RHS, nullptr, Name); return CreateBinaryIntrinsic(Intrinsic::minimum, LHS, RHS, nullptr, Name);
} }
/// Create call to the maximum intrinsic. /// Create call to the maximum intrinsic.
CallInst *CreateMaximum(Value *LHS, Value *RHS, const Twine &Name = "") { CallInst *CreateMaximum(Value *LHS, Value *RHS, const Twine &Name = "") {
return CreateBinaryIntrinsic(Intrinsic::maximum, LHS, RHS, nullptr, Name); return CreateBinaryIntrinsic(Intrinsic::maximum, LHS, RHS, nullptr, Name);
} }
/// Create call to the copysign intrinsic.
CallInst *CreateCopySign(Value *LHS, Value *RHS,
Instruction *FMFSource = nullptr,
const Twine &Name = "") {
kpnUnsubmitted
Done
ReplyInline Actions

This isn't used? Is it needed yet?

kpn: This isn't used? Is it needed yet?
arsenmAuthorUnsubmitted
Done
ReplyInline Actions

I have a stack of copysign patches it's used somewhere. I'll split this out to first use before pushing

arsenm: I have a stack of copysign patches it's used somewhere. I'll split this out to first use before…
return CreateBinaryIntrinsic(Intrinsic::copysign, LHS, RHS, FMFSource,
Name);
}
/// Create a call to the arithmetic_fence intrinsic. /// Create a call to the arithmetic_fence intrinsic.
CallInst *CreateArithmeticFence(Value *Val, Type *DstType, CallInst *CreateArithmeticFence(Value *Val, Type *DstType,
const Twine &Name = "") { const Twine &Name = "") {
return CreateIntrinsic(Intrinsic::arithmetic_fence, DstType, Val, nullptr, return CreateIntrinsic(Intrinsic::arithmetic_fence, DstType, Val, nullptr,
Name); Name);
} }
/// Create a call to the vector.extract intrinsic. /// Create a call to the vector.extract intrinsic.
▲ Show 20 Lines • Show All 1,657 Lines • Show Last 20 Lines

llvm/include/llvm/IR/PatternMatch.h

Show First 20 Lines • Show All 2,200 Lines • ▼ Show 20 Linesm_FShr(const Opnd0 &Op0, const Opnd1 &Op1, const Opnd2 &Op2) {
return m_Intrinsic<Intrinsic::fshr>(Op0, Op1, Op2); return m_Intrinsic<Intrinsic::fshr>(Op0, Op1, Op2);
} }
template <typename Opnd0> template <typename Opnd0>
inline typename m_Intrinsic_Ty<Opnd0>::Ty m_Sqrt(const Opnd0 &Op0) { inline typename m_Intrinsic_Ty<Opnd0>::Ty m_Sqrt(const Opnd0 &Op0) {
return m_Intrinsic<Intrinsic::sqrt>(Op0); return m_Intrinsic<Intrinsic::sqrt>(Op0);
} }
template <typename Opnd0, typename Opnd1>
inline typename m_Intrinsic_Ty<Opnd0, Opnd1>::Ty m_CopySign(const Opnd0 &Op0,
const Opnd1 &Op1) {
return m_Intrinsic<Intrinsic::copysign>(Op0, Op1);
}
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Matchers for two-operands operators with the operators in either order // Matchers for two-operands operators with the operators in either order
// //
/// Matches a BinaryOperator with LHS and RHS in either order. /// Matches a BinaryOperator with LHS and RHS in either order.
template <typename LHS, typename RHS> template <typename LHS, typename RHS>
inline AnyBinaryOp_match<LHS, RHS, true> m_c_BinOp(const LHS &L, const RHS &R) { inline AnyBinaryOp_match<LHS, RHS, true> m_c_BinOp(const LHS &L, const RHS &R) {
return AnyBinaryOp_match<LHS, RHS, true>(L, R); return AnyBinaryOp_match<LHS, RHS, true>(L, R);
▲ Show 20 Lines • Show All 363 Lines • Show Last 20 Lines

llvm/lib/Transforms/InstCombine/InstCombineCalls.cpp

Show First 20 Lines • Show All 2,002 Lines • ▼ Show 20 Lines if (match(II->getArgOperand(0),
// fabs (select Cond, -FVal, FVal) --> fabs FVal // fabs (select Cond, -FVal, FVal) --> fabs FVal
if (match(TVal, m_FNeg(m_Specific(FVal)))) if (match(TVal, m_FNeg(m_Specific(FVal))))
return replaceOperand(*II, 0, FVal); return replaceOperand(*II, 0, FVal);
// fabs (select Cond, TVal, -TVal) --> fabs TVal // fabs (select Cond, TVal, -TVal) --> fabs TVal
if (match(FVal, m_FNeg(m_Specific(TVal)))) if (match(FVal, m_FNeg(m_Specific(TVal))))
return replaceOperand(*II, 0, TVal); return replaceOperand(*II, 0, TVal);
} }
Value *Magnitude, *Sign;
if (match(II->getArgOperand(0),
m_CopySign(m_Value(Magnitude), m_Value(Sign)))) {
// fabs (copysign x, y) -> (fabs x)
CallInst *AbsSign =
Builder.CreateCall(II->getCalledFunction(), {Magnitude});
AbsSign->copyFastMathFlags(II);
return replaceInstUsesWith(*II, AbsSign);
}
[[fallthrough]]; [[fallthrough]];
} }
case Intrinsic::ceil: case Intrinsic::ceil:
case Intrinsic::floor: case Intrinsic::floor:
case Intrinsic::round: case Intrinsic::round:
case Intrinsic::roundeven: case Intrinsic::roundeven:
case Intrinsic::nearbyint: case Intrinsic::nearbyint:
case Intrinsic::rint: case Intrinsic::rint:
▲ Show 20 Lines • Show All 1,781 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/copysign-fneg-fabs.ll

Show First 20 Lines • Show All 73 Lines • ▼ Show 20 Lines
; ;
%copysign = call half @llvm.copysign.f16(half %x, half %y) %copysign = call half @llvm.copysign.f16(half %x, half %y)
%fneg.copysign = fneg half %copysign %fneg.copysign = fneg half %copysign
ret half %fneg.copysign ret half %fneg.copysign
} }
define half @fneg_fabs_copysign(half %x, half %y) { define half @fneg_fabs_copysign(half %x, half %y) {
; CHECK-LABEL: @fneg_fabs_copysign( ; CHECK-LABEL: @fneg_fabs_copysign(
; CHECK-NEXT: [[COPYSIGN:%.*]] = call half @llvm.copysign.f16(half [[X:%.*]], half [[Y:%.*]]) ; CHECK-NEXT: [[TMP1:%.*]] = call half @llvm.fabs.f16(half [[X:%.*]])
; CHECK-NEXT: [[FABS_COPYSIGN:%.*]] = call half @llvm.fabs.f16(half [[COPYSIGN]]) ; CHECK-NEXT: [[FNEG_FABS_COPYSIGN:%.*]] = fneg half [[TMP1]]
; CHECK-NEXT: [[FNEG_FABS_COPYSIGN:%.*]] = fneg half [[FABS_COPYSIGN]]
; CHECK-NEXT: ret half [[FNEG_FABS_COPYSIGN]] ; CHECK-NEXT: ret half [[FNEG_FABS_COPYSIGN]]
; ;
%copysign = call half @llvm.copysign.f16(half %x, half %y) %copysign = call half @llvm.copysign.f16(half %x, half %y)
%fabs.copysign = call half @llvm.fabs.f16(half %copysign) %fabs.copysign = call half @llvm.fabs.f16(half %copysign)
%fneg.fabs.copysign = fneg half %fabs.copysign %fneg.fabs.copysign = fneg half %fabs.copysign
ret half %fneg.fabs.copysign ret half %fneg.fabs.copysign
} }
; https://alive2.llvm.org/ce/z/Ft-7ea ; https://alive2.llvm.org/ce/z/Ft-7ea
define half @fabs_copysign(half %x, half %y) { define half @fabs_copysign(half %x, half %y) {
; CHECK-LABEL: @fabs_copysign( ; CHECK-LABEL: @fabs_copysign(
; CHECK-NEXT: [[COPYSIGN:%.*]] = call half @llvm.copysign.f16(half [[X:%.*]], half [[Y:%.*]]) ; CHECK-NEXT: [[TMP1:%.*]] = call half @llvm.fabs.f16(half [[X:%.*]])
; CHECK-NEXT: [[FABS_COPYSIGN:%.*]] = call half @llvm.fabs.f16(half [[COPYSIGN]]) ; CHECK-NEXT: ret half [[TMP1]]
; CHECK-NEXT: ret half [[FABS_COPYSIGN]]
; ;
%copysign = call half @llvm.copysign.f16(half %x, half %y) %copysign = call half @llvm.copysign.f16(half %x, half %y)
%fabs.copysign = call half @llvm.fabs.f16(half %copysign) %fabs.copysign = call half @llvm.fabs.f16(half %copysign)
ret half %fabs.copysign ret half %fabs.copysign
} }
define <2 x half> @fneg_copysign_vector(<2 x half> %x, <2 x half> %y) { define <2 x half> @fneg_copysign_vector(<2 x half> %x, <2 x half> %y) {
; CHECK-LABEL: @fneg_copysign_vector( ; CHECK-LABEL: @fneg_copysign_vector(
; CHECK-NEXT: [[COPYSIGN:%.*]] = call <2 x half> @llvm.copysign.v2f16(<2 x half> [[X:%.*]], <2 x half> [[Y:%.*]]) ; CHECK-NEXT: [[COPYSIGN:%.*]] = call <2 x half> @llvm.copysign.v2f16(<2 x half> [[X:%.*]], <2 x half> [[Y:%.*]])
; CHECK-NEXT: [[FNEG_COPYSIGN:%.*]] = fneg <2 x half> [[COPYSIGN]] ; CHECK-NEXT: [[FNEG_COPYSIGN:%.*]] = fneg <2 x half> [[COPYSIGN]]
; CHECK-NEXT: ret <2 x half> [[FNEG_COPYSIGN]] ; CHECK-NEXT: ret <2 x half> [[FNEG_COPYSIGN]]
; ;
%copysign = call <2 x half> @llvm.copysign.v2f16(<2 x half> %x, <2 x half> %y) %copysign = call <2 x half> @llvm.copysign.v2f16(<2 x half> %x, <2 x half> %y)
%fneg.copysign = fneg <2 x half> %copysign %fneg.copysign = fneg <2 x half> %copysign
ret <2 x half> %fneg.copysign ret <2 x half> %fneg.copysign
} }
define <2 x half> @fneg_fabs_copysign_vector(<2 x half> %x, <2 x half> %y) { define <2 x half> @fneg_fabs_copysign_vector(<2 x half> %x, <2 x half> %y) {
; CHECK-LABEL: @fneg_fabs_copysign_vector( ; CHECK-LABEL: @fneg_fabs_copysign_vector(
; CHECK-NEXT: [[COPYSIGN:%.*]] = call <2 x half> @llvm.copysign.v2f16(<2 x half> [[X:%.*]], <2 x half> [[Y:%.*]]) ; CHECK-NEXT: [[TMP1:%.*]] = call <2 x half> @llvm.fabs.v2f16(<2 x half> [[X:%.*]])
; CHECK-NEXT: [[FABS_COPYSIGN:%.*]] = call <2 x half> @llvm.fabs.v2f16(<2 x half> [[COPYSIGN]]) ; CHECK-NEXT: [[FNEG_FABS_COPYSIGN:%.*]] = fneg <2 x half> [[TMP1]]
; CHECK-NEXT: [[FNEG_FABS_COPYSIGN:%.*]] = fneg <2 x half> [[FABS_COPYSIGN]]
; CHECK-NEXT: ret <2 x half> [[FNEG_FABS_COPYSIGN]] ; CHECK-NEXT: ret <2 x half> [[FNEG_FABS_COPYSIGN]]
; ;
%copysign = call <2 x half> @llvm.copysign.v2f16(<2 x half> %x, <2 x half> %y) %copysign = call <2 x half> @llvm.copysign.v2f16(<2 x half> %x, <2 x half> %y)
%fabs.copysign = call <2 x half> @llvm.fabs.v2f16(<2 x half> %copysign) %fabs.copysign = call <2 x half> @llvm.fabs.v2f16(<2 x half> %copysign)
%fneg.fabs.copysign = fneg <2 x half> %fabs.copysign %fneg.fabs.copysign = fneg <2 x half> %fabs.copysign
ret <2 x half> %fneg.fabs.copysign ret <2 x half> %fneg.fabs.copysign
} }
define <2 x half> @fabs_copysign_vector(<2 x half> %x, <2 x half> %y) { define <2 x half> @fabs_copysign_vector(<2 x half> %x, <2 x half> %y) {
; CHECK-LABEL: @fabs_copysign_vector( ; CHECK-LABEL: @fabs_copysign_vector(
; CHECK-NEXT: [[COPYSIGN:%.*]] = call <2 x half> @llvm.copysign.v2f16(<2 x half> [[X:%.*]], <2 x half> [[Y:%.*]]) ; CHECK-NEXT: [[TMP1:%.*]] = call <2 x half> @llvm.fabs.v2f16(<2 x half> [[X:%.*]])
; CHECK-NEXT: [[FABS_COPYSIGN:%.*]] = call <2 x half> @llvm.fabs.v2f16(<2 x half> [[COPYSIGN]]) ; CHECK-NEXT: ret <2 x half> [[TMP1]]
; CHECK-NEXT: ret <2 x half> [[FABS_COPYSIGN]]
; ;
%copysign = call <2 x half> @llvm.copysign.v2f16(<2 x half> %x, <2 x half> %y) %copysign = call <2 x half> @llvm.copysign.v2f16(<2 x half> %x, <2 x half> %y)
%fabs.copysign = call <2 x half> @llvm.fabs.v2f16(<2 x half> %copysign) %fabs.copysign = call <2 x half> @llvm.fabs.v2f16(<2 x half> %copysign)
ret <2 x half> %fabs.copysign ret <2 x half> %fabs.copysign
} }
define half @fneg_copysign_flags(half %x, half %y) { define half @fneg_copysign_flags(half %x, half %y) {
; CHECK-LABEL: @fneg_copysign_flags( ; CHECK-LABEL: @fneg_copysign_flags(
; CHECK-NEXT: [[COPYSIGN:%.*]] = call nnan nsz half @llvm.copysign.f16(half [[X:%.*]], half [[Y:%.*]]) ; CHECK-NEXT: [[COPYSIGN:%.*]] = call nnan nsz half @llvm.copysign.f16(half [[X:%.*]], half [[Y:%.*]])
; CHECK-NEXT: [[FNEG_COPYSIGN:%.*]] = fneg ninf nsz half [[COPYSIGN]] ; CHECK-NEXT: [[FNEG_COPYSIGN:%.*]] = fneg ninf nsz half [[COPYSIGN]]
; CHECK-NEXT: ret half [[FNEG_COPYSIGN]] ; CHECK-NEXT: ret half [[FNEG_COPYSIGN]]
; ;
%copysign = call nnan nsz half @llvm.copysign.f16(half %x, half %y) %copysign = call nnan nsz half @llvm.copysign.f16(half %x, half %y)
%fneg.copysign = fneg ninf nsz half %copysign %fneg.copysign = fneg ninf nsz half %copysign
ret half %fneg.copysign ret half %fneg.copysign
} }
define half @fneg_fabs_copysign_flags(half %x, half %y) { define half @fneg_fabs_copysign_flags(half %x, half %y) {
; CHECK-LABEL: @fneg_fabs_copysign_flags( ; CHECK-LABEL: @fneg_fabs_copysign_flags(
; CHECK-NEXT: [[COPYSIGN:%.*]] = call nnan ninf nsz half @llvm.copysign.f16(half [[X:%.*]], half [[Y:%.*]]) ; CHECK-NEXT: [[TMP1:%.*]] = call nnan ninf afn half @llvm.fabs.f16(half [[X:%.*]])
; CHECK-NEXT: [[FABS_COPYSIGN:%.*]] = call nnan ninf afn half @llvm.fabs.f16(half [[COPYSIGN]]) ; CHECK-NEXT: [[FNEG_FABS_COPYSIGN:%.*]] = fneg reassoc ninf half [[TMP1]]
; CHECK-NEXT: [[FNEG_FABS_COPYSIGN:%.*]] = fneg reassoc ninf half [[FABS_COPYSIGN]]
; CHECK-NEXT: ret half [[FNEG_FABS_COPYSIGN]] ; CHECK-NEXT: ret half [[FNEG_FABS_COPYSIGN]]
; ;
%copysign = call nnan nsz ninf half @llvm.copysign.f16(half %x, half %y) %copysign = call nnan nsz ninf half @llvm.copysign.f16(half %x, half %y)
%fabs.copysign = call nnan afn ninf half @llvm.fabs.f16(half %copysign) %fabs.copysign = call nnan afn ninf half @llvm.fabs.f16(half %copysign)
%fneg.fabs.copysign = fneg reassoc ninf half %fabs.copysign %fneg.fabs.copysign = fneg reassoc ninf half %fabs.copysign
ret half %fneg.fabs.copysign ret half %fneg.fabs.copysign
} }
; Make sure we don't break things by polluting copysign with nsz ; Make sure we don't break things by polluting copysign with nsz
define half @fneg_nsz_copysign(half %x, half %y) { define half @fneg_nsz_copysign(half %x, half %y) {
; CHECK-LABEL: @fneg_nsz_copysign( ; CHECK-LABEL: @fneg_nsz_copysign(
; CHECK-NEXT: [[COPYSIGN:%.*]] = call half @llvm.copysign.f16(half [[X:%.*]], half [[Y:%.*]]) ; CHECK-NEXT: [[COPYSIGN:%.*]] = call half @llvm.copysign.f16(half [[X:%.*]], half [[Y:%.*]])
; CHECK-NEXT: [[FNEG_COPYSIGN:%.*]] = fneg nsz half [[COPYSIGN]] ; CHECK-NEXT: [[FNEG_COPYSIGN:%.*]] = fneg nsz half [[COPYSIGN]]
; CHECK-NEXT: ret half [[FNEG_COPYSIGN]] ; CHECK-NEXT: ret half [[FNEG_COPYSIGN]]
; ;
%copysign = call half @llvm.copysign.f16(half %x, half %y) %copysign = call half @llvm.copysign.f16(half %x, half %y)
%fneg.copysign = fneg nsz half %copysign %fneg.copysign = fneg nsz half %copysign
ret half %fneg.copysign ret half %fneg.copysign
} }
define half @fneg_fabs_copysign_flags_none_fabs(half %x, half %y) { define half @fneg_fabs_copysign_flags_none_fabs(half %x, half %y) {
; CHECK-LABEL: @fneg_fabs_copysign_flags_none_fabs( ; CHECK-LABEL: @fneg_fabs_copysign_flags_none_fabs(
; CHECK-NEXT: [[COPYSIGN:%.*]] = call nnan ninf nsz half @llvm.copysign.f16(half [[X:%.*]], half [[Y:%.*]]) ; CHECK-NEXT: [[TMP1:%.*]] = call half @llvm.fabs.f16(half [[X:%.*]])
; CHECK-NEXT: [[FABS_COPYSIGN:%.*]] = call half @llvm.fabs.f16(half [[COPYSIGN]]) ; CHECK-NEXT: [[FNEG_FABS_COPYSIGN:%.*]] = fneg fast half [[TMP1]]
; CHECK-NEXT: [[FNEG_FABS_COPYSIGN:%.*]] = fneg fast half [[FABS_COPYSIGN]]
; CHECK-NEXT: ret half [[FNEG_FABS_COPYSIGN]] ; CHECK-NEXT: ret half [[FNEG_FABS_COPYSIGN]]
; ;
%copysign = call nnan nsz ninf half @llvm.copysign.f16(half %x, half %y) %copysign = call nnan nsz ninf half @llvm.copysign.f16(half %x, half %y)
%fabs.copysign = call half @llvm.fabs.f16(half %copysign) %fabs.copysign = call half @llvm.fabs.f16(half %copysign)
%fneg.fabs.copysign = fneg fast half %fabs.copysign %fneg.fabs.copysign = fneg fast half %fabs.copysign
ret half %fneg.fabs.copysign ret half %fneg.fabs.copysign
} }
define half @fabs_copysign_flags(half %x, half %y) { define half @fabs_copysign_flags(half %x, half %y) {
; CHECK-LABEL: @fabs_copysign_flags( ; CHECK-LABEL: @fabs_copysign_flags(
; CHECK-NEXT: [[COPYSIGN:%.*]] = call nnan half @llvm.copysign.f16(half [[X:%.*]], half [[Y:%.*]]) ; CHECK-NEXT: [[TMP1:%.*]] = call nnan nsz half @llvm.fabs.f16(half [[X:%.*]])
; CHECK-NEXT: [[FABS_COPYSIGN:%.*]] = call nnan nsz half @llvm.fabs.f16(half [[COPYSIGN]]) ; CHECK-NEXT: ret half [[TMP1]]
; CHECK-NEXT: ret half [[FABS_COPYSIGN]]
; ;
%copysign = call nnan half @llvm.copysign.f16(half %x, half %y) %copysign = call nnan half @llvm.copysign.f16(half %x, half %y)
%fabs.copysign = call nsz nnan half @llvm.fabs.f16(half %copysign) %fabs.copysign = call nsz nnan half @llvm.fabs.f16(half %copysign)
ret half %fabs.copysign ret half %fabs.copysign
} }
define half @fabs_copysign_all_flags(half %x, half %y) { define half @fabs_copysign_all_flags(half %x, half %y) {
; CHECK-LABEL: @fabs_copysign_all_flags( ; CHECK-LABEL: @fabs_copysign_all_flags(
; CHECK-NEXT: [[COPYSIGN:%.*]] = call fast half @llvm.copysign.f16(half [[X:%.*]], half [[Y:%.*]]) ; CHECK-NEXT: [[TMP1:%.*]] = call fast half @llvm.fabs.f16(half [[X:%.*]])
; CHECK-NEXT: [[FABS_COPYSIGN:%.*]] = call fast half @llvm.fabs.f16(half [[COPYSIGN]]) ; CHECK-NEXT: ret half [[TMP1]]
; CHECK-NEXT: ret half [[FABS_COPYSIGN]]
; ;
%copysign = call fast half @llvm.copysign.f16(half %x, half %y) %copysign = call fast half @llvm.copysign.f16(half %x, half %y)
%fabs.copysign = call fast half @llvm.fabs.f16(half %copysign) %fabs.copysign = call fast half @llvm.fabs.f16(half %copysign)
ret half %fabs.copysign ret half %fabs.copysign
} }
define half @fabs_copysign_no_flags_copysign_user(half %x, half %y, ptr %ptr) { define half @fabs_copysign_no_flags_copysign_user(half %x, half %y, ptr %ptr) {
; CHECK-LABEL: @fabs_copysign_no_flags_copysign_user( ; CHECK-LABEL: @fabs_copysign_no_flags_copysign_user(
; CHECK-NEXT: [[COPYSIGN:%.*]] = call half @llvm.copysign.f16(half [[X:%.*]], half [[Y:%.*]]) ; CHECK-NEXT: [[COPYSIGN:%.*]] = call half @llvm.copysign.f16(half [[X:%.*]], half [[Y:%.*]])
; CHECK-NEXT: store half [[COPYSIGN]], ptr [[PTR:%.*]], align 2 ; CHECK-NEXT: store half [[COPYSIGN]], ptr [[PTR:%.*]], align 2
; CHECK-NEXT: [[FABS_COPYSIGN:%.*]] = call fast half @llvm.fabs.f16(half [[COPYSIGN]]) ; CHECK-NEXT: [[TMP1:%.*]] = call fast half @llvm.fabs.f16(half [[X]])
; CHECK-NEXT: ret half [[FABS_COPYSIGN]] ; CHECK-NEXT: ret half [[TMP1]]
; ;
%copysign = call half @llvm.copysign.f16(half %x, half %y) %copysign = call half @llvm.copysign.f16(half %x, half %y)
store half %copysign, ptr %ptr store half %copysign, ptr %ptr
%fabs.copysign = call fast half @llvm.fabs.f16(half %copysign) %fabs.copysign = call fast half @llvm.fabs.f16(half %copysign)
ret half %fabs.copysign ret half %fabs.copysign
} }
define half @fneg_fabs_copysign_drop_flags(half %x, half %y) { define half @fneg_fabs_copysign_drop_flags(half %x, half %y) {
; CHECK-LABEL: @fneg_fabs_copysign_drop_flags( ; CHECK-LABEL: @fneg_fabs_copysign_drop_flags(
; CHECK-NEXT: [[COPYSIGN:%.*]] = call nnan half @llvm.copysign.f16(half [[X:%.*]], half [[Y:%.*]]) ; CHECK-NEXT: [[TMP1:%.*]] = call ninf half @llvm.fabs.f16(half [[X:%.*]])
; CHECK-NEXT: [[FABS_COPYSIGN:%.*]] = call ninf half @llvm.fabs.f16(half [[COPYSIGN]]) ; CHECK-NEXT: [[FNEG_FABS_COPYSIGN:%.*]] = fneg nsz half [[TMP1]]
; CHECK-NEXT: [[FNEG_FABS_COPYSIGN:%.*]] = fneg nsz half [[FABS_COPYSIGN]]
; CHECK-NEXT: ret half [[FNEG_FABS_COPYSIGN]] ; CHECK-NEXT: ret half [[FNEG_FABS_COPYSIGN]]
; ;
%copysign = call nnan half @llvm.copysign.f16(half %x, half %y) %copysign = call nnan half @llvm.copysign.f16(half %x, half %y)
%fabs.copysign = call ninf half @llvm.fabs.f16(half %copysign) %fabs.copysign = call ninf half @llvm.fabs.f16(half %copysign)
%fneg.fabs.copysign = fneg nsz half %fabs.copysign %fneg.fabs.copysign = fneg nsz half %fabs.copysign
ret half %fneg.fabs.copysign ret half %fneg.fabs.copysign
} }
Show All 9 Lines;
%fneg.copysign = fneg half %copysign %fneg.copysign = fneg half %copysign
ret half %fneg.copysign ret half %fneg.copysign
} }
define half @fabs_copysign_multi_use(half %x, half %y, ptr %ptr) { define half @fabs_copysign_multi_use(half %x, half %y, ptr %ptr) {
; CHECK-LABEL: @fabs_copysign_multi_use( ; CHECK-LABEL: @fabs_copysign_multi_use(
; CHECK-NEXT: [[COPYSIGN:%.*]] = call half @llvm.copysign.f16(half [[X:%.*]], half [[Y:%.*]]) ; CHECK-NEXT: [[COPYSIGN:%.*]] = call half @llvm.copysign.f16(half [[X:%.*]], half [[Y:%.*]])
; CHECK-NEXT: store half [[COPYSIGN]], ptr [[PTR:%.*]], align 2 ; CHECK-NEXT: store half [[COPYSIGN]], ptr [[PTR:%.*]], align 2
; CHECK-NEXT: [[FABS_COPYSIGN:%.*]] = call half @llvm.fabs.f16(half [[COPYSIGN]]) ; CHECK-NEXT: [[TMP1:%.*]] = call half @llvm.fabs.f16(half [[X]])
; CHECK-NEXT: ret half [[FABS_COPYSIGN]] ; CHECK-NEXT: ret half [[TMP1]]
; ;
%copysign = call half @llvm.copysign.f16(half %x, half %y) %copysign = call half @llvm.copysign.f16(half %x, half %y)
store half %copysign, ptr %ptr store half %copysign, ptr %ptr
%fabs.copysign = call half @llvm.fabs.f16(half %copysign) %fabs.copysign = call half @llvm.fabs.f16(half %copysign)
ret half %fabs.copysign ret half %fabs.copysign
} }
define half @fabs_flags_copysign_multi_use(half %x, half %y, ptr %ptr) { define half @fabs_flags_copysign_multi_use(half %x, half %y, ptr %ptr) {
; CHECK-LABEL: @fabs_flags_copysign_multi_use( ; CHECK-LABEL: @fabs_flags_copysign_multi_use(
; CHECK-NEXT: [[COPYSIGN:%.*]] = call half @llvm.copysign.f16(half [[X:%.*]], half [[Y:%.*]]) ; CHECK-NEXT: [[COPYSIGN:%.*]] = call half @llvm.copysign.f16(half [[X:%.*]], half [[Y:%.*]])
; CHECK-NEXT: store half [[COPYSIGN]], ptr [[PTR:%.*]], align 2 ; CHECK-NEXT: store half [[COPYSIGN]], ptr [[PTR:%.*]], align 2
; CHECK-NEXT: [[FABS_COPYSIGN:%.*]] = call nnan ninf half @llvm.fabs.f16(half [[COPYSIGN]]) ; CHECK-NEXT: [[TMP1:%.*]] = call nnan ninf half @llvm.fabs.f16(half [[X]])
; CHECK-NEXT: ret half [[FABS_COPYSIGN]] ; CHECK-NEXT: ret half [[TMP1]]
; ;
%copysign = call half @llvm.copysign.f16(half %x, half %y) %copysign = call half @llvm.copysign.f16(half %x, half %y)
store half %copysign, ptr %ptr store half %copysign, ptr %ptr
%fabs.copysign = call ninf nnan half @llvm.fabs.f16(half %copysign) %fabs.copysign = call ninf nnan half @llvm.fabs.f16(half %copysign)
ret half %fabs.copysign ret half %fabs.copysign
} }
define half @fneg_fabs_copysign_multi_use_fabs(half %x, half %y, ptr %ptr) { define half @fneg_fabs_copysign_multi_use_fabs(half %x, half %y, ptr %ptr) {
; CHECK-LABEL: @fneg_fabs_copysign_multi_use_fabs( ; CHECK-LABEL: @fneg_fabs_copysign_multi_use_fabs(
; CHECK-NEXT: [[COPYSIGN:%.*]] = call half @llvm.copysign.f16(half [[X:%.*]], half [[Y:%.*]]) ; CHECK-NEXT: [[TMP1:%.*]] = call half @llvm.fabs.f16(half [[X:%.*]])
; CHECK-NEXT: [[FABS_COPYSIGN:%.*]] = call half @llvm.fabs.f16(half [[COPYSIGN]]) ; CHECK-NEXT: store half [[TMP1]], ptr [[PTR:%.*]], align 2
; CHECK-NEXT: store half [[FABS_COPYSIGN]], ptr [[PTR:%.*]], align 2 ; CHECK-NEXT: ret half [[TMP1]]
; CHECK-NEXT: ret half [[FABS_COPYSIGN]]
; ;
%copysign = call half @llvm.copysign.f16(half %x, half %y) %copysign = call half @llvm.copysign.f16(half %x, half %y)
%fabs.copysign = call half @llvm.fabs.f16(half %copysign) %fabs.copysign = call half @llvm.fabs.f16(half %copysign)
store half %fabs.copysign, ptr %ptr store half %fabs.copysign, ptr %ptr
ret half %fabs.copysign ret half %fabs.copysign
} }
declare half @llvm.fabs.f16(half) declare half @llvm.fabs.f16(half)
declare <2 x half> @llvm.fabs.v2f16(<2 x half>) declare <2 x half> @llvm.fabs.v2f16(<2 x half>)
declare half @llvm.copysign.f16(half, half) declare half @llvm.copysign.f16(half, half)
declare <2 x half> @llvm.copysign.v2f16(<2 x half>, <2 x half>) declare <2 x half> @llvm.copysign.v2f16(<2 x half>, <2 x half>)