This is an archive of the discontinued LLVM Phabricator instance.

Differential D75895

[PowerPC] Select the select_cc for f64/f32 as set_cc + vselect if VSX enabled
AbandonedPublic

Authored by qiucf on Mar 10 2020, 1:14 AM.

Details

Reviewers
nemanjai
steven.zhang
jsji
Group Reviewers
Restricted Project
Summary

This is the motivated case:

define double @test(double %a, double %b, double %c, double %d) {
entry:
  %cmp = fcmp fast oeq double %a, %b
  %cond = select fast i1 %cmp, double %c, double %d
  ret double %cond
}

We are now using cmp + branch for this case. It could be improved with cmp + xxsel which is explicit suggested by Power ISA programming node.

Programming Note
xscmpeqdp can be used to implement the 
C/C++/Java conditional operation, RESULT = (x==y) ? a : b.
xscmpeqdp fEQ,fX,fY
xxsel           fRESULT,fA,fB,fEQ

Diff Detail

Event Timeline

steven.zhang created this revision.Mar 10 2020, 1:14 AM
Herald added a project: Restricted Project. · View Herald TranscriptMar 10 2020, 1:14 AM
Herald added subscribers: shchenz, • wuzish, kbarton, hiraditya. · View Herald Transcript
Harbormaster completed remote builds in B48641: Diff 249286.Mar 10 2020, 3:03 AM
steven.zhang added a comment.Mar 18 2020, 9:29 PM

ping

steven.zhang added a comment.May 13 2020, 8:10 PM

Gentle ping ...

steven.zhang planned changes to this revision.Nov 25 2020, 6:37 PM
qiucf commandeered this revision.Sep 1 2021, 12:11 AM
qiucf added a reviewer: steven.zhang.
jsji resigned from this revision.Jun 2 2022, 7:59 AM
Herald added a project: Restricted Project. · View Herald TranscriptJun 2 2022, 7:59 AM
qiucf abandoned this revision.Sep 19 2023, 12:46 AM

This can be split into two patches. One is already on GitHub https://github.com/llvm/llvm-project/pull/65295. Close.

Revision Contents

PathSize
llvm/
lib/
Target/
PowerPC/
48 lines
37 lines
test/
CodeGen/
PowerPC/
56 lines
22 lines
22 lines
516 lines
4 lines
8 lines
16 lines

Diff 249286

llvm/lib/Target/PowerPC/PPCISelLowering.cpp

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 7,714 Lines • ▼ Show 20 Lines if (Subtarget.hasP9Vector() && LHS == TV && RHS == FV) {
case ISD::SETOGT: case ISD::SETOGT:
case ISD::SETGT: case ISD::SETGT:
return DAG.getNode(PPCISD::XSMAXCDP, dl, Op.getValueType(), LHS, RHS); return DAG.getNode(PPCISD::XSMAXCDP, dl, Op.getValueType(), LHS, RHS);
case ISD::SETOLT: case ISD::SETOLT:
case ISD::SETLT: case ISD::SETLT:
return DAG.getNode(PPCISD::XSMINCDP, dl, Op.getValueType(), LHS, RHS); return DAG.getNode(PPCISD::XSMINCDP, dl, Op.getValueType(), LHS, RHS);
} }
} }
// Cannot do any optimization if there is NaNs.
if (!DAG.getTarget().Options.NoNaNsFPMath)
return Op;
SDNodeFlags Flags;
Flags.setNoNaNs(true);
bool IsValidFpType = (CmpVT == MVT::f32 || CmpVT == MVT::f64) &&
(ResVT == MVT::f32 || ResVT == MVT::f64);
bool IsRHSZero = isFloatingPointZero(RHS);
// (select_cc A, B, C, D, Pred) can be selected as
// (xxsel D, C, (xscmpeqdp/xscmpgtdp/... A, B)) if VSX is enabled. Don't do
// this if the rhs is zero as we could do some optimization later.
if (Subtarget.hasVSX() && IsValidFpType && !IsRHSZero) {
SDValue RegIdx = DAG.getTargetConstant(1, dl, MVT::i64);
SDValue SubReg = DAG.getTargetConstant(PPC::sub_64, dl, MVT::i32);
// Promote the type f32/f64 to v4i32 which vselect prefer.
LHS = SDValue(DAG.getMachineNode(TargetOpcode::SUBREG_TO_REG, dl,
MVT::v4i32, RegIdx, LHS, SubReg),
0);
RHS = SDValue(DAG.getMachineNode(TargetOpcode::SUBREG_TO_REG, dl,
MVT::v4i32, RegIdx, RHS, SubReg),
0);
TV = SDValue(DAG.getMachineNode(TargetOpcode::SUBREG_TO_REG, dl, MVT::v4i32,
RegIdx, TV, SubReg),
0);
FV = SDValue(DAG.getMachineNode(TargetOpcode::SUBREG_TO_REG, dl, MVT::v4i32,
RegIdx, FV, SubReg),
0);
// Lowering the select_cc to vselect + setcc.
SDValue SetCC = DAG.getNode(ISD::SETCC, dl, MVT::v4i32, LHS, RHS,
Op.getOperand(4), Flags);
SDValue SEL =
DAG.getNode(ISD::VSELECT, dl, MVT::v4i32, SetCC, TV, FV, Flags);
return SDValue(DAG.getMachineNode(TargetOpcode::EXTRACT_SUBREG, dl,
MVT::f64, SEL, SubReg),
0);
}
// We might be able to do better than this under some circumstances, but in // We might be able to do better than this under some circumstances, but in
// general, fsel-based lowering of select is a finite-math-only optimization. // general, fsel-based lowering of select is a finite-math-only optimization.
// For more information, see section F.3 of the 2.06 ISA specification. // For more information, see section F.3 of the 2.06 ISA specification.
// With ISA 3.0 // With ISA 3.0
if (!DAG.getTarget().Options.NoInfsFPMath || if (!DAG.getTarget().Options.NoInfsFPMath)
!DAG.getTarget().Options.NoNaNsFPMath)
return Op; return Op;
// TODO: Propagate flags from the select rather than global settings. // TODO: Propagate flags from the select rather than global settings.
SDNodeFlags Flags;
Flags.setNoInfs(true); Flags.setNoInfs(true);
Flags.setNoNaNs(true);
// If the RHS of the comparison is a 0.0, we don't need to do the // If the RHS of the comparison is a 0.0, we don't need to do the
// subtraction at all. // subtraction at all.
SDValue Sel1; SDValue Sel1;
if (isFloatingPointZero(RHS)) if (IsRHSZero)
switch (CC) { switch (CC) {
default: break; // SETUO etc aren't handled by fsel. default: break; // SETUO etc aren't handled by fsel.
case ISD::SETNE: case ISD::SETNE:
std::swap(TV, FV); std::swap(TV, FV);
LLVM_FALLTHROUGH; LLVM_FALLTHROUGH;
case ISD::SETEQ: case ISD::SETEQ:
if (LHS.getValueType() == MVT::f32) // Comparison is always 64-bits if (LHS.getValueType() == MVT::f32) // Comparison is always 64-bits
LHS = DAG.getNode(ISD::FP_EXTEND, dl, MVT::f64, LHS); LHS = DAG.getNode(ISD::FP_EXTEND, dl, MVT::f64, LHS);
▲ Show 20 Lines • Show All 8,843 Lines • Show Last 20 Lines

llvm/lib/Target/PowerPC/PPCInstrVSX.td

Show First 20 Lines • Show All 1,215 Lines • ▼ Show 20 Linesdef : Pat<(vselect v4i32:$vA, v4i32:$vB, v4i32:$vC),
(XXSEL $vC, $vB, $vA)>; (XXSEL $vC, $vB, $vA)>;
def : Pat<(vselect v2i64:$vA, v2i64:$vB, v2i64:$vC), def : Pat<(vselect v2i64:$vA, v2i64:$vB, v2i64:$vC),
(XXSEL $vC, $vB, $vA)>; (XXSEL $vC, $vB, $vA)>;
def : Pat<(vselect v4i32:$vA, v4f32:$vB, v4f32:$vC), def : Pat<(vselect v4i32:$vA, v4f32:$vB, v4f32:$vC),
(XXSEL $vC, $vB, $vA)>; (XXSEL $vC, $vB, $vA)>;
def : Pat<(vselect v2i64:$vA, v2f64:$vB, v2f64:$vC), def : Pat<(vselect v2i64:$vA, v2f64:$vB, v2f64:$vC),
(XXSEL $vC, $vB, $vA)>; (XXSEL $vC, $vB, $vA)>;
multiclass SelectCmpPat<PatLeaf Cmp, PatLeaf CmpPred, PatLeaf NCmpPred> {
def : Pat<(vselect (v4i32(setcc v4i32:$lhs, v4i32:$rhs, CmpPred)),
v4i32:$tval, v4i32:$fval),
(XXSEL $fval, $tval, (Cmp $lhs, $rhs))>;
def : Pat<(vselect (v4i32(setcc v4i32:$lhs, v4i32:$rhs, NCmpPred)),
v4i32:$tval, v4i32:$fval),
(XXSEL $tval, $fval, (Cmp $lhs, $rhs))>;
}
defm : SelectCmpPat<XVCMPEQDP, SETEQ, SETNE>;
defm : SelectCmpPat<XVCMPGEDP, SETGE, SETLT>;
defm : SelectCmpPat<XVCMPGTDP, SETGT, SETLE>;
defm : SelectCmpPat<XVCMPEQDP, SETOEQ, SETONE>;
defm : SelectCmpPat<XVCMPGEDP, SETOGE, SETOLT>;
defm : SelectCmpPat<XVCMPGTDP, SETOGT, SETOLE>;
def : Pat<(v4f32 (fmaxnum v4f32:$src1, v4f32:$src2)), def : Pat<(v4f32 (fmaxnum v4f32:$src1, v4f32:$src2)),
(v4f32 (XVMAXSP $src1, $src2))>; (v4f32 (XVMAXSP $src1, $src2))>;
def : Pat<(v4f32 (fminnum v4f32:$src1, v4f32:$src2)), def : Pat<(v4f32 (fminnum v4f32:$src1, v4f32:$src2)),
(v4f32 (XVMINSP $src1, $src2))>; (v4f32 (XVMINSP $src1, $src2))>;
def : Pat<(v2f64 (fmaxnum v2f64:$src1, v2f64:$src2)), def : Pat<(v2f64 (fmaxnum v2f64:$src1, v2f64:$src2)),
(v2f64 (XVMAXDP $src1, $src2))>; (v2f64 (XVMAXDP $src1, $src2))>;
def : Pat<(v2f64 (fminnum v2f64:$src1, v2f64:$src2)), def : Pat<(v2f64 (fminnum v2f64:$src1, v2f64:$src2)),
(v2f64 (XVMINDP $src1, $src2))>; (v2f64 (XVMINDP $src1, $src2))>;
▲ Show 20 Lines • Show All 1,541 Lines • ▼ Show 20 Lineslet AddedComplexity = 400, Predicates = [HasP9Vector] in {
def XSCMPEXPDP : XX3Form_1<60, 59, def XSCMPEXPDP : XX3Form_1<60, 59,
(outs crrc:$crD), (ins vsfrc:$XA, vsfrc:$XB), (outs crrc:$crD), (ins vsfrc:$XA, vsfrc:$XB),
"xscmpexpdp $crD, $XA, $XB", IIC_FPCompare, []>; "xscmpexpdp $crD, $XA, $XB", IIC_FPCompare, []>;
def XSCMPEXPQP : X_BF3_VA5_VB5<63, 164, "xscmpexpqp", []>; def XSCMPEXPQP : X_BF3_VA5_VB5<63, 164, "xscmpexpqp", []>;
// DP Compare ==, >=, >, != // DP Compare ==, >=, >, !=
// Use vsrc for XT, because the entire register of XT is set. // Use vsrc for XT, because the entire register of XT is set.
// XT.dword[1] = 0x0000_0000_0000_0000 // XT.dword[1] = 0x0000_0000_0000_0000
def XSCMPEQDP : XX3_XT5_XA5_XB5<60, 3, "xscmpeqdp", vsrc, vsfrc, vsfrc, def XSCMPEQDP : XX3_XT5_XA5_XB5<60, 3, "xscmpeqdp", vsrc, vsrc, vsrc,
IIC_FPCompare, []>; IIC_FPCompare, []>;
def XSCMPGEDP : XX3_XT5_XA5_XB5<60, 19, "xscmpgedp", vsrc, vsfrc, vsfrc, def XSCMPGEDP : XX3_XT5_XA5_XB5<60, 19, "xscmpgedp", vsrc, vsrc, vsrc,
IIC_FPCompare, []>; IIC_FPCompare, []>;
def XSCMPGTDP : XX3_XT5_XA5_XB5<60, 11, "xscmpgtdp", vsrc, vsfrc, vsfrc, def XSCMPGTDP : XX3_XT5_XA5_XB5<60, 11, "xscmpgtdp", vsrc, vsrc, vsrc,
IIC_FPCompare, []>; IIC_FPCompare, []>;
// Prefer the "VSX Scalar Compare Equal Double-Precision" instruction to
// "VSX Vector Compare Equal To Double-Precision" as it didn't update the CR6.
// FIXME - use a better mechanism instead of hardcode the complexity. Assume
// the complexity of XV instruction is 400.
let AddedComplexity = 410 in {
defm : SelectCmpPat<XSCMPEQDP, SETEQ, SETNE>;
defm : SelectCmpPat<XSCMPGEDP, SETGE, SETLT>;
defm : SelectCmpPat<XSCMPGTDP, SETGT, SETLE>;
defm : SelectCmpPat<XSCMPEQDP, SETOEQ, SETONE>;
defm : SelectCmpPat<XSCMPGEDP, SETOGE, SETOLT>;
defm : SelectCmpPat<XSCMPGTDP, SETOGT, SETOLE>;
}
//===--------------------------------------------------------------------===// //===--------------------------------------------------------------------===//
// Quad-Precision Floating-Point Conversion Instructions: // Quad-Precision Floating-Point Conversion Instructions:
// Convert DP -> QP // Convert DP -> QP
def XSCVDPQP : X_VT5_XO5_VB5_TyVB<63, 22, 836, "xscvdpqp", vfrc, def XSCVDPQP : X_VT5_XO5_VB5_TyVB<63, 22, 836, "xscvdpqp", vfrc,
[(set f128:$vT, (fpextend f64:$vB))]>; [(set f128:$vT, (fpextend f64:$vB))]>;
// Round & Convert QP -> DP (dword[1] is set to zero) // Round & Convert QP -> DP (dword[1] is set to zero)
▲ Show 20 Lines • Show All 1,633 Lines • Show Last 20 Lines

llvm/test/CodeGen/PowerPC/fmf-propagation.ll

Show First 20 Lines • Show All 297 Lines • ▼ Show 20 Lines
; FMF-NEXT: xsaddsp 0, 0, 3 ; FMF-NEXT: xsaddsp 0, 0, 3
; FMF-NEXT: xsmulsp 0, 1, 0 ; FMF-NEXT: xsmulsp 0, 1, 0
; FMF-NEXT: .LBB10_2: ; FMF-NEXT: .LBB10_2:
; FMF-NEXT: fmr 1, 0 ; FMF-NEXT: fmr 1, 0
; FMF-NEXT: blr ; FMF-NEXT: blr
; ;
; GLOBAL-LABEL: sqrt_afn_ieee: ; GLOBAL-LABEL: sqrt_afn_ieee:
; GLOBAL: # %bb.0: ; GLOBAL: # %bb.0:
; GLOBAL-NEXT: addis 3, 2, .LCPI10_2@toc@ha
; GLOBAL-NEXT: fabs 0, 1
; GLOBAL-NEXT: lfs 2, .LCPI10_2@toc@l(3)
; GLOBAL-NEXT: fcmpu 0, 0, 2
; GLOBAL-NEXT: xxlxor 0, 0, 0
; GLOBAL-NEXT: blt 0, .LBB10_2
; GLOBAL-NEXT: # %bb.1:
; GLOBAL-NEXT: xsrsqrtesp 0, 1 ; GLOBAL-NEXT: xsrsqrtesp 0, 1
; GLOBAL-NEXT: addis 3, 2, .LCPI10_0@toc@ha ; GLOBAL-NEXT: addis 3, 2, .LCPI10_0@toc@ha
; GLOBAL-NEXT: addis 4, 2, .LCPI10_1@toc@ha ; GLOBAL-NEXT: addis 4, 2, .LCPI10_1@toc@ha
; GLOBAL-NEXT: lfs 2, .LCPI10_0@toc@l(3) ; GLOBAL-NEXT: lfs 3, .LCPI10_0@toc@l(3)
; GLOBAL-NEXT: lfs 3, .LCPI10_1@toc@l(4) ; GLOBAL-NEXT: lfs 4, .LCPI10_1@toc@l(4)
; GLOBAL-NEXT: xsmulsp 1, 1, 0 ; GLOBAL-NEXT: addis 3, 2, .LCPI10_2@toc@ha
; GLOBAL-NEXT: xsmaddasp 2, 1, 0 ; GLOBAL-NEXT: xsmulsp 2, 1, 0
; GLOBAL-NEXT: xsmulsp 0, 1, 3 ; GLOBAL-NEXT: fabs 1, 1
; GLOBAL-NEXT: xsmulsp 0, 0, 2 ; GLOBAL-NEXT: xsmaddasp 3, 2, 0
; GLOBAL-NEXT: .LBB10_2: ; GLOBAL-NEXT: xsmulsp 0, 2, 4
; GLOBAL-NEXT: fmr 1, 0 ; GLOBAL-NEXT: lfs 2, .LCPI10_2@toc@l(3)
; GLOBAL-NEXT: xvcmpgedp 1, 1, 2
; GLOBAL-NEXT: xxlxor 2, 2, 2
; GLOBAL-NEXT: xsmulsp 0, 0, 3
; GLOBAL-NEXT: xxsel 1, 2, 0, 1
; GLOBAL-NEXT: # kill: def $f1 killed $f1 killed $vsl1
; GLOBAL-NEXT: blr ; GLOBAL-NEXT: blr
%rt = call afn float @llvm.sqrt.f32(float %x) %rt = call afn float @llvm.sqrt.f32(float %x)
ret float %rt ret float %rt
} }
; FMFDEBUG-LABEL: Optimized lowered selection DAG: %bb.0 'sqrt_afn_preserve_sign:' ; FMFDEBUG-LABEL: Optimized lowered selection DAG: %bb.0 'sqrt_afn_preserve_sign:'
; FMFDEBUG: fmul afn {{t[0-9]+}} ; FMFDEBUG: fmul afn {{t[0-9]+}}
; FMFDEBUG: Type-legalized selection DAG: %bb.0 'sqrt_afn_preserve_sign:' ; FMFDEBUG: Type-legalized selection DAG: %bb.0 'sqrt_afn_preserve_sign:'
▲ Show 20 Lines • Show All 75 Lines • ▼ Show 20 Lines
; FMF-NEXT: xsmulsp 0, 1, 3 ; FMF-NEXT: xsmulsp 0, 1, 3
; FMF-NEXT: xsmulsp 0, 0, 2 ; FMF-NEXT: xsmulsp 0, 0, 2
; FMF-NEXT: .LBB12_2: ; FMF-NEXT: .LBB12_2:
; FMF-NEXT: fmr 1, 0 ; FMF-NEXT: fmr 1, 0
; FMF-NEXT: blr ; FMF-NEXT: blr
; ;
; GLOBAL-LABEL: sqrt_fast_ieee: ; GLOBAL-LABEL: sqrt_fast_ieee:
; GLOBAL: # %bb.0: ; GLOBAL: # %bb.0:
; GLOBAL-NEXT: addis 3, 2, .LCPI12_2@toc@ha
; GLOBAL-NEXT: fabs 0, 1
; GLOBAL-NEXT: lfs 2, .LCPI12_2@toc@l(3)
; GLOBAL-NEXT: fcmpu 0, 0, 2
; GLOBAL-NEXT: xxlxor 0, 0, 0
; GLOBAL-NEXT: blt 0, .LBB12_2
; GLOBAL-NEXT: # %bb.1:
; GLOBAL-NEXT: xsrsqrtesp 0, 1 ; GLOBAL-NEXT: xsrsqrtesp 0, 1
; GLOBAL-NEXT: addis 3, 2, .LCPI12_0@toc@ha ; GLOBAL-NEXT: addis 3, 2, .LCPI12_0@toc@ha
; GLOBAL-NEXT: addis 4, 2, .LCPI12_1@toc@ha ; GLOBAL-NEXT: addis 4, 2, .LCPI12_1@toc@ha
; GLOBAL-NEXT: lfs 2, .LCPI12_0@toc@l(3) ; GLOBAL-NEXT: lfs 3, .LCPI12_0@toc@l(3)
; GLOBAL-NEXT: lfs 3, .LCPI12_1@toc@l(4) ; GLOBAL-NEXT: lfs 4, .LCPI12_1@toc@l(4)
; GLOBAL-NEXT: xsmulsp 1, 1, 0 ; GLOBAL-NEXT: addis 3, 2, .LCPI12_2@toc@ha
; GLOBAL-NEXT: xsmaddasp 2, 1, 0 ; GLOBAL-NEXT: xsmulsp 2, 1, 0
; GLOBAL-NEXT: xsmulsp 0, 1, 3 ; GLOBAL-NEXT: fabs 1, 1
; GLOBAL-NEXT: xsmulsp 0, 0, 2 ; GLOBAL-NEXT: xsmaddasp 3, 2, 0
; GLOBAL-NEXT: .LBB12_2: ; GLOBAL-NEXT: xsmulsp 0, 2, 4
; GLOBAL-NEXT: fmr 1, 0 ; GLOBAL-NEXT: lfs 2, .LCPI12_2@toc@l(3)
; GLOBAL-NEXT: xvcmpgedp 1, 1, 2
; GLOBAL-NEXT: xxlxor 2, 2, 2
; GLOBAL-NEXT: xsmulsp 0, 0, 3
; GLOBAL-NEXT: xxsel 1, 2, 0, 1
; GLOBAL-NEXT: # kill: def $f1 killed $f1 killed $vsl1
; GLOBAL-NEXT: blr ; GLOBAL-NEXT: blr
%rt = call fast float @llvm.sqrt.f32(float %x) %rt = call fast float @llvm.sqrt.f32(float %x)
ret float %rt ret float %rt
} }
; The call is now fully 'fast'. This implies that approximation is allowed. ; The call is now fully 'fast'. This implies that approximation is allowed.
; FMFDEBUG-LABEL: Optimized lowered selection DAG: %bb.0 'sqrt_fast_preserve_sign:' ; FMFDEBUG-LABEL: Optimized lowered selection DAG: %bb.0 'sqrt_fast_preserve_sign:'
▲ Show 20 Lines • Show All 156 Lines • Show Last 20 Lines

llvm/test/CodeGen/PowerPC/fsel.ll

Show First 20 Lines • Show All 77 Lines • ▼ Show 20 Lines
; CHECK: blr ; CHECK: blr
; CHECK-FM: @min1 ; CHECK-FM: @min1
; CHECK-FM: fsub [[REG:[0-9]+]], 2, 1 ; CHECK-FM: fsub [[REG:[0-9]+]], 2, 1
; CHECK-FM: fsel 1, [[REG]], 1, 2 ; CHECK-FM: fsel 1, [[REG]], 1, 2
; CHECK-FM: blr ; CHECK-FM: blr
; CHECK-FM-VSX: @min1 ; CHECK-FM-VSX: @min1
; CHECK-FM-VSX: xssubdp [[REG:[0-9]+]], 2, 1 ; CHECK-FM-VSX: xvcmpgtdp [[REG:[0-9]+]], 1, 2
; CHECK-FM-VSX: fsel 1, [[REG]], 1, 2 ; CHECK-FM-VSX: xxsel 1, 1, 2, [[REG]]
; CHECK-FM-VSX: blr ; CHECK-FM-VSX: blr
} }
define double @max1(double %a, double %b) #0 { define double @max1(double %a, double %b) #0 {
entry: entry:
%cmp = fcmp oge double %a, %b %cmp = fcmp oge double %a, %b
%cond = select i1 %cmp, double %a, double %b %cond = select i1 %cmp, double %a, double %b
ret double %cond ret double %cond
; CHECK: @max1 ; CHECK: @max1
; CHECK-NOT: fsel ; CHECK-NOT: fsel
; CHECK: blr ; CHECK: blr
; CHECK-FM: @max1 ; CHECK-FM: @max1
; CHECK-FM: fsub [[REG:[0-9]+]], 1, 2 ; CHECK-FM: fsub [[REG:[0-9]+]], 1, 2
; CHECK-FM: fsel 1, [[REG]], 1, 2 ; CHECK-FM: fsel 1, [[REG]], 1, 2
; CHECK-FM: blr ; CHECK-FM: blr
; CHECK-FM-VSX: @max1 ; CHECK-FM-VSX: @max1
; CHECK-FM-VSX: xssubdp [[REG:[0-9]+]], 1, 2 ; CHECK-FM-VSX: xvcmpgedp [[REG:[0-9]+]], 1, 2
; CHECK-FM-VSX: fsel 1, [[REG]], 1, 2 ; CHECK-FM-VSX: xxsel 1, 2, 1, [[REG]]
; CHECK-FM-VSX: blr ; CHECK-FM-VSX: blr
} }
define double @cmp1(double %a, double %b, double %y, double %z) #0 { define double @cmp1(double %a, double %b, double %y, double %z) #0 {
entry: entry:
%cmp = fcmp ult double %a, %b %cmp = fcmp ult double %a, %b
%z.y = select i1 %cmp, double %z, double %y %z.y = select i1 %cmp, double %z, double %y
ret double %z.y ret double %z.y
; CHECK: @cmp1 ; CHECK: @cmp1
; CHECK-NOT: fsel ; CHECK-NOT: fsel
; CHECK: blr ; CHECK: blr
; CHECK-FM: @cmp1 ; CHECK-FM: @cmp1
; CHECK-FM: fsub [[REG:[0-9]+]], 1, 2 ; CHECK-FM: fsub [[REG:[0-9]+]], 1, 2
; CHECK-FM: fsel 1, [[REG]], 3, 4 ; CHECK-FM: fsel 1, [[REG]], 3, 4
; CHECK-FM: blr ; CHECK-FM: blr
; CHECK-FM-VSX: @cmp1 ; CHECK-FM-VSX: @cmp1
; CHECK-FM-VSX: xssubdp [[REG:[0-9]+]], 1, 2 ; CHECK-FM-VSX: xvcmpgedp [[REG:[0-9]+]], 1, 2
; CHECK-FM-VSX: fsel 1, [[REG]], 3, 4 ; CHECK-FM-VSX: xxsel 1, 4, 3, [[REG]]
; CHECK-FM-VSX: blr ; CHECK-FM-VSX: blr
} }
define double @cmp2(double %a, double %b, double %y, double %z) #0 { define double @cmp2(double %a, double %b, double %y, double %z) #0 {
entry: entry:
%cmp = fcmp ogt double %a, %b %cmp = fcmp ogt double %a, %b
%y.z = select i1 %cmp, double %y, double %z %y.z = select i1 %cmp, double %y, double %z
ret double %y.z ret double %y.z
; CHECK: @cmp2 ; CHECK: @cmp2
; CHECK-NOT: fsel ; CHECK-NOT: fsel
; CHECK: blr ; CHECK: blr
; CHECK-FM: @cmp2 ; CHECK-FM: @cmp2
; CHECK-FM: fsub [[REG:[0-9]+]], 2, 1 ; CHECK-FM: fsub [[REG:[0-9]+]], 2, 1
; CHECK-FM: fsel 1, [[REG]], 4, 3 ; CHECK-FM: fsel 1, [[REG]], 4, 3
; CHECK-FM: blr ; CHECK-FM: blr
; CHECK-FM-VSX: @cmp2 ; CHECK-FM-VSX: @cmp2
; CHECK-FM-VSX: xssubdp [[REG:[0-9]+]], 2, 1 ; CHECK-FM-VSX: xvcmpgtdp [[REG:[0-9]+]], 1, 2
; CHECK-FM-VSX: fsel 1, [[REG]], 4, 3 ; CHECK-FM-VSX: xxsel 1, 4, 3, [[REG]]
; CHECK-FM-VSX: blr ; CHECK-FM-VSX: blr
} }
define double @cmp3(double %a, double %b, double %y, double %z) #0 { define double @cmp3(double %a, double %b, double %y, double %z) #0 {
entry: entry:
%cmp = fcmp oeq double %a, %b %cmp = fcmp oeq double %a, %b
%y.z = select i1 %cmp, double %y, double %z %y.z = select i1 %cmp, double %y, double %z
ret double %y.z ret double %y.z
; CHECK: @cmp3 ; CHECK: @cmp3
; CHECK-NOT: fsel ; CHECK-NOT: fsel
; CHECK: blr ; CHECK: blr
; CHECK-FM: @cmp3 ; CHECK-FM: @cmp3
; CHECK-FM: fsub [[REG:[0-9]+]], 1, 2 ; CHECK-FM: fsub [[REG:[0-9]+]], 1, 2
; CHECK-FM: fsel [[REG2:[0-9]+]], [[REG]], 3, 4 ; CHECK-FM: fsel [[REG2:[0-9]+]], [[REG]], 3, 4
; CHECK-FM: fneg [[REG3:[0-9]+]], [[REG]] ; CHECK-FM: fneg [[REG3:[0-9]+]], [[REG]]
; CHECK-FM: fsel 1, [[REG3]], [[REG2]], 4 ; CHECK-FM: fsel 1, [[REG3]], [[REG2]], 4
; CHECK-FM: blr ; CHECK-FM: blr
; CHECK-FM-VSX: @cmp3 ; CHECK-FM-VSX: @cmp3
; CHECK-FM-VSX: xssubdp [[REG:[0-9]+]], 1, 2 ; CHECK-FM-VSX: xvcmpeqdp [[REG:[0-9]+]], 1, 2
; CHECK-FM-VSX: xsnegdp [[REG3:[0-9]+]], [[REG]] ; CHECK-FM-VSX: xxsel 1, 4, 3, [[REG]]
; CHECK-FM-VSX: fsel [[REG2:[0-9]+]], [[REG]], 3, 4
; CHECK-FM-VSX: fsel 1, [[REG3]], [[REG2]], 4
; CHECK-FM-VSX: blr ; CHECK-FM-VSX: blr
} }
attributes #0 = { nounwind readnone } attributes #0 = { nounwind readnone }

llvm/test/CodeGen/PowerPC/scalar-equal.ll

Show All 13 Lines
; RUN: --check-prefix=NO-FAST-P9 ; RUN: --check-prefix=NO-FAST-P9
; RUN: llc -mcpu=pwr8 -ppc-asm-full-reg-names -verify-machineinstrs \ ; RUN: llc -mcpu=pwr8 -ppc-asm-full-reg-names -verify-machineinstrs \
; RUN: -mtriple=powerpc64le-unknown-unknown < %s | FileCheck %s \ ; RUN: -mtriple=powerpc64le-unknown-unknown < %s | FileCheck %s \
; RUN: --check-prefix=NO-FAST-P8 ; RUN: --check-prefix=NO-FAST-P8
define double @testoeq(double %a, double %b, double %c, double %d) { define double @testoeq(double %a, double %b, double %c, double %d) {
; FAST-P8-LABEL: testoeq: ; FAST-P8-LABEL: testoeq:
; FAST-P8: # %bb.0: # %entry ; FAST-P8: # %bb.0: # %entry
; FAST-P8-NEXT: xssubdp f0, f1, f2 ; FAST-P8-NEXT: # kill: def $f2 killed $f2 def $vsl2
; FAST-P8-NEXT: xsnegdp f1, f0 ; FAST-P8-NEXT: # kill: def $f1 killed $f1 def $vsl1
; FAST-P8-NEXT: fsel f0, f0, f3, f4 ; FAST-P8-NEXT: xvcmpeqdp vs0, vs1, vs2
; FAST-P8-NEXT: fsel f1, f1, f0, f4 ; FAST-P8-NEXT: # kill: def $f4 killed $f4 def $vsl4
; FAST-P8-NEXT: # kill: def $f3 killed $f3 def $vsl3
; FAST-P8-NEXT: xxsel vs1, vs4, vs3, vs0
; FAST-P8-NEXT: # kill: def $f1 killed $f1 killed $vsl1
; FAST-P8-NEXT: blr ; FAST-P8-NEXT: blr
; ;
; FAST-P9-LABEL: testoeq: ; FAST-P9-LABEL: testoeq:
; FAST-P9: # %bb.0: # %entry ; FAST-P9: # %bb.0: # %entry
; FAST-P9-NEXT: xssubdp f0, f1, f2 ; FAST-P9-NEXT: # kill: def $f2 killed $f2 def $vsl2
; FAST-P9-NEXT: fsel f1, f0, f3, f4 ; FAST-P9-NEXT: # kill: def $f1 killed $f1 def $vsl1
; FAST-P9-NEXT: xsnegdp f0, f0 ; FAST-P9-NEXT: xscmpeqdp vs0, vs1, vs2
; FAST-P9-NEXT: fsel f1, f0, f1, f4 ; FAST-P9-NEXT: # kill: def $f4 killed $f4 def $vsl4
; FAST-P9-NEXT: # kill: def $f3 killed $f3 def $vsl3
; FAST-P9-NEXT: xxsel vs1, vs4, vs3, vs0
; FAST-P9-NEXT: # kill: def $f1 killed $f1 killed $vsl1
; FAST-P9-NEXT: blr ; FAST-P9-NEXT: blr
; ;
; NO-FAST-P9-LABEL: testoeq: ; NO-FAST-P9-LABEL: testoeq:
; NO-FAST-P9: # %bb.0: # %entry ; NO-FAST-P9: # %bb.0: # %entry
; NO-FAST-P9-NEXT: xscmpudp cr0, f1, f2 ; NO-FAST-P9-NEXT: xscmpudp cr0, f1, f2
; NO-FAST-P9-NEXT: beq cr0, .LBB0_2 ; NO-FAST-P9-NEXT: beq cr0, .LBB0_2
; NO-FAST-P9-NEXT: # %bb.1: # %entry ; NO-FAST-P9-NEXT: # %bb.1: # %entry
; NO-FAST-P9-NEXT: fmr f3, f4 ; NO-FAST-P9-NEXT: fmr f3, f4
Show All 17 Lines

llvm/test/CodeGen/PowerPC/scalar_cmp.ll

Show All 14 Lines
; RUN: llc -mcpu=pwr9 -ppc-asm-full-reg-names -verify-machineinstrs \ ; RUN: llc -mcpu=pwr9 -ppc-asm-full-reg-names -verify-machineinstrs \
; RUN: -mtriple=powerpc64le-unknown-unknown < %s | FileCheck %s \ ; RUN: -mtriple=powerpc64le-unknown-unknown < %s | FileCheck %s \
; RUN: --check-prefix=NO-FAST-P9 ; RUN: --check-prefix=NO-FAST-P9
; Test oeq ; Test oeq
define float @select_oeq_float(float %a, float %b, float %c, float %d) { define float @select_oeq_float(float %a, float %b, float %c, float %d) {
; FAST-P8-LABEL: select_oeq_float: ; FAST-P8-LABEL: select_oeq_float:
; FAST-P8: # %bb.0: # %entry ; FAST-P8: # %bb.0: # %entry
; FAST-P8-NEXT: xssubsp f0, f1, f2 ; FAST-P8-NEXT: # kill: def $f2 killed $f2 def $vsl2
; FAST-P8-NEXT: xssubsp f1, f2, f1 ; FAST-P8-NEXT: # kill: def $f1 killed $f1 def $vsl1
; FAST-P8-NEXT: fsel f0, f0, f3, f4 ; FAST-P8-NEXT: xvcmpeqdp vs0, vs1, vs2
; FAST-P8-NEXT: fsel f1, f1, f0, f4 ; FAST-P8-NEXT: # kill: def $f4 killed $f4 def $vsl4
; FAST-P8-NEXT: # kill: def $f3 killed $f3 def $vsl3
; FAST-P8-NEXT: xxsel vs1, vs4, vs3, vs0
; FAST-P8-NEXT: # kill: def $f1 killed $f1 killed $vsl1
; FAST-P8-NEXT: blr ; FAST-P8-NEXT: blr
; ;
; FAST-P9-LABEL: select_oeq_float: ; FAST-P9-LABEL: select_oeq_float:
; FAST-P9: # %bb.0: # %entry ; FAST-P9: # %bb.0: # %entry
; FAST-P9-NEXT: xssubsp f0, f2, f1 ; FAST-P9-NEXT: # kill: def $f2 killed $f2 def $vsl2
; FAST-P9-NEXT: xssubsp f1, f1, f2 ; FAST-P9-NEXT: # kill: def $f1 killed $f1 def $vsl1
; FAST-P9-NEXT: fsel f1, f1, f3, f4 ; FAST-P9-NEXT: xscmpeqdp vs0, vs1, vs2
; FAST-P9-NEXT: fsel f1, f0, f1, f4 ; FAST-P9-NEXT: # kill: def $f4 killed $f4 def $vsl4
; FAST-P9-NEXT: # kill: def $f3 killed $f3 def $vsl3
; FAST-P9-NEXT: xxsel vs1, vs4, vs3, vs0
; FAST-P9-NEXT: # kill: def $f1 killed $f1 killed $vsl1
; FAST-P9-NEXT: blr ; FAST-P9-NEXT: blr
; ;
; NO-FAST-P8-LABEL: select_oeq_float: ; NO-FAST-P8-LABEL: select_oeq_float:
; NO-FAST-P8: # %bb.0: # %entry ; NO-FAST-P8: # %bb.0: # %entry
; NO-FAST-P8-NEXT: fcmpu cr0, f1, f2 ; NO-FAST-P8-NEXT: fcmpu cr0, f1, f2
; NO-FAST-P8-NEXT: fmr f1, f3 ; NO-FAST-P8-NEXT: fmr f1, f3
; NO-FAST-P8-NEXT: beqlr cr0 ; NO-FAST-P8-NEXT: beqlr cr0
; NO-FAST-P8-NEXT: # %bb.1: # %entry ; NO-FAST-P8-NEXT: # %bb.1: # %entry
Show All 13 Linesentry:
%cmp = fcmp oeq float %a, %b %cmp = fcmp oeq float %a, %b
%cond = select i1 %cmp, float %c, float %d %cond = select i1 %cmp, float %c, float %d
ret float %cond ret float %cond
} }
define double @select_oeq_double(double %a, double %b, double %c, double %d) { define double @select_oeq_double(double %a, double %b, double %c, double %d) {
; FAST-P8-LABEL: select_oeq_double: ; FAST-P8-LABEL: select_oeq_double:
; FAST-P8: # %bb.0: # %entry ; FAST-P8: # %bb.0: # %entry
; FAST-P8-NEXT: xssubdp f0, f1, f2 ; FAST-P8-NEXT: # kill: def $f2 killed $f2 def $vsl2
; FAST-P8-NEXT: xsnegdp f1, f0 ; FAST-P8-NEXT: # kill: def $f1 killed $f1 def $vsl1
; FAST-P8-NEXT: fsel f0, f0, f3, f4 ; FAST-P8-NEXT: xvcmpeqdp vs0, vs1, vs2
; FAST-P8-NEXT: fsel f1, f1, f0, f4 ; FAST-P8-NEXT: # kill: def $f4 killed $f4 def $vsl4
; FAST-P8-NEXT: # kill: def $f3 killed $f3 def $vsl3
; FAST-P8-NEXT: xxsel vs1, vs4, vs3, vs0
; FAST-P8-NEXT: # kill: def $f1 killed $f1 killed $vsl1
; FAST-P8-NEXT: blr ; FAST-P8-NEXT: blr
; ;
; FAST-P9-LABEL: select_oeq_double: ; FAST-P9-LABEL: select_oeq_double:
; FAST-P9: # %bb.0: # %entry ; FAST-P9: # %bb.0: # %entry
; FAST-P9-NEXT: xssubdp f0, f1, f2 ; FAST-P9-NEXT: # kill: def $f2 killed $f2 def $vsl2
; FAST-P9-NEXT: fsel f1, f0, f3, f4 ; FAST-P9-NEXT: # kill: def $f1 killed $f1 def $vsl1
; FAST-P9-NEXT: xsnegdp f0, f0 ; FAST-P9-NEXT: xscmpeqdp vs0, vs1, vs2
; FAST-P9-NEXT: fsel f1, f0, f1, f4 ; FAST-P9-NEXT: # kill: def $f4 killed $f4 def $vsl4
; FAST-P9-NEXT: # kill: def $f3 killed $f3 def $vsl3
; FAST-P9-NEXT: xxsel vs1, vs4, vs3, vs0
; FAST-P9-NEXT: # kill: def $f1 killed $f1 killed $vsl1
; FAST-P9-NEXT: blr ; FAST-P9-NEXT: blr
; ;
; NO-FAST-P8-LABEL: select_oeq_double: ; NO-FAST-P8-LABEL: select_oeq_double:
; NO-FAST-P8: # %bb.0: # %entry ; NO-FAST-P8: # %bb.0: # %entry
; NO-FAST-P8-NEXT: xscmpudp cr0, f1, f2 ; NO-FAST-P8-NEXT: xscmpudp cr0, f1, f2
; NO-FAST-P8-NEXT: fmr f1, f3 ; NO-FAST-P8-NEXT: fmr f1, f3
; NO-FAST-P8-NEXT: beqlr cr0 ; NO-FAST-P8-NEXT: beqlr cr0
; NO-FAST-P8-NEXT: # %bb.1: # %entry ; NO-FAST-P8-NEXT: # %bb.1: # %entry
Show All 13 Linesentry:
%cmp = fcmp oeq double %a, %b %cmp = fcmp oeq double %a, %b
%cond = select i1 %cmp, double %c, double %d %cond = select i1 %cmp, double %c, double %d
ret double %cond ret double %cond
} }
define float @select_fast_oeq_float(float %a, float %b, float %c, float %d) { define float @select_fast_oeq_float(float %a, float %b, float %c, float %d) {
; FAST-P8-LABEL: select_fast_oeq_float: ; FAST-P8-LABEL: select_fast_oeq_float:
; FAST-P8: # %bb.0: # %entry ; FAST-P8: # %bb.0: # %entry
; FAST-P8-NEXT: xssubsp f0, f1, f2 ; FAST-P8-NEXT: # kill: def $f2 killed $f2 def $vsl2
; FAST-P8-NEXT: xssubsp f1, f2, f1 ; FAST-P8-NEXT: # kill: def $f1 killed $f1 def $vsl1
; FAST-P8-NEXT: fsel f0, f0, f3, f4 ; FAST-P8-NEXT: xvcmpeqdp vs0, vs1, vs2
; FAST-P8-NEXT: fsel f1, f1, f0, f4 ; FAST-P8-NEXT: # kill: def $f4 killed $f4 def $vsl4
; FAST-P8-NEXT: # kill: def $f3 killed $f3 def $vsl3
; FAST-P8-NEXT: xxsel vs1, vs4, vs3, vs0
; FAST-P8-NEXT: # kill: def $f1 killed $f1 killed $vsl1
; FAST-P8-NEXT: blr ; FAST-P8-NEXT: blr
; ;
; FAST-P9-LABEL: select_fast_oeq_float: ; FAST-P9-LABEL: select_fast_oeq_float:
; FAST-P9: # %bb.0: # %entry ; FAST-P9: # %bb.0: # %entry
; FAST-P9-NEXT: xssubsp f0, f2, f1 ; FAST-P9-NEXT: # kill: def $f2 killed $f2 def $vsl2
; FAST-P9-NEXT: xssubsp f1, f1, f2 ; FAST-P9-NEXT: # kill: def $f1 killed $f1 def $vsl1
; FAST-P9-NEXT: fsel f1, f1, f3, f4 ; FAST-P9-NEXT: xscmpeqdp vs0, vs1, vs2
; FAST-P9-NEXT: fsel f1, f0, f1, f4 ; FAST-P9-NEXT: # kill: def $f4 killed $f4 def $vsl4
; FAST-P9-NEXT: # kill: def $f3 killed $f3 def $vsl3
; FAST-P9-NEXT: xxsel vs1, vs4, vs3, vs0
; FAST-P9-NEXT: # kill: def $f1 killed $f1 killed $vsl1
; FAST-P9-NEXT: blr ; FAST-P9-NEXT: blr
; ;
; NO-FAST-P8-LABEL: select_fast_oeq_float: ; NO-FAST-P8-LABEL: select_fast_oeq_float:
; NO-FAST-P8: # %bb.0: # %entry ; NO-FAST-P8: # %bb.0: # %entry
; NO-FAST-P8-NEXT: fcmpu cr0, f1, f2 ; NO-FAST-P8-NEXT: fcmpu cr0, f1, f2
; NO-FAST-P8-NEXT: fmr f1, f3 ; NO-FAST-P8-NEXT: fmr f1, f3
; NO-FAST-P8-NEXT: beqlr cr0 ; NO-FAST-P8-NEXT: beqlr cr0
; NO-FAST-P8-NEXT: # %bb.1: # %entry ; NO-FAST-P8-NEXT: # %bb.1: # %entry
Show All 13 Linesentry:
%cmp = fcmp fast oeq float %a, %b %cmp = fcmp fast oeq float %a, %b
%cond = select fast i1 %cmp, float %c, float %d %cond = select fast i1 %cmp, float %c, float %d
ret float %cond ret float %cond
} }
define double @select_fast_oeq_double(double %a, double %b, double %c, double %d) { define double @select_fast_oeq_double(double %a, double %b, double %c, double %d) {
; FAST-P8-LABEL: select_fast_oeq_double: ; FAST-P8-LABEL: select_fast_oeq_double:
; FAST-P8: # %bb.0: # %entry ; FAST-P8: # %bb.0: # %entry
; FAST-P8-NEXT: xssubdp f0, f1, f2 ; FAST-P8-NEXT: # kill: def $f2 killed $f2 def $vsl2
; FAST-P8-NEXT: xsnegdp f1, f0 ; FAST-P8-NEXT: # kill: def $f1 killed $f1 def $vsl1
; FAST-P8-NEXT: fsel f0, f0, f3, f4 ; FAST-P8-NEXT: xvcmpeqdp vs0, vs1, vs2
; FAST-P8-NEXT: fsel f1, f1, f0, f4 ; FAST-P8-NEXT: # kill: def $f4 killed $f4 def $vsl4
; FAST-P8-NEXT: # kill: def $f3 killed $f3 def $vsl3
; FAST-P8-NEXT: xxsel vs1, vs4, vs3, vs0
; FAST-P8-NEXT: # kill: def $f1 killed $f1 killed $vsl1
; FAST-P8-NEXT: blr ; FAST-P8-NEXT: blr
; ;
; FAST-P9-LABEL: select_fast_oeq_double: ; FAST-P9-LABEL: select_fast_oeq_double:
; FAST-P9: # %bb.0: # %entry ; FAST-P9: # %bb.0: # %entry
; FAST-P9-NEXT: xssubdp f0, f1, f2 ; FAST-P9-NEXT: # kill: def $f2 killed $f2 def $vsl2
; FAST-P9-NEXT: fsel f1, f0, f3, f4 ; FAST-P9-NEXT: # kill: def $f1 killed $f1 def $vsl1
; FAST-P9-NEXT: xsnegdp f0, f0 ; FAST-P9-NEXT: xscmpeqdp vs0, vs1, vs2
; FAST-P9-NEXT: fsel f1, f0, f1, f4 ; FAST-P9-NEXT: # kill: def $f4 killed $f4 def $vsl4
; FAST-P9-NEXT: # kill: def $f3 killed $f3 def $vsl3
; FAST-P9-NEXT: xxsel vs1, vs4, vs3, vs0
; FAST-P9-NEXT: # kill: def $f1 killed $f1 killed $vsl1
; FAST-P9-NEXT: blr ; FAST-P9-NEXT: blr
; ;
; NO-FAST-P8-LABEL: select_fast_oeq_double: ; NO-FAST-P8-LABEL: select_fast_oeq_double:
; NO-FAST-P8: # %bb.0: # %entry ; NO-FAST-P8: # %bb.0: # %entry
; NO-FAST-P8-NEXT: xscmpudp cr0, f1, f2 ; NO-FAST-P8-NEXT: xscmpudp cr0, f1, f2
; NO-FAST-P8-NEXT: fmr f1, f3 ; NO-FAST-P8-NEXT: fmr f1, f3
; NO-FAST-P8-NEXT: beqlr cr0 ; NO-FAST-P8-NEXT: beqlr cr0
; NO-FAST-P8-NEXT: # %bb.1: # %entry ; NO-FAST-P8-NEXT: # %bb.1: # %entry
Show All 15 Linesentry:
ret double %cond ret double %cond
} }
; Test one ; Test one
define float @select_one_float(float %a, float %b, float %c, float %d) { define float @select_one_float(float %a, float %b, float %c, float %d) {
; FAST-P8-LABEL: select_one_float: ; FAST-P8-LABEL: select_one_float:
; FAST-P8: # %bb.0: # %entry ; FAST-P8: # %bb.0: # %entry
; FAST-P8-NEXT: xssubsp f0, f1, f2 ; FAST-P8-NEXT: # kill: def $f2 killed $f2 def $vsl2
; FAST-P8-NEXT: xssubsp f1, f2, f1 ; FAST-P8-NEXT: # kill: def $f1 killed $f1 def $vsl1
; FAST-P8-NEXT: fsel f0, f0, f4, f3 ; FAST-P8-NEXT: xvcmpeqdp vs0, vs1, vs2
; FAST-P8-NEXT: fsel f1, f1, f0, f3 ; FAST-P8-NEXT: # kill: def $f4 killed $f4 def $vsl4
; FAST-P8-NEXT: # kill: def $f3 killed $f3 def $vsl3
; FAST-P8-NEXT: xxsel vs1, vs3, vs4, vs0
; FAST-P8-NEXT: # kill: def $f1 killed $f1 killed $vsl1
; FAST-P8-NEXT: blr ; FAST-P8-NEXT: blr
; ;
; FAST-P9-LABEL: select_one_float: ; FAST-P9-LABEL: select_one_float:
; FAST-P9: # %bb.0: # %entry ; FAST-P9: # %bb.0: # %entry
; FAST-P9-NEXT: xssubsp f0, f2, f1 ; FAST-P9-NEXT: # kill: def $f2 killed $f2 def $vsl2
; FAST-P9-NEXT: xssubsp f1, f1, f2 ; FAST-P9-NEXT: # kill: def $f1 killed $f1 def $vsl1
; FAST-P9-NEXT: fsel f1, f1, f4, f3 ; FAST-P9-NEXT: xscmpeqdp vs0, vs1, vs2
; FAST-P9-NEXT: fsel f1, f0, f1, f3 ; FAST-P9-NEXT: # kill: def $f4 killed $f4 def $vsl4
; FAST-P9-NEXT: # kill: def $f3 killed $f3 def $vsl3
; FAST-P9-NEXT: xxsel vs1, vs3, vs4, vs0
; FAST-P9-NEXT: # kill: def $f1 killed $f1 killed $vsl1
; FAST-P9-NEXT: blr ; FAST-P9-NEXT: blr
; ;
; NO-FAST-P8-LABEL: select_one_float: ; NO-FAST-P8-LABEL: select_one_float:
; NO-FAST-P8: # %bb.0: # %entry ; NO-FAST-P8: # %bb.0: # %entry
; NO-FAST-P8-NEXT: fcmpu cr0, f1, f2 ; NO-FAST-P8-NEXT: fcmpu cr0, f1, f2
; NO-FAST-P8-NEXT: fmr f1, f3 ; NO-FAST-P8-NEXT: fmr f1, f3
; NO-FAST-P8-NEXT: crnor 4*cr5+lt, un, eq ; NO-FAST-P8-NEXT: crnor 4*cr5+lt, un, eq
; NO-FAST-P8-NEXT: bclr 12, 4*cr5+lt, 0 ; NO-FAST-P8-NEXT: bclr 12, 4*cr5+lt, 0
Show All 15 Linesentry:
%cmp = fcmp one float %a, %b %cmp = fcmp one float %a, %b
%cond = select i1 %cmp, float %c, float %d %cond = select i1 %cmp, float %c, float %d
ret float %cond ret float %cond
} }
define double @select_one_double(double %a, double %b, double %c, double %d) { define double @select_one_double(double %a, double %b, double %c, double %d) {
; FAST-P8-LABEL: select_one_double: ; FAST-P8-LABEL: select_one_double:
; FAST-P8: # %bb.0: # %entry ; FAST-P8: # %bb.0: # %entry
; FAST-P8-NEXT: xssubdp f0, f1, f2 ; FAST-P8-NEXT: # kill: def $f2 killed $f2 def $vsl2
; FAST-P8-NEXT: xsnegdp f1, f0 ; FAST-P8-NEXT: # kill: def $f1 killed $f1 def $vsl1
; FAST-P8-NEXT: fsel f0, f0, f4, f3 ; FAST-P8-NEXT: xvcmpeqdp vs0, vs1, vs2
; FAST-P8-NEXT: fsel f1, f1, f0, f3 ; FAST-P8-NEXT: # kill: def $f4 killed $f4 def $vsl4
; FAST-P8-NEXT: # kill: def $f3 killed $f3 def $vsl3
; FAST-P8-NEXT: xxsel vs1, vs3, vs4, vs0
; FAST-P8-NEXT: # kill: def $f1 killed $f1 killed $vsl1
; FAST-P8-NEXT: blr ; FAST-P8-NEXT: blr
; ;
; FAST-P9-LABEL: select_one_double: ; FAST-P9-LABEL: select_one_double:
; FAST-P9: # %bb.0: # %entry ; FAST-P9: # %bb.0: # %entry
; FAST-P9-NEXT: xssubdp f0, f1, f2 ; FAST-P9-NEXT: # kill: def $f2 killed $f2 def $vsl2
; FAST-P9-NEXT: fsel f1, f0, f4, f3 ; FAST-P9-NEXT: # kill: def $f1 killed $f1 def $vsl1
; FAST-P9-NEXT: xsnegdp f0, f0 ; FAST-P9-NEXT: xscmpeqdp vs0, vs1, vs2
; FAST-P9-NEXT: fsel f1, f0, f1, f3 ; FAST-P9-NEXT: # kill: def $f4 killed $f4 def $vsl4
; FAST-P9-NEXT: # kill: def $f3 killed $f3 def $vsl3
; FAST-P9-NEXT: xxsel vs1, vs3, vs4, vs0
; FAST-P9-NEXT: # kill: def $f1 killed $f1 killed $vsl1
; FAST-P9-NEXT: blr ; FAST-P9-NEXT: blr
; ;
; NO-FAST-P8-LABEL: select_one_double: ; NO-FAST-P8-LABEL: select_one_double:
; NO-FAST-P8: # %bb.0: # %entry ; NO-FAST-P8: # %bb.0: # %entry
; NO-FAST-P8-NEXT: fcmpu cr0, f1, f2 ; NO-FAST-P8-NEXT: fcmpu cr0, f1, f2
; NO-FAST-P8-NEXT: fmr f1, f3 ; NO-FAST-P8-NEXT: fmr f1, f3
; NO-FAST-P8-NEXT: crnor 4*cr5+lt, un, eq ; NO-FAST-P8-NEXT: crnor 4*cr5+lt, un, eq
; NO-FAST-P8-NEXT: bclr 12, 4*cr5+lt, 0 ; NO-FAST-P8-NEXT: bclr 12, 4*cr5+lt, 0
Show All 15 Linesentry:
%cmp = fcmp one double %a, %b %cmp = fcmp one double %a, %b
%cond = select i1 %cmp, double %c, double %d %cond = select i1 %cmp, double %c, double %d
ret double %cond ret double %cond
} }
define float @select_fast_one_float(float %a, float %b, float %c, float %d) { define float @select_fast_one_float(float %a, float %b, float %c, float %d) {
; FAST-P8-LABEL: select_fast_one_float: ; FAST-P8-LABEL: select_fast_one_float:
; FAST-P8: # %bb.0: # %entry ; FAST-P8: # %bb.0: # %entry
; FAST-P8-NEXT: xssubsp f0, f1, f2 ; FAST-P8-NEXT: # kill: def $f2 killed $f2 def $vsl2
; FAST-P8-NEXT: xssubsp f1, f2, f1 ; FAST-P8-NEXT: # kill: def $f1 killed $f1 def $vsl1
; FAST-P8-NEXT: fsel f0, f0, f4, f3 ; FAST-P8-NEXT: xvcmpeqdp vs0, vs1, vs2
; FAST-P8-NEXT: fsel f1, f1, f0, f3 ; FAST-P8-NEXT: # kill: def $f4 killed $f4 def $vsl4
; FAST-P8-NEXT: # kill: def $f3 killed $f3 def $vsl3
; FAST-P8-NEXT: xxsel vs1, vs3, vs4, vs0
; FAST-P8-NEXT: # kill: def $f1 killed $f1 killed $vsl1
; FAST-P8-NEXT: blr ; FAST-P8-NEXT: blr
; ;
; FAST-P9-LABEL: select_fast_one_float: ; FAST-P9-LABEL: select_fast_one_float:
; FAST-P9: # %bb.0: # %entry ; FAST-P9: # %bb.0: # %entry
; FAST-P9-NEXT: xssubsp f0, f2, f1 ; FAST-P9-NEXT: # kill: def $f2 killed $f2 def $vsl2
; FAST-P9-NEXT: xssubsp f1, f1, f2 ; FAST-P9-NEXT: # kill: def $f1 killed $f1 def $vsl1
; FAST-P9-NEXT: fsel f1, f1, f4, f3 ; FAST-P9-NEXT: xscmpeqdp vs0, vs1, vs2
; FAST-P9-NEXT: fsel f1, f0, f1, f3 ; FAST-P9-NEXT: # kill: def $f4 killed $f4 def $vsl4
; FAST-P9-NEXT: # kill: def $f3 killed $f3 def $vsl3
; FAST-P9-NEXT: xxsel vs1, vs3, vs4, vs0
; FAST-P9-NEXT: # kill: def $f1 killed $f1 killed $vsl1
; FAST-P9-NEXT: blr ; FAST-P9-NEXT: blr
; ;
; NO-FAST-P8-LABEL: select_fast_one_float: ; NO-FAST-P8-LABEL: select_fast_one_float:
; NO-FAST-P8: # %bb.0: # %entry ; NO-FAST-P8: # %bb.0: # %entry
; NO-FAST-P8-NEXT: fcmpu cr0, f1, f2 ; NO-FAST-P8-NEXT: fcmpu cr0, f1, f2
; NO-FAST-P8-NEXT: fmr f1, f3 ; NO-FAST-P8-NEXT: fmr f1, f3
; NO-FAST-P8-NEXT: bnelr cr0 ; NO-FAST-P8-NEXT: bnelr cr0
; NO-FAST-P8-NEXT: # %bb.1: # %entry ; NO-FAST-P8-NEXT: # %bb.1: # %entry
Show All 13 Linesentry:
%cmp = fcmp fast one float %a, %b %cmp = fcmp fast one float %a, %b
%cond = select fast i1 %cmp, float %c, float %d %cond = select fast i1 %cmp, float %c, float %d
ret float %cond ret float %cond
} }
define double @select_fast_one_double(double %a, double %b, double %c, double %d) { define double @select_fast_one_double(double %a, double %b, double %c, double %d) {
; FAST-P8-LABEL: select_fast_one_double: ; FAST-P8-LABEL: select_fast_one_double:
; FAST-P8: # %bb.0: # %entry ; FAST-P8: # %bb.0: # %entry
; FAST-P8-NEXT: xssubdp f0, f1, f2 ; FAST-P8-NEXT: # kill: def $f2 killed $f2 def $vsl2
; FAST-P8-NEXT: xsnegdp f1, f0 ; FAST-P8-NEXT: # kill: def $f1 killed $f1 def $vsl1
; FAST-P8-NEXT: fsel f0, f0, f4, f3 ; FAST-P8-NEXT: xvcmpeqdp vs0, vs1, vs2
; FAST-P8-NEXT: fsel f1, f1, f0, f3 ; FAST-P8-NEXT: # kill: def $f4 killed $f4 def $vsl4
; FAST-P8-NEXT: # kill: def $f3 killed $f3 def $vsl3
; FAST-P8-NEXT: xxsel vs1, vs3, vs4, vs0
; FAST-P8-NEXT: # kill: def $f1 killed $f1 killed $vsl1
; FAST-P8-NEXT: blr ; FAST-P8-NEXT: blr
; ;
; FAST-P9-LABEL: select_fast_one_double: ; FAST-P9-LABEL: select_fast_one_double:
; FAST-P9: # %bb.0: # %entry ; FAST-P9: # %bb.0: # %entry
; FAST-P9-NEXT: xssubdp f0, f1, f2 ; FAST-P9-NEXT: # kill: def $f2 killed $f2 def $vsl2
; FAST-P9-NEXT: fsel f1, f0, f4, f3 ; FAST-P9-NEXT: # kill: def $f1 killed $f1 def $vsl1
; FAST-P9-NEXT: xsnegdp f0, f0 ; FAST-P9-NEXT: xscmpeqdp vs0, vs1, vs2
; FAST-P9-NEXT: fsel f1, f0, f1, f3 ; FAST-P9-NEXT: # kill: def $f4 killed $f4 def $vsl4
; FAST-P9-NEXT: # kill: def $f3 killed $f3 def $vsl3
; FAST-P9-NEXT: xxsel vs1, vs3, vs4, vs0
; FAST-P9-NEXT: # kill: def $f1 killed $f1 killed $vsl1
; FAST-P9-NEXT: blr ; FAST-P9-NEXT: blr
; ;
; NO-FAST-P8-LABEL: select_fast_one_double: ; NO-FAST-P8-LABEL: select_fast_one_double:
; NO-FAST-P8: # %bb.0: # %entry ; NO-FAST-P8: # %bb.0: # %entry
; NO-FAST-P8-NEXT: xscmpudp cr0, f1, f2 ; NO-FAST-P8-NEXT: xscmpudp cr0, f1, f2
; NO-FAST-P8-NEXT: fmr f1, f3 ; NO-FAST-P8-NEXT: fmr f1, f3
; NO-FAST-P8-NEXT: bnelr cr0 ; NO-FAST-P8-NEXT: bnelr cr0
; NO-FAST-P8-NEXT: # %bb.1: # %entry ; NO-FAST-P8-NEXT: # %bb.1: # %entry
Show All 15 Linesentry:
ret double %cond ret double %cond
} }
; Test oge ; Test oge
define float @select_oge_float(float %a, float %b, float %c, float %d) { define float @select_oge_float(float %a, float %b, float %c, float %d) {
; FAST-P8-LABEL: select_oge_float: ; FAST-P8-LABEL: select_oge_float:
; FAST-P8: # %bb.0: # %entry ; FAST-P8: # %bb.0: # %entry
; FAST-P8-NEXT: xssubsp f0, f1, f2 ; FAST-P8-NEXT: # kill: def $f2 killed $f2 def $vsl2
; FAST-P8-NEXT: fsel f1, f0, f3, f4 ; FAST-P8-NEXT: # kill: def $f1 killed $f1 def $vsl1
; FAST-P8-NEXT: xvcmpgedp vs0, vs1, vs2
; FAST-P8-NEXT: # kill: def $f4 killed $f4 def $vsl4
; FAST-P8-NEXT: # kill: def $f3 killed $f3 def $vsl3
; FAST-P8-NEXT: xxsel vs1, vs4, vs3, vs0
; FAST-P8-NEXT: # kill: def $f1 killed $f1 killed $vsl1
; FAST-P8-NEXT: blr ; FAST-P8-NEXT: blr
; ;
; FAST-P9-LABEL: select_oge_float: ; FAST-P9-LABEL: select_oge_float:
; FAST-P9: # %bb.0: # %entry ; FAST-P9: # %bb.0: # %entry
; FAST-P9-NEXT: xssubsp f0, f1, f2 ; FAST-P9-NEXT: # kill: def $f2 killed $f2 def $vsl2
; FAST-P9-NEXT: fsel f1, f0, f3, f4 ; FAST-P9-NEXT: # kill: def $f1 killed $f1 def $vsl1
; FAST-P9-NEXT: xscmpgedp vs0, vs1, vs2
; FAST-P9-NEXT: # kill: def $f4 killed $f4 def $vsl4
; FAST-P9-NEXT: # kill: def $f3 killed $f3 def $vsl3
; FAST-P9-NEXT: xxsel vs1, vs4, vs3, vs0
; FAST-P9-NEXT: # kill: def $f1 killed $f1 killed $vsl1
; FAST-P9-NEXT: blr ; FAST-P9-NEXT: blr
; ;
; NO-FAST-P8-LABEL: select_oge_float: ; NO-FAST-P8-LABEL: select_oge_float:
; NO-FAST-P8: # %bb.0: # %entry ; NO-FAST-P8: # %bb.0: # %entry
; NO-FAST-P8-NEXT: fcmpu cr0, f1, f2 ; NO-FAST-P8-NEXT: fcmpu cr0, f1, f2
; NO-FAST-P8-NEXT: fmr f1, f3 ; NO-FAST-P8-NEXT: fmr f1, f3
; NO-FAST-P8-NEXT: crnor 4*cr5+lt, un, lt ; NO-FAST-P8-NEXT: crnor 4*cr5+lt, un, lt
; NO-FAST-P8-NEXT: bclr 12, 4*cr5+lt, 0 ; NO-FAST-P8-NEXT: bclr 12, 4*cr5+lt, 0
Show All 15 Linesentry:
%cmp = fcmp oge float %a, %b %cmp = fcmp oge float %a, %b
%cond = select i1 %cmp, float %c, float %d %cond = select i1 %cmp, float %c, float %d
ret float %cond ret float %cond
} }
define double @select_oge_double(double %a, double %b, double %c, double %d) { define double @select_oge_double(double %a, double %b, double %c, double %d) {
; FAST-P8-LABEL: select_oge_double: ; FAST-P8-LABEL: select_oge_double:
; FAST-P8: # %bb.0: # %entry ; FAST-P8: # %bb.0: # %entry
; FAST-P8-NEXT: xssubdp f0, f1, f2 ; FAST-P8-NEXT: # kill: def $f2 killed $f2 def $vsl2
; FAST-P8-NEXT: fsel f1, f0, f3, f4 ; FAST-P8-NEXT: # kill: def $f1 killed $f1 def $vsl1
; FAST-P8-NEXT: xvcmpgedp vs0, vs1, vs2
; FAST-P8-NEXT: # kill: def $f4 killed $f4 def $vsl4
; FAST-P8-NEXT: # kill: def $f3 killed $f3 def $vsl3
; FAST-P8-NEXT: xxsel vs1, vs4, vs3, vs0
; FAST-P8-NEXT: # kill: def $f1 killed $f1 killed $vsl1
; FAST-P8-NEXT: blr ; FAST-P8-NEXT: blr
; ;
; FAST-P9-LABEL: select_oge_double: ; FAST-P9-LABEL: select_oge_double:
; FAST-P9: # %bb.0: # %entry ; FAST-P9: # %bb.0: # %entry
; FAST-P9-NEXT: xssubdp f0, f1, f2 ; FAST-P9-NEXT: # kill: def $f2 killed $f2 def $vsl2
; FAST-P9-NEXT: fsel f1, f0, f3, f4 ; FAST-P9-NEXT: # kill: def $f1 killed $f1 def $vsl1
; FAST-P9-NEXT: xscmpgedp vs0, vs1, vs2
; FAST-P9-NEXT: # kill: def $f4 killed $f4 def $vsl4
; FAST-P9-NEXT: # kill: def $f3 killed $f3 def $vsl3
; FAST-P9-NEXT: xxsel vs1, vs4, vs3, vs0
; FAST-P9-NEXT: # kill: def $f1 killed $f1 killed $vsl1
; FAST-P9-NEXT: blr ; FAST-P9-NEXT: blr
; ;
; NO-FAST-P8-LABEL: select_oge_double: ; NO-FAST-P8-LABEL: select_oge_double:
; NO-FAST-P8: # %bb.0: # %entry ; NO-FAST-P8: # %bb.0: # %entry
; NO-FAST-P8-NEXT: fcmpu cr0, f1, f2 ; NO-FAST-P8-NEXT: fcmpu cr0, f1, f2
; NO-FAST-P8-NEXT: fmr f1, f3 ; NO-FAST-P8-NEXT: fmr f1, f3
; NO-FAST-P8-NEXT: crnor 4*cr5+lt, un, lt ; NO-FAST-P8-NEXT: crnor 4*cr5+lt, un, lt
; NO-FAST-P8-NEXT: bclr 12, 4*cr5+lt, 0 ; NO-FAST-P8-NEXT: bclr 12, 4*cr5+lt, 0
Show All 15 Linesentry:
%cmp = fcmp oge double %a, %b %cmp = fcmp oge double %a, %b
%cond = select i1 %cmp, double %c, double %d %cond = select i1 %cmp, double %c, double %d
ret double %cond ret double %cond
} }
define float @select_fast_oge_float(float %a, float %b, float %c, float %d) { define float @select_fast_oge_float(float %a, float %b, float %c, float %d) {
; FAST-P8-LABEL: select_fast_oge_float: ; FAST-P8-LABEL: select_fast_oge_float:
; FAST-P8: # %bb.0: # %entry ; FAST-P8: # %bb.0: # %entry
; FAST-P8-NEXT: xssubsp f0, f1, f2 ; FAST-P8-NEXT: # kill: def $f2 killed $f2 def $vsl2
; FAST-P8-NEXT: fsel f1, f0, f3, f4 ; FAST-P8-NEXT: # kill: def $f1 killed $f1 def $vsl1
; FAST-P8-NEXT: xvcmpgedp vs0, vs1, vs2
; FAST-P8-NEXT: # kill: def $f4 killed $f4 def $vsl4
; FAST-P8-NEXT: # kill: def $f3 killed $f3 def $vsl3
; FAST-P8-NEXT: xxsel vs1, vs4, vs3, vs0
; FAST-P8-NEXT: # kill: def $f1 killed $f1 killed $vsl1
; FAST-P8-NEXT: blr ; FAST-P8-NEXT: blr
; ;
; FAST-P9-LABEL: select_fast_oge_float: ; FAST-P9-LABEL: select_fast_oge_float:
; FAST-P9: # %bb.0: # %entry ; FAST-P9: # %bb.0: # %entry
; FAST-P9-NEXT: xssubsp f0, f1, f2 ; FAST-P9-NEXT: # kill: def $f2 killed $f2 def $vsl2
; FAST-P9-NEXT: fsel f1, f0, f3, f4 ; FAST-P9-NEXT: # kill: def $f1 killed $f1 def $vsl1
; FAST-P9-NEXT: xscmpgedp vs0, vs1, vs2
; FAST-P9-NEXT: # kill: def $f4 killed $f4 def $vsl4
; FAST-P9-NEXT: # kill: def $f3 killed $f3 def $vsl3
; FAST-P9-NEXT: xxsel vs1, vs4, vs3, vs0
; FAST-P9-NEXT: # kill: def $f1 killed $f1 killed $vsl1
; FAST-P9-NEXT: blr ; FAST-P9-NEXT: blr
; ;
; NO-FAST-P8-LABEL: select_fast_oge_float: ; NO-FAST-P8-LABEL: select_fast_oge_float:
; NO-FAST-P8: # %bb.0: # %entry ; NO-FAST-P8: # %bb.0: # %entry
; NO-FAST-P8-NEXT: fcmpu cr0, f1, f2 ; NO-FAST-P8-NEXT: fcmpu cr0, f1, f2
; NO-FAST-P8-NEXT: fmr f1, f3 ; NO-FAST-P8-NEXT: fmr f1, f3
; NO-FAST-P8-NEXT: bgelr cr0 ; NO-FAST-P8-NEXT: bgelr cr0
; NO-FAST-P8-NEXT: # %bb.1: # %entry ; NO-FAST-P8-NEXT: # %bb.1: # %entry
Show All 13 Linesentry:
%cmp = fcmp fast oge float %a, %b %cmp = fcmp fast oge float %a, %b
%cond = select fast i1 %cmp, float %c, float %d %cond = select fast i1 %cmp, float %c, float %d
ret float %cond ret float %cond
} }
define double @select_fast_oge_double(double %a, double %b, double %c, double %d) { define double @select_fast_oge_double(double %a, double %b, double %c, double %d) {
; FAST-P8-LABEL: select_fast_oge_double: ; FAST-P8-LABEL: select_fast_oge_double:
; FAST-P8: # %bb.0: # %entry ; FAST-P8: # %bb.0: # %entry
; FAST-P8-NEXT: xssubdp f0, f1, f2 ; FAST-P8-NEXT: # kill: def $f2 killed $f2 def $vsl2
; FAST-P8-NEXT: fsel f1, f0, f3, f4 ; FAST-P8-NEXT: # kill: def $f1 killed $f1 def $vsl1
; FAST-P8-NEXT: xvcmpgedp vs0, vs1, vs2
; FAST-P8-NEXT: # kill: def $f4 killed $f4 def $vsl4
; FAST-P8-NEXT: # kill: def $f3 killed $f3 def $vsl3
; FAST-P8-NEXT: xxsel vs1, vs4, vs3, vs0
; FAST-P8-NEXT: # kill: def $f1 killed $f1 killed $vsl1
; FAST-P8-NEXT: blr ; FAST-P8-NEXT: blr
; ;
; FAST-P9-LABEL: select_fast_oge_double: ; FAST-P9-LABEL: select_fast_oge_double:
; FAST-P9: # %bb.0: # %entry ; FAST-P9: # %bb.0: # %entry
; FAST-P9-NEXT: xssubdp f0, f1, f2 ; FAST-P9-NEXT: # kill: def $f2 killed $f2 def $vsl2
; FAST-P9-NEXT: fsel f1, f0, f3, f4 ; FAST-P9-NEXT: # kill: def $f1 killed $f1 def $vsl1
; FAST-P9-NEXT: xscmpgedp vs0, vs1, vs2
; FAST-P9-NEXT: # kill: def $f4 killed $f4 def $vsl4
; FAST-P9-NEXT: # kill: def $f3 killed $f3 def $vsl3
; FAST-P9-NEXT: xxsel vs1, vs4, vs3, vs0
; FAST-P9-NEXT: # kill: def $f1 killed $f1 killed $vsl1
; FAST-P9-NEXT: blr ; FAST-P9-NEXT: blr
; ;
; NO-FAST-P8-LABEL: select_fast_oge_double: ; NO-FAST-P8-LABEL: select_fast_oge_double:
; NO-FAST-P8: # %bb.0: # %entry ; NO-FAST-P8: # %bb.0: # %entry
; NO-FAST-P8-NEXT: xscmpudp cr0, f1, f2 ; NO-FAST-P8-NEXT: xscmpudp cr0, f1, f2
; NO-FAST-P8-NEXT: fmr f1, f3 ; NO-FAST-P8-NEXT: fmr f1, f3
; NO-FAST-P8-NEXT: bgelr cr0 ; NO-FAST-P8-NEXT: bgelr cr0
; NO-FAST-P8-NEXT: # %bb.1: # %entry ; NO-FAST-P8-NEXT: # %bb.1: # %entry
Show All 15 Linesentry:
ret double %cond ret double %cond
} }
; Test olt ; Test olt
define float @select_olt_float(float %a, float %b, float %c, float %d) { define float @select_olt_float(float %a, float %b, float %c, float %d) {
; FAST-P8-LABEL: select_olt_float: ; FAST-P8-LABEL: select_olt_float:
; FAST-P8: # %bb.0: # %entry ; FAST-P8: # %bb.0: # %entry
; FAST-P8-NEXT: xssubsp f0, f1, f2 ; FAST-P8-NEXT: # kill: def $f2 killed $f2 def $vsl2
; FAST-P8-NEXT: fsel f1, f0, f4, f3 ; FAST-P8-NEXT: # kill: def $f1 killed $f1 def $vsl1
; FAST-P8-NEXT: xvcmpgedp vs0, vs1, vs2
; FAST-P8-NEXT: # kill: def $f4 killed $f4 def $vsl4
; FAST-P8-NEXT: # kill: def $f3 killed $f3 def $vsl3
; FAST-P8-NEXT: xxsel vs1, vs3, vs4, vs0
; FAST-P8-NEXT: # kill: def $f1 killed $f1 killed $vsl1
; FAST-P8-NEXT: blr ; FAST-P8-NEXT: blr
; ;
; FAST-P9-LABEL: select_olt_float: ; FAST-P9-LABEL: select_olt_float:
; FAST-P9: # %bb.0: # %entry ; FAST-P9: # %bb.0: # %entry
; FAST-P9-NEXT: xssubsp f0, f1, f2 ; FAST-P9-NEXT: # kill: def $f2 killed $f2 def $vsl2
; FAST-P9-NEXT: fsel f1, f0, f4, f3 ; FAST-P9-NEXT: # kill: def $f1 killed $f1 def $vsl1
; FAST-P9-NEXT: xscmpgedp vs0, vs1, vs2
; FAST-P9-NEXT: # kill: def $f4 killed $f4 def $vsl4
; FAST-P9-NEXT: # kill: def $f3 killed $f3 def $vsl3
; FAST-P9-NEXT: xxsel vs1, vs3, vs4, vs0
; FAST-P9-NEXT: # kill: def $f1 killed $f1 killed $vsl1
; FAST-P9-NEXT: blr ; FAST-P9-NEXT: blr
; ;
; NO-FAST-P8-LABEL: select_olt_float: ; NO-FAST-P8-LABEL: select_olt_float:
; NO-FAST-P8: # %bb.0: # %entry ; NO-FAST-P8: # %bb.0: # %entry
; NO-FAST-P8-NEXT: fcmpu cr0, f1, f2 ; NO-FAST-P8-NEXT: fcmpu cr0, f1, f2
; NO-FAST-P8-NEXT: fmr f1, f3 ; NO-FAST-P8-NEXT: fmr f1, f3
; NO-FAST-P8-NEXT: bltlr cr0 ; NO-FAST-P8-NEXT: bltlr cr0
; NO-FAST-P8-NEXT: # %bb.1: # %entry ; NO-FAST-P8-NEXT: # %bb.1: # %entry
Show All 13 Linesentry:
%cmp = fcmp olt float %a, %b %cmp = fcmp olt float %a, %b
%cond = select i1 %cmp, float %c, float %d %cond = select i1 %cmp, float %c, float %d
ret float %cond ret float %cond
} }
define double @select_olt_double(double %a, double %b, double %c, double %d) { define double @select_olt_double(double %a, double %b, double %c, double %d) {
; FAST-P8-LABEL: select_olt_double: ; FAST-P8-LABEL: select_olt_double:
; FAST-P8: # %bb.0: # %entry ; FAST-P8: # %bb.0: # %entry
; FAST-P8-NEXT: xssubdp f0, f1, f2 ; FAST-P8-NEXT: # kill: def $f2 killed $f2 def $vsl2
; FAST-P8-NEXT: fsel f1, f0, f4, f3 ; FAST-P8-NEXT: # kill: def $f1 killed $f1 def $vsl1
; FAST-P8-NEXT: xvcmpgedp vs0, vs1, vs2
; FAST-P8-NEXT: # kill: def $f4 killed $f4 def $vsl4
; FAST-P8-NEXT: # kill: def $f3 killed $f3 def $vsl3
; FAST-P8-NEXT: xxsel vs1, vs3, vs4, vs0
; FAST-P8-NEXT: # kill: def $f1 killed $f1 killed $vsl1
; FAST-P8-NEXT: blr ; FAST-P8-NEXT: blr
; ;
; FAST-P9-LABEL: select_olt_double: ; FAST-P9-LABEL: select_olt_double:
; FAST-P9: # %bb.0: # %entry ; FAST-P9: # %bb.0: # %entry
; FAST-P9-NEXT: xssubdp f0, f1, f2 ; FAST-P9-NEXT: # kill: def $f2 killed $f2 def $vsl2
; FAST-P9-NEXT: fsel f1, f0, f4, f3 ; FAST-P9-NEXT: # kill: def $f1 killed $f1 def $vsl1
; FAST-P9-NEXT: xscmpgedp vs0, vs1, vs2
; FAST-P9-NEXT: # kill: def $f4 killed $f4 def $vsl4
; FAST-P9-NEXT: # kill: def $f3 killed $f3 def $vsl3
; FAST-P9-NEXT: xxsel vs1, vs3, vs4, vs0
; FAST-P9-NEXT: # kill: def $f1 killed $f1 killed $vsl1
; FAST-P9-NEXT: blr ; FAST-P9-NEXT: blr
; ;
; NO-FAST-P8-LABEL: select_olt_double: ; NO-FAST-P8-LABEL: select_olt_double:
; NO-FAST-P8: # %bb.0: # %entry ; NO-FAST-P8: # %bb.0: # %entry
; NO-FAST-P8-NEXT: xscmpudp cr0, f1, f2 ; NO-FAST-P8-NEXT: xscmpudp cr0, f1, f2
; NO-FAST-P8-NEXT: fmr f1, f3 ; NO-FAST-P8-NEXT: fmr f1, f3
; NO-FAST-P8-NEXT: bltlr cr0 ; NO-FAST-P8-NEXT: bltlr cr0
; NO-FAST-P8-NEXT: # %bb.1: # %entry ; NO-FAST-P8-NEXT: # %bb.1: # %entry
Show All 13 Linesentry:
%cmp = fcmp olt double %a, %b %cmp = fcmp olt double %a, %b
%cond = select i1 %cmp, double %c, double %d %cond = select i1 %cmp, double %c, double %d
ret double %cond ret double %cond
} }
define float @select_fast_olt_float(float %a, float %b, float %c, float %d) { define float @select_fast_olt_float(float %a, float %b, float %c, float %d) {
; FAST-P8-LABEL: select_fast_olt_float: ; FAST-P8-LABEL: select_fast_olt_float:
; FAST-P8: # %bb.0: # %entry ; FAST-P8: # %bb.0: # %entry
; FAST-P8-NEXT: xssubsp f0, f1, f2 ; FAST-P8-NEXT: # kill: def $f2 killed $f2 def $vsl2
; FAST-P8-NEXT: fsel f1, f0, f4, f3 ; FAST-P8-NEXT: # kill: def $f1 killed $f1 def $vsl1
; FAST-P8-NEXT: xvcmpgedp vs0, vs1, vs2
; FAST-P8-NEXT: # kill: def $f4 killed $f4 def $vsl4
; FAST-P8-NEXT: # kill: def $f3 killed $f3 def $vsl3
; FAST-P8-NEXT: xxsel vs1, vs3, vs4, vs0
; FAST-P8-NEXT: # kill: def $f1 killed $f1 killed $vsl1
; FAST-P8-NEXT: blr ; FAST-P8-NEXT: blr
; ;
; FAST-P9-LABEL: select_fast_olt_float: ; FAST-P9-LABEL: select_fast_olt_float:
; FAST-P9: # %bb.0: # %entry ; FAST-P9: # %bb.0: # %entry
; FAST-P9-NEXT: xssubsp f0, f1, f2 ; FAST-P9-NEXT: # kill: def $f2 killed $f2 def $vsl2
; FAST-P9-NEXT: fsel f1, f0, f4, f3 ; FAST-P9-NEXT: # kill: def $f1 killed $f1 def $vsl1
; FAST-P9-NEXT: xscmpgedp vs0, vs1, vs2
; FAST-P9-NEXT: # kill: def $f4 killed $f4 def $vsl4
; FAST-P9-NEXT: # kill: def $f3 killed $f3 def $vsl3
; FAST-P9-NEXT: xxsel vs1, vs3, vs4, vs0
; FAST-P9-NEXT: # kill: def $f1 killed $f1 killed $vsl1
; FAST-P9-NEXT: blr ; FAST-P9-NEXT: blr
; ;
; NO-FAST-P8-LABEL: select_fast_olt_float: ; NO-FAST-P8-LABEL: select_fast_olt_float:
; NO-FAST-P8: # %bb.0: # %entry ; NO-FAST-P8: # %bb.0: # %entry
; NO-FAST-P8-NEXT: fcmpu cr0, f1, f2 ; NO-FAST-P8-NEXT: fcmpu cr0, f1, f2
; NO-FAST-P8-NEXT: fmr f1, f3 ; NO-FAST-P8-NEXT: fmr f1, f3
; NO-FAST-P8-NEXT: bltlr cr0 ; NO-FAST-P8-NEXT: bltlr cr0
; NO-FAST-P8-NEXT: # %bb.1: # %entry ; NO-FAST-P8-NEXT: # %bb.1: # %entry
Show All 13 Linesentry:
%cmp = fcmp fast olt float %a, %b %cmp = fcmp fast olt float %a, %b
%cond = select fast i1 %cmp, float %c, float %d %cond = select fast i1 %cmp, float %c, float %d
ret float %cond ret float %cond
} }
define double @select_fast_olt_double(double %a, double %b, double %c, double %d) { define double @select_fast_olt_double(double %a, double %b, double %c, double %d) {
; FAST-P8-LABEL: select_fast_olt_double: ; FAST-P8-LABEL: select_fast_olt_double:
; FAST-P8: # %bb.0: # %entry ; FAST-P8: # %bb.0: # %entry
; FAST-P8-NEXT: xssubdp f0, f1, f2 ; FAST-P8-NEXT: # kill: def $f2 killed $f2 def $vsl2
; FAST-P8-NEXT: fsel f1, f0, f4, f3 ; FAST-P8-NEXT: # kill: def $f1 killed $f1 def $vsl1
; FAST-P8-NEXT: xvcmpgedp vs0, vs1, vs2
; FAST-P8-NEXT: # kill: def $f4 killed $f4 def $vsl4
; FAST-P8-NEXT: # kill: def $f3 killed $f3 def $vsl3
; FAST-P8-NEXT: xxsel vs1, vs3, vs4, vs0
; FAST-P8-NEXT: # kill: def $f1 killed $f1 killed $vsl1
; FAST-P8-NEXT: blr ; FAST-P8-NEXT: blr
; ;
; FAST-P9-LABEL: select_fast_olt_double: ; FAST-P9-LABEL: select_fast_olt_double:
; FAST-P9: # %bb.0: # %entry ; FAST-P9: # %bb.0: # %entry
; FAST-P9-NEXT: xssubdp f0, f1, f2 ; FAST-P9-NEXT: # kill: def $f2 killed $f2 def $vsl2
; FAST-P9-NEXT: fsel f1, f0, f4, f3 ; FAST-P9-NEXT: # kill: def $f1 killed $f1 def $vsl1
; FAST-P9-NEXT: xscmpgedp vs0, vs1, vs2
; FAST-P9-NEXT: # kill: def $f4 killed $f4 def $vsl4
; FAST-P9-NEXT: # kill: def $f3 killed $f3 def $vsl3
; FAST-P9-NEXT: xxsel vs1, vs3, vs4, vs0
; FAST-P9-NEXT: # kill: def $f1 killed $f1 killed $vsl1
; FAST-P9-NEXT: blr ; FAST-P9-NEXT: blr
; ;
; NO-FAST-P8-LABEL: select_fast_olt_double: ; NO-FAST-P8-LABEL: select_fast_olt_double:
; NO-FAST-P8: # %bb.0: # %entry ; NO-FAST-P8: # %bb.0: # %entry
; NO-FAST-P8-NEXT: xscmpudp cr0, f1, f2 ; NO-FAST-P8-NEXT: xscmpudp cr0, f1, f2
; NO-FAST-P8-NEXT: fmr f1, f3 ; NO-FAST-P8-NEXT: fmr f1, f3
; NO-FAST-P8-NEXT: bltlr cr0 ; NO-FAST-P8-NEXT: bltlr cr0
; NO-FAST-P8-NEXT: # %bb.1: # %entry ; NO-FAST-P8-NEXT: # %bb.1: # %entry
Show All 15 Linesentry:
ret double %cond ret double %cond
} }
; Test ogt ; Test ogt
define float @select_ogt_float(float %a, float %b, float %c, float %d) { define float @select_ogt_float(float %a, float %b, float %c, float %d) {
; FAST-P8-LABEL: select_ogt_float: ; FAST-P8-LABEL: select_ogt_float:
; FAST-P8: # %bb.0: # %entry ; FAST-P8: # %bb.0: # %entry
; FAST-P8-NEXT: xssubsp f0, f2, f1 ; FAST-P8-NEXT: # kill: def $f2 killed $f2 def $vsl2
; FAST-P8-NEXT: fsel f1, f0, f4, f3 ; FAST-P8-NEXT: # kill: def $f1 killed $f1 def $vsl1
; FAST-P8-NEXT: xvcmpgtdp vs0, vs1, vs2
; FAST-P8-NEXT: # kill: def $f4 killed $f4 def $vsl4
; FAST-P8-NEXT: # kill: def $f3 killed $f3 def $vsl3
; FAST-P8-NEXT: xxsel vs1, vs4, vs3, vs0
; FAST-P8-NEXT: # kill: def $f1 killed $f1 killed $vsl1
; FAST-P8-NEXT: blr ; FAST-P8-NEXT: blr
; ;
; FAST-P9-LABEL: select_ogt_float: ; FAST-P9-LABEL: select_ogt_float:
; FAST-P9: # %bb.0: # %entry ; FAST-P9: # %bb.0: # %entry
; FAST-P9-NEXT: xssubsp f0, f2, f1 ; FAST-P9-NEXT: # kill: def $f2 killed $f2 def $vsl2
; FAST-P9-NEXT: fsel f1, f0, f4, f3 ; FAST-P9-NEXT: # kill: def $f1 killed $f1 def $vsl1
; FAST-P9-NEXT: xscmpgtdp vs0, vs1, vs2
; FAST-P9-NEXT: # kill: def $f4 killed $f4 def $vsl4
; FAST-P9-NEXT: # kill: def $f3 killed $f3 def $vsl3
; FAST-P9-NEXT: xxsel vs1, vs4, vs3, vs0
; FAST-P9-NEXT: # kill: def $f1 killed $f1 killed $vsl1
; FAST-P9-NEXT: blr ; FAST-P9-NEXT: blr
; ;
; NO-FAST-P8-LABEL: select_ogt_float: ; NO-FAST-P8-LABEL: select_ogt_float:
; NO-FAST-P8: # %bb.0: # %entry ; NO-FAST-P8: # %bb.0: # %entry
; NO-FAST-P8-NEXT: fcmpu cr0, f1, f2 ; NO-FAST-P8-NEXT: fcmpu cr0, f1, f2
; NO-FAST-P8-NEXT: fmr f1, f3 ; NO-FAST-P8-NEXT: fmr f1, f3
; NO-FAST-P8-NEXT: bgtlr cr0 ; NO-FAST-P8-NEXT: bgtlr cr0
; NO-FAST-P8-NEXT: # %bb.1: # %entry ; NO-FAST-P8-NEXT: # %bb.1: # %entry
Show All 13 Linesentry:
%cmp = fcmp ogt float %a, %b %cmp = fcmp ogt float %a, %b
%cond = select i1 %cmp, float %c, float %d %cond = select i1 %cmp, float %c, float %d
ret float %cond ret float %cond
} }
define double @select_ogt_double(double %a, double %b, double %c, double %d) { define double @select_ogt_double(double %a, double %b, double %c, double %d) {
; FAST-P8-LABEL: select_ogt_double: ; FAST-P8-LABEL: select_ogt_double:
; FAST-P8: # %bb.0: # %entry ; FAST-P8: # %bb.0: # %entry
; FAST-P8-NEXT: xssubdp f0, f2, f1 ; FAST-P8-NEXT: # kill: def $f2 killed $f2 def $vsl2
; FAST-P8-NEXT: fsel f1, f0, f4, f3 ; FAST-P8-NEXT: # kill: def $f1 killed $f1 def $vsl1
; FAST-P8-NEXT: xvcmpgtdp vs0, vs1, vs2
; FAST-P8-NEXT: # kill: def $f4 killed $f4 def $vsl4
; FAST-P8-NEXT: # kill: def $f3 killed $f3 def $vsl3
; FAST-P8-NEXT: xxsel vs1, vs4, vs3, vs0
; FAST-P8-NEXT: # kill: def $f1 killed $f1 killed $vsl1
; FAST-P8-NEXT: blr ; FAST-P8-NEXT: blr
; ;
; FAST-P9-LABEL: select_ogt_double: ; FAST-P9-LABEL: select_ogt_double:
; FAST-P9: # %bb.0: # %entry ; FAST-P9: # %bb.0: # %entry
; FAST-P9-NEXT: xssubdp f0, f2, f1 ; FAST-P9-NEXT: # kill: def $f2 killed $f2 def $vsl2
; FAST-P9-NEXT: fsel f1, f0, f4, f3 ; FAST-P9-NEXT: # kill: def $f1 killed $f1 def $vsl1
; FAST-P9-NEXT: xscmpgtdp vs0, vs1, vs2
; FAST-P9-NEXT: # kill: def $f4 killed $f4 def $vsl4
; FAST-P9-NEXT: # kill: def $f3 killed $f3 def $vsl3
; FAST-P9-NEXT: xxsel vs1, vs4, vs3, vs0
; FAST-P9-NEXT: # kill: def $f1 killed $f1 killed $vsl1
; FAST-P9-NEXT: blr ; FAST-P9-NEXT: blr
; ;
; NO-FAST-P8-LABEL: select_ogt_double: ; NO-FAST-P8-LABEL: select_ogt_double:
; NO-FAST-P8: # %bb.0: # %entry ; NO-FAST-P8: # %bb.0: # %entry
; NO-FAST-P8-NEXT: xscmpudp cr0, f1, f2 ; NO-FAST-P8-NEXT: xscmpudp cr0, f1, f2
; NO-FAST-P8-NEXT: fmr f1, f3 ; NO-FAST-P8-NEXT: fmr f1, f3
; NO-FAST-P8-NEXT: bgtlr cr0 ; NO-FAST-P8-NEXT: bgtlr cr0
; NO-FAST-P8-NEXT: # %bb.1: # %entry ; NO-FAST-P8-NEXT: # %bb.1: # %entry
Show All 13 Linesentry:
%cmp = fcmp ogt double %a, %b %cmp = fcmp ogt double %a, %b
%cond = select i1 %cmp, double %c, double %d %cond = select i1 %cmp, double %c, double %d
ret double %cond ret double %cond
} }
define float @select_fast_ogt_float(float %a, float %b, float %c, float %d) { define float @select_fast_ogt_float(float %a, float %b, float %c, float %d) {
; FAST-P8-LABEL: select_fast_ogt_float: ; FAST-P8-LABEL: select_fast_ogt_float:
; FAST-P8: # %bb.0: # %entry ; FAST-P8: # %bb.0: # %entry
; FAST-P8-NEXT: xssubsp f0, f2, f1 ; FAST-P8-NEXT: # kill: def $f2 killed $f2 def $vsl2
; FAST-P8-NEXT: fsel f1, f0, f4, f3 ; FAST-P8-NEXT: # kill: def $f1 killed $f1 def $vsl1
; FAST-P8-NEXT: xvcmpgtdp vs0, vs1, vs2
; FAST-P8-NEXT: # kill: def $f4 killed $f4 def $vsl4
; FAST-P8-NEXT: # kill: def $f3 killed $f3 def $vsl3
; FAST-P8-NEXT: xxsel vs1, vs4, vs3, vs0
; FAST-P8-NEXT: # kill: def $f1 killed $f1 killed $vsl1
; FAST-P8-NEXT: blr ; FAST-P8-NEXT: blr
; ;
; FAST-P9-LABEL: select_fast_ogt_float: ; FAST-P9-LABEL: select_fast_ogt_float:
; FAST-P9: # %bb.0: # %entry ; FAST-P9: # %bb.0: # %entry
; FAST-P9-NEXT: xssubsp f0, f2, f1 ; FAST-P9-NEXT: # kill: def $f2 killed $f2 def $vsl2
; FAST-P9-NEXT: fsel f1, f0, f4, f3 ; FAST-P9-NEXT: # kill: def $f1 killed $f1 def $vsl1
; FAST-P9-NEXT: xscmpgtdp vs0, vs1, vs2
; FAST-P9-NEXT: # kill: def $f4 killed $f4 def $vsl4
; FAST-P9-NEXT: # kill: def $f3 killed $f3 def $vsl3
; FAST-P9-NEXT: xxsel vs1, vs4, vs3, vs0
; FAST-P9-NEXT: # kill: def $f1 killed $f1 killed $vsl1
; FAST-P9-NEXT: blr ; FAST-P9-NEXT: blr
; ;
; NO-FAST-P8-LABEL: select_fast_ogt_float: ; NO-FAST-P8-LABEL: select_fast_ogt_float:
; NO-FAST-P8: # %bb.0: # %entry ; NO-FAST-P8: # %bb.0: # %entry
; NO-FAST-P8-NEXT: fcmpu cr0, f1, f2 ; NO-FAST-P8-NEXT: fcmpu cr0, f1, f2
; NO-FAST-P8-NEXT: fmr f1, f3 ; NO-FAST-P8-NEXT: fmr f1, f3
; NO-FAST-P8-NEXT: bgtlr cr0 ; NO-FAST-P8-NEXT: bgtlr cr0
; NO-FAST-P8-NEXT: # %bb.1: # %entry ; NO-FAST-P8-NEXT: # %bb.1: # %entry
Show All 13 Linesentry:
%cmp = fcmp fast ogt float %a, %b %cmp = fcmp fast ogt float %a, %b
%cond = select fast i1 %cmp, float %c, float %d %cond = select fast i1 %cmp, float %c, float %d
ret float %cond ret float %cond
} }
define double @select_fast_ogt_double(double %a, double %b, double %c, double %d) { define double @select_fast_ogt_double(double %a, double %b, double %c, double %d) {
; FAST-P8-LABEL: select_fast_ogt_double: ; FAST-P8-LABEL: select_fast_ogt_double:
; FAST-P8: # %bb.0: # %entry ; FAST-P8: # %bb.0: # %entry
; FAST-P8-NEXT: xssubdp f0, f2, f1 ; FAST-P8-NEXT: # kill: def $f2 killed $f2 def $vsl2
; FAST-P8-NEXT: fsel f1, f0, f4, f3 ; FAST-P8-NEXT: # kill: def $f1 killed $f1 def $vsl1
; FAST-P8-NEXT: xvcmpgtdp vs0, vs1, vs2
; FAST-P8-NEXT: # kill: def $f4 killed $f4 def $vsl4
; FAST-P8-NEXT: # kill: def $f3 killed $f3 def $vsl3
; FAST-P8-NEXT: xxsel vs1, vs4, vs3, vs0
; FAST-P8-NEXT: # kill: def $f1 killed $f1 killed $vsl1
; FAST-P8-NEXT: blr ; FAST-P8-NEXT: blr
; ;
; FAST-P9-LABEL: select_fast_ogt_double: ; FAST-P9-LABEL: select_fast_ogt_double:
; FAST-P9: # %bb.0: # %entry ; FAST-P9: # %bb.0: # %entry
; FAST-P9-NEXT: xssubdp f0, f2, f1 ; FAST-P9-NEXT: # kill: def $f2 killed $f2 def $vsl2
; FAST-P9-NEXT: fsel f1, f0, f4, f3 ; FAST-P9-NEXT: # kill: def $f1 killed $f1 def $vsl1
; FAST-P9-NEXT: xscmpgtdp vs0, vs1, vs2
; FAST-P9-NEXT: # kill: def $f4 killed $f4 def $vsl4
; FAST-P9-NEXT: # kill: def $f3 killed $f3 def $vsl3
; FAST-P9-NEXT: xxsel vs1, vs4, vs3, vs0
; FAST-P9-NEXT: # kill: def $f1 killed $f1 killed $vsl1
; FAST-P9-NEXT: blr ; FAST-P9-NEXT: blr
; ;
; NO-FAST-P8-LABEL: select_fast_ogt_double: ; NO-FAST-P8-LABEL: select_fast_ogt_double:
; NO-FAST-P8: # %bb.0: # %entry ; NO-FAST-P8: # %bb.0: # %entry
; NO-FAST-P8-NEXT: xscmpudp cr0, f1, f2 ; NO-FAST-P8-NEXT: xscmpudp cr0, f1, f2
; NO-FAST-P8-NEXT: fmr f1, f3 ; NO-FAST-P8-NEXT: fmr f1, f3
; NO-FAST-P8-NEXT: bgtlr cr0 ; NO-FAST-P8-NEXT: bgtlr cr0
; NO-FAST-P8-NEXT: # %bb.1: # %entry ; NO-FAST-P8-NEXT: # %bb.1: # %entry
Show All 15 Linesentry:
ret double %cond ret double %cond
} }
; Test ole ; Test ole
define float @select_ole_float(float %a, float %b, float %c, float %d) { define float @select_ole_float(float %a, float %b, float %c, float %d) {
; FAST-P8-LABEL: select_ole_float: ; FAST-P8-LABEL: select_ole_float:
; FAST-P8: # %bb.0: # %entry ; FAST-P8: # %bb.0: # %entry
; FAST-P8-NEXT: xssubsp f0, f2, f1 ; FAST-P8-NEXT: # kill: def $f2 killed $f2 def $vsl2
; FAST-P8-NEXT: fsel f1, f0, f3, f4 ; FAST-P8-NEXT: # kill: def $f1 killed $f1 def $vsl1
; FAST-P8-NEXT: xvcmpgtdp vs0, vs1, vs2
; FAST-P8-NEXT: # kill: def $f4 killed $f4 def $vsl4
; FAST-P8-NEXT: # kill: def $f3 killed $f3 def $vsl3
; FAST-P8-NEXT: xxsel vs1, vs3, vs4, vs0
; FAST-P8-NEXT: # kill: def $f1 killed $f1 killed $vsl1
; FAST-P8-NEXT: blr ; FAST-P8-NEXT: blr
; ;
; FAST-P9-LABEL: select_ole_float: ; FAST-P9-LABEL: select_ole_float:
; FAST-P9: # %bb.0: # %entry ; FAST-P9: # %bb.0: # %entry
; FAST-P9-NEXT: xssubsp f0, f2, f1 ; FAST-P9-NEXT: # kill: def $f2 killed $f2 def $vsl2
; FAST-P9-NEXT: fsel f1, f0, f3, f4 ; FAST-P9-NEXT: # kill: def $f1 killed $f1 def $vsl1
; FAST-P9-NEXT: xscmpgtdp vs0, vs1, vs2
; FAST-P9-NEXT: # kill: def $f4 killed $f4 def $vsl4
; FAST-P9-NEXT: # kill: def $f3 killed $f3 def $vsl3
; FAST-P9-NEXT: xxsel vs1, vs3, vs4, vs0
; FAST-P9-NEXT: # kill: def $f1 killed $f1 killed $vsl1
; FAST-P9-NEXT: blr ; FAST-P9-NEXT: blr
; ;
; NO-FAST-P8-LABEL: select_ole_float: ; NO-FAST-P8-LABEL: select_ole_float:
; NO-FAST-P8: # %bb.0: # %entry ; NO-FAST-P8: # %bb.0: # %entry
; NO-FAST-P8-NEXT: fcmpu cr0, f1, f2 ; NO-FAST-P8-NEXT: fcmpu cr0, f1, f2
; NO-FAST-P8-NEXT: fmr f1, f3 ; NO-FAST-P8-NEXT: fmr f1, f3
; NO-FAST-P8-NEXT: crnor 4*cr5+lt, un, gt ; NO-FAST-P8-NEXT: crnor 4*cr5+lt, un, gt
; NO-FAST-P8-NEXT: bclr 12, 4*cr5+lt, 0 ; NO-FAST-P8-NEXT: bclr 12, 4*cr5+lt, 0
Show All 15 Linesentry:
%cmp = fcmp ole float %a, %b %cmp = fcmp ole float %a, %b
%cond = select i1 %cmp, float %c, float %d %cond = select i1 %cmp, float %c, float %d
ret float %cond ret float %cond
} }
define double @select_ole_double(double %a, double %b, double %c, double %d) { define double @select_ole_double(double %a, double %b, double %c, double %d) {
; FAST-P8-LABEL: select_ole_double: ; FAST-P8-LABEL: select_ole_double:
; FAST-P8: # %bb.0: # %entry ; FAST-P8: # %bb.0: # %entry
; FAST-P8-NEXT: xssubdp f0, f2, f1 ; FAST-P8-NEXT: # kill: def $f2 killed $f2 def $vsl2
; FAST-P8-NEXT: fsel f1, f0, f3, f4 ; FAST-P8-NEXT: # kill: def $f1 killed $f1 def $vsl1
; FAST-P8-NEXT: xvcmpgtdp vs0, vs1, vs2
; FAST-P8-NEXT: # kill: def $f4 killed $f4 def $vsl4
; FAST-P8-NEXT: # kill: def $f3 killed $f3 def $vsl3
; FAST-P8-NEXT: xxsel vs1, vs3, vs4, vs0
; FAST-P8-NEXT: # kill: def $f1 killed $f1 killed $vsl1
; FAST-P8-NEXT: blr ; FAST-P8-NEXT: blr
; ;
; FAST-P9-LABEL: select_ole_double: ; FAST-P9-LABEL: select_ole_double:
; FAST-P9: # %bb.0: # %entry ; FAST-P9: # %bb.0: # %entry
; FAST-P9-NEXT: xssubdp f0, f2, f1 ; FAST-P9-NEXT: # kill: def $f2 killed $f2 def $vsl2
; FAST-P9-NEXT: fsel f1, f0, f3, f4 ; FAST-P9-NEXT: # kill: def $f1 killed $f1 def $vsl1
; FAST-P9-NEXT: xscmpgtdp vs0, vs1, vs2
; FAST-P9-NEXT: # kill: def $f4 killed $f4 def $vsl4
; FAST-P9-NEXT: # kill: def $f3 killed $f3 def $vsl3
; FAST-P9-NEXT: xxsel vs1, vs3, vs4, vs0
; FAST-P9-NEXT: # kill: def $f1 killed $f1 killed $vsl1
; FAST-P9-NEXT: blr ; FAST-P9-NEXT: blr
; ;
; NO-FAST-P8-LABEL: select_ole_double: ; NO-FAST-P8-LABEL: select_ole_double:
; NO-FAST-P8: # %bb.0: # %entry ; NO-FAST-P8: # %bb.0: # %entry
; NO-FAST-P8-NEXT: fcmpu cr0, f1, f2 ; NO-FAST-P8-NEXT: fcmpu cr0, f1, f2
; NO-FAST-P8-NEXT: fmr f1, f3 ; NO-FAST-P8-NEXT: fmr f1, f3
; NO-FAST-P8-NEXT: crnor 4*cr5+lt, un, gt ; NO-FAST-P8-NEXT: crnor 4*cr5+lt, un, gt
; NO-FAST-P8-NEXT: bclr 12, 4*cr5+lt, 0 ; NO-FAST-P8-NEXT: bclr 12, 4*cr5+lt, 0
Show All 15 Linesentry:
%cmp = fcmp ole double %a, %b %cmp = fcmp ole double %a, %b
%cond = select i1 %cmp, double %c, double %d %cond = select i1 %cmp, double %c, double %d
ret double %cond ret double %cond
} }
define float @select_fast_ole_float(float %a, float %b, float %c, float %d) { define float @select_fast_ole_float(float %a, float %b, float %c, float %d) {
; FAST-P8-LABEL: select_fast_ole_float: ; FAST-P8-LABEL: select_fast_ole_float:
; FAST-P8: # %bb.0: # %entry ; FAST-P8: # %bb.0: # %entry
; FAST-P8-NEXT: xssubsp f0, f2, f1 ; FAST-P8-NEXT: # kill: def $f2 killed $f2 def $vsl2
; FAST-P8-NEXT: fsel f1, f0, f3, f4 ; FAST-P8-NEXT: # kill: def $f1 killed $f1 def $vsl1
; FAST-P8-NEXT: xvcmpgtdp vs0, vs1, vs2
; FAST-P8-NEXT: # kill: def $f4 killed $f4 def $vsl4
; FAST-P8-NEXT: # kill: def $f3 killed $f3 def $vsl3
; FAST-P8-NEXT: xxsel vs1, vs3, vs4, vs0
; FAST-P8-NEXT: # kill: def $f1 killed $f1 killed $vsl1
; FAST-P8-NEXT: blr ; FAST-P8-NEXT: blr
; ;
; FAST-P9-LABEL: select_fast_ole_float: ; FAST-P9-LABEL: select_fast_ole_float:
; FAST-P9: # %bb.0: # %entry ; FAST-P9: # %bb.0: # %entry
; FAST-P9-NEXT: xssubsp f0, f2, f1 ; FAST-P9-NEXT: # kill: def $f2 killed $f2 def $vsl2
; FAST-P9-NEXT: fsel f1, f0, f3, f4 ; FAST-P9-NEXT: # kill: def $f1 killed $f1 def $vsl1
; FAST-P9-NEXT: xscmpgtdp vs0, vs1, vs2
; FAST-P9-NEXT: # kill: def $f4 killed $f4 def $vsl4
; FAST-P9-NEXT: # kill: def $f3 killed $f3 def $vsl3
; FAST-P9-NEXT: xxsel vs1, vs3, vs4, vs0
; FAST-P9-NEXT: # kill: def $f1 killed $f1 killed $vsl1
; FAST-P9-NEXT: blr ; FAST-P9-NEXT: blr
; ;
; NO-FAST-P8-LABEL: select_fast_ole_float: ; NO-FAST-P8-LABEL: select_fast_ole_float:
; NO-FAST-P8: # %bb.0: # %entry ; NO-FAST-P8: # %bb.0: # %entry
; NO-FAST-P8-NEXT: fcmpu cr0, f1, f2 ; NO-FAST-P8-NEXT: fcmpu cr0, f1, f2
; NO-FAST-P8-NEXT: fmr f1, f3 ; NO-FAST-P8-NEXT: fmr f1, f3
; NO-FAST-P8-NEXT: blelr cr0 ; NO-FAST-P8-NEXT: blelr cr0
; NO-FAST-P8-NEXT: # %bb.1: # %entry ; NO-FAST-P8-NEXT: # %bb.1: # %entry
Show All 13 Linesentry:
%cmp = fcmp fast ole float %a, %b %cmp = fcmp fast ole float %a, %b
%cond = select fast i1 %cmp, float %c, float %d %cond = select fast i1 %cmp, float %c, float %d
ret float %cond ret float %cond
} }
define double @select_fast_ole_double(double %a, double %b, double %c, double %d) { define double @select_fast_ole_double(double %a, double %b, double %c, double %d) {
; FAST-P8-LABEL: select_fast_ole_double: ; FAST-P8-LABEL: select_fast_ole_double:
; FAST-P8: # %bb.0: # %entry ; FAST-P8: # %bb.0: # %entry
; FAST-P8-NEXT: xssubdp f0, f2, f1 ; FAST-P8-NEXT: # kill: def $f2 killed $f2 def $vsl2
; FAST-P8-NEXT: fsel f1, f0, f3, f4 ; FAST-P8-NEXT: # kill: def $f1 killed $f1 def $vsl1
; FAST-P8-NEXT: xvcmpgtdp vs0, vs1, vs2
; FAST-P8-NEXT: # kill: def $f4 killed $f4 def $vsl4
; FAST-P8-NEXT: # kill: def $f3 killed $f3 def $vsl3
; FAST-P8-NEXT: xxsel vs1, vs3, vs4, vs0
; FAST-P8-NEXT: # kill: def $f1 killed $f1 killed $vsl1
; FAST-P8-NEXT: blr ; FAST-P8-NEXT: blr
; ;
; FAST-P9-LABEL: select_fast_ole_double: ; FAST-P9-LABEL: select_fast_ole_double:
; FAST-P9: # %bb.0: # %entry ; FAST-P9: # %bb.0: # %entry
; FAST-P9-NEXT: xssubdp f0, f2, f1 ; FAST-P9-NEXT: # kill: def $f2 killed $f2 def $vsl2
; FAST-P9-NEXT: fsel f1, f0, f3, f4 ; FAST-P9-NEXT: # kill: def $f1 killed $f1 def $vsl1
; FAST-P9-NEXT: xscmpgtdp vs0, vs1, vs2
; FAST-P9-NEXT: # kill: def $f4 killed $f4 def $vsl4
; FAST-P9-NEXT: # kill: def $f3 killed $f3 def $vsl3
; FAST-P9-NEXT: xxsel vs1, vs3, vs4, vs0
; FAST-P9-NEXT: # kill: def $f1 killed $f1 killed $vsl1
; FAST-P9-NEXT: blr ; FAST-P9-NEXT: blr
; ;
; NO-FAST-P8-LABEL: select_fast_ole_double: ; NO-FAST-P8-LABEL: select_fast_ole_double:
; NO-FAST-P8: # %bb.0: # %entry ; NO-FAST-P8: # %bb.0: # %entry
; NO-FAST-P8-NEXT: xscmpudp cr0, f1, f2 ; NO-FAST-P8-NEXT: xscmpudp cr0, f1, f2
; NO-FAST-P8-NEXT: fmr f1, f3 ; NO-FAST-P8-NEXT: fmr f1, f3
; NO-FAST-P8-NEXT: blelr cr0 ; NO-FAST-P8-NEXT: blelr cr0
; NO-FAST-P8-NEXT: # %bb.1: # %entry ; NO-FAST-P8-NEXT: # %bb.1: # %entry
Show All 15 Linesentry:
ret double %cond ret double %cond
} }
; Test RHS is 1.000000e+00 ; Test RHS is 1.000000e+00
define double @onecmp1(double %a, double %y, double %z) { define double @onecmp1(double %a, double %y, double %z) {
; FAST-P8-LABEL: onecmp1: ; FAST-P8-LABEL: onecmp1:
; FAST-P8: # %bb.0: # %entry ; FAST-P8: # %bb.0: # %entry
; FAST-P8-NEXT: addis r3, r2, .LCPI24_0@toc@ha ; FAST-P8-NEXT: addis r3, r2, .LCPI24_0@toc@ha
; FAST-P8-NEXT: # kill: def $f1 killed $f1 def $vsl1
; FAST-P8-NEXT: # kill: def $f3 killed $f3 def $vsl3
; FAST-P8-NEXT: # kill: def $f2 killed $f2 def $vsl2
; FAST-P8-NEXT: lfs f0, .LCPI24_0@toc@l(r3) ; FAST-P8-NEXT: lfs f0, .LCPI24_0@toc@l(r3)
; FAST-P8-NEXT: xssubdp f0, f1, f0 ; FAST-P8-NEXT: xvcmpgedp vs0, vs1, vs0
; FAST-P8-NEXT: fsel f1, f0, f2, f3 ; FAST-P8-NEXT: xxsel vs1, vs3, vs2, vs0
; FAST-P8-NEXT: # kill: def $f1 killed $f1 killed $vsl1
; FAST-P8-NEXT: blr ; FAST-P8-NEXT: blr
; ;
; FAST-P9-LABEL: onecmp1: ; FAST-P9-LABEL: onecmp1:
; FAST-P9: # %bb.0: # %entry ; FAST-P9: # %bb.0: # %entry
; FAST-P9-NEXT: addis r3, r2, .LCPI24_0@toc@ha ; FAST-P9-NEXT: addis r3, r2, .LCPI24_0@toc@ha
; FAST-P9-NEXT: lfs f0, .LCPI24_0@toc@l(r3) ; FAST-P9-NEXT: lfs f0, .LCPI24_0@toc@l(r3)
; FAST-P9-NEXT: xssubdp f0, f1, f0 ; FAST-P9-NEXT: # kill: def $f1 killed $f1 def $vsl1
; FAST-P9-NEXT: fsel f1, f0, f2, f3 ; FAST-P9-NEXT: xscmpgedp vs0, vs1, vs0
; FAST-P9-NEXT: # kill: def $f3 killed $f3 def $vsl3
; FAST-P9-NEXT: # kill: def $f2 killed $f2 def $vsl2
; FAST-P9-NEXT: xxsel vs1, vs3, vs2, vs0
; FAST-P9-NEXT: # kill: def $f1 killed $f1 killed $vsl1
; FAST-P9-NEXT: blr ; FAST-P9-NEXT: blr
; ;
; NO-FAST-P8-LABEL: onecmp1: ; NO-FAST-P8-LABEL: onecmp1:
; NO-FAST-P8: # %bb.0: # %entry ; NO-FAST-P8: # %bb.0: # %entry
; NO-FAST-P8-NEXT: addis r3, r2, .LCPI24_0@toc@ha ; NO-FAST-P8-NEXT: addis r3, r2, .LCPI24_0@toc@ha
; NO-FAST-P8-NEXT: lfs f0, .LCPI24_0@toc@l(r3) ; NO-FAST-P8-NEXT: lfs f0, .LCPI24_0@toc@l(r3)
; NO-FAST-P8-NEXT: fcmpu cr0, f1, f0 ; NO-FAST-P8-NEXT: fcmpu cr0, f1, f0
; NO-FAST-P8-NEXT: cror 4*cr5+lt, lt, un ; NO-FAST-P8-NEXT: cror 4*cr5+lt, lt, un
Show All 21 Linesentry:
%z.y = select i1 %cmp, double %z, double %y %z.y = select i1 %cmp, double %z, double %y
ret double %z.y ret double %z.y
} }
define double @onecmp2(double %a, double %y, double %z) { define double @onecmp2(double %a, double %y, double %z) {
; FAST-P8-LABEL: onecmp2: ; FAST-P8-LABEL: onecmp2:
; FAST-P8: # %bb.0: # %entry ; FAST-P8: # %bb.0: # %entry
; FAST-P8-NEXT: addis r3, r2, .LCPI25_0@toc@ha ; FAST-P8-NEXT: addis r3, r2, .LCPI25_0@toc@ha
; FAST-P8-NEXT: # kill: def $f1 killed $f1 def $vsl1
; FAST-P8-NEXT: # kill: def $f3 killed $f3 def $vsl3
; FAST-P8-NEXT: # kill: def $f2 killed $f2 def $vsl2
; FAST-P8-NEXT: lfs f0, .LCPI25_0@toc@l(r3) ; FAST-P8-NEXT: lfs f0, .LCPI25_0@toc@l(r3)
; FAST-P8-NEXT: xssubdp f0, f0, f1 ; FAST-P8-NEXT: xvcmpgtdp vs0, vs1, vs0
; FAST-P8-NEXT: fsel f1, f0, f3, f2 ; FAST-P8-NEXT: xxsel vs1, vs3, vs2, vs0
; FAST-P8-NEXT: # kill: def $f1 killed $f1 killed $vsl1
; FAST-P8-NEXT: blr ; FAST-P8-NEXT: blr
; ;
; FAST-P9-LABEL: onecmp2: ; FAST-P9-LABEL: onecmp2:
; FAST-P9: # %bb.0: # %entry ; FAST-P9: # %bb.0: # %entry
; FAST-P9-NEXT: addis r3, r2, .LCPI25_0@toc@ha ; FAST-P9-NEXT: addis r3, r2, .LCPI25_0@toc@ha
; FAST-P9-NEXT: lfs f0, .LCPI25_0@toc@l(r3) ; FAST-P9-NEXT: lfs f0, .LCPI25_0@toc@l(r3)
; FAST-P9-NEXT: xssubdp f0, f0, f1 ; FAST-P9-NEXT: # kill: def $f1 killed $f1 def $vsl1
; FAST-P9-NEXT: fsel f1, f0, f3, f2 ; FAST-P9-NEXT: xscmpgtdp vs0, vs1, vs0
; FAST-P9-NEXT: # kill: def $f3 killed $f3 def $vsl3
; FAST-P9-NEXT: # kill: def $f2 killed $f2 def $vsl2
; FAST-P9-NEXT: xxsel vs1, vs3, vs2, vs0
; FAST-P9-NEXT: # kill: def $f1 killed $f1 killed $vsl1
; FAST-P9-NEXT: blr ; FAST-P9-NEXT: blr
; ;
; NO-FAST-P8-LABEL: onecmp2: ; NO-FAST-P8-LABEL: onecmp2:
; NO-FAST-P8: # %bb.0: # %entry ; NO-FAST-P8: # %bb.0: # %entry
; NO-FAST-P8-NEXT: addis r3, r2, .LCPI25_0@toc@ha ; NO-FAST-P8-NEXT: addis r3, r2, .LCPI25_0@toc@ha
; NO-FAST-P8-NEXT: lfs f0, .LCPI25_0@toc@l(r3) ; NO-FAST-P8-NEXT: lfs f0, .LCPI25_0@toc@l(r3)
; NO-FAST-P8-NEXT: xscmpudp cr0, f1, f0 ; NO-FAST-P8-NEXT: xscmpudp cr0, f1, f0
; NO-FAST-P8-NEXT: fmr f1, f2 ; NO-FAST-P8-NEXT: fmr f1, f2
Show All 18 Linesentry:
%y.z = select i1 %cmp, double %y, double %z %y.z = select i1 %cmp, double %y, double %z
ret double %y.z ret double %y.z
} }
define double @onecmp3(double %a, double %y, double %z) { define double @onecmp3(double %a, double %y, double %z) {
; FAST-P8-LABEL: onecmp3: ; FAST-P8-LABEL: onecmp3:
; FAST-P8: # %bb.0: # %entry ; FAST-P8: # %bb.0: # %entry
; FAST-P8-NEXT: addis r3, r2, .LCPI26_0@toc@ha ; FAST-P8-NEXT: addis r3, r2, .LCPI26_0@toc@ha
; FAST-P8-NEXT: # kill: def $f1 killed $f1 def $vsl1
; FAST-P8-NEXT: # kill: def $f3 killed $f3 def $vsl3
; FAST-P8-NEXT: # kill: def $f2 killed $f2 def $vsl2
; FAST-P8-NEXT: lfs f0, .LCPI26_0@toc@l(r3) ; FAST-P8-NEXT: lfs f0, .LCPI26_0@toc@l(r3)
; FAST-P8-NEXT: xssubdp f0, f1, f0 ; FAST-P8-NEXT: xvcmpeqdp vs0, vs1, vs0
; FAST-P8-NEXT: xsnegdp f1, f0 ; FAST-P8-NEXT: xxsel vs1, vs3, vs2, vs0
; FAST-P8-NEXT: fsel f0, f0, f2, f3 ; FAST-P8-NEXT: # kill: def $f1 killed $f1 killed $vsl1
; FAST-P8-NEXT: fsel f1, f1, f0, f3
; FAST-P8-NEXT: blr ; FAST-P8-NEXT: blr
; ;
; FAST-P9-LABEL: onecmp3: ; FAST-P9-LABEL: onecmp3:
; FAST-P9: # %bb.0: # %entry ; FAST-P9: # %bb.0: # %entry
; FAST-P9-NEXT: addis r3, r2, .LCPI26_0@toc@ha ; FAST-P9-NEXT: addis r3, r2, .LCPI26_0@toc@ha
; FAST-P9-NEXT: lfs f0, .LCPI26_0@toc@l(r3) ; FAST-P9-NEXT: lfs f0, .LCPI26_0@toc@l(r3)
; FAST-P9-NEXT: xssubdp f0, f1, f0 ; FAST-P9-NEXT: # kill: def $f1 killed $f1 def $vsl1
; FAST-P9-NEXT: fsel f1, f0, f2, f3 ; FAST-P9-NEXT: xscmpeqdp vs0, vs1, vs0
; FAST-P9-NEXT: xsnegdp f0, f0 ; FAST-P9-NEXT: # kill: def $f3 killed $f3 def $vsl3
; FAST-P9-NEXT: fsel f1, f0, f1, f3 ; FAST-P9-NEXT: # kill: def $f2 killed $f2 def $vsl2
; FAST-P9-NEXT: xxsel vs1, vs3, vs2, vs0
; FAST-P9-NEXT: # kill: def $f1 killed $f1 killed $vsl1
; FAST-P9-NEXT: blr ; FAST-P9-NEXT: blr
; ;
; NO-FAST-P8-LABEL: onecmp3: ; NO-FAST-P8-LABEL: onecmp3:
; NO-FAST-P8: # %bb.0: # %entry ; NO-FAST-P8: # %bb.0: # %entry
; NO-FAST-P8-NEXT: addis r3, r2, .LCPI26_0@toc@ha ; NO-FAST-P8-NEXT: addis r3, r2, .LCPI26_0@toc@ha
; NO-FAST-P8-NEXT: lfs f0, .LCPI26_0@toc@l(r3) ; NO-FAST-P8-NEXT: lfs f0, .LCPI26_0@toc@l(r3)
; NO-FAST-P8-NEXT: xscmpudp cr0, f1, f0 ; NO-FAST-P8-NEXT: xscmpudp cr0, f1, f0
; NO-FAST-P8-NEXT: fmr f1, f2 ; NO-FAST-P8-NEXT: fmr f1, f2
Show All 21 Lines

llvm/test/CodeGen/PowerPC/vec_select.ll

Show First 20 Lines • Show All 68 Lines • ▼ Show 20 Lines
define <4 x i32> @test5(<4 x i32> %a, <4 x i32> %b, <4 x i32> %c, <4 x i32> %d) { define <4 x i32> @test5(<4 x i32> %a, <4 x i32> %b, <4 x i32> %c, <4 x i32> %d) {
entry: entry:
%m = icmp eq <4 x i32> %c, %d %m = icmp eq <4 x i32> %c, %d
%v = select <4 x i1> %m, <4 x i32> %a, <4 x i32> %b %v = select <4 x i1> %m, <4 x i32> %a, <4 x i32> %b
ret <4 x i32> %v ret <4 x i32> %v
} }
; CHECK-VSX-LABLE: test5 ; CHECK-VSX-LABLE: test5
; CHECK-VSX: vcmpequw v[[REG1:[0-9]+]], v4, v5 ; CHECK-VSX: xvcmpeqdp vs[[REG1:[0-9]+]], v4, v5
; CHECK-VSX: xxsel v2, v3, v2, v[[REG1]] ; CHECK-VSX: xxsel v2, v3, v2, vs[[REG1]]
; CHECK-VSX: blr ; CHECK-VSX: blr
; CHECK-NOVSX-LABLE: test5 ; CHECK-NOVSX-LABLE: test5
; CHECK-NOVSX: vcmpequw v[[REG1:[0-9]+]], v4, v5 ; CHECK-NOVSX: vcmpequw v[[REG1:[0-9]+]], v4, v5
; CHECK-NOVSX: vsel v2, v3, v2, v[[REG1]] ; CHECK-NOVSX: vsel v2, v3, v2, v[[REG1]]
; CHECK-NOVSX: blr ; CHECK-NOVSX: blr
define <2 x i64> @test6(<2 x i64> %a, <2 x i64> %b, <2 x i64> %c, <2 x i64> %d) { define <2 x i64> @test6(<2 x i64> %a, <2 x i64> %b, <2 x i64> %c, <2 x i64> %d) {
Show All 14 Lines

llvm/test/CodeGen/PowerPC/vselect-constants.ll

Show All 24 Lines
; CHECK-NEXT: blr ; CHECK-NEXT: blr
%add = select <4 x i1> %cond, <4 x i32> <i32 3000, i32 1, i32 -1, i32 0>, <4 x i32> <i32 42, i32 0, i32 -2, i32 -1> %add = select <4 x i1> %cond, <4 x i32> <i32 3000, i32 1, i32 -1, i32 0>, <4 x i32> <i32 42, i32 0, i32 -2, i32 -1>
ret <4 x i32> %add ret <4 x i32> %add
} }
define <4 x i32> @cmp_sel_C1_or_C2_vec(<4 x i32> %x, <4 x i32> %y) { define <4 x i32> @cmp_sel_C1_or_C2_vec(<4 x i32> %x, <4 x i32> %y) {
; CHECK-LABEL: cmp_sel_C1_or_C2_vec: ; CHECK-LABEL: cmp_sel_C1_or_C2_vec:
; CHECK: # %bb.0: ; CHECK: # %bb.0:
; CHECK-NEXT: vcmpequw 2, 2, 3 ; CHECK-NEXT: xvcmpeqdp 0, 34, 35
; CHECK-NEXT: addis 3, 2, .LCPI1_0@toc@ha ; CHECK-NEXT: addis 3, 2, .LCPI1_0@toc@ha
; CHECK-NEXT: addis 4, 2, .LCPI1_1@toc@ha ; CHECK-NEXT: addis 4, 2, .LCPI1_1@toc@ha
; CHECK-NEXT: addi 3, 3, .LCPI1_0@toc@l ; CHECK-NEXT: addi 3, 3, .LCPI1_0@toc@l
; CHECK-NEXT: addi 4, 4, .LCPI1_1@toc@l ; CHECK-NEXT: addi 4, 4, .LCPI1_1@toc@l
; CHECK-NEXT: lvx 3, 0, 3 ; CHECK-NEXT: lvx 2, 0, 3
; CHECK-NEXT: lvx 4, 0, 4 ; CHECK-NEXT: lvx 3, 0, 4
; CHECK-NEXT: xxsel 34, 36, 35, 34 ; CHECK-NEXT: xxsel 34, 35, 34, 0
; CHECK-NEXT: blr ; CHECK-NEXT: blr
%cond = icmp eq <4 x i32> %x, %y %cond = icmp eq <4 x i32> %x, %y
%add = select <4 x i1> %cond, <4 x i32> <i32 3000, i32 1, i32 -1, i32 0>, <4 x i32> <i32 42, i32 0, i32 -2, i32 -1> %add = select <4 x i1> %cond, <4 x i32> <i32 3000, i32 1, i32 -1, i32 0>, <4 x i32> <i32 42, i32 0, i32 -2, i32 -1>
ret <4 x i32> %add ret <4 x i32> %add
} }
define <4 x i32> @sel_Cplus1_or_C_vec(<4 x i1> %cond) { define <4 x i32> @sel_Cplus1_or_C_vec(<4 x i1> %cond) {
; CHECK-LABEL: sel_Cplus1_or_C_vec: ; CHECK-LABEL: sel_Cplus1_or_C_vec:
▲ Show 20 Lines • Show All 148 Lines • Show Last 20 Lines

llvm/test/CodeGen/PowerPC/vsx.ll

Show First 20 Lines • Show All 566 Lines • ▼ Show 20 Lines
} }
define <4 x i32> @test20(<4 x i32> %a, <4 x i32> %b, <4 x i32> %c, <4 x i32> %d) { define <4 x i32> @test20(<4 x i32> %a, <4 x i32> %b, <4 x i32> %c, <4 x i32> %d) {
; CHECK-LABEL: test20: ; CHECK-LABEL: test20:
; CHECK: # %bb.0: # %entry ; CHECK: # %bb.0: # %entry
; CHECK-NEXT: vcmpequw v4, v4, v5 ; CHECK-NEXT: xvcmpeqdp vs0, v4, v5
; CHECK-NEXT: xxsel v2, v3, v2, v4 ; CHECK-NEXT: xxsel v2, v3, v2, vs0
; CHECK-NEXT: blr ; CHECK-NEXT: blr
; ;
; CHECK-REG-LABEL: test20: ; CHECK-REG-LABEL: test20:
; CHECK-REG: # %bb.0: # %entry ; CHECK-REG: # %bb.0: # %entry
; CHECK-REG-NEXT: vcmpequw v4, v4, v5 ; CHECK-REG-NEXT: xvcmpeqdp vs0, v4, v5
; CHECK-REG-NEXT: xxsel v2, v3, v2, v4 ; CHECK-REG-NEXT: xxsel v2, v3, v2, vs0
; CHECK-REG-NEXT: blr ; CHECK-REG-NEXT: blr
; ;
; CHECK-FISL-LABEL: test20: ; CHECK-FISL-LABEL: test20:
; CHECK-FISL: # %bb.0: # %entry ; CHECK-FISL: # %bb.0: # %entry
; CHECK-FISL-NEXT: vcmpequw v4, v4, v5 ; CHECK-FISL-NEXT: xvcmpeqdp vs0, v4, v5
; CHECK-FISL-NEXT: xxsel v2, v3, v2, v4 ; CHECK-FISL-NEXT: xxsel v2, v3, v2, vs0
; CHECK-FISL-NEXT: blr ; CHECK-FISL-NEXT: blr
; ;
; CHECK-LE-LABEL: test20: ; CHECK-LE-LABEL: test20:
; CHECK-LE: # %bb.0: # %entry ; CHECK-LE: # %bb.0: # %entry
; CHECK-LE-NEXT: vcmpequw v4, v4, v5 ; CHECK-LE-NEXT: xvcmpeqdp vs0, v4, v5
; CHECK-LE-NEXT: xxsel v2, v3, v2, v4 ; CHECK-LE-NEXT: xxsel v2, v3, v2, vs0
; CHECK-LE-NEXT: blr ; CHECK-LE-NEXT: blr
entry: entry:
%m = icmp eq <4 x i32> %c, %d %m = icmp eq <4 x i32> %c, %d
%v = select <4 x i1> %m, <4 x i32> %a, <4 x i32> %b %v = select <4 x i1> %m, <4 x i32> %a, <4 x i32> %b
ret <4 x i32> %v ret <4 x i32> %v
▲ Show 20 Lines • Show All 1,928 Lines • Show Last 20 Lines