This is an archive of the discontinued LLVM Phabricator instance.

Differential D58812

[ARM] Consider undefined-on-NaN conditions in checkVSELConstraints
ClosedPublic

Authored by olista01 on Mar 1 2019, 1:27 AM.

Details

Reviewers
efriedma
SjoerdMeijer
Commits
rGe019e6223b63: [ARM] Consider undefined-on-NaN conditions in checkVSELConstraints
rL355199: [ARM] Consider undefined-on-NaN conditions in checkVSELConstraints
Summary

This function was not checking for the condition code variants which are undefined if either input is NaN, so we were missing selection of the VSEL instruction in some cases when using -fno-honor-nans or -ffast-math.

Diff Detail

Repository
rL LLVM

Event Timeline

olista01 created this revision.Mar 1 2019, 1:27 AM
Herald added a project: Restricted Project. · View Herald TranscriptMar 1 2019, 1:27 AM
Herald added subscribers: kristof.beyls, javed.absar. · View Herald Transcript
olista01 added a child revision: D58813: [ARM] Fix select_cc lowering for fp16.Mar 1 2019, 1:28 AM
SjoerdMeijer accepted this revision.Mar 1 2019, 3:54 AM

Looks like a good fix to me

This revision is now accepted and ready to land.Mar 1 2019, 3:54 AM
Closed by commit rL355199: [ARM] Consider undefined-on-NaN conditions in checkVSELConstraints (authored by olista01). · Explain WhyMar 1 2019, 5:57 AM
This revision was automatically updated to reflect the committed changes.

Revision Contents

PathSize
llvm/
trunk/
lib/
Target/
ARM/
11 lines
test/
CodeGen/
ARM/
285 lines

Diff 188891

llvm/trunk/lib/Target/ARM/ARMISelLowering.cpp

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 4,168 Lines • ▼ Show 20 Lines return DAG.getSelectCC(dl, Cond,
SelectTrue, SelectFalse, ISD::SETNE); SelectTrue, SelectFalse, ISD::SETNE);
} }
static void checkVSELConstraints(ISD::CondCode CC, ARMCC::CondCodes &CondCode, static void checkVSELConstraints(ISD::CondCode CC, ARMCC::CondCodes &CondCode,
bool &swpCmpOps, bool &swpVselOps) { bool &swpCmpOps, bool &swpVselOps) {
// Start by selecting the GE condition code for opcodes that return true for // Start by selecting the GE condition code for opcodes that return true for
// 'equality' // 'equality'
if (CC == ISD::SETUGE || CC == ISD::SETOGE || CC == ISD::SETOLE || if (CC == ISD::SETUGE || CC == ISD::SETOGE || CC == ISD::SETOLE ||
CC == ISD::SETULE) CC == ISD::SETULE || CC == ISD::SETGE || CC == ISD::SETLE)
CondCode = ARMCC::GE; CondCode = ARMCC::GE;
// and GT for opcodes that return false for 'equality'. // and GT for opcodes that return false for 'equality'.
else if (CC == ISD::SETUGT || CC == ISD::SETOGT || CC == ISD::SETOLT || else if (CC == ISD::SETUGT || CC == ISD::SETOGT || CC == ISD::SETOLT ||
CC == ISD::SETULT) CC == ISD::SETULT || CC == ISD::SETGT || CC == ISD::SETLT)
CondCode = ARMCC::GT; CondCode = ARMCC::GT;
// Since we are constrained to GE/GT, if the opcode contains 'less', we need // Since we are constrained to GE/GT, if the opcode contains 'less', we need
// to swap the compare operands. // to swap the compare operands.
if (CC == ISD::SETOLE || CC == ISD::SETULE || CC == ISD::SETOLT || if (CC == ISD::SETOLE || CC == ISD::SETULE || CC == ISD::SETOLT ||
CC == ISD::SETULT) CC == ISD::SETULT || CC == ISD::SETLE || CC == ISD::SETLT)
swpCmpOps = true; swpCmpOps = true;
// Both GT and GE are ordered comparisons, and return false for 'unordered'. // Both GT and GE are ordered comparisons, and return false for 'unordered'.
// If we have an unordered opcode, we need to swap the operands to the VSEL // If we have an unordered opcode, we need to swap the operands to the VSEL
// instruction (effectively negating the condition). // instruction (effectively negating the condition).
// //
// This also has the effect of swapping which one of 'less' or 'greater' // This also has the effect of swapping which one of 'less' or 'greater'
// returns true, so we also swap the compare operands. It also switches // returns true, so we also swap the compare operands. It also switches
Show All 9 Linesstatic void checkVSELConstraints(ISD::CondCode CC, ARMCC::CondCodes &CondCode,
// 'ordered' is 'anything but unordered', so use the VS condition code and // 'ordered' is 'anything but unordered', so use the VS condition code and
// swap the VSEL operands. // swap the VSEL operands.
if (CC == ISD::SETO) { if (CC == ISD::SETO) {
CondCode = ARMCC::VS; CondCode = ARMCC::VS;
swpVselOps = true; swpVselOps = true;
} }
// 'unordered or not equal' is 'anything but equal', so use the EQ condition // 'unordered or not equal' is 'anything but equal', so use the EQ condition
// code and swap the VSEL operands. // code and swap the VSEL operands. Also do this if we don't care about the
if (CC == ISD::SETUNE) { // unordered case.
if (CC == ISD::SETUNE || CC == ISD::SETNE) {
CondCode = ARMCC::EQ; CondCode = ARMCC::EQ;
swpVselOps = true; swpVselOps = true;
} }
} }
SDValue ARMTargetLowering::getCMOV(const SDLoc &dl, EVT VT, SDValue FalseVal, SDValue ARMTargetLowering::getCMOV(const SDLoc &dl, EVT VT, SDValue FalseVal,
SDValue TrueVal, SDValue ARMcc, SDValue CCR, SDValue TrueVal, SDValue ARMcc, SDValue CCR,
SDValue Cmp, SelectionDAG &DAG) const { SDValue Cmp, SelectionDAG &DAG) const {
▲ Show 20 Lines • Show All 11,024 Lines • Show Last 20 Lines

llvm/trunk/test/CodeGen/ARM/vsel.ll

; RUN: llc < %s -mtriple=armv8-linux-gnueabihf -mattr=+fp-armv8 -float-abi=hard | FileCheck %s ; RUN: llc < %s -mtriple=armv8-linux-gnueabihf -mattr=+fp-armv8 -float-abi=hard | FileCheck %s
@varfloat = global float 0.0 @varfloat = global float 0.0
@vardouble = global double 0.0 @vardouble = global double 0.0
define void @test_vsel32sgt(i32 %lhs32, i32 %rhs32, float %a, float %b) { define void @test_vsel32sgt(i32 %lhs32, i32 %rhs32, float %a, float %b) {
; CHECK: test_vsel32sgt ; CHECK-LABEL: test_vsel32sgt
%tst1 = icmp sgt i32 %lhs32, %rhs32 %tst1 = icmp sgt i32 %lhs32, %rhs32
%val1 = select i1 %tst1, float %a, float %b %val1 = select i1 %tst1, float %a, float %b
store float %val1, float* @varfloat store float %val1, float* @varfloat
; CHECK: cmp r0, r1 ; CHECK: cmp r0, r1
; CHECK: vselgt.f32 s0, s0, s1 ; CHECK: vselgt.f32 s0, s0, s1
ret void ret void
} }
define void @test_vsel64sgt(i32 %lhs32, i32 %rhs32, double %a, double %b) { define void @test_vsel64sgt(i32 %lhs32, i32 %rhs32, double %a, double %b) {
; CHECK: test_vsel64sgt ; CHECK-LABEL: test_vsel64sgt
%tst1 = icmp sgt i32 %lhs32, %rhs32 %tst1 = icmp sgt i32 %lhs32, %rhs32
%val1 = select i1 %tst1, double %a, double %b %val1 = select i1 %tst1, double %a, double %b
store double %val1, double* @vardouble store double %val1, double* @vardouble
; CHECK: cmp r0, r1 ; CHECK: cmp r0, r1
; CHECK: vselgt.f64 d16, d0, d1 ; CHECK: vselgt.f64 d16, d0, d1
ret void ret void
} }
define void @test_vsel32sge(i32 %lhs32, i32 %rhs32, float %a, float %b) { define void @test_vsel32sge(i32 %lhs32, i32 %rhs32, float %a, float %b) {
; CHECK: test_vsel32sge ; CHECK-LABEL: test_vsel32sge
%tst1 = icmp sge i32 %lhs32, %rhs32 %tst1 = icmp sge i32 %lhs32, %rhs32
%val1 = select i1 %tst1, float %a, float %b %val1 = select i1 %tst1, float %a, float %b
store float %val1, float* @varfloat store float %val1, float* @varfloat
; CHECK: cmp r0, r1 ; CHECK: cmp r0, r1
; CHECK: vselge.f32 s0, s0, s1 ; CHECK: vselge.f32 s0, s0, s1
ret void ret void
} }
define void @test_vsel64sge(i32 %lhs32, i32 %rhs32, double %a, double %b) { define void @test_vsel64sge(i32 %lhs32, i32 %rhs32, double %a, double %b) {
; CHECK: test_vsel64sge ; CHECK-LABEL: test_vsel64sge
%tst1 = icmp sge i32 %lhs32, %rhs32 %tst1 = icmp sge i32 %lhs32, %rhs32
%val1 = select i1 %tst1, double %a, double %b %val1 = select i1 %tst1, double %a, double %b
store double %val1, double* @vardouble store double %val1, double* @vardouble
; CHECK: cmp r0, r1 ; CHECK: cmp r0, r1
; CHECK: vselge.f64 d16, d0, d1 ; CHECK: vselge.f64 d16, d0, d1
ret void ret void
} }
define void @test_vsel32eq(i32 %lhs32, i32 %rhs32, float %a, float %b) { define void @test_vsel32eq(i32 %lhs32, i32 %rhs32, float %a, float %b) {
; CHECK: test_vsel32eq ; CHECK-LABEL: test_vsel32eq
%tst1 = icmp eq i32 %lhs32, %rhs32 %tst1 = icmp eq i32 %lhs32, %rhs32
%val1 = select i1 %tst1, float %a, float %b %val1 = select i1 %tst1, float %a, float %b
store float %val1, float* @varfloat store float %val1, float* @varfloat
; CHECK: cmp r0, r1 ; CHECK: cmp r0, r1
; CHECK: vseleq.f32 s0, s0, s1 ; CHECK: vseleq.f32 s0, s0, s1
ret void ret void
} }
define void @test_vsel64eq(i32 %lhs32, i32 %rhs32, double %a, double %b) { define void @test_vsel64eq(i32 %lhs32, i32 %rhs32, double %a, double %b) {
; CHECK: test_vsel64eq ; CHECK-LABEL: test_vsel64eq
%tst1 = icmp eq i32 %lhs32, %rhs32 %tst1 = icmp eq i32 %lhs32, %rhs32
%val1 = select i1 %tst1, double %a, double %b %val1 = select i1 %tst1, double %a, double %b
store double %val1, double* @vardouble store double %val1, double* @vardouble
; CHECK: cmp r0, r1 ; CHECK: cmp r0, r1
; CHECK: vseleq.f64 d16, d0, d1 ; CHECK: vseleq.f64 d16, d0, d1
ret void ret void
} }
define void @test_vsel32slt(i32 %lhs32, i32 %rhs32, float %a, float %b) { define void @test_vsel32slt(i32 %lhs32, i32 %rhs32, float %a, float %b) {
; CHECK: test_vsel32slt ; CHECK-LABEL: test_vsel32slt
%tst1 = icmp slt i32 %lhs32, %rhs32 %tst1 = icmp slt i32 %lhs32, %rhs32
%val1 = select i1 %tst1, float %a, float %b %val1 = select i1 %tst1, float %a, float %b
store float %val1, float* @varfloat store float %val1, float* @varfloat
; CHECK: cmp r0, r1 ; CHECK: cmp r0, r1
; CHECK: vselge.f32 s0, s1, s0 ; CHECK: vselge.f32 s0, s1, s0
ret void ret void
} }
define void @test_vsel64slt(i32 %lhs32, i32 %rhs32, double %a, double %b) { define void @test_vsel64slt(i32 %lhs32, i32 %rhs32, double %a, double %b) {
; CHECK: test_vsel64slt ; CHECK-LABEL: test_vsel64slt
%tst1 = icmp slt i32 %lhs32, %rhs32 %tst1 = icmp slt i32 %lhs32, %rhs32
%val1 = select i1 %tst1, double %a, double %b %val1 = select i1 %tst1, double %a, double %b
store double %val1, double* @vardouble store double %val1, double* @vardouble
; CHECK: cmp r0, r1 ; CHECK: cmp r0, r1
; CHECK: vselge.f64 d16, d1, d0 ; CHECK: vselge.f64 d16, d1, d0
ret void ret void
} }
define void @test_vsel32sle(i32 %lhs32, i32 %rhs32, float %a, float %b) { define void @test_vsel32sle(i32 %lhs32, i32 %rhs32, float %a, float %b) {
; CHECK: test_vsel32sle ; CHECK-LABEL: test_vsel32sle
%tst1 = icmp sle i32 %lhs32, %rhs32 %tst1 = icmp sle i32 %lhs32, %rhs32
%val1 = select i1 %tst1, float %a, float %b %val1 = select i1 %tst1, float %a, float %b
store float %val1, float* @varfloat store float %val1, float* @varfloat
; CHECK: cmp r0, r1 ; CHECK: cmp r0, r1
; CHECK: vselgt.f32 s0, s1, s0 ; CHECK: vselgt.f32 s0, s1, s0
ret void ret void
} }
define void @test_vsel64sle(i32 %lhs32, i32 %rhs32, double %a, double %b) { define void @test_vsel64sle(i32 %lhs32, i32 %rhs32, double %a, double %b) {
; CHECK: test_vsel64sle ; CHECK-LABEL: test_vsel64sle
%tst1 = icmp sle i32 %lhs32, %rhs32 %tst1 = icmp sle i32 %lhs32, %rhs32
%val1 = select i1 %tst1, double %a, double %b %val1 = select i1 %tst1, double %a, double %b
store double %val1, double* @vardouble store double %val1, double* @vardouble
; CHECK: cmp r0, r1 ; CHECK: cmp r0, r1
; CHECK: vselgt.f64 d16, d1, d0 ; CHECK: vselgt.f64 d16, d1, d0
ret void ret void
} }
define void @test_vsel32ogt(float %lhs32, float %rhs32, float %a, float %b) { define void @test_vsel32ogt(float %lhs32, float %rhs32, float %a, float %b) {
; CHECK: test_vsel32ogt ; CHECK-LABEL: test_vsel32ogt
%tst1 = fcmp ogt float %lhs32, %rhs32 %tst1 = fcmp ogt float %lhs32, %rhs32
%val1 = select i1 %tst1, float %a, float %b %val1 = select i1 %tst1, float %a, float %b
store float %val1, float* @varfloat store float %val1, float* @varfloat
; CHECK: vcmpe.f32 s0, s1 ; CHECK: vcmpe.f32 s0, s1
; CHECK: vselgt.f32 s0, s2, s3 ; CHECK: vselgt.f32 s0, s2, s3
ret void ret void
} }
define void @test_vsel64ogt(float %lhs32, float %rhs32, double %a, double %b) { define void @test_vsel64ogt(float %lhs32, float %rhs32, double %a, double %b) {
; CHECK: test_vsel64ogt ; CHECK-LABEL: test_vsel64ogt
%tst1 = fcmp ogt float %lhs32, %rhs32 %tst1 = fcmp ogt float %lhs32, %rhs32
%val1 = select i1 %tst1, double %a, double %b %val1 = select i1 %tst1, double %a, double %b
store double %val1, double* @vardouble store double %val1, double* @vardouble
; CHECK: vcmpe.f32 s0, s1 ; CHECK: vcmpe.f32 s0, s1
; CHECK: vselgt.f64 d16, d1, d2 ; CHECK: vselgt.f64 d16, d1, d2
ret void ret void
} }
define void @test_vsel32oge(float %lhs32, float %rhs32, float %a, float %b) { define void @test_vsel32oge(float %lhs32, float %rhs32, float %a, float %b) {
; CHECK: test_vsel32oge ; CHECK-LABEL: test_vsel32oge
%tst1 = fcmp oge float %lhs32, %rhs32 %tst1 = fcmp oge float %lhs32, %rhs32
%val1 = select i1 %tst1, float %a, float %b %val1 = select i1 %tst1, float %a, float %b
store float %val1, float* @varfloat store float %val1, float* @varfloat
; CHECK: vcmpe.f32 s0, s1 ; CHECK: vcmpe.f32 s0, s1
; CHECK: vselge.f32 s0, s2, s3 ; CHECK: vselge.f32 s0, s2, s3
ret void ret void
} }
define void @test_vsel64oge(float %lhs32, float %rhs32, double %a, double %b) { define void @test_vsel64oge(float %lhs32, float %rhs32, double %a, double %b) {
; CHECK: test_vsel64oge ; CHECK-LABEL: test_vsel64oge
%tst1 = fcmp oge float %lhs32, %rhs32 %tst1 = fcmp oge float %lhs32, %rhs32
%val1 = select i1 %tst1, double %a, double %b %val1 = select i1 %tst1, double %a, double %b
store double %val1, double* @vardouble store double %val1, double* @vardouble
; CHECK: vcmpe.f32 s0, s1 ; CHECK: vcmpe.f32 s0, s1
; CHECK: vselge.f64 d16, d1, d2 ; CHECK: vselge.f64 d16, d1, d2
ret void ret void
} }
define void @test_vsel32oeq(float %lhs32, float %rhs32, float %a, float %b) { define void @test_vsel32oeq(float %lhs32, float %rhs32, float %a, float %b) {
; CHECK: test_vsel32oeq ; CHECK-LABEL: test_vsel32oeq
%tst1 = fcmp oeq float %lhs32, %rhs32 %tst1 = fcmp oeq float %lhs32, %rhs32
%val1 = select i1 %tst1, float %a, float %b %val1 = select i1 %tst1, float %a, float %b
store float %val1, float* @varfloat store float %val1, float* @varfloat
; CHECK: vcmp.f32 s0, s1 ; CHECK: vcmp.f32 s0, s1
; CHECK: vseleq.f32 s0, s2, s3 ; CHECK: vseleq.f32 s0, s2, s3
ret void ret void
} }
define void @test_vsel64oeq(float %lhs32, float %rhs32, double %a, double %b) { define void @test_vsel64oeq(float %lhs32, float %rhs32, double %a, double %b) {
; CHECK: test_vsel64oeq ; CHECK-LABEL: test_vsel64oeq
%tst1 = fcmp oeq float %lhs32, %rhs32 %tst1 = fcmp oeq float %lhs32, %rhs32
%val1 = select i1 %tst1, double %a, double %b %val1 = select i1 %tst1, double %a, double %b
store double %val1, double* @vardouble store double %val1, double* @vardouble
; CHECK: vcmp.f32 s0, s1 ; CHECK: vcmp.f32 s0, s1
; CHECK: vseleq.f64 d16, d1, d2 ; CHECK: vseleq.f64 d16, d1, d2
ret void ret void
} }
define void @test_vsel32ugt(float %lhs32, float %rhs32, float %a, float %b) { define void @test_vsel32ugt(float %lhs32, float %rhs32, float %a, float %b) {
; CHECK: test_vsel32ugt ; CHECK-LABEL: test_vsel32ugt
%tst1 = fcmp ugt float %lhs32, %rhs32 %tst1 = fcmp ugt float %lhs32, %rhs32
%val1 = select i1 %tst1, float %a, float %b %val1 = select i1 %tst1, float %a, float %b
store float %val1, float* @varfloat store float %val1, float* @varfloat
; CHECK: vcmpe.f32 s1, s0 ; CHECK: vcmpe.f32 s1, s0
; CHECK: vselge.f32 s0, s3, s2 ; CHECK: vselge.f32 s0, s3, s2
ret void ret void
} }
define void @test_vsel64ugt(float %lhs32, float %rhs32, double %a, double %b) { define void @test_vsel64ugt(float %lhs32, float %rhs32, double %a, double %b) {
; CHECK: test_vsel64ugt ; CHECK-LABEL: test_vsel64ugt
%tst1 = fcmp ugt float %lhs32, %rhs32 %tst1 = fcmp ugt float %lhs32, %rhs32
%val1 = select i1 %tst1, double %a, double %b %val1 = select i1 %tst1, double %a, double %b
store double %val1, double* @vardouble store double %val1, double* @vardouble
; CHECK: vcmpe.f32 s1, s0 ; CHECK: vcmpe.f32 s1, s0
; CHECK: vselge.f64 d16, d2, d1 ; CHECK: vselge.f64 d16, d2, d1
ret void ret void
} }
define void @test_vsel32uge(float %lhs32, float %rhs32, float %a, float %b) { define void @test_vsel32uge(float %lhs32, float %rhs32, float %a, float %b) {
; CHECK: test_vsel32uge ; CHECK-LABEL: test_vsel32uge
%tst1 = fcmp uge float %lhs32, %rhs32 %tst1 = fcmp uge float %lhs32, %rhs32
%val1 = select i1 %tst1, float %a, float %b %val1 = select i1 %tst1, float %a, float %b
store float %val1, float* @varfloat store float %val1, float* @varfloat
; CHECK: vcmpe.f32 s1, s0 ; CHECK: vcmpe.f32 s1, s0
; CHECK: vselgt.f32 s0, s3, s2 ; CHECK: vselgt.f32 s0, s3, s2
ret void ret void
} }
define void @test_vsel64uge(float %lhs32, float %rhs32, double %a, double %b) { define void @test_vsel64uge(float %lhs32, float %rhs32, double %a, double %b) {
; CHECK: test_vsel64uge ; CHECK-LABEL: test_vsel64uge
%tst1 = fcmp uge float %lhs32, %rhs32 %tst1 = fcmp uge float %lhs32, %rhs32
%val1 = select i1 %tst1, double %a, double %b %val1 = select i1 %tst1, double %a, double %b
store double %val1, double* @vardouble store double %val1, double* @vardouble
; CHECK: vcmpe.f32 s1, s0 ; CHECK: vcmpe.f32 s1, s0
; CHECK: vselgt.f64 d16, d2, d1 ; CHECK: vselgt.f64 d16, d2, d1
ret void ret void
} }
define void @test_vsel32olt(float %lhs32, float %rhs32, float %a, float %b) { define void @test_vsel32olt(float %lhs32, float %rhs32, float %a, float %b) {
; CHECK: test_vsel32olt ; CHECK-LABEL: test_vsel32olt
%tst1 = fcmp olt float %lhs32, %rhs32 %tst1 = fcmp olt float %lhs32, %rhs32
%val1 = select i1 %tst1, float %a, float %b %val1 = select i1 %tst1, float %a, float %b
store float %val1, float* @varfloat store float %val1, float* @varfloat
; CHECK: vcmpe.f32 s1, s0 ; CHECK: vcmpe.f32 s1, s0
; CHECK: vselgt.f32 s0, s2, s3 ; CHECK: vselgt.f32 s0, s2, s3
ret void ret void
} }
define void @test_vsel64olt(float %lhs32, float %rhs32, double %a, double %b) { define void @test_vsel64olt(float %lhs32, float %rhs32, double %a, double %b) {
; CHECK: test_vsel64olt ; CHECK-LABEL: test_vsel64olt
%tst1 = fcmp olt float %lhs32, %rhs32 %tst1 = fcmp olt float %lhs32, %rhs32
%val1 = select i1 %tst1, double %a, double %b %val1 = select i1 %tst1, double %a, double %b
store double %val1, double* @vardouble store double %val1, double* @vardouble
; CHECK: vcmpe.f32 s1, s0 ; CHECK: vcmpe.f32 s1, s0
; CHECK: vselgt.f64 d16, d1, d2 ; CHECK: vselgt.f64 d16, d1, d2
ret void ret void
} }
define void @test_vsel32ult(float %lhs32, float %rhs32, float %a, float %b) { define void @test_vsel32ult(float %lhs32, float %rhs32, float %a, float %b) {
; CHECK: test_vsel32ult ; CHECK-LABEL: test_vsel32ult
%tst1 = fcmp ult float %lhs32, %rhs32 %tst1 = fcmp ult float %lhs32, %rhs32
%val1 = select i1 %tst1, float %a, float %b %val1 = select i1 %tst1, float %a, float %b
store float %val1, float* @varfloat store float %val1, float* @varfloat
; CHECK: vcmpe.f32 s0, s1 ; CHECK: vcmpe.f32 s0, s1
; CHECK: vselge.f32 s0, s3, s2 ; CHECK: vselge.f32 s0, s3, s2
ret void ret void
} }
define void @test_vsel64ult(float %lhs32, float %rhs32, double %a, double %b) { define void @test_vsel64ult(float %lhs32, float %rhs32, double %a, double %b) {
; CHECK: test_vsel64ult ; CHECK-LABEL: test_vsel64ult
%tst1 = fcmp ult float %lhs32, %rhs32 %tst1 = fcmp ult float %lhs32, %rhs32
%val1 = select i1 %tst1, double %a, double %b %val1 = select i1 %tst1, double %a, double %b
store double %val1, double* @vardouble store double %val1, double* @vardouble
; CHECK: vcmpe.f32 s0, s1 ; CHECK: vcmpe.f32 s0, s1
; CHECK: vselge.f64 d16, d2, d1 ; CHECK: vselge.f64 d16, d2, d1
ret void ret void
} }
define void @test_vsel32ole(float %lhs32, float %rhs32, float %a, float %b) { define void @test_vsel32ole(float %lhs32, float %rhs32, float %a, float %b) {
; CHECK: test_vsel32ole ; CHECK-LABEL: test_vsel32ole
%tst1 = fcmp ole float %lhs32, %rhs32 %tst1 = fcmp ole float %lhs32, %rhs32
%val1 = select i1 %tst1, float %a, float %b %val1 = select i1 %tst1, float %a, float %b
store float %val1, float* @varfloat store float %val1, float* @varfloat
; CHECK: vcmpe.f32 s1, s0 ; CHECK: vcmpe.f32 s1, s0
; CHECK: vselge.f32 s0, s2, s3 ; CHECK: vselge.f32 s0, s2, s3
ret void ret void
} }
define void @test_vsel64ole(float %lhs32, float %rhs32, double %a, double %b) { define void @test_vsel64ole(float %lhs32, float %rhs32, double %a, double %b) {
; CHECK: test_vsel64ole ; CHECK-LABEL: test_vsel64ole
%tst1 = fcmp ole float %lhs32, %rhs32 %tst1 = fcmp ole float %lhs32, %rhs32
%val1 = select i1 %tst1, double %a, double %b %val1 = select i1 %tst1, double %a, double %b
store double %val1, double* @vardouble store double %val1, double* @vardouble
; CHECK: vcmpe.f32 s1, s0 ; CHECK: vcmpe.f32 s1, s0
; CHECK: vselge.f64 d16, d1, d2 ; CHECK: vselge.f64 d16, d1, d2
ret void ret void
} }
define void @test_vsel32ule(float %lhs32, float %rhs32, float %a, float %b) { define void @test_vsel32ule(float %lhs32, float %rhs32, float %a, float %b) {
; CHECK: test_vsel32ule ; CHECK-LABEL: test_vsel32ule
%tst1 = fcmp ule float %lhs32, %rhs32 %tst1 = fcmp ule float %lhs32, %rhs32
%val1 = select i1 %tst1, float %a, float %b %val1 = select i1 %tst1, float %a, float %b
store float %val1, float* @varfloat store float %val1, float* @varfloat
; CHECK: vcmpe.f32 s0, s1 ; CHECK: vcmpe.f32 s0, s1
; CHECK: vselgt.f32 s0, s3, s2 ; CHECK: vselgt.f32 s0, s3, s2
ret void ret void
} }
define void @test_vsel64ule(float %lhs32, float %rhs32, double %a, double %b) { define void @test_vsel64ule(float %lhs32, float %rhs32, double %a, double %b) {
; CHECK: test_vsel64ule ; CHECK-LABEL: test_vsel64ule
%tst1 = fcmp ule float %lhs32, %rhs32 %tst1 = fcmp ule float %lhs32, %rhs32
%val1 = select i1 %tst1, double %a, double %b %val1 = select i1 %tst1, double %a, double %b
store double %val1, double* @vardouble store double %val1, double* @vardouble
; CHECK: vcmpe.f32 s0, s1 ; CHECK: vcmpe.f32 s0, s1
; CHECK: vselgt.f64 d16, d2, d1 ; CHECK: vselgt.f64 d16, d2, d1
ret void ret void
} }
define void @test_vsel32ord(float %lhs32, float %rhs32, float %a, float %b) { define void @test_vsel32ord(float %lhs32, float %rhs32, float %a, float %b) {
; CHECK: test_vsel32ord ; CHECK-LABEL: test_vsel32ord
%tst1 = fcmp ord float %lhs32, %rhs32 %tst1 = fcmp ord float %lhs32, %rhs32
%val1 = select i1 %tst1, float %a, float %b %val1 = select i1 %tst1, float %a, float %b
store float %val1, float* @varfloat store float %val1, float* @varfloat
; CHECK: vcmpe.f32 s0, s1 ; CHECK: vcmpe.f32 s0, s1
; CHECK: vselvs.f32 s0, s3, s2 ; CHECK: vselvs.f32 s0, s3, s2
ret void ret void
} }
define void @test_vsel64ord(float %lhs32, float %rhs32, double %a, double %b) { define void @test_vsel64ord(float %lhs32, float %rhs32, double %a, double %b) {
; CHECK: test_vsel64ord ; CHECK-LABEL: test_vsel64ord
%tst1 = fcmp ord float %lhs32, %rhs32 %tst1 = fcmp ord float %lhs32, %rhs32
%val1 = select i1 %tst1, double %a, double %b %val1 = select i1 %tst1, double %a, double %b
store double %val1, double* @vardouble store double %val1, double* @vardouble
; CHECK: vcmpe.f32 s0, s1 ; CHECK: vcmpe.f32 s0, s1
; CHECK: vselvs.f64 d16, d2, d1 ; CHECK: vselvs.f64 d16, d2, d1
ret void ret void
} }
define void @test_vsel32une(float %lhs32, float %rhs32, float %a, float %b) { define void @test_vsel32une(float %lhs32, float %rhs32, float %a, float %b) {
; CHECK: test_vsel32une ; CHECK-LABEL: test_vsel32une
%tst1 = fcmp une float %lhs32, %rhs32 %tst1 = fcmp une float %lhs32, %rhs32
%val1 = select i1 %tst1, float %a, float %b %val1 = select i1 %tst1, float %a, float %b
store float %val1, float* @varfloat store float %val1, float* @varfloat
; CHECK: vcmp.f32 s0, s1 ; CHECK: vcmp.f32 s0, s1
; CHECK: vseleq.f32 s0, s3, s2 ; CHECK: vseleq.f32 s0, s3, s2
ret void ret void
} }
define void @test_vsel64une(float %lhs32, float %rhs32, double %a, double %b) { define void @test_vsel64une(float %lhs32, float %rhs32, double %a, double %b) {
; CHECK: test_vsel64une ; CHECK-LABEL: test_vsel64une
%tst1 = fcmp une float %lhs32, %rhs32 %tst1 = fcmp une float %lhs32, %rhs32
%val1 = select i1 %tst1, double %a, double %b %val1 = select i1 %tst1, double %a, double %b
store double %val1, double* @vardouble store double %val1, double* @vardouble
; CHECK: vcmp.f32 s0, s1 ; CHECK: vcmp.f32 s0, s1
; CHECK: vseleq.f64 d16, d2, d1 ; CHECK: vseleq.f64 d16, d2, d1
ret void ret void
} }
define void @test_vsel32uno(float %lhs32, float %rhs32, float %a, float %b) { define void @test_vsel32uno(float %lhs32, float %rhs32, float %a, float %b) {
; CHECK: test_vsel32uno ; CHECK-LABEL: test_vsel32uno
%tst1 = fcmp uno float %lhs32, %rhs32 %tst1 = fcmp uno float %lhs32, %rhs32
%val1 = select i1 %tst1, float %a, float %b %val1 = select i1 %tst1, float %a, float %b
store float %val1, float* @varfloat store float %val1, float* @varfloat
; CHECK: vcmpe.f32 s0, s1 ; CHECK: vcmpe.f32 s0, s1
; CHECK: vselvs.f32 s0, s2, s3 ; CHECK: vselvs.f32 s0, s2, s3
ret void ret void
} }
define void @test_vsel64uno(float %lhs32, float %rhs32, double %a, double %b) { define void @test_vsel64uno(float %lhs32, float %rhs32, double %a, double %b) {
; CHECK: test_vsel64uno ; CHECK-LABEL: test_vsel64uno
%tst1 = fcmp uno float %lhs32, %rhs32 %tst1 = fcmp uno float %lhs32, %rhs32
%val1 = select i1 %tst1, double %a, double %b %val1 = select i1 %tst1, double %a, double %b
store double %val1, double* @vardouble store double %val1, double* @vardouble
; CHECK: vcmpe.f32 s0, s1 ; CHECK: vcmpe.f32 s0, s1
; CHECK: vselvs.f64 d16, d1, d2 ; CHECK: vselvs.f64 d16, d1, d2
ret void ret void
} }
define void @test_vsel32ogt_nnan(float %lhs32, float %rhs32, float %a, float %b) {
; CHECK-LABEL: test_vsel32ogt_nnan
%tst1 = fcmp nnan ogt float %lhs32, %rhs32
%val1 = select i1 %tst1, float %a, float %b
store float %val1, float* @varfloat
; CHECK: vcmpe.f32 s0, s1
; CHECK: vselgt.f32 s0, s2, s3
ret void
}
define void @test_vsel64ogt_nnan(float %lhs32, float %rhs32, double %a, double %b) {
; CHECK-LABEL: test_vsel64ogt_nnan
%tst1 = fcmp nnan ogt float %lhs32, %rhs32
%val1 = select i1 %tst1, double %a, double %b
store double %val1, double* @vardouble
; CHECK: vcmpe.f32 s0, s1
; CHECK: vselgt.f64 d16, d1, d2
ret void
}
define void @test_vsel32oge_nnan(float %lhs32, float %rhs32, float %a, float %b) {
; CHECK-LABEL: test_vsel32oge_nnan
%tst1 = fcmp nnan oge float %lhs32, %rhs32
%val1 = select i1 %tst1, float %a, float %b
store float %val1, float* @varfloat
; CHECK: vcmpe.f32 s0, s1
; CHECK: vselge.f32 s0, s2, s3
ret void
}
define void @test_vsel64oge_nnan(float %lhs32, float %rhs32, double %a, double %b) {
; CHECK-LABEL: test_vsel64oge_nnan
%tst1 = fcmp nnan oge float %lhs32, %rhs32
%val1 = select i1 %tst1, double %a, double %b
store double %val1, double* @vardouble
; CHECK: vcmpe.f32 s0, s1
; CHECK: vselge.f64 d16, d1, d2
ret void
}
define void @test_vsel32oeq_nnan(float %lhs32, float %rhs32, float %a, float %b) {
; CHECK-LABEL: test_vsel32oeq_nnan
%tst1 = fcmp nnan oeq float %lhs32, %rhs32
%val1 = select i1 %tst1, float %a, float %b
store float %val1, float* @varfloat
; CHECK: vcmp.f32 s0, s1
; CHECK: vseleq.f32 s0, s2, s3
ret void
}
define void @test_vsel64oeq_nnan(float %lhs32, float %rhs32, double %a, double %b) {
; CHECK-LABEL: test_vsel64oeq_nnan
%tst1 = fcmp nnan oeq float %lhs32, %rhs32
%val1 = select i1 %tst1, double %a, double %b
store double %val1, double* @vardouble
; CHECK: vcmp.f32 s0, s1
; CHECK: vseleq.f64 d16, d1, d2
ret void
}
define void @test_vsel32ugt_nnan(float %lhs32, float %rhs32, float %a, float %b) {
; CHECK-LABEL: test_vsel32ugt_nnan
%tst1 = fcmp nnan ugt float %lhs32, %rhs32
%val1 = select i1 %tst1, float %a, float %b
store float %val1, float* @varfloat
; CHECK: vcmpe.f32 s0, s1
; CHECK: vselgt.f32 s0, s2, s3
ret void
}
define void @test_vsel64ugt_nnan(float %lhs32, float %rhs32, double %a, double %b) {
; CHECK-LABEL: test_vsel64ugt_nnan
%tst1 = fcmp nnan ugt float %lhs32, %rhs32
%val1 = select i1 %tst1, double %a, double %b
store double %val1, double* @vardouble
; CHECK: vcmpe.f32 s0, s1
; CHECK: vselgt.f64 d16, d1, d2
ret void
}
define void @test_vsel32uge_nnan(float %lhs32, float %rhs32, float %a, float %b) {
; CHECK-LABEL: test_vsel32uge_nnan
%tst1 = fcmp nnan uge float %lhs32, %rhs32
%val1 = select i1 %tst1, float %a, float %b
store float %val1, float* @varfloat
; CHECK: vcmpe.f32 s0, s1
; CHECK: vselge.f32 s0, s2, s3
ret void
}
define void @test_vsel64uge_nnan(float %lhs32, float %rhs32, double %a, double %b) {
; CHECK-LABEL: test_vsel64uge_nnan
%tst1 = fcmp nnan uge float %lhs32, %rhs32
%val1 = select i1 %tst1, double %a, double %b
store double %val1, double* @vardouble
; CHECK: vcmpe.f32 s0, s1
; CHECK: vselge.f64 d16, d1, d2
ret void
}
define void @test_vsel32olt_nnan(float %lhs32, float %rhs32, float %a, float %b) {
; CHECK-LABEL: test_vsel32olt_nnan
%tst1 = fcmp nnan olt float %lhs32, %rhs32
%val1 = select i1 %tst1, float %a, float %b
store float %val1, float* @varfloat
; CHECK: vcmpe.f32 s1, s0
; CHECK: vselgt.f32 s0, s2, s3
ret void
}
define void @test_vsel64olt_nnan(float %lhs32, float %rhs32, double %a, double %b) {
; CHECK-LABEL: test_vsel64olt_nnan
%tst1 = fcmp nnan olt float %lhs32, %rhs32
%val1 = select i1 %tst1, double %a, double %b
store double %val1, double* @vardouble
; CHECK: vcmpe.f32 s1, s0
; CHECK: vselgt.f64 d16, d1, d2
ret void
}
define void @test_vsel32ult_nnan(float %lhs32, float %rhs32, float %a, float %b) {
; CHECK-LABEL: test_vsel32ult_nnan
%tst1 = fcmp nnan ult float %lhs32, %rhs32
%val1 = select i1 %tst1, float %a, float %b
store float %val1, float* @varfloat
; CHECK: vcmpe.f32 s1, s0
; CHECK: vselgt.f32 s0, s2, s3
ret void
}
define void @test_vsel64ult_nnan(float %lhs32, float %rhs32, double %a, double %b) {
; CHECK-LABEL: test_vsel64ult_nnan
%tst1 = fcmp nnan ult float %lhs32, %rhs32
%val1 = select i1 %tst1, double %a, double %b
store double %val1, double* @vardouble
; CHECK: vcmpe.f32 s1, s0
; CHECK: vselgt.f64 d16, d1, d2
ret void
}
define void @test_vsel32ole_nnan(float %lhs32, float %rhs32, float %a, float %b) {
; CHECK-LABEL: test_vsel32ole_nnan
%tst1 = fcmp nnan ole float %lhs32, %rhs32
%val1 = select i1 %tst1, float %a, float %b
store float %val1, float* @varfloat
; CHECK: vcmpe.f32 s1, s0
; CHECK: vselge.f32 s0, s2, s3
ret void
}
define void @test_vsel64ole_nnan(float %lhs32, float %rhs32, double %a, double %b) {
; CHECK-LABEL: test_vsel64ole_nnan
%tst1 = fcmp nnan ole float %lhs32, %rhs32
%val1 = select i1 %tst1, double %a, double %b
store double %val1, double* @vardouble
; CHECK: vcmpe.f32 s1, s0
; CHECK: vselge.f64 d16, d1, d2
ret void
}
define void @test_vsel32ule_nnan(float %lhs32, float %rhs32, float %a, float %b) {
; CHECK-LABEL: test_vsel32ule_nnan
%tst1 = fcmp nnan ule float %lhs32, %rhs32
%val1 = select i1 %tst1, float %a, float %b
store float %val1, float* @varfloat
; CHECK: vcmpe.f32 s1, s0
; CHECK: vselge.f32 s0, s2, s3
ret void
}
define void @test_vsel64ule_nnan(float %lhs32, float %rhs32, double %a, double %b) {
; CHECK-LABEL: test_vsel64ule_nnan
%tst1 = fcmp nnan ule float %lhs32, %rhs32
%val1 = select i1 %tst1, double %a, double %b
store double %val1, double* @vardouble
; CHECK: vcmpe.f32 s1, s0
; CHECK: vselge.f64 d16, d1, d2
ret void
}
define void @test_vsel32ord_nnan(float %lhs32, float %rhs32, float %a, float %b) {
; CHECK-LABEL: test_vsel32ord_nnan
%tst1 = fcmp nnan ord float %lhs32, %rhs32
%val1 = select i1 %tst1, float %a, float %b
store float %val1, float* @varfloat
; CHECK: vcmpe.f32 s0, s1
; CHECK: vselvs.f32 s0, s3, s2
ret void
}
define void @test_vsel64ord_nnan(float %lhs32, float %rhs32, double %a, double %b) {
; CHECK-LABEL: test_vsel64ord_nnan
%tst1 = fcmp nnan ord float %lhs32, %rhs32
%val1 = select i1 %tst1, double %a, double %b
store double %val1, double* @vardouble
; CHECK: vcmpe.f32 s0, s1
; CHECK: vselvs.f64 d16, d2, d1
ret void
}
define void @test_vsel32une_nnan(float %lhs32, float %rhs32, float %a, float %b) {
; CHECK-LABEL: test_vsel32une_nnan
%tst1 = fcmp nnan une float %lhs32, %rhs32
%val1 = select i1 %tst1, float %a, float %b
store float %val1, float* @varfloat
; CHECK: vcmp.f32 s0, s1
; CHECK: vseleq.f32 s0, s3, s2
ret void
}
define void @test_vsel64une_nnan(float %lhs32, float %rhs32, double %a, double %b) {
; CHECK-LABEL: test_vsel64une_nnan
%tst1 = fcmp nnan une float %lhs32, %rhs32
%val1 = select i1 %tst1, double %a, double %b
store double %val1, double* @vardouble
; CHECK: vcmp.f32 s0, s1
; CHECK: vseleq.f64 d16, d2, d1
ret void
}
define void @test_vsel32uno_nnan(float %lhs32, float %rhs32, float %a, float %b) {
; CHECK-LABEL: test_vsel32uno_nnan
%tst1 = fcmp nnan uno float %lhs32, %rhs32
%val1 = select i1 %tst1, float %a, float %b
store float %val1, float* @varfloat
; CHECK: vcmpe.f32 s0, s1
; CHECK: vselvs.f32 s0, s2, s3
ret void
}
define void @test_vsel64uno_nnan(float %lhs32, float %rhs32, double %a, double %b) {
; CHECK-LABEL: test_vsel64uno_nnan
%tst1 = fcmp nnan uno float %lhs32, %rhs32
%val1 = select i1 %tst1, double %a, double %b
store double %val1, double* @vardouble
; CHECK: vcmpe.f32 s0, s1
; CHECK: vselvs.f64 d16, d1, d2
ret void
}