maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity

[SDAG] Vector op legalization for overflow ops 

Fixes issue reported by aemerson on D57348. Vector op legalization
support is added for uaddo, usubo, saddo and ssubo (umulo and smulo
were already supported). As usual, by extracting TargetLowering methods
and calling them from vector op legalization.

Vector op legalization doesn't really deal with multiple result nodes,
so I'm explicitly performing a recursive legalization call on the
result value that is not being legalized.

There are some existing test changes because expansion happens
earlier, so we don't get a DAG combiner run in between anymore.

Differential Revision: https://reviews.llvm.org/D61692

llvm-svn: 361166
This commit is contained in:
Nikita Popov 2019-05-20 16:09:22 +00:00
parent 72f821d3de
commit 9060b6df97
9 changed files with 1179 additions and 915 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
llvm/include/llvm/CodeGen/TargetLowering.h
View File

@ -3956,6 +3956,16 @@ public:
/// integers as its arguments.
SDValue expandFixedPointMul(SDNode *Node, SelectionDAG &DAG) const;
/// Method for building the DAG expansion of ISD::U(ADD|SUB)O. Expansion
/// always suceeds and populates the Result and Overflow arguments.
void expandUADDSUBO(SDNode *Node, SDValue &Result, SDValue &Overflow,
SelectionDAG &DAG) const;
/// Method for building the DAG expansion of ISD::S(ADD|SUB)O. Expansion
/// always suceeds and populates the Result and Overflow arguments.
void expandSADDSUBO(SDNode *Node, SDValue &Result, SDValue &Overflow,
SelectionDAG &DAG) const;
/// Method for building the DAG expansion of ISD::[US]MULO. Returns whether
/// expansion was successful and populates the Result and Overflow arguments.
bool expandMULO(SDNode *Node, SDValue &Result, SDValue &Overflow,

74
llvm/lib/CodeGen/SelectionDAG/LegalizeDAG.cpp
View File

@ -3381,76 +3381,18 @@ bool SelectionDAGLegalize::ExpandNode(SDNode *Node) {
}
case ISD::SADDO:
case ISD::SSUBO: {
SDValue LHS = Node->getOperand(0);
SDValue RHS = Node->getOperand(1);
bool IsAdd = Node->getOpcode() == ISD::SADDO;
SDValue Sum = DAG.getNode(IsAdd ? ISD::ADD : ISD::SUB, dl,
LHS.getValueType(), LHS, RHS);
Results.push_back(Sum);
EVT ResultType = Node->getValueType(1);
EVT OType = getSetCCResultType(Node->getValueType(0));
// If SADDSAT/SSUBSAT is legal, compare results to detect overflow.
unsigned OpcSat = IsAdd ? ISD::SADDSAT : ISD::SSUBSAT;
if (TLI.isOperationLegalOrCustom(OpcSat, LHS.getValueType())) {
SDValue Sat = DAG.getNode(OpcSat, dl, LHS.getValueType(), LHS, RHS);
SDValue SetCC = DAG.getSetCC(dl, OType, Sum, Sat, ISD::SETNE);
Results.push_back(
DAG.getBoolExtOrTrunc(SetCC, dl, ResultType, ResultType));
break;
}
SDValue Zero = DAG.getConstant(0, dl, LHS.getValueType());
// LHSSign -> LHS >= 0
// RHSSign -> RHS >= 0
// SumSign -> Sum >= 0
//
// Add:
// Overflow -> (LHSSign == RHSSign) && (LHSSign != SumSign)
// Sub:
// Overflow -> (LHSSign != RHSSign) && (LHSSign != SumSign)
SDValue LHSSign = DAG.getSetCC(dl, OType, LHS, Zero, ISD::SETGE);
SDValue RHSSign = DAG.getSetCC(dl, OType, RHS, Zero, ISD::SETGE);
SDValue SignsMatch = DAG.getSetCC(dl, OType, LHSSign, RHSSign,
IsAdd ? ISD::SETEQ : ISD::SETNE);
SDValue SumSign = DAG.getSetCC(dl, OType, Sum, Zero, ISD::SETGE);
SDValue SumSignNE = DAG.getSetCC(dl, OType, LHSSign, SumSign, ISD::SETNE);
SDValue Cmp = DAG.getNode(ISD::AND, dl, OType, SignsMatch, SumSignNE);
Results.push_back(DAG.getBoolExtOrTrunc(Cmp, dl, ResultType, ResultType));
SDValue Result, Overflow;
TLI.expandSADDSUBO(Node, Result, Overflow, DAG);
Results.push_back(Result);
Results.push_back(Overflow);
break;
}
case ISD::UADDO:
case ISD::USUBO: {
SDValue LHS = Node->getOperand(0);
SDValue RHS = Node->getOperand(1);
bool IsAdd = Node->getOpcode() == ISD::UADDO;
// If ADD/SUBCARRY is legal, use that instead.
unsigned OpcCarry = IsAdd ? ISD::ADDCARRY : ISD::SUBCARRY;
if (TLI.isOperationLegalOrCustom(OpcCarry, Node->getValueType(0))) {
SDValue CarryIn = DAG.getConstant(0, dl, Node->getValueType(1));
SDValue NodeCarry = DAG.getNode(OpcCarry, dl, Node->getVTList(),
{ LHS, RHS, CarryIn });
Results.push_back(SDValue(NodeCarry.getNode(), 0));
Results.push_back(SDValue(NodeCarry.getNode(), 1));
break;
}
SDValue Sum = DAG.getNode(IsAdd ? ISD::ADD : ISD::SUB, dl,
LHS.getValueType(), LHS, RHS);
Results.push_back(Sum);
EVT ResultType = Node->getValueType(1);
EVT SetCCType = getSetCCResultType(Node->getValueType(0));
ISD::CondCode CC = IsAdd ? ISD::SETULT : ISD::SETUGT;
SDValue SetCC = DAG.getSetCC(dl, SetCCType, Sum, LHS, CC);
Results.push_back(DAG.getBoolExtOrTrunc(SetCC, dl, ResultType, ResultType));
SDValue Result, Overflow;
TLI.expandUADDSUBO(Node, Result, Overflow, DAG);
Results.push_back(Result);
Results.push_back(Overflow);
break;
}
case ISD::UMULO:

38
llvm/lib/CodeGen/SelectionDAG/LegalizeVectorOps.cpp
View File

@ -140,6 +140,8 @@ class VectorLegalizer {
SDValue ExpandFunnelShift(SDValue Op);
SDValue ExpandROT(SDValue Op);
SDValue ExpandFMINNUM_FMAXNUM(SDValue Op);
SDValue ExpandUADDSUBO(SDValue Op);
SDValue ExpandSADDSUBO(SDValue Op);
SDValue ExpandMULO(SDValue Op);
SDValue ExpandAddSubSat(SDValue Op);
SDValue ExpandFixedPointMul(SDValue Op);
@ -422,6 +424,10 @@ SDValue VectorLegalizer::LegalizeOp(SDValue Op) {
case ISD::UMAX:
case ISD::SMUL_LOHI:
case ISD::UMUL_LOHI:
case ISD::SADDO:
case ISD::UADDO:
case ISD::SSUBO:
case ISD::USUBO:
case ISD::SMULO:
case ISD::UMULO:
case ISD::FCANONICALIZE:
@ -796,6 +802,12 @@ SDValue VectorLegalizer::Expand(SDValue Op) {
case ISD::FMINNUM:
case ISD::FMAXNUM:
return ExpandFMINNUM_FMAXNUM(Op);
case ISD::UADDO:
case ISD::USUBO:
return ExpandUADDSUBO(Op);
case ISD::SADDO:
case ISD::SSUBO:
return ExpandSADDSUBO(Op);
case ISD::UMULO:
case ISD::SMULO:
return ExpandMULO(Op);
@ -1250,6 +1262,32 @@ SDValue VectorLegalizer::ExpandFMINNUM_FMAXNUM(SDValue Op) {
return DAG.UnrollVectorOp(Op.getNode());
}
SDValue VectorLegalizer::ExpandUADDSUBO(SDValue Op) {
SDValue Result, Overflow;
TLI.expandUADDSUBO(Op.getNode(), Result, Overflow, DAG);
if (Op.getResNo() == 0) {
AddLegalizedOperand(Op.getValue(1), LegalizeOp(Overflow));
return Result;
} else {
AddLegalizedOperand(Op.getValue(0), LegalizeOp(Result));
return Overflow;
}
}
SDValue VectorLegalizer::ExpandSADDSUBO(SDValue Op) {
SDValue Result, Overflow;
TLI.expandSADDSUBO(Op.getNode(), Result, Overflow, DAG);
if (Op.getResNo() == 0) {
AddLegalizedOperand(Op.getValue(1), LegalizeOp(Overflow));
return Result;
} else {
AddLegalizedOperand(Op.getValue(0), LegalizeOp(Result));
return Overflow;
}
}
SDValue VectorLegalizer::ExpandMULO(SDValue Op) {
SDValue Result, Overflow;
if (!TLI.expandMULO(Op.getNode(), Result, Overflow, DAG))

74
llvm/lib/CodeGen/SelectionDAG/TargetLowering.cpp
View File

@ -5750,6 +5750,80 @@ TargetLowering::expandFixedPointMul(SDNode *Node, SelectionDAG &DAG) const {
DAG.getConstant(Scale, dl, ShiftTy));
}
void TargetLowering::expandUADDSUBO(
SDNode *Node, SDValue &Result, SDValue &Overflow, SelectionDAG &DAG) const {
SDLoc dl(Node);
SDValue LHS = Node->getOperand(0);
SDValue RHS = Node->getOperand(1);
bool IsAdd = Node->getOpcode() == ISD::UADDO;
// If ADD/SUBCARRY is legal, use that instead.
unsigned OpcCarry = IsAdd ? ISD::ADDCARRY : ISD::SUBCARRY;
if (isOperationLegalOrCustom(OpcCarry, Node->getValueType(0))) {
SDValue CarryIn = DAG.getConstant(0, dl, Node->getValueType(1));
SDValue NodeCarry = DAG.getNode(OpcCarry, dl, Node->getVTList(),
{ LHS, RHS, CarryIn });
Result = SDValue(NodeCarry.getNode(), 0);
Overflow = SDValue(NodeCarry.getNode(), 1);
return;
}
Result = DAG.getNode(IsAdd ? ISD::ADD : ISD::SUB, dl,
LHS.getValueType(), LHS, RHS);
EVT ResultType = Node->getValueType(1);
EVT SetCCType = getSetCCResultType(
DAG.getDataLayout(), *DAG.getContext(), Node->getValueType(0));
ISD::CondCode CC = IsAdd ? ISD::SETULT : ISD::SETUGT;
SDValue SetCC = DAG.getSetCC(dl, SetCCType, Result, LHS, CC);
Overflow = DAG.getBoolExtOrTrunc(SetCC, dl, ResultType, ResultType);
}
void TargetLowering::expandSADDSUBO(
SDNode *Node, SDValue &Result, SDValue &Overflow, SelectionDAG &DAG) const {
SDLoc dl(Node);
SDValue LHS = Node->getOperand(0);
SDValue RHS = Node->getOperand(1);
bool IsAdd = Node->getOpcode() == ISD::SADDO;
Result = DAG.getNode(IsAdd ? ISD::ADD : ISD::SUB, dl,
LHS.getValueType(), LHS, RHS);
EVT ResultType = Node->getValueType(1);
EVT OType = getSetCCResultType(
DAG.getDataLayout(), *DAG.getContext(), Node->getValueType(0));
// If SADDSAT/SSUBSAT is legal, compare results to detect overflow.
unsigned OpcSat = IsAdd ? ISD::SADDSAT : ISD::SSUBSAT;
if (isOperationLegalOrCustom(OpcSat, LHS.getValueType())) {
SDValue Sat = DAG.getNode(OpcSat, dl, LHS.getValueType(), LHS, RHS);
SDValue SetCC = DAG.getSetCC(dl, OType, Result, Sat, ISD::SETNE);
Overflow = DAG.getBoolExtOrTrunc(SetCC, dl, ResultType, ResultType);
return;
}
SDValue Zero = DAG.getConstant(0, dl, LHS.getValueType());
// LHSSign -> LHS >= 0
// RHSSign -> RHS >= 0
// SumSign -> Result >= 0
//
// Add:
// Overflow -> (LHSSign == RHSSign) && (LHSSign != SumSign)
// Sub:
// Overflow -> (LHSSign != RHSSign) && (LHSSign != SumSign)
SDValue LHSSign = DAG.getSetCC(dl, OType, LHS, Zero, ISD::SETGE);
SDValue RHSSign = DAG.getSetCC(dl, OType, RHS, Zero, ISD::SETGE);
SDValue SignsMatch = DAG.getSetCC(dl, OType, LHSSign, RHSSign,
IsAdd ? ISD::SETEQ : ISD::SETNE);
SDValue SumSign = DAG.getSetCC(dl, OType, Result, Zero, ISD::SETGE);
SDValue SumSignNE = DAG.getSetCC(dl, OType, LHSSign, SumSign, ISD::SETNE);
SDValue Cmp = DAG.getNode(ISD::AND, dl, OType, SignsMatch, SumSignNE);
Overflow = DAG.getBoolExtOrTrunc(Cmp, dl, ResultType, ResultType);
}
bool TargetLowering::expandMULO(SDNode *Node, SDValue &Result,
SDValue &Overflow, SelectionDAG &DAG) const {
SDLoc dl(Node);

258
llvm/test/CodeGen/AArch64/addsubo-legalization.ll Normal file
View File

@ -0,0 +1,258 @@
; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
; RUN: llc < %s -mtriple=thumbv7k-linux-gnu | FileCheck %s
declare {<2 x i64>, <2 x i1>} @llvm.uadd.with.overflow.v2i64(<2 x i64>, <2 x i64>)
declare {<2 x i64>, <2 x i1>} @llvm.usub.with.overflow.v2i64(<2 x i64>, <2 x i64>)
declare {<2 x i64>, <2 x i1>} @llvm.sadd.with.overflow.v2i64(<2 x i64>, <2 x i64>)
declare {<2 x i64>, <2 x i1>} @llvm.ssub.with.overflow.v2i64(<2 x i64>, <2 x i64>)
define <2 x i1> @uaddo(<2 x i64> *%ptr, <2 x i64> *%ptr2) {
; CHECK-LABEL: uaddo:
; CHECK: @ %bb.0:
; CHECK-NEXT: push {r4, r5, r6, r7, lr}
; CHECK-NEXT: vld1.64 {d18, d19}, [r0]
; CHECK-NEXT: vld1.64 {d16, d17}, [r1]
; CHECK-NEXT: movs r1, #0
; CHECK-NEXT: vadd.i64 q8, q9, q8
; CHECK-NEXT: vmov.32 r3, d18[0]
; CHECK-NEXT: vmov.32 r2, d18[1]
; CHECK-NEXT: vmov.32 r12, d16[0]
; CHECK-NEXT: vmov.32 lr, d16[1]
; CHECK-NEXT: vmov.32 r4, d17[0]
; CHECK-NEXT: vmov.32 r5, d19[0]
; CHECK-NEXT: vmov.32 r6, d17[1]
; CHECK-NEXT: vmov.32 r7, d19[1]
; CHECK-NEXT: subs.w r3, r12, r3
; CHECK-NEXT: sbcs.w r2, lr, r2
; CHECK-NEXT: mov.w r2, #0
; CHECK-NEXT: it lo
; CHECK-NEXT: movlo r2, #1
; CHECK-NEXT: cmp r2, #0
; CHECK-NEXT: it ne
; CHECK-NEXT: movne.w r2, #-1
; CHECK-NEXT: subs r3, r4, r5
; CHECK-NEXT: sbcs.w r3, r6, r7
; CHECK-NEXT: it lo
; CHECK-NEXT: movlo r1, #1
; CHECK-NEXT: cmp r1, #0
; CHECK-NEXT: it ne
; CHECK-NEXT: movne.w r1, #-1
; CHECK-NEXT: vst1.64 {d16, d17}, [r0]
; CHECK-NEXT: mov r0, r2
; CHECK-NEXT: pop {r4, r5, r6, r7, pc}
%x = load <2 x i64>, <2 x i64>* %ptr, align 8
%y = load <2 x i64>, <2 x i64>* %ptr2, align 8
%s = call {<2 x i64>, <2 x i1>} @llvm.uadd.with.overflow.v2i64(<2 x i64> %x, <2 x i64> %y)
%m = extractvalue {<2 x i64>, <2 x i1>} %s, 0
%o = extractvalue {<2 x i64>, <2 x i1>} %s, 1
store <2 x i64> %m, <2 x i64>* %ptr
ret <2 x i1> %o
}
define <2 x i1> @usubo(<2 x i64> *%ptr, <2 x i64> *%ptr2) {
; CHECK-LABEL: usubo:
; CHECK: @ %bb.0:
; CHECK-NEXT: push {r4, r5, r6, r7, lr}
; CHECK-NEXT: vld1.64 {d16, d17}, [r1]
; CHECK-NEXT: movs r1, #0
; CHECK-NEXT: vld1.64 {d18, d19}, [r0]
; CHECK-NEXT: vsub.i64 q8, q9, q8
; CHECK-NEXT: vmov.32 r12, d18[0]
; CHECK-NEXT: vmov.32 lr, d18[1]
; CHECK-NEXT: vmov.32 r3, d16[0]
; CHECK-NEXT: vmov.32 r2, d16[1]
; CHECK-NEXT: vmov.32 r4, d19[0]
; CHECK-NEXT: vmov.32 r5, d17[0]
; CHECK-NEXT: vmov.32 r6, d19[1]
; CHECK-NEXT: vmov.32 r7, d17[1]
; CHECK-NEXT: subs.w r3, r12, r3
; CHECK-NEXT: sbcs.w r2, lr, r2
; CHECK-NEXT: mov.w r2, #0
; CHECK-NEXT: it lo
; CHECK-NEXT: movlo r2, #1
; CHECK-NEXT: cmp r2, #0
; CHECK-NEXT: it ne
; CHECK-NEXT: movne.w r2, #-1
; CHECK-NEXT: subs r3, r4, r5
; CHECK-NEXT: sbcs.w r3, r6, r7
; CHECK-NEXT: it lo
; CHECK-NEXT: movlo r1, #1
; CHECK-NEXT: cmp r1, #0
; CHECK-NEXT: it ne
; CHECK-NEXT: movne.w r1, #-1
; CHECK-NEXT: vst1.64 {d16, d17}, [r0]
; CHECK-NEXT: mov r0, r2
; CHECK-NEXT: pop {r4, r5, r6, r7, pc}
%x = load <2 x i64>, <2 x i64>* %ptr, align 8
%y = load <2 x i64>, <2 x i64>* %ptr2, align 8
%s = call {<2 x i64>, <2 x i1>} @llvm.usub.with.overflow.v2i64(<2 x i64> %x, <2 x i64> %y)
%m = extractvalue {<2 x i64>, <2 x i1>} %s, 0
%o = extractvalue {<2 x i64>, <2 x i1>} %s, 1
store <2 x i64> %m, <2 x i64>* %ptr
ret <2 x i1> %o
}
define <2 x i1> @saddo(<2 x i64> *%ptr, <2 x i64> *%ptr2) {
; CHECK-LABEL: saddo:
; CHECK: @ %bb.0:
; CHECK-NEXT: push {r4, r5, r6, r7, lr}
; CHECK-NEXT: vld1.64 {d16, d17}, [r1]
; CHECK-NEXT: movs r5, #0
; CHECK-NEXT: movs r6, #0
; CHECK-NEXT: movs r3, #0
; CHECK-NEXT: vmov.32 r1, d16[1]
; CHECK-NEXT: vld1.64 {d18, d19}, [r0]
; CHECK-NEXT: vmov.32 r2, d17[1]
; CHECK-NEXT: vadd.i64 q8, q9, q8
; CHECK-NEXT: vmov.32 r12, d18[1]
; CHECK-NEXT: vmov.32 r4, d19[1]
; CHECK-NEXT: vmov.32 lr, d16[1]
; CHECK-NEXT: vmov.32 r7, d17[1]
; CHECK-NEXT: cmp.w r1, #-1
; CHECK-NEXT: mov.w r1, #0
; CHECK-NEXT: it gt
; CHECK-NEXT: movgt r1, #1
; CHECK-NEXT: cmp r1, #0
; CHECK-NEXT: it ne
; CHECK-NEXT: movne.w r1, #-1
; CHECK-NEXT: cmp.w r2, #-1
; CHECK-NEXT: mov.w r2, #0
; CHECK-NEXT: it gt
; CHECK-NEXT: movgt r2, #1
; CHECK-NEXT: cmp.w r12, #-1
; CHECK-NEXT: it gt
; CHECK-NEXT: movgt r5, #1
; CHECK-NEXT: cmp r5, #0
; CHECK-NEXT: it ne
; CHECK-NEXT: movne.w r5, #-1
; CHECK-NEXT: cmp.w r4, #-1
; CHECK-NEXT: mov.w r4, #0
; CHECK-NEXT: it gt
; CHECK-NEXT: movgt r4, #1
; CHECK-NEXT: cmp.w lr, #-1
; CHECK-NEXT: it gt
; CHECK-NEXT: movgt r6, #1
; CHECK-NEXT: cmp r6, #0
; CHECK-NEXT: it ne
; CHECK-NEXT: movne.w r6, #-1
; CHECK-NEXT: cmp.w r7, #-1
; CHECK-NEXT: it gt
; CHECK-NEXT: movgt r3, #1
; CHECK-NEXT: cmp r3, #0
; CHECK-NEXT: it ne
; CHECK-NEXT: movne.w r3, #-1
; CHECK-NEXT: cmp r4, #0
; CHECK-NEXT: vdup.32 d19, r3
; CHECK-NEXT: it ne
; CHECK-NEXT: movne.w r4, #-1
; CHECK-NEXT: cmp r2, #0
; CHECK-NEXT: it ne
; CHECK-NEXT: movne.w r2, #-1
; CHECK-NEXT: vdup.32 d23, r2
; CHECK-NEXT: vdup.32 d21, r4
; CHECK-NEXT: vdup.32 d18, r6
; CHECK-NEXT: vdup.32 d22, r1
; CHECK-NEXT: vdup.32 d20, r5
; CHECK-NEXT: vceq.i32 q9, q10, q9
; CHECK-NEXT: vst1.64 {d16, d17}, [r0]
; CHECK-NEXT: vceq.i32 q10, q10, q11
; CHECK-NEXT: vrev64.32 q11, q9
; CHECK-NEXT: vrev64.32 q12, q10
; CHECK-NEXT: vand q9, q9, q11
; CHECK-NEXT: vand q10, q10, q12
; CHECK-NEXT: vbic q9, q10, q9
; CHECK-NEXT: vmovn.i64 d18, q9
; CHECK-NEXT: vmov r2, r1, d18
; CHECK-NEXT: mov r0, r2
; CHECK-NEXT: pop {r4, r5, r6, r7, pc}
%x = load <2 x i64>, <2 x i64>* %ptr, align 8
%y = load <2 x i64>, <2 x i64>* %ptr2, align 8
%s = call {<2 x i64>, <2 x i1>} @llvm.sadd.with.overflow.v2i64(<2 x i64> %x, <2 x i64> %y)
%m = extractvalue {<2 x i64>, <2 x i1>} %s, 0
%o = extractvalue {<2 x i64>, <2 x i1>} %s, 1
store <2 x i64> %m, <2 x i64>* %ptr
ret <2 x i1> %o
}
define <2 x i1> @ssubo(<2 x i64> *%ptr, <2 x i64> *%ptr2) {
; CHECK-LABEL: ssubo:
; CHECK: @ %bb.0:
; CHECK-NEXT: push {r4, r5, r6, r7, lr}
; CHECK-NEXT: vld1.64 {d18, d19}, [r1]
; CHECK-NEXT: movs r5, #0
; CHECK-NEXT: movs r6, #0
; CHECK-NEXT: movs r3, #0
; CHECK-NEXT: vld1.64 {d20, d21}, [r0]
; CHECK-NEXT: vsub.i64 q8, q10, q9
; CHECK-NEXT: vmov.32 r12, d20[1]
; CHECK-NEXT: vmov.32 lr, d21[1]
; CHECK-NEXT: vmov.32 r1, d16[1]
; CHECK-NEXT: vmov.32 r2, d17[1]
; CHECK-NEXT: vmov.32 r4, d18[1]
; CHECK-NEXT: vmov.32 r7, d19[1]
; CHECK-NEXT: cmp.w r1, #-1
; CHECK-NEXT: mov.w r1, #0
; CHECK-NEXT: it gt
; CHECK-NEXT: movgt r1, #1
; CHECK-NEXT: cmp r1, #0
; CHECK-NEXT: it ne
; CHECK-NEXT: movne.w r1, #-1
; CHECK-NEXT: cmp.w r2, #-1
; CHECK-NEXT: mov.w r2, #0
; CHECK-NEXT: it gt
; CHECK-NEXT: movgt r2, #1
; CHECK-NEXT: cmp.w r12, #-1
; CHECK-NEXT: it gt
; CHECK-NEXT: movgt r5, #1
; CHECK-NEXT: cmp r5, #0
; CHECK-NEXT: it ne
; CHECK-NEXT: movne.w r5, #-1
; CHECK-NEXT: cmp.w lr, #-1
; CHECK-NEXT: it gt
; CHECK-NEXT: movgt r6, #1
; CHECK-NEXT: cmp.w r4, #-1
; CHECK-NEXT: mov.w r4, #0
; CHECK-NEXT: it gt
; CHECK-NEXT: movgt r4, #1
; CHECK-NEXT: cmp r4, #0
; CHECK-NEXT: it ne
; CHECK-NEXT: movne.w r4, #-1
; CHECK-NEXT: cmp.w r7, #-1
; CHECK-NEXT: it gt
; CHECK-NEXT: movgt r3, #1
; CHECK-NEXT: cmp r3, #0
; CHECK-NEXT: it ne
; CHECK-NEXT: movne.w r3, #-1
; CHECK-NEXT: vdup.32 d19, r3
; CHECK-NEXT: cmp r6, #0
; CHECK-NEXT: it ne
; CHECK-NEXT: movne.w r6, #-1
; CHECK-NEXT: vdup.32 d21, r6
; CHECK-NEXT: cmp r2, #0
; CHECK-NEXT: vdup.32 d18, r4
; CHECK-NEXT: it ne
; CHECK-NEXT: movne.w r2, #-1
; CHECK-NEXT: vdup.32 d23, r2
; CHECK-NEXT: vdup.32 d20, r5
; CHECK-NEXT: vdup.32 d22, r1
; CHECK-NEXT: vceq.i32 q9, q10, q9
; CHECK-NEXT: vst1.64 {d16, d17}, [r0]
; CHECK-NEXT: vceq.i32 q10, q10, q11
; CHECK-NEXT: vrev64.32 q11, q9
; CHECK-NEXT: vrev64.32 q12, q10
; CHECK-NEXT: vand q9, q9, q11
; CHECK-NEXT: vand q10, q10, q12
; CHECK-NEXT: vmvn q9, q9
; CHECK-NEXT: vbic q9, q9, q10
; CHECK-NEXT: vmovn.i64 d18, q9
; CHECK-NEXT: vmov r2, r1, d18
; CHECK-NEXT: mov r0, r2
; CHECK-NEXT: pop {r4, r5, r6, r7, pc}
%x = load <2 x i64>, <2 x i64>* %ptr, align 8
%y = load <2 x i64>, <2 x i64>* %ptr2, align 8
%s = call {<2 x i64>, <2 x i1>} @llvm.ssub.with.overflow.v2i64(<2 x i64> %x, <2 x i64> %y)
%m = extractvalue {<2 x i64>, <2 x i1>} %s, 0
%o = extractvalue {<2 x i64>, <2 x i1>} %s, 1
store <2 x i64> %m, <2 x i64>* %ptr
ret <2 x i1> %o
}

632
llvm/test/CodeGen/X86/sadd_sat_vec.ll
View File

@ -663,7 +663,7 @@ define <2 x i32> @v2i32(<2 x i32> %x, <2 x i32> %y) nounwind {
; SSE2-NEXT: psllq $32, %xmm0
; SSE2-NEXT: movdqa %xmm0, %xmm3
; SSE2-NEXT: paddq %xmm1, %xmm0
; SSE2-NEXT: pxor %xmm2, %xmm1
; SSE2-NEXT: por %xmm2, %xmm1
; SSE2-NEXT: movdqa %xmm2, %xmm4
; SSE2-NEXT: pcmpgtd %xmm1, %xmm4
; SSE2-NEXT: pshufd {{.*#+}} xmm5 = xmm4[0,0,2,2]
@ -674,7 +674,7 @@ define <2 x i32> @v2i32(<2 x i32> %x, <2 x i32> %y) nounwind {
; SSE2-NEXT: por %xmm1, %xmm4
; SSE2-NEXT: pcmpeqd %xmm1, %xmm1
; SSE2-NEXT: pxor %xmm1, %xmm4
; SSE2-NEXT: pxor %xmm2, %xmm3
; SSE2-NEXT: por %xmm2, %xmm3
; SSE2-NEXT: movdqa %xmm2, %xmm5
; SSE2-NEXT: pcmpgtd %xmm3, %xmm5
; SSE2-NEXT: pshufd {{.*#+}} xmm6 = xmm5[0,0,2,2]
@ -688,37 +688,27 @@ define <2 x i32> @v2i32(<2 x i32> %x, <2 x i32> %y) nounwind {
; SSE2-NEXT: pshufd {{.*#+}} xmm3 = xmm4[1,0,3,2]
; SSE2-NEXT: pand %xmm4, %xmm3
; SSE2-NEXT: movdqa %xmm0, %xmm4
; SSE2-NEXT: pxor %xmm2, %xmm4
; SSE2-NEXT: por %xmm2, %xmm4
; SSE2-NEXT: movdqa %xmm2, %xmm6
; SSE2-NEXT: pcmpgtd %xmm4, %xmm6
; SSE2-NEXT: pshufd {{.*#+}} xmm7 = xmm6[0,0,2,2]
; SSE2-NEXT: pcmpeqd %xmm2, %xmm4
; SSE2-NEXT: pshufd {{.*#+}} xmm4 = xmm4[1,1,3,3]
; SSE2-NEXT: pand %xmm7, %xmm4
; SSE2-NEXT: pshufd {{.*#+}} xmm6 = xmm6[1,1,3,3]
; SSE2-NEXT: por %xmm4, %xmm6
; SSE2-NEXT: pxor %xmm1, %xmm6
; SSE2-NEXT: pcmpeqd %xmm5, %xmm6
; SSE2-NEXT: pshufd {{.*#+}} xmm1 = xmm6[1,0,3,2]
; SSE2-NEXT: pand %xmm6, %xmm1
; SSE2-NEXT: pandn %xmm3, %xmm1
; SSE2-NEXT: movdqa %xmm1, %xmm3
; SSE2-NEXT: pandn %xmm0, %xmm3
; SSE2-NEXT: por %xmm2, %xmm0
; SSE2-NEXT: movdqa %xmm2, %xmm4
; SSE2-NEXT: pcmpgtd %xmm0, %xmm4
; SSE2-NEXT: pshufd {{.*#+}} xmm5 = xmm4[0,0,2,2]
; SSE2-NEXT: pcmpeqd %xmm2, %xmm0
; SSE2-NEXT: pshufd {{.*#+}} xmm0 = xmm0[1,1,3,3]
; SSE2-NEXT: pand %xmm5, %xmm0
; SSE2-NEXT: pshufd {{.*#+}} xmm2 = xmm4[1,1,3,3]
; SSE2-NEXT: por %xmm0, %xmm2
; SSE2-NEXT: movdqa %xmm2, %xmm0
; SSE2-NEXT: pandn {{.*}}(%rip), %xmm0
; SSE2-NEXT: pand {{.*}}(%rip), %xmm2
; SSE2-NEXT: por %xmm0, %xmm2
; SSE2-NEXT: pand %xmm7, %xmm2
; SSE2-NEXT: pshufd {{.*#+}} xmm4 = xmm6[1,1,3,3]
; SSE2-NEXT: por %xmm2, %xmm4
; SSE2-NEXT: pxor %xmm4, %xmm1
; SSE2-NEXT: pcmpeqd %xmm5, %xmm1
; SSE2-NEXT: pshufd {{.*#+}} xmm2 = xmm1[1,0,3,2]
; SSE2-NEXT: pand %xmm1, %xmm2
; SSE2-NEXT: por %xmm3, %xmm2
; SSE2-NEXT: pandn %xmm3, %xmm2
; SSE2-NEXT: movdqa %xmm4, %xmm1
; SSE2-NEXT: pandn {{.*}}(%rip), %xmm1
; SSE2-NEXT: pand {{.*}}(%rip), %xmm4
; SSE2-NEXT: por %xmm1, %xmm4
; SSE2-NEXT: pand %xmm2, %xmm4
; SSE2-NEXT: pandn %xmm0, %xmm2
; SSE2-NEXT: por %xmm4, %xmm2
; SSE2-NEXT: pshufd {{.*#+}} xmm0 = xmm2[1,3,2,3]
; SSE2-NEXT: psrad $31, %xmm2
; SSE2-NEXT: pshufd {{.*#+}} xmm1 = xmm2[1,3,2,3]
@ -732,7 +722,7 @@ define <2 x i32> @v2i32(<2 x i32> %x, <2 x i32> %y) nounwind {
; SSSE3-NEXT: psllq $32, %xmm0
; SSSE3-NEXT: movdqa %xmm0, %xmm3
; SSSE3-NEXT: paddq %xmm1, %xmm0
; SSSE3-NEXT: pxor %xmm2, %xmm1
; SSSE3-NEXT: por %xmm2, %xmm1
; SSSE3-NEXT: movdqa %xmm2, %xmm4
; SSSE3-NEXT: pcmpgtd %xmm1, %xmm4
; SSSE3-NEXT: pshufd {{.*#+}} xmm5 = xmm4[0,0,2,2]
@ -743,7 +733,7 @@ define <2 x i32> @v2i32(<2 x i32> %x, <2 x i32> %y) nounwind {
; SSSE3-NEXT: por %xmm1, %xmm4
; SSSE3-NEXT: pcmpeqd %xmm1, %xmm1
; SSSE3-NEXT: pxor %xmm1, %xmm4
; SSSE3-NEXT: pxor %xmm2, %xmm3
; SSSE3-NEXT: por %xmm2, %xmm3
; SSSE3-NEXT: movdqa %xmm2, %xmm5
; SSSE3-NEXT: pcmpgtd %xmm3, %xmm5
; SSSE3-NEXT: pshufd {{.*#+}} xmm6 = xmm5[0,0,2,2]
@ -757,37 +747,27 @@ define <2 x i32> @v2i32(<2 x i32> %x, <2 x i32> %y) nounwind {
; SSSE3-NEXT: pshufd {{.*#+}} xmm3 = xmm4[1,0,3,2]
; SSSE3-NEXT: pand %xmm4, %xmm3
; SSSE3-NEXT: movdqa %xmm0, %xmm4
; SSSE3-NEXT: pxor %xmm2, %xmm4
; SSSE3-NEXT: por %xmm2, %xmm4
; SSSE3-NEXT: movdqa %xmm2, %xmm6
; SSSE3-NEXT: pcmpgtd %xmm4, %xmm6
; SSSE3-NEXT: pshufd {{.*#+}} xmm7 = xmm6[0,0,2,2]
; SSSE3-NEXT: pcmpeqd %xmm2, %xmm4
; SSSE3-NEXT: pshufd {{.*#+}} xmm4 = xmm4[1,1,3,3]
; SSSE3-NEXT: pand %xmm7, %xmm4
; SSSE3-NEXT: pshufd {{.*#+}} xmm6 = xmm6[1,1,3,3]
; SSSE3-NEXT: por %xmm4, %xmm6
; SSSE3-NEXT: pxor %xmm1, %xmm6
; SSSE3-NEXT: pcmpeqd %xmm5, %xmm6
; SSSE3-NEXT: pshufd {{.*#+}} xmm1 = xmm6[1,0,3,2]
; SSSE3-NEXT: pand %xmm6, %xmm1
; SSSE3-NEXT: pandn %xmm3, %xmm1
; SSSE3-NEXT: movdqa %xmm1, %xmm3
; SSSE3-NEXT: pandn %xmm0, %xmm3
; SSSE3-NEXT: por %xmm2, %xmm0
; SSSE3-NEXT: movdqa %xmm2, %xmm4
; SSSE3-NEXT: pcmpgtd %xmm0, %xmm4
; SSSE3-NEXT: pshufd {{.*#+}} xmm5 = xmm4[0,0,2,2]
; SSSE3-NEXT: pcmpeqd %xmm2, %xmm0
; SSSE3-NEXT: pshufd {{.*#+}} xmm0 = xmm0[1,1,3,3]
; SSSE3-NEXT: pand %xmm5, %xmm0
; SSSE3-NEXT: pshufd {{.*#+}} xmm2 = xmm4[1,1,3,3]
; SSSE3-NEXT: por %xmm0, %xmm2
; SSSE3-NEXT: movdqa %xmm2, %xmm0
; SSSE3-NEXT: pandn {{.*}}(%rip), %xmm0
; SSSE3-NEXT: pand {{.*}}(%rip), %xmm2
; SSSE3-NEXT: por %xmm0, %xmm2
; SSSE3-NEXT: pand %xmm7, %xmm2
; SSSE3-NEXT: pshufd {{.*#+}} xmm4 = xmm6[1,1,3,3]
; SSSE3-NEXT: por %xmm2, %xmm4
; SSSE3-NEXT: pxor %xmm4, %xmm1
; SSSE3-NEXT: pcmpeqd %xmm5, %xmm1
; SSSE3-NEXT: pshufd {{.*#+}} xmm2 = xmm1[1,0,3,2]
; SSSE3-NEXT: pand %xmm1, %xmm2
; SSSE3-NEXT: por %xmm3, %xmm2
; SSSE3-NEXT: pandn %xmm3, %xmm2
; SSSE3-NEXT: movdqa %xmm4, %xmm1
; SSSE3-NEXT: pandn {{.*}}(%rip), %xmm1
; SSSE3-NEXT: pand {{.*}}(%rip), %xmm4
; SSSE3-NEXT: por %xmm1, %xmm4
; SSSE3-NEXT: pand %xmm2, %xmm4
; SSSE3-NEXT: pandn %xmm0, %xmm2
; SSSE3-NEXT: por %xmm4, %xmm2
; SSSE3-NEXT: pshufd {{.*#+}} xmm0 = xmm2[1,3,2,3]
; SSSE3-NEXT: psrad $31, %xmm2
; SSSE3-NEXT: pshufd {{.*#+}} xmm1 = xmm2[1,3,2,3]
@ -802,7 +782,7 @@ define <2 x i32> @v2i32(<2 x i32> %x, <2 x i32> %y) nounwind {
; SSE41-NEXT: psllq $32, %xmm2
; SSE41-NEXT: movdqa %xmm2, %xmm3
; SSE41-NEXT: paddq %xmm1, %xmm2
; SSE41-NEXT: pxor %xmm0, %xmm1
; SSE41-NEXT: por %xmm0, %xmm1
; SSE41-NEXT: movdqa %xmm0, %xmm4
; SSE41-NEXT: pcmpgtd %xmm1, %xmm4
; SSE41-NEXT: pshufd {{.*#+}} xmm5 = xmm4[0,0,2,2]
@ -811,41 +791,32 @@ define <2 x i32> @v2i32(<2 x i32> %x, <2 x i32> %y) nounwind {
; SSE41-NEXT: pand %xmm5, %xmm1
; SSE41-NEXT: pshufd {{.*#+}} xmm4 = xmm4[1,1,3,3]
; SSE41-NEXT: por %xmm1, %xmm4
; SSE41-NEXT: pcmpeqd %xmm8, %xmm8
; SSE41-NEXT: pxor %xmm8, %xmm4
; SSE41-NEXT: pxor %xmm0, %xmm3
; SSE41-NEXT: movdqa %xmm0, %xmm1
; SSE41-NEXT: pcmpgtd %xmm3, %xmm1
; SSE41-NEXT: pshufd {{.*#+}} xmm6 = xmm1[0,0,2,2]
; SSE41-NEXT: pcmpeqd %xmm1, %xmm1
; SSE41-NEXT: pxor %xmm1, %xmm4
; SSE41-NEXT: por %xmm0, %xmm3
; SSE41-NEXT: movdqa %xmm0, %xmm5
; SSE41-NEXT: pcmpgtd %xmm3, %xmm5
; SSE41-NEXT: pshufd {{.*#+}} xmm6 = xmm5[0,0,2,2]
; SSE41-NEXT: pcmpeqd %xmm0, %xmm3
; SSE41-NEXT: pshufd {{.*#+}} xmm3 = xmm3[1,1,3,3]
; SSE41-NEXT: pand %xmm6, %xmm3
; SSE41-NEXT: pshufd {{.*#+}} xmm6 = xmm1[1,1,3,3]
; SSE41-NEXT: por %xmm3, %xmm6
; SSE41-NEXT: pxor %xmm8, %xmm6
; SSE41-NEXT: pcmpeqq %xmm6, %xmm4
; SSE41-NEXT: movdqa %xmm2, %xmm1
; SSE41-NEXT: pxor %xmm0, %xmm1
; SSE41-NEXT: movdqa %xmm0, %xmm3
; SSE41-NEXT: pcmpgtd %xmm1, %xmm3
; SSE41-NEXT: pshufd {{.*#+}} xmm7 = xmm3[0,0,2,2]
; SSE41-NEXT: pcmpeqd %xmm0, %xmm1
; SSE41-NEXT: pshufd {{.*#+}} xmm5 = xmm1[1,1,3,3]
; SSE41-NEXT: pand %xmm7, %xmm5
; SSE41-NEXT: pshufd {{.*#+}} xmm1 = xmm3[1,1,3,3]
; SSE41-NEXT: por %xmm5, %xmm1
; SSE41-NEXT: pxor %xmm8, %xmm1
; SSE41-NEXT: pcmpeqq %xmm6, %xmm1
; SSE41-NEXT: pandn %xmm4, %xmm1
; SSE41-NEXT: pshufd {{.*#+}} xmm5 = xmm5[1,1,3,3]
; SSE41-NEXT: por %xmm3, %xmm5
; SSE41-NEXT: pxor %xmm1, %xmm5
; SSE41-NEXT: pcmpeqq %xmm5, %xmm4
; SSE41-NEXT: movdqa %xmm2, %xmm3
; SSE41-NEXT: por %xmm0, %xmm3
; SSE41-NEXT: movdqa %xmm0, %xmm4
; SSE41-NEXT: pcmpgtd %xmm3, %xmm4
; SSE41-NEXT: pshufd {{.*#+}} xmm5 = xmm4[0,0,2,2]
; SSE41-NEXT: movdqa %xmm0, %xmm6
; SSE41-NEXT: pcmpgtd %xmm3, %xmm6
; SSE41-NEXT: pshufd {{.*#+}} xmm7 = xmm6[0,0,2,2]
; SSE41-NEXT: pcmpeqd %xmm0, %xmm3
; SSE41-NEXT: pshufd {{.*#+}} xmm0 = xmm3[1,1,3,3]
; SSE41-NEXT: pand %xmm5, %xmm0
; SSE41-NEXT: por %xmm4, %xmm0
; SSE41-NEXT: pshufd {{.*#+}} xmm3 = xmm3[1,1,3,3]
; SSE41-NEXT: pand %xmm7, %xmm3
; SSE41-NEXT: pshufd {{.*#+}} xmm0 = xmm6[1,1,3,3]
; SSE41-NEXT: por %xmm3, %xmm0
; SSE41-NEXT: pxor %xmm0, %xmm1
; SSE41-NEXT: pcmpeqq %xmm5, %xmm1
; SSE41-NEXT: pandn %xmm4, %xmm1
; SSE41-NEXT: movapd {{.*#+}} xmm3 = [9223372036854775808,9223372036854775808]
; SSE41-NEXT: blendvpd %xmm0, {{.*}}(%rip), %xmm3
; SSE41-NEXT: movdqa %xmm1, %xmm0
@ -869,12 +840,12 @@ define <2 x i32> @v2i32(<2 x i32> %x, <2 x i32> %y) nounwind {
; AVX1-NEXT: vpcmpeqq %xmm3, %xmm5, %xmm3
; AVX1-NEXT: vpaddq %xmm1, %xmm0, %xmm0
; AVX1-NEXT: vpcmpgtq %xmm0, %xmm2, %xmm1
; AVX1-NEXT: vpxor %xmm4, %xmm1, %xmm1
; AVX1-NEXT: vpcmpeqq %xmm1, %xmm5, %xmm1
; AVX1-NEXT: vpandn %xmm3, %xmm1, %xmm1
; AVX1-NEXT: vmovapd {{.*#+}} xmm2 = [9223372036854775808,9223372036854775808]
; AVX1-NEXT: vblendvpd %xmm0, {{.*}}(%rip), %xmm2, %xmm2
; AVX1-NEXT: vblendvpd %xmm1, %xmm2, %xmm0, %xmm0
; AVX1-NEXT: vpxor %xmm4, %xmm1, %xmm2
; AVX1-NEXT: vpcmpeqq %xmm2, %xmm5, %xmm2
; AVX1-NEXT: vpandn %xmm3, %xmm2, %xmm2
; AVX1-NEXT: vmovapd {{.*#+}} xmm3 = [9223372036854775808,9223372036854775808]
; AVX1-NEXT: vblendvpd %xmm1, {{.*}}(%rip), %xmm3, %xmm1
; AVX1-NEXT: vblendvpd %xmm2, %xmm1, %xmm0, %xmm0
; AVX1-NEXT: vpsrad $31, %xmm0, %xmm1
; AVX1-NEXT: vpshufd {{.*#+}} xmm0 = xmm0[1,1,3,3]
; AVX1-NEXT: vpblendw {{.*#+}} xmm0 = xmm0[0,1],xmm1[2,3],xmm0[4,5],xmm1[6,7]
@ -893,12 +864,12 @@ define <2 x i32> @v2i32(<2 x i32> %x, <2 x i32> %y) nounwind {
; AVX2-NEXT: vpcmpeqq %xmm3, %xmm5, %xmm3
; AVX2-NEXT: vpaddq %xmm1, %xmm0, %xmm0
; AVX2-NEXT: vpcmpgtq %xmm0, %xmm2, %xmm1
; AVX2-NEXT: vpxor %xmm4, %xmm1, %xmm1
; AVX2-NEXT: vpcmpeqq %xmm1, %xmm5, %xmm1
; AVX2-NEXT: vpandn %xmm3, %xmm1, %xmm1
; AVX2-NEXT: vmovapd {{.*#+}} xmm2 = [9223372036854775808,9223372036854775808]
; AVX2-NEXT: vblendvpd %xmm0, {{.*}}(%rip), %xmm2, %xmm2
; AVX2-NEXT: vblendvpd %xmm1, %xmm2, %xmm0, %xmm0
; AVX2-NEXT: vpxor %xmm4, %xmm1, %xmm2
; AVX2-NEXT: vpcmpeqq %xmm2, %xmm5, %xmm2
; AVX2-NEXT: vpandn %xmm3, %xmm2, %xmm2
; AVX2-NEXT: vmovapd {{.*#+}} xmm3 = [9223372036854775808,9223372036854775808]
; AVX2-NEXT: vblendvpd %xmm1, {{.*}}(%rip), %xmm3, %xmm1
; AVX2-NEXT: vblendvpd %xmm2, %xmm1, %xmm0, %xmm0
; AVX2-NEXT: vpsrad $31, %xmm0, %xmm1
; AVX2-NEXT: vpshufd {{.*#+}} xmm0 = xmm0[1,1,3,3]
; AVX2-NEXT: vpblendd {{.*#+}} xmm0 = xmm0[0],xmm1[1],xmm0[2],xmm1[3]
@ -982,22 +953,21 @@ define <4 x i32> @v4i32(<4 x i32> %x, <4 x i32> %y) nounwind {
; SSE41-LABEL: v4i32:
; SSE41: # %bb.0:
; SSE41-NEXT: movdqa %xmm0, %xmm2
; SSE41-NEXT: pxor %xmm3, %xmm3
; SSE41-NEXT: pxor %xmm0, %xmm0
; SSE41-NEXT: pcmpgtd %xmm1, %xmm0
; SSE41-NEXT: pcmpeqd %xmm4, %xmm4
; SSE41-NEXT: pxor %xmm4, %xmm0
; SSE41-NEXT: pxor %xmm4, %xmm4
; SSE41-NEXT: pcmpgtd %xmm1, %xmm4
; SSE41-NEXT: pcmpeqd %xmm3, %xmm3
; SSE41-NEXT: pxor %xmm3, %xmm4
; SSE41-NEXT: pxor %xmm5, %xmm5
; SSE41-NEXT: pcmpgtd %xmm2, %xmm5
; SSE41-NEXT: pxor %xmm4, %xmm5
; SSE41-NEXT: pcmpeqd %xmm5, %xmm0
; SSE41-NEXT: pxor %xmm3, %xmm5
; SSE41-NEXT: pcmpeqd %xmm5, %xmm4
; SSE41-NEXT: paddd %xmm1, %xmm2
; SSE41-NEXT: pcmpgtd %xmm2, %xmm3
; SSE41-NEXT: pxor %xmm4, %xmm3
; SSE41-NEXT: pcmpgtd %xmm2, %xmm0
; SSE41-NEXT: pxor %xmm0, %xmm3
; SSE41-NEXT: pcmpeqd %xmm5, %xmm3
; SSE41-NEXT: pandn %xmm0, %xmm3
; SSE41-NEXT: pandn %xmm4, %xmm3
; SSE41-NEXT: movaps {{.*#+}} xmm1 = [2147483648,2147483648,2147483648,2147483648]
; SSE41-NEXT: movdqa %xmm2, %xmm0
; SSE41-NEXT: blendvps %xmm0, {{.*}}(%rip), %xmm1
; SSE41-NEXT: movdqa %xmm3, %xmm0
; SSE41-NEXT: blendvps %xmm0, %xmm1, %xmm2
@ -1015,12 +985,12 @@ define <4 x i32> @v4i32(<4 x i32> %x, <4 x i32> %y) nounwind {
; AVX1-NEXT: vpcmpeqd %xmm3, %xmm5, %xmm3
; AVX1-NEXT: vpaddd %xmm1, %xmm0, %xmm0
; AVX1-NEXT: vpcmpgtd %xmm0, %xmm2, %xmm1
; AVX1-NEXT: vpxor %xmm4, %xmm1, %xmm1
; AVX1-NEXT: vpcmpeqd %xmm1, %xmm5, %xmm1
; AVX1-NEXT: vpandn %xmm3, %xmm1, %xmm1
; AVX1-NEXT: vmovaps {{.*#+}} xmm2 = [2147483648,2147483648,2147483648,2147483648]
; AVX1-NEXT: vblendvps %xmm0, {{.*}}(%rip), %xmm2, %xmm2
; AVX1-NEXT: vblendvps %xmm1, %xmm2, %xmm0, %xmm0
; AVX1-NEXT: vpxor %xmm4, %xmm1, %xmm2
; AVX1-NEXT: vpcmpeqd %xmm2, %xmm5, %xmm2
; AVX1-NEXT: vpandn %xmm3, %xmm2, %xmm2
; AVX1-NEXT: vmovaps {{.*#+}} xmm3 = [2147483648,2147483648,2147483648,2147483648]
; AVX1-NEXT: vblendvps %xmm1, {{.*}}(%rip), %xmm3, %xmm1
; AVX1-NEXT: vblendvps %xmm2, %xmm1, %xmm0, %xmm0
; AVX1-NEXT: retq
;
; AVX2-LABEL: v4i32:
@ -1034,13 +1004,13 @@ define <4 x i32> @v4i32(<4 x i32> %x, <4 x i32> %y) nounwind {
; AVX2-NEXT: vpcmpeqd %xmm3, %xmm5, %xmm3
; AVX2-NEXT: vpaddd %xmm1, %xmm0, %xmm0
; AVX2-NEXT: vpcmpgtd %xmm0, %xmm2, %xmm1
; AVX2-NEXT: vpxor %xmm4, %xmm1, %xmm1
; AVX2-NEXT: vpcmpeqd %xmm1, %xmm5, %xmm1
; AVX2-NEXT: vpandn %xmm3, %xmm1, %xmm1
; AVX2-NEXT: vbroadcastss {{.*#+}} xmm2 = [2147483647,2147483647,2147483647,2147483647]
; AVX2-NEXT: vbroadcastss {{.*#+}} xmm3 = [2147483648,2147483648,2147483648,2147483648]
; AVX2-NEXT: vblendvps %xmm0, %xmm2, %xmm3, %xmm2
; AVX2-NEXT: vblendvps %xmm1, %xmm2, %xmm0, %xmm0
; AVX2-NEXT: vpxor %xmm4, %xmm1, %xmm2
; AVX2-NEXT: vpcmpeqd %xmm2, %xmm5, %xmm2
; AVX2-NEXT: vpandn %xmm3, %xmm2, %xmm2
; AVX2-NEXT: vbroadcastss {{.*#+}} xmm3 = [2147483647,2147483647,2147483647,2147483647]
; AVX2-NEXT: vbroadcastss {{.*#+}} xmm4 = [2147483648,2147483648,2147483648,2147483648]
; AVX2-NEXT: vblendvps %xmm1, %xmm3, %xmm4, %xmm1
; AVX2-NEXT: vblendvps %xmm2, %xmm1, %xmm0, %xmm0
; AVX2-NEXT: retq
;
; AVX512-LABEL: v4i32:
@ -1163,46 +1133,46 @@ define <8 x i32> @v8i32(<8 x i32> %x, <8 x i32> %y) nounwind {
;
; SSE41-LABEL: v8i32:
; SSE41: # %bb.0:
; SSE41-NEXT: movdqa %xmm0, %xmm5
; SSE41-NEXT: pxor %xmm4, %xmm4
; SSE41-NEXT: pxor %xmm0, %xmm0
; SSE41-NEXT: pcmpgtd %xmm2, %xmm0
; SSE41-NEXT: pcmpeqd %xmm9, %xmm9
; SSE41-NEXT: pxor %xmm9, %xmm0
; SSE41-NEXT: movdqa %xmm0, %xmm6
; SSE41-NEXT: pxor %xmm8, %xmm8
; SSE41-NEXT: pxor %xmm7, %xmm7
; SSE41-NEXT: pcmpgtd %xmm5, %xmm7
; SSE41-NEXT: pxor %xmm9, %xmm7
; SSE41-NEXT: pcmpeqd %xmm7, %xmm0
; SSE41-NEXT: paddd %xmm2, %xmm5
; SSE41-NEXT: pxor %xmm2, %xmm2
; SSE41-NEXT: pcmpgtd %xmm5, %xmm2
; SSE41-NEXT: pxor %xmm9, %xmm2
; SSE41-NEXT: pcmpeqd %xmm7, %xmm2
; SSE41-NEXT: pandn %xmm0, %xmm2
; SSE41-NEXT: movaps {{.*#+}} xmm8 = [2147483647,2147483647,2147483647,2147483647]
; SSE41-NEXT: movaps {{.*#+}} xmm6 = [2147483648,2147483648,2147483648,2147483648]
; SSE41-NEXT: movaps %xmm6, %xmm7
; SSE41-NEXT: movdqa %xmm5, %xmm0
; SSE41-NEXT: blendvps %xmm0, %xmm8, %xmm7
; SSE41-NEXT: pcmpgtd %xmm2, %xmm7
; SSE41-NEXT: pcmpeqd %xmm4, %xmm4
; SSE41-NEXT: pxor %xmm4, %xmm7
; SSE41-NEXT: pxor %xmm5, %xmm5
; SSE41-NEXT: pcmpgtd %xmm0, %xmm5
; SSE41-NEXT: pxor %xmm4, %xmm5
; SSE41-NEXT: pcmpeqd %xmm5, %xmm7
; SSE41-NEXT: paddd %xmm2, %xmm6
; SSE41-NEXT: pxor %xmm0, %xmm0
; SSE41-NEXT: pcmpgtd %xmm6, %xmm0
; SSE41-NEXT: movdqa %xmm0, %xmm2
; SSE41-NEXT: pxor %xmm4, %xmm2
; SSE41-NEXT: pcmpeqd %xmm5, %xmm2
; SSE41-NEXT: pandn %xmm7, %xmm2
; SSE41-NEXT: movaps {{.*#+}} xmm9 = [2147483647,2147483647,2147483647,2147483647]
; SSE41-NEXT: movaps {{.*#+}} xmm5 = [2147483648,2147483648,2147483648,2147483648]
; SSE41-NEXT: movaps %xmm5, %xmm7
; SSE41-NEXT: blendvps %xmm0, %xmm9, %xmm7
; SSE41-NEXT: movdqa %xmm2, %xmm0
; SSE41-NEXT: blendvps %xmm0, %xmm7, %xmm5
; SSE41-NEXT: blendvps %xmm0, %xmm7, %xmm6
; SSE41-NEXT: pxor %xmm0, %xmm0
; SSE41-NEXT: pcmpgtd %xmm3, %xmm0
; SSE41-NEXT: pxor %xmm9, %xmm0
; SSE41-NEXT: pxor %xmm4, %xmm0
; SSE41-NEXT: pxor %xmm2, %xmm2
; SSE41-NEXT: pcmpgtd %xmm1, %xmm2
; SSE41-NEXT: pxor %xmm9, %xmm2
; SSE41-NEXT: pxor %xmm4, %xmm2
; SSE41-NEXT: pcmpeqd %xmm2, %xmm0
; SSE41-NEXT: paddd %xmm3, %xmm1
; SSE41-NEXT: pcmpgtd %xmm1, %xmm4
; SSE41-NEXT: pxor %xmm9, %xmm4
; SSE41-NEXT: pcmpgtd %xmm1, %xmm8
; SSE41-NEXT: pxor %xmm8, %xmm4
; SSE41-NEXT: pcmpeqd %xmm2, %xmm4
; SSE41-NEXT: pandn %xmm0, %xmm4
; SSE41-NEXT: movdqa %xmm1, %xmm0
; SSE41-NEXT: blendvps %xmm0, %xmm8, %xmm6
; SSE41-NEXT: movdqa %xmm8, %xmm0
; SSE41-NEXT: blendvps %xmm0, %xmm9, %xmm5
; SSE41-NEXT: movdqa %xmm4, %xmm0
; SSE41-NEXT: blendvps %xmm0, %xmm6, %xmm1
; SSE41-NEXT: movaps %xmm5, %xmm0
; SSE41-NEXT: blendvps %xmm0, %xmm5, %xmm1
; SSE41-NEXT: movaps %xmm6, %xmm0
; SSE41-NEXT: retq
;
; AVX1-LABEL: v8i32:
@ -1229,16 +1199,16 @@ define <8 x i32> @v8i32(<8 x i32> %x, <8 x i32> %y) nounwind {
; AVX1-NEXT: vpxor %xmm5, %xmm2, %xmm2
; AVX1-NEXT: vpaddd %xmm1, %xmm0, %xmm0
; AVX1-NEXT: vpcmpgtd %xmm0, %xmm3, %xmm1
; AVX1-NEXT: vpxor %xmm5, %xmm1, %xmm1
; AVX1-NEXT: vpcmpeqd %xmm1, %xmm4, %xmm1
; AVX1-NEXT: vpxor %xmm5, %xmm1, %xmm1
; AVX1-NEXT: vinsertf128 $1, %xmm2, %ymm1, %ymm1
; AVX1-NEXT: vandps %ymm1, %ymm8, %ymm1
; AVX1-NEXT: vinsertf128 $1, %xmm6, %ymm0, %ymm2
; AVX1-NEXT: vpxor %xmm5, %xmm1, %xmm3
; AVX1-NEXT: vpcmpeqd %xmm3, %xmm4, %xmm3
; AVX1-NEXT: vpxor %xmm5, %xmm3, %xmm3
; AVX1-NEXT: vinsertf128 $1, %xmm2, %ymm3, %ymm2
; AVX1-NEXT: vandps %ymm2, %ymm8, %ymm2
; AVX1-NEXT: vinsertf128 $1, %xmm6, %ymm1, %ymm1
; AVX1-NEXT: vmovaps {{.*#+}} ymm3 = [2147483648,2147483648,2147483648,2147483648,2147483648,2147483648,2147483648,2147483648]
; AVX1-NEXT: vblendvps %ymm2, {{.*}}(%rip), %ymm3, %ymm2
; AVX1-NEXT: vblendvps %ymm1, {{.*}}(%rip), %ymm3, %ymm1
; AVX1-NEXT: vinsertf128 $1, %xmm9, %ymm0, %ymm0
; AVX1-NEXT: vblendvps %ymm1, %ymm2, %ymm0, %ymm0
; AVX1-NEXT: vblendvps %ymm2, %ymm1, %ymm0, %ymm0
; AVX1-NEXT: retq
;
; AVX2-LABEL: v8i32:
@ -1252,13 +1222,13 @@ define <8 x i32> @v8i32(<8 x i32> %x, <8 x i32> %y) nounwind {
; AVX2-NEXT: vpcmpeqd %ymm3, %ymm5, %ymm3
; AVX2-NEXT: vpaddd %ymm1, %ymm0, %ymm0
; AVX2-NEXT: vpcmpgtd %ymm0, %ymm2, %ymm1
; AVX2-NEXT: vpxor %ymm4, %ymm1, %ymm1
; AVX2-NEXT: vpcmpeqd %ymm1, %ymm5, %ymm1
; AVX2-NEXT: vpandn %ymm3, %ymm1, %ymm1
; AVX2-NEXT: vbroadcastss {{.*#+}} ymm2 = [2147483647,2147483647,2147483647,2147483647,2147483647,2147483647,2147483647,2147483647]
; AVX2-NEXT: vbroadcastss {{.*#+}} ymm3 = [2147483648,2147483648,2147483648,2147483648,2147483648,2147483648,2147483648,2147483648]
; AVX2-NEXT: vblendvps %ymm0, %ymm2, %ymm3, %ymm2
; AVX2-NEXT: vblendvps %ymm1, %ymm2, %ymm0, %ymm0
; AVX2-NEXT: vpxor %ymm4, %ymm1, %ymm2
; AVX2-NEXT: vpcmpeqd %ymm2, %ymm5, %ymm2
; AVX2-NEXT: vpandn %ymm3, %ymm2, %ymm2
; AVX2-NEXT: vbroadcastss {{.*#+}} ymm3 = [2147483647,2147483647,2147483647,2147483647,2147483647,2147483647,2147483647,2147483647]
; AVX2-NEXT: vbroadcastss {{.*#+}} ymm4 = [2147483648,2147483648,2147483648,2147483648,2147483648,2147483648,2147483648,2147483648]
; AVX2-NEXT: vblendvps %ymm1, %ymm3, %ymm4, %ymm1
; AVX2-NEXT: vblendvps %ymm2, %ymm1, %ymm0, %ymm0
; AVX2-NEXT: retq
;
; AVX512-LABEL: v8i32:
@ -1469,62 +1439,62 @@ define <16 x i32> @v16i32(<16 x i32> %x, <16 x i32> %y) nounwind {
;
; SSE41-LABEL: v16i32:
; SSE41: # %bb.0:
; SSE41-NEXT: movdqa %xmm0, %xmm8
; SSE41-NEXT: pxor %xmm9, %xmm9
; SSE41-NEXT: movdqa %xmm0, %xmm9
; SSE41-NEXT: pxor %xmm8, %xmm8
; SSE41-NEXT: pxor %xmm11, %xmm11
; SSE41-NEXT: pcmpgtd %xmm4, %xmm11
; SSE41-NEXT: pcmpeqd %xmm10, %xmm10
; SSE41-NEXT: pxor %xmm10, %xmm11
; SSE41-NEXT: pxor %xmm12, %xmm12
; SSE41-NEXT: pcmpgtd %xmm0, %xmm12
; SSE41-NEXT: pxor %xmm10, %xmm12
; SSE41-NEXT: pcmpeqd %xmm12, %xmm11
; SSE41-NEXT: paddd %xmm4, %xmm9
; SSE41-NEXT: pxor %xmm0, %xmm0
; SSE41-NEXT: pcmpgtd %xmm8, %xmm0
; SSE41-NEXT: pxor %xmm10, %xmm0
; SSE41-NEXT: pcmpeqd %xmm0, %xmm11
; SSE41-NEXT: paddd %xmm4, %xmm8
; SSE41-NEXT: pxor %xmm4, %xmm4
; SSE41-NEXT: pcmpgtd %xmm8, %xmm4
; SSE41-NEXT: pcmpgtd %xmm9, %xmm0
; SSE41-NEXT: movdqa %xmm0, %xmm4
; SSE41-NEXT: pxor %xmm10, %xmm4
; SSE41-NEXT: pcmpeqd %xmm0, %xmm4
; SSE41-NEXT: pcmpeqd %xmm12, %xmm4
; SSE41-NEXT: pandn %xmm11, %xmm4
; SSE41-NEXT: movaps {{.*#+}} xmm12 = [2147483647,2147483647,2147483647,2147483647]
; SSE41-NEXT: movaps {{.*#+}} xmm11 = [2147483648,2147483648,2147483648,2147483648]
; SSE41-NEXT: movaps %xmm11, %xmm13
; SSE41-NEXT: movdqa %xmm8, %xmm0
; SSE41-NEXT: blendvps %xmm0, %xmm12, %xmm13
; SSE41-NEXT: movdqa %xmm4, %xmm0
; SSE41-NEXT: blendvps %xmm0, %xmm13, %xmm8
; SSE41-NEXT: blendvps %xmm0, %xmm13, %xmm9
; SSE41-NEXT: xorps %xmm13, %xmm13
; SSE41-NEXT: pcmpgtd %xmm5, %xmm13
; SSE41-NEXT: pxor %xmm10, %xmm13
; SSE41-NEXT: pxor %xmm14, %xmm14
; SSE41-NEXT: pcmpgtd %xmm1, %xmm14
; SSE41-NEXT: pxor %xmm10, %xmm14
; SSE41-NEXT: pcmpeqd %xmm14, %xmm13
; SSE41-NEXT: paddd %xmm5, %xmm1
; SSE41-NEXT: pxor %xmm0, %xmm0
; SSE41-NEXT: pcmpgtd %xmm1, %xmm0
; SSE41-NEXT: pxor %xmm10, %xmm0
; SSE41-NEXT: pcmpeqd %xmm0, %xmm13
; SSE41-NEXT: paddd %xmm5, %xmm1
; SSE41-NEXT: pxor %xmm4, %xmm4
; SSE41-NEXT: pcmpgtd %xmm1, %xmm4
; SSE41-NEXT: movdqa %xmm0, %xmm4
; SSE41-NEXT: pxor %xmm10, %xmm4
; SSE41-NEXT: pcmpeqd %xmm0, %xmm4
; SSE41-NEXT: pcmpeqd %xmm14, %xmm4
; SSE41-NEXT: pandn %xmm13, %xmm4
; SSE41-NEXT: movaps %xmm11, %xmm5
; SSE41-NEXT: movdqa %xmm1, %xmm0
; SSE41-NEXT: blendvps %xmm0, %xmm12, %xmm5
; SSE41-NEXT: movdqa %xmm4, %xmm0
; SSE41-NEXT: blendvps %xmm0, %xmm5, %xmm1
; SSE41-NEXT: pxor %xmm0, %xmm0
; SSE41-NEXT: pcmpgtd %xmm6, %xmm0
; SSE41-NEXT: pxor %xmm10, %xmm0
; SSE41-NEXT: pxor %xmm13, %xmm13
; SSE41-NEXT: pcmpgtd %xmm6, %xmm13
; SSE41-NEXT: pxor %xmm10, %xmm13
; SSE41-NEXT: xorps %xmm5, %xmm5
; SSE41-NEXT: pcmpgtd %xmm2, %xmm5
; SSE41-NEXT: pxor %xmm10, %xmm5
; SSE41-NEXT: pcmpeqd %xmm5, %xmm0
; SSE41-NEXT: pcmpeqd %xmm5, %xmm13
; SSE41-NEXT: paddd %xmm6, %xmm2
; SSE41-NEXT: pxor %xmm4, %xmm4
; SSE41-NEXT: pcmpgtd %xmm2, %xmm4
; SSE41-NEXT: pxor %xmm0, %xmm0
; SSE41-NEXT: pcmpgtd %xmm2, %xmm0
; SSE41-NEXT: movdqa %xmm0, %xmm4
; SSE41-NEXT: pxor %xmm10, %xmm4
; SSE41-NEXT: pcmpeqd %xmm5, %xmm4
; SSE41-NEXT: pandn %xmm0, %xmm4
; SSE41-NEXT: pandn %xmm13, %xmm4
; SSE41-NEXT: movaps %xmm11, %xmm5
; SSE41-NEXT: movdqa %xmm2, %xmm0
; SSE41-NEXT: blendvps %xmm0, %xmm12, %xmm5
; SSE41-NEXT: movdqa %xmm4, %xmm0
; SSE41-NEXT: blendvps %xmm0, %xmm5, %xmm2
@ -1536,80 +1506,80 @@ define <16 x i32> @v16i32(<16 x i32> %x, <16 x i32> %y) nounwind {
; SSE41-NEXT: pxor %xmm10, %xmm4
; SSE41-NEXT: pcmpeqd %xmm4, %xmm0
; SSE41-NEXT: paddd %xmm7, %xmm3
; SSE41-NEXT: pcmpgtd %xmm3, %xmm9
; SSE41-NEXT: pxor %xmm10, %xmm9
; SSE41-NEXT: pcmpeqd %xmm4, %xmm9
; SSE41-NEXT: pandn %xmm0, %xmm9
; SSE41-NEXT: movdqa %xmm3, %xmm0
; SSE41-NEXT: pcmpgtd %xmm3, %xmm8
; SSE41-NEXT: pxor %xmm8, %xmm10
; SSE41-NEXT: pcmpeqd %xmm4, %xmm10
; SSE41-NEXT: pandn %xmm0, %xmm10
; SSE41-NEXT: movdqa %xmm8, %xmm0
; SSE41-NEXT: blendvps %xmm0, %xmm12, %xmm11
; SSE41-NEXT: movdqa %xmm9, %xmm0
; SSE41-NEXT: movdqa %xmm10, %xmm0
; SSE41-NEXT: blendvps %xmm0, %xmm11, %xmm3
; SSE41-NEXT: movaps %xmm8, %xmm0
; SSE41-NEXT: movaps %xmm9, %xmm0
; SSE41-NEXT: retq
;
; AVX1-LABEL: v16i32:
; AVX1: # %bb.0:
; AVX1-NEXT: vextractf128 $1, %ymm2, %xmm9
; AVX1-NEXT: vpxor %xmm12, %xmm12, %xmm12
; AVX1-NEXT: vpcmpgtd %xmm9, %xmm12, %xmm7
; AVX1-NEXT: vpxor %xmm10, %xmm10, %xmm10
; AVX1-NEXT: vpcmpgtd %xmm9, %xmm10, %xmm7
; AVX1-NEXT: vpcmpeqd %xmm4, %xmm4, %xmm4
; AVX1-NEXT: vpxor %xmm4, %xmm7, %xmm8
; AVX1-NEXT: vextractf128 $1, %ymm0, %xmm7
; AVX1-NEXT: vpcmpgtd %xmm7, %xmm12, %xmm6
; AVX1-NEXT: vpxor %xmm4, %xmm6, %xmm10
; AVX1-NEXT: vpcmpeqd %xmm8, %xmm10, %xmm8
; AVX1-NEXT: vpcmpgtd %xmm2, %xmm12, %xmm6
; AVX1-NEXT: vpxor %xmm4, %xmm6, %xmm11
; AVX1-NEXT: vpcmpgtd %xmm0, %xmm12, %xmm6
; AVX1-NEXT: vpxor %xmm4, %xmm6, %xmm6
; AVX1-NEXT: vpcmpeqd %xmm11, %xmm6, %xmm11
; AVX1-NEXT: vpcmpgtd %xmm7, %xmm10, %xmm6
; AVX1-NEXT: vpxor %xmm4, %xmm6, %xmm12
; AVX1-NEXT: vpcmpeqd %xmm8, %xmm12, %xmm8
; AVX1-NEXT: vpcmpgtd %xmm2, %xmm10, %xmm5
; AVX1-NEXT: vpxor %xmm4, %xmm5, %xmm11
; AVX1-NEXT: vpcmpgtd %xmm0, %xmm10, %xmm5
; AVX1-NEXT: vpxor %xmm4, %xmm5, %xmm5
; AVX1-NEXT: vpcmpeqd %xmm11, %xmm5, %xmm11
; AVX1-NEXT: vinsertf128 $1, %xmm8, %ymm11, %ymm8
; AVX1-NEXT: vpaddd %xmm9, %xmm7, %xmm9
; AVX1-NEXT: vpcmpgtd %xmm9, %xmm12, %xmm7
; AVX1-NEXT: vpxor %xmm4, %xmm7, %xmm5
; AVX1-NEXT: vpcmpeqd %xmm5, %xmm10, %xmm5
; AVX1-NEXT: vpxor %xmm4, %xmm5, %xmm5
; AVX1-NEXT: vpcmpgtd %xmm9, %xmm10, %xmm7
; AVX1-NEXT: vpxor %xmm4, %xmm7, %xmm6
; AVX1-NEXT: vpcmpeqd %xmm6, %xmm12, %xmm6
; AVX1-NEXT: vpxor %xmm4, %xmm6, %xmm11
; AVX1-NEXT: vpaddd %xmm2, %xmm0, %xmm0
; AVX1-NEXT: vpcmpgtd %xmm0, %xmm12, %xmm2
; AVX1-NEXT: vpxor %xmm4, %xmm2, %xmm2
; AVX1-NEXT: vpcmpeqd %xmm2, %xmm6, %xmm2
; AVX1-NEXT: vpxor %xmm4, %xmm2, %xmm2
; AVX1-NEXT: vinsertf128 $1, %xmm5, %ymm2, %ymm2
; AVX1-NEXT: vandps %ymm2, %ymm8, %ymm5
; AVX1-NEXT: vinsertf128 $1, %xmm7, %ymm0, %ymm7
; AVX1-NEXT: vpcmpgtd %xmm0, %xmm10, %xmm2
; AVX1-NEXT: vpxor %xmm4, %xmm2, %xmm6
; AVX1-NEXT: vpcmpeqd %xmm6, %xmm5, %xmm5
; AVX1-NEXT: vpxor %xmm4, %xmm5, %xmm5
; AVX1-NEXT: vinsertf128 $1, %xmm11, %ymm5, %ymm5
; AVX1-NEXT: vandps %ymm5, %ymm8, %ymm5
; AVX1-NEXT: vinsertf128 $1, %xmm7, %ymm2, %ymm7
; AVX1-NEXT: vmovaps {{.*#+}} ymm8 = [2147483647,2147483647,2147483647,2147483647,2147483647,2147483647,2147483647,2147483647]
; AVX1-NEXT: vmovaps {{.*#+}} ymm10 = [2147483648,2147483648,2147483648,2147483648,2147483648,2147483648,2147483648,2147483648]
; AVX1-NEXT: vblendvps %ymm7, %ymm8, %ymm10, %ymm7
; AVX1-NEXT: vmovaps {{.*#+}} ymm11 = [2147483648,2147483648,2147483648,2147483648,2147483648,2147483648,2147483648,2147483648]
; AVX1-NEXT: vblendvps %ymm7, %ymm8, %ymm11, %ymm7
; AVX1-NEXT: vinsertf128 $1, %xmm9, %ymm0, %ymm0
; AVX1-NEXT: vblendvps %ymm5, %ymm7, %ymm0, %ymm0
; AVX1-NEXT: vextractf128 $1, %ymm3, %xmm5
; AVX1-NEXT: vpcmpgtd %xmm5, %xmm12, %xmm7
; AVX1-NEXT: vpcmpgtd %xmm5, %xmm10, %xmm7
; AVX1-NEXT: vpxor %xmm4, %xmm7, %xmm7
; AVX1-NEXT: vextractf128 $1, %ymm1, %xmm2
; AVX1-NEXT: vpcmpgtd %xmm2, %xmm12, %xmm6
; AVX1-NEXT: vpcmpgtd %xmm2, %xmm10, %xmm6
; AVX1-NEXT: vpxor %xmm4, %xmm6, %xmm6
; AVX1-NEXT: vpcmpeqd %xmm7, %xmm6, %xmm9
; AVX1-NEXT: vpcmpgtd %xmm3, %xmm12, %xmm7
; AVX1-NEXT: vpxor %xmm4, %xmm7, %xmm11
; AVX1-NEXT: vpcmpgtd %xmm1, %xmm12, %xmm7
; AVX1-NEXT: vpcmpgtd %xmm3, %xmm10, %xmm7
; AVX1-NEXT: vpxor %xmm4, %xmm7, %xmm12
; AVX1-NEXT: vpcmpgtd %xmm1, %xmm10, %xmm7
; AVX1-NEXT: vpxor %xmm4, %xmm7, %xmm7
; AVX1-NEXT: vpcmpeqd %xmm11, %xmm7, %xmm11
; AVX1-NEXT: vinsertf128 $1, %xmm9, %ymm11, %ymm9
; AVX1-NEXT: vpaddd %xmm5, %xmm2, %xmm11
; AVX1-NEXT: vpcmpgtd %xmm11, %xmm12, %xmm5
; AVX1-NEXT: vpcmpeqd %xmm12, %xmm7, %xmm12
; AVX1-NEXT: vinsertf128 $1, %xmm9, %ymm12, %ymm9
; AVX1-NEXT: vpaddd %xmm5, %xmm2, %xmm12
; AVX1-NEXT: vpcmpgtd %xmm12, %xmm10, %xmm5
; AVX1-NEXT: vpxor %xmm4, %xmm5, %xmm2
; AVX1-NEXT: vpcmpeqd %xmm2, %xmm6, %xmm2
; AVX1-NEXT: vpxor %xmm4, %xmm2, %xmm2
; AVX1-NEXT: vpaddd %xmm3, %xmm1, %xmm1
; AVX1-NEXT: vpcmpgtd %xmm1, %xmm12, %xmm3
; AVX1-NEXT: vpxor %xmm4, %xmm3, %xmm3
; AVX1-NEXT: vpcmpeqd %xmm3, %xmm7, %xmm3
; AVX1-NEXT: vpxor %xmm4, %xmm3, %xmm3
; AVX1-NEXT: vinsertf128 $1, %xmm2, %ymm3, %ymm2
; AVX1-NEXT: vpcmpgtd %xmm1, %xmm10, %xmm3
; AVX1-NEXT: vpxor %xmm4, %xmm3, %xmm6
; AVX1-NEXT: vpcmpeqd %xmm6, %xmm7, %xmm6
; AVX1-NEXT: vpxor %xmm4, %xmm6, %xmm4
; AVX1-NEXT: vinsertf128 $1, %xmm2, %ymm4, %ymm2
; AVX1-NEXT: vandps %ymm2, %ymm9, %ymm2
; AVX1-NEXT: vinsertf128 $1, %xmm5, %ymm1, %ymm3
; AVX1-NEXT: vblendvps %ymm3, %ymm8, %ymm10, %ymm3
; AVX1-NEXT: vinsertf128 $1, %xmm11, %ymm1, %ymm1
; AVX1-NEXT: vinsertf128 $1, %xmm5, %ymm3, %ymm3
; AVX1-NEXT: vblendvps %ymm3, %ymm8, %ymm11, %ymm3
; AVX1-NEXT: vinsertf128 $1, %xmm12, %ymm1, %ymm1
; AVX1-NEXT: vblendvps %ymm2, %ymm3, %ymm1, %ymm1
; AVX1-NEXT: retq
;
@ -1624,24 +1594,24 @@ define <16 x i32> @v16i32(<16 x i32> %x, <16 x i32> %y) nounwind {
; AVX2-NEXT: vpcmpeqd %ymm5, %ymm7, %ymm5
; AVX2-NEXT: vpaddd %ymm2, %ymm0, %ymm0
; AVX2-NEXT: vpcmpgtd %ymm0, %ymm4, %ymm2
; AVX2-NEXT: vpxor %ymm6, %ymm2, %ymm2
; AVX2-NEXT: vpcmpeqd %ymm2, %ymm7, %ymm2
; AVX2-NEXT: vpandn %ymm5, %ymm2, %ymm2
; AVX2-NEXT: vbroadcastss {{.*#+}} ymm5 = [2147483647,2147483647,2147483647,2147483647,2147483647,2147483647,2147483647,2147483647]
; AVX2-NEXT: vbroadcastss {{.*#+}} ymm7 = [2147483648,2147483648,2147483648,2147483648,2147483648,2147483648,2147483648,2147483648]
; AVX2-NEXT: vblendvps %ymm0, %ymm5, %ymm7, %ymm8
; AVX2-NEXT: vblendvps %ymm2, %ymm8, %ymm0, %ymm0
; AVX2-NEXT: vpxor %ymm6, %ymm2, %ymm8
; AVX2-NEXT: vpcmpeqd %ymm8, %ymm7, %ymm7
; AVX2-NEXT: vpandn %ymm5, %ymm7, %ymm5
; AVX2-NEXT: vbroadcastss {{.*#+}} ymm7 = [2147483647,2147483647,2147483647,2147483647,2147483647,2147483647,2147483647,2147483647]
; AVX2-NEXT: vbroadcastss {{.*#+}} ymm8 = [2147483648,2147483648,2147483648,2147483648,2147483648,2147483648,2147483648,2147483648]
; AVX2-NEXT: vblendvps %ymm2, %ymm7, %ymm8, %ymm2
; AVX2-NEXT: vblendvps %ymm5, %ymm2, %ymm0, %ymm0
; AVX2-NEXT: vpcmpgtd %ymm3, %ymm4, %ymm2
; AVX2-NEXT: vpxor %ymm6, %ymm2, %ymm2
; AVX2-NEXT: vpcmpgtd %ymm1, %ymm4, %ymm8
; AVX2-NEXT: vpxor %ymm6, %ymm8, %ymm8
; AVX2-NEXT: vpcmpeqd %ymm2, %ymm8, %ymm2
; AVX2-NEXT: vpcmpgtd %ymm1, %ymm4, %ymm5
; AVX2-NEXT: vpxor %ymm6, %ymm5, %ymm5
; AVX2-NEXT: vpcmpeqd %ymm2, %ymm5, %ymm2
; AVX2-NEXT: vpaddd %ymm3, %ymm1, %ymm1
; AVX2-NEXT: vpcmpgtd %ymm1, %ymm4, %ymm3
; AVX2-NEXT: vpxor %ymm6, %ymm3, %ymm3
; AVX2-NEXT: vpcmpeqd %ymm3, %ymm8, %ymm3
; AVX2-NEXT: vpandn %ymm2, %ymm3, %ymm2
; AVX2-NEXT: vblendvps %ymm1, %ymm5, %ymm7, %ymm3
; AVX2-NEXT: vpxor %ymm6, %ymm3, %ymm4
; AVX2-NEXT: vpcmpeqd %ymm4, %ymm5, %ymm4
; AVX2-NEXT: vpandn %ymm2, %ymm4, %ymm2
; AVX2-NEXT: vblendvps %ymm3, %ymm7, %ymm8, %ymm3
; AVX2-NEXT: vblendvps %ymm2, %ymm3, %ymm1, %ymm1
; AVX2-NEXT: retq
;
@ -1832,12 +1802,12 @@ define <2 x i64> @v2i64(<2 x i64> %x, <2 x i64> %y) nounwind {
; AVX1-NEXT: vpcmpeqq %xmm3, %xmm5, %xmm3
; AVX1-NEXT: vpaddq %xmm1, %xmm0, %xmm0
; AVX1-NEXT: vpcmpgtq %xmm0, %xmm2, %xmm1
; AVX1-NEXT: vpxor %xmm4, %xmm1, %xmm1
; AVX1-NEXT: vpcmpeqq %xmm1, %xmm5, %xmm1
; AVX1-NEXT: vpandn %xmm3, %xmm1, %xmm1
; AVX1-NEXT: vmovapd {{.*#+}} xmm2 = [9223372036854775808,9223372036854775808]
; AVX1-NEXT: vblendvpd %xmm0, {{.*}}(%rip), %xmm2, %xmm2
; AVX1-NEXT: vblendvpd %xmm1, %xmm2, %xmm0, %xmm0
; AVX1-NEXT: vpxor %xmm4, %xmm1, %xmm2
; AVX1-NEXT: vpcmpeqq %xmm2, %xmm5, %xmm2
; AVX1-NEXT: vpandn %xmm3, %xmm2, %xmm2
; AVX1-NEXT: vmovapd {{.*#+}} xmm3 = [9223372036854775808,9223372036854775808]
; AVX1-NEXT: vblendvpd %xmm1, {{.*}}(%rip), %xmm3, %xmm1
; AVX1-NEXT: vblendvpd %xmm2, %xmm1, %xmm0, %xmm0
; AVX1-NEXT: retq
;
; AVX2-LABEL: v2i64:
@ -1851,12 +1821,12 @@ define <2 x i64> @v2i64(<2 x i64> %x, <2 x i64> %y) nounwind {
; AVX2-NEXT: vpcmpeqq %xmm3, %xmm5, %xmm3
; AVX2-NEXT: vpaddq %xmm1, %xmm0, %xmm0
; AVX2-NEXT: vpcmpgtq %xmm0, %xmm2, %xmm1
; AVX2-NEXT: vpxor %xmm4, %xmm1, %xmm1
; AVX2-NEXT: vpcmpeqq %xmm1, %xmm5, %xmm1
; AVX2-NEXT: vpandn %xmm3, %xmm1, %xmm1
; AVX2-NEXT: vmovapd {{.*#+}} xmm2 = [9223372036854775808,9223372036854775808]
; AVX2-NEXT: vblendvpd %xmm0, {{.*}}(%rip), %xmm2, %xmm2
; AVX2-NEXT: vblendvpd %xmm1, %xmm2, %xmm0, %xmm0
; AVX2-NEXT: vpxor %xmm4, %xmm1, %xmm2
; AVX2-NEXT: vpcmpeqq %xmm2, %xmm5, %xmm2
; AVX2-NEXT: vpandn %xmm3, %xmm2, %xmm2
; AVX2-NEXT: vmovapd {{.*#+}} xmm3 = [9223372036854775808,9223372036854775808]
; AVX2-NEXT: vblendvpd %xmm1, {{.*}}(%rip), %xmm3, %xmm1
; AVX2-NEXT: vblendvpd %xmm2, %xmm1, %xmm0, %xmm0
; AVX2-NEXT: retq
;
; AVX512-LABEL: v2i64:
@ -2200,16 +2170,16 @@ define <4 x i64> @v4i64(<4 x i64> %x, <4 x i64> %y) nounwind {
; AVX1-NEXT: vpxor %xmm5, %xmm2, %xmm2
; AVX1-NEXT: vpaddq %xmm1, %xmm0, %xmm0
; AVX1-NEXT: vpcmpgtq %xmm0, %xmm3, %xmm1
; AVX1-NEXT: vpxor %xmm5, %xmm1, %xmm1
; AVX1-NEXT: vpcmpeqq %xmm1, %xmm4, %xmm1
; AVX1-NEXT: vpxor %xmm5, %xmm1, %xmm1
; AVX1-NEXT: vinsertf128 $1, %xmm2, %ymm1, %ymm1
; AVX1-NEXT: vandpd %ymm1, %ymm8, %ymm1
; AVX1-NEXT: vinsertf128 $1, %xmm6, %ymm0, %ymm2
; AVX1-NEXT: vpxor %xmm5, %xmm1, %xmm3
; AVX1-NEXT: vpcmpeqq %xmm3, %xmm4, %xmm3
; AVX1-NEXT: vpxor %xmm5, %xmm3, %xmm3
; AVX1-NEXT: vinsertf128 $1, %xmm2, %ymm3, %ymm2
; AVX1-NEXT: vandpd %ymm2, %ymm8, %ymm2
; AVX1-NEXT: vinsertf128 $1, %xmm6, %ymm1, %ymm1
; AVX1-NEXT: vmovapd {{.*#+}} ymm3 = [9223372036854775808,9223372036854775808,9223372036854775808,9223372036854775808]
; AVX1-NEXT: vblendvpd %ymm2, {{.*}}(%rip), %ymm3, %ymm2
; AVX1-NEXT: vblendvpd %ymm1, {{.*}}(%rip), %ymm3, %ymm1
; AVX1-NEXT: vinsertf128 $1, %xmm9, %ymm0, %ymm0
; AVX1-NEXT: vblendvpd %ymm1, %ymm2, %ymm0, %ymm0
; AVX1-NEXT: vblendvpd %ymm2, %ymm1, %ymm0, %ymm0
; AVX1-NEXT: retq
;
; AVX2-LABEL: v4i64:
@ -2223,13 +2193,13 @@ define <4 x i64> @v4i64(<4 x i64> %x, <4 x i64> %y) nounwind {
; AVX2-NEXT: vpcmpeqq %ymm3, %ymm5, %ymm3
; AVX2-NEXT: vpaddq %ymm1, %ymm0, %ymm0
; AVX2-NEXT: vpcmpgtq %ymm0, %ymm2, %ymm1
; AVX2-NEXT: vpxor %ymm4, %ymm1, %ymm1
; AVX2-NEXT: vpcmpeqq %ymm1, %ymm5, %ymm1
; AVX2-NEXT: vpandn %ymm3, %ymm1, %ymm1
; AVX2-NEXT: vbroadcastsd {{.*#+}} ymm2 = [9223372036854775807,9223372036854775807,9223372036854775807,9223372036854775807]
; AVX2-NEXT: vbroadcastsd {{.*#+}} ymm3 = [9223372036854775808,9223372036854775808,9223372036854775808,9223372036854775808]
; AVX2-NEXT: vblendvpd %ymm0, %ymm2, %ymm3, %ymm2
; AVX2-NEXT: vblendvpd %ymm1, %ymm2, %ymm0, %ymm0
; AVX2-NEXT: vpxor %ymm4, %ymm1, %ymm2
; AVX2-NEXT: vpcmpeqq %ymm2, %ymm5, %ymm2
; AVX2-NEXT: vpandn %ymm3, %ymm2, %ymm2
; AVX2-NEXT: vbroadcastsd {{.*#+}} ymm3 = [9223372036854775807,9223372036854775807,9223372036854775807,9223372036854775807]
; AVX2-NEXT: vbroadcastsd {{.*#+}} ymm4 = [9223372036854775808,9223372036854775808,9223372036854775808,9223372036854775808]
; AVX2-NEXT: vblendvpd %ymm1, %ymm3, %ymm4, %ymm1
; AVX2-NEXT: vblendvpd %ymm2, %ymm1, %ymm0, %ymm0
; AVX2-NEXT: retq
;
; AVX512-LABEL: v4i64:
@ -2831,66 +2801,66 @@ define <8 x i64> @v8i64(<8 x i64> %x, <8 x i64> %y) nounwind {
; AVX1-LABEL: v8i64:
; AVX1: # %bb.0:
; AVX1-NEXT: vextractf128 $1, %ymm2, %xmm9
; AVX1-NEXT: vpxor %xmm12, %xmm12, %xmm12
; AVX1-NEXT: vpcmpgtq %xmm9, %xmm12, %xmm7
; AVX1-NEXT: vpxor %xmm10, %xmm10, %xmm10
; AVX1-NEXT: vpcmpgtq %xmm9, %xmm10, %xmm7
; AVX1-NEXT: vpcmpeqd %xmm4, %xmm4, %xmm4
; AVX1-NEXT: vpxor %xmm4, %xmm7, %xmm8
; AVX1-NEXT: vextractf128 $1, %ymm0, %xmm7
; AVX1-NEXT: vpcmpgtq %xmm7, %xmm12, %xmm6
; AVX1-NEXT: vpxor %xmm4, %xmm6, %xmm10
; AVX1-NEXT: vpcmpeqq %xmm8, %xmm10, %xmm8
; AVX1-NEXT: vpcmpgtq %xmm2, %xmm12, %xmm6
; AVX1-NEXT: vpxor %xmm4, %xmm6, %xmm11
; AVX1-NEXT: vpcmpgtq %xmm0, %xmm12, %xmm6
; AVX1-NEXT: vpxor %xmm4, %xmm6, %xmm6
; AVX1-NEXT: vpcmpeqq %xmm11, %xmm6, %xmm11
; AVX1-NEXT: vpcmpgtq %xmm7, %xmm10, %xmm6
; AVX1-NEXT: vpxor %xmm4, %xmm6, %xmm12
; AVX1-NEXT: vpcmpeqq %xmm8, %xmm12, %xmm8
; AVX1-NEXT: vpcmpgtq %xmm2, %xmm10, %xmm5
; AVX1-NEXT: vpxor %xmm4, %xmm5, %xmm11
; AVX1-NEXT: vpcmpgtq %xmm0, %xmm10, %xmm5
; AVX1-NEXT: vpxor %xmm4, %xmm5, %xmm5
; AVX1-NEXT: vpcmpeqq %xmm11, %xmm5, %xmm11
; AVX1-NEXT: vinsertf128 $1, %xmm8, %ymm11, %ymm8
; AVX1-NEXT: vpaddq %xmm9, %xmm7, %xmm9
; AVX1-NEXT: vpcmpgtq %xmm9, %xmm12, %xmm7
; AVX1-NEXT: vpxor %xmm4, %xmm7, %xmm5
; AVX1-NEXT: vpcmpeqq %xmm5, %xmm10, %xmm5
; AVX1-NEXT: vpxor %xmm4, %xmm5, %xmm5
; AVX1-NEXT: vpcmpgtq %xmm9, %xmm10, %xmm7
; AVX1-NEXT: vpxor %xmm4, %xmm7, %xmm6
; AVX1-NEXT: vpcmpeqq %xmm6, %xmm12, %xmm6
; AVX1-NEXT: vpxor %xmm4, %xmm6, %xmm11
; AVX1-NEXT: vpaddq %xmm2, %xmm0, %xmm0
; AVX1-NEXT: vpcmpgtq %xmm0, %xmm12, %xmm2
; AVX1-NEXT: vpxor %xmm4, %xmm2, %xmm2
; AVX1-NEXT: vpcmpeqq %xmm2, %xmm6, %xmm2
; AVX1-NEXT: vpxor %xmm4, %xmm2, %xmm2
; AVX1-NEXT: vinsertf128 $1, %xmm5, %ymm2, %ymm2
; AVX1-NEXT: vandpd %ymm2, %ymm8, %ymm5
; AVX1-NEXT: vinsertf128 $1, %xmm7, %ymm0, %ymm7
; AVX1-NEXT: vpcmpgtq %xmm0, %xmm10, %xmm2
; AVX1-NEXT: vpxor %xmm4, %xmm2, %xmm6
; AVX1-NEXT: vpcmpeqq %xmm6, %xmm5, %xmm5
; AVX1-NEXT: vpxor %xmm4, %xmm5, %xmm5
; AVX1-NEXT: vinsertf128 $1, %xmm11, %ymm5, %ymm5
; AVX1-NEXT: vandpd %ymm5, %ymm8, %ymm5
; AVX1-NEXT: vinsertf128 $1, %xmm7, %ymm2, %ymm7
; AVX1-NEXT: vmovapd {{.*#+}} ymm8 = [9223372036854775807,9223372036854775807,9223372036854775807,9223372036854775807]
; AVX1-NEXT: vmovapd {{.*#+}} ymm10 = [9223372036854775808,9223372036854775808,9223372036854775808,9223372036854775808]
; AVX1-NEXT: vblendvpd %ymm7, %ymm8, %ymm10, %ymm7
; AVX1-NEXT: vmovapd {{.*#+}} ymm11 = [9223372036854775808,9223372036854775808,9223372036854775808,9223372036854775808]
; AVX1-NEXT: vblendvpd %ymm7, %ymm8, %ymm11, %ymm7
; AVX1-NEXT: vinsertf128 $1, %xmm9, %ymm0, %ymm0
; AVX1-NEXT: vblendvpd %ymm5, %ymm7, %ymm0, %ymm0
; AVX1-NEXT: vextractf128 $1, %ymm3, %xmm5
; AVX1-NEXT: vpcmpgtq %xmm5, %xmm12, %xmm7
; AVX1-NEXT: vpcmpgtq %xmm5, %xmm10, %xmm7
; AVX1-NEXT: vpxor %xmm4, %xmm7, %xmm7
; AVX1-NEXT: vextractf128 $1, %ymm1, %xmm2
; AVX1-NEXT: vpcmpgtq %xmm2, %xmm12, %xmm6
; AVX1-NEXT: vpcmpgtq %xmm2, %xmm10, %xmm6
; AVX1-NEXT: vpxor %xmm4, %xmm6, %xmm6
; AVX1-NEXT: vpcmpeqq %xmm7, %xmm6, %xmm9
; AVX1-NEXT: vpcmpgtq %xmm3, %xmm12, %xmm7
; AVX1-NEXT: vpxor %xmm4, %xmm7, %xmm11
; AVX1-NEXT: vpcmpgtq %xmm1, %xmm12, %xmm7
; AVX1-NEXT: vpcmpgtq %xmm3, %xmm10, %xmm7
; AVX1-NEXT: vpxor %xmm4, %xmm7, %xmm12
; AVX1-NEXT: vpcmpgtq %xmm1, %xmm10, %xmm7
; AVX1-NEXT: vpxor %xmm4, %xmm7, %xmm7
; AVX1-NEXT: vpcmpeqq %xmm11, %xmm7, %xmm11
; AVX1-NEXT: vinsertf128 $1, %xmm9, %ymm11, %ymm9
; AVX1-NEXT: vpaddq %xmm5, %xmm2, %xmm11
; AVX1-NEXT: vpcmpgtq %xmm11, %xmm12, %xmm5
; AVX1-NEXT: vpcmpeqq %xmm12, %xmm7, %xmm12
; AVX1-NEXT: vinsertf128 $1, %xmm9, %ymm12, %ymm9
; AVX1-NEXT: vpaddq %xmm5, %xmm2, %xmm12
; AVX1-NEXT: vpcmpgtq %xmm12, %xmm10, %xmm5
; AVX1-NEXT: vpxor %xmm4, %xmm5, %xmm2
; AVX1-NEXT: vpcmpeqq %xmm2, %xmm6, %xmm2
; AVX1-NEXT: vpxor %xmm4, %xmm2, %xmm2
; AVX1-NEXT: vpaddq %xmm3, %xmm1, %xmm1
; AVX1-NEXT: vpcmpgtq %xmm1, %xmm12, %xmm3
; AVX1-NEXT: vpxor %xmm4, %xmm3, %xmm3
; AVX1-NEXT: vpcmpeqq %xmm3, %xmm7, %xmm3
; AVX1-NEXT: vpxor %xmm4, %xmm3, %xmm3
; AVX1-NEXT: vinsertf128 $1, %xmm2, %ymm3, %ymm2
; AVX1-NEXT: vpcmpgtq %xmm1, %xmm10, %xmm3
; AVX1-NEXT: vpxor %xmm4, %xmm3, %xmm6
; AVX1-NEXT: vpcmpeqq %xmm6, %xmm7, %xmm6
; AVX1-NEXT: vpxor %xmm4, %xmm6, %xmm4
; AVX1-NEXT: vinsertf128 $1, %xmm2, %ymm4, %ymm2
; AVX1-NEXT: vandpd %ymm2, %ymm9, %ymm2
; AVX1-NEXT: vinsertf128 $1, %xmm5, %ymm1, %ymm3
; AVX1-NEXT: vblendvpd %ymm3, %ymm8, %ymm10, %ymm3
; AVX1-NEXT: vinsertf128 $1, %xmm11, %ymm1, %ymm1
; AVX1-NEXT: vinsertf128 $1, %xmm5, %ymm3, %ymm3
; AVX1-NEXT: vblendvpd %ymm3, %ymm8, %ymm11, %ymm3
; AVX1-NEXT: vinsertf128 $1, %xmm12, %ymm1, %ymm1
; AVX1-NEXT: vblendvpd %ymm2, %ymm3, %ymm1, %ymm1
; AVX1-NEXT: retq
;
@ -2905,24 +2875,24 @@ define <8 x i64> @v8i64(<8 x i64> %x, <8 x i64> %y) nounwind {
; AVX2-NEXT: vpcmpeqq %ymm5, %ymm7, %ymm5
; AVX2-NEXT: vpaddq %ymm2, %ymm0, %ymm0
; AVX2-NEXT: vpcmpgtq %ymm0, %ymm4, %ymm2
; AVX2-NEXT: vpxor %ymm6, %ymm2, %ymm2
; AVX2-NEXT: vpcmpeqq %ymm2, %ymm7, %ymm2
; AVX2-NEXT: vpandn %ymm5, %ymm2, %ymm2
; AVX2-NEXT: vbroadcastsd {{.*#+}} ymm5 = [9223372036854775807,9223372036854775807,9223372036854775807,9223372036854775807]
; AVX2-NEXT: vbroadcastsd {{.*#+}} ymm7 = [9223372036854775808,9223372036854775808,9223372036854775808,9223372036854775808]
; AVX2-NEXT: vblendvpd %ymm0, %ymm5, %ymm7, %ymm8
; AVX2-NEXT: vblendvpd %ymm2, %ymm8, %ymm0, %ymm0
; AVX2-NEXT: vpxor %ymm6, %ymm2, %ymm8
; AVX2-NEXT: vpcmpeqq %ymm8, %ymm7, %ymm7
; AVX2-NEXT: vpandn %ymm5, %ymm7, %ymm5
; AVX2-NEXT: vbroadcastsd {{.*#+}} ymm7 = [9223372036854775807,9223372036854775807,9223372036854775807,9223372036854775807]
; AVX2-NEXT: vbroadcastsd {{.*#+}} ymm8 = [9223372036854775808,9223372036854775808,9223372036854775808,9223372036854775808]
; AVX2-NEXT: vblendvpd %ymm2, %ymm7, %ymm8, %ymm2
; AVX2-NEXT: vblendvpd %ymm5, %ymm2, %ymm0, %ymm0
; AVX2-NEXT: vpcmpgtq %ymm3, %ymm4, %ymm2
; AVX2-NEXT: vpxor %ymm6, %ymm2, %ymm2
; AVX2-NEXT: vpcmpgtq %ymm1, %ymm4, %ymm8
; AVX2-NEXT: vpxor %ymm6, %ymm8, %ymm8
; AVX2-NEXT: vpcmpeqq %ymm2, %ymm8, %ymm2
; AVX2-NEXT: vpcmpgtq %ymm1, %ymm4, %ymm5
; AVX2-NEXT: vpxor %ymm6, %ymm5, %ymm5
; AVX2-NEXT: vpcmpeqq %ymm2, %ymm5, %ymm2
; AVX2-NEXT: vpaddq %ymm3, %ymm1, %ymm1
; AVX2-NEXT: vpcmpgtq %ymm1, %ymm4, %ymm3
; AVX2-NEXT: vpxor %ymm6, %ymm3, %ymm3
; AVX2-NEXT: vpcmpeqq %ymm3, %ymm8, %ymm3
; AVX2-NEXT: vpandn %ymm2, %ymm3, %ymm2
; AVX2-NEXT: vblendvpd %ymm1, %ymm5, %ymm7, %ymm3
; AVX2-NEXT: vpxor %ymm6, %ymm3, %ymm4
; AVX2-NEXT: vpcmpeqq %ymm4, %ymm5, %ymm4
; AVX2-NEXT: vpandn %ymm2, %ymm4, %ymm2
; AVX2-NEXT: vblendvpd %ymm3, %ymm7, %ymm8, %ymm3
; AVX2-NEXT: vblendvpd %ymm2, %ymm3, %ymm1, %ymm1
; AVX2-NEXT: retq
;

752
llvm/test/CodeGen/X86/ssub_sat_vec.ll
View File

File diff suppressed because it is too large Load Diff

102
llvm/test/CodeGen/X86/vec_saddo.ll
View File

@ -807,62 +807,57 @@ define <16 x i32> @saddo_v16i32(<16 x i32> %a0, <16 x i32> %a1, <16 x i32>* %p2)
; AVX1-NEXT: vextractf128 $1, %ymm3, %xmm9
; AVX1-NEXT: vpxor %xmm5, %xmm5, %xmm5
; AVX1-NEXT: vpcmpgtd %xmm9, %xmm5, %xmm7
; AVX1-NEXT: vpcmpeqd %xmm4, %xmm4, %xmm4
; AVX1-NEXT: vpxor %xmm4, %xmm7, %xmm8
; AVX1-NEXT: vpcmpeqd %xmm6, %xmm6, %xmm6
; AVX1-NEXT: vpxor %xmm6, %xmm7, %xmm8
; AVX1-NEXT: vextractf128 $1, %ymm1, %xmm7
; AVX1-NEXT: vpcmpgtd %xmm7, %xmm5, %xmm6
; AVX1-NEXT: vpxor %xmm4, %xmm6, %xmm10
; AVX1-NEXT: vpcmpeqd %xmm8, %xmm10, %xmm8
; AVX1-NEXT: vpcmpgtd %xmm3, %xmm5, %xmm6
; AVX1-NEXT: vpxor %xmm4, %xmm6, %xmm11
; AVX1-NEXT: vpcmpgtd %xmm1, %xmm5, %xmm6
; AVX1-NEXT: vpxor %xmm4, %xmm6, %xmm6
; AVX1-NEXT: vpcmpeqd %xmm11, %xmm6, %xmm11
; AVX1-NEXT: vinsertf128 $1, %xmm8, %ymm11, %ymm11
; AVX1-NEXT: vpcmpgtd %xmm7, %xmm5, %xmm4
; AVX1-NEXT: vpxor %xmm6, %xmm4, %xmm4
; AVX1-NEXT: vpcmpeqd %xmm8, %xmm4, %xmm8
; AVX1-NEXT: vpaddd %xmm9, %xmm7, %xmm9
; AVX1-NEXT: vpcmpgtd %xmm9, %xmm5, %xmm7
; AVX1-NEXT: vpxor %xmm4, %xmm7, %xmm7
; AVX1-NEXT: vpcmpeqd %xmm7, %xmm10, %xmm7
; AVX1-NEXT: vpxor %xmm4, %xmm7, %xmm10
; AVX1-NEXT: vpaddd %xmm3, %xmm1, %xmm12
; AVX1-NEXT: vpcmpgtd %xmm12, %xmm5, %xmm3
; AVX1-NEXT: vpxor %xmm4, %xmm3, %xmm3
; AVX1-NEXT: vpcmpeqd %xmm3, %xmm6, %xmm3
; AVX1-NEXT: vpxor %xmm4, %xmm3, %xmm3
; AVX1-NEXT: vinsertf128 $1, %xmm10, %ymm3, %ymm3
; AVX1-NEXT: vandps %ymm3, %ymm11, %ymm3
; AVX1-NEXT: vpandn %xmm8, %xmm7, %xmm6
; AVX1-NEXT: vpackssdw %xmm6, %xmm3, %xmm8
; AVX1-NEXT: vextractf128 $1, %ymm2, %xmm6
; AVX1-NEXT: vpcmpgtd %xmm6, %xmm5, %xmm7
; AVX1-NEXT: vpxor %xmm4, %xmm7, %xmm7
; AVX1-NEXT: vpxor %xmm6, %xmm7, %xmm7
; AVX1-NEXT: vpcmpeqd %xmm7, %xmm4, %xmm4
; AVX1-NEXT: vpandn %xmm8, %xmm4, %xmm8
; AVX1-NEXT: vpcmpgtd %xmm3, %xmm5, %xmm7
; AVX1-NEXT: vpxor %xmm6, %xmm7, %xmm7
; AVX1-NEXT: vpcmpgtd %xmm1, %xmm5, %xmm4
; AVX1-NEXT: vpxor %xmm6, %xmm4, %xmm4
; AVX1-NEXT: vpcmpeqd %xmm7, %xmm4, %xmm7
; AVX1-NEXT: vpaddd %xmm3, %xmm1, %xmm11
; AVX1-NEXT: vpcmpgtd %xmm11, %xmm5, %xmm3
; AVX1-NEXT: vpxor %xmm6, %xmm3, %xmm3
; AVX1-NEXT: vpcmpeqd %xmm3, %xmm4, %xmm3
; AVX1-NEXT: vpandn %xmm7, %xmm3, %xmm3
; AVX1-NEXT: vpackssdw %xmm8, %xmm3, %xmm3
; AVX1-NEXT: vmovdqa {{.*#+}} xmm8 = <0,2,4,6,8,10,12,14,u,u,u,u,u,u,u,u>
; AVX1-NEXT: vpshufb %xmm8, %xmm3, %xmm10
; AVX1-NEXT: vextractf128 $1, %ymm2, %xmm7
; AVX1-NEXT: vpcmpgtd %xmm7, %xmm5, %xmm4
; AVX1-NEXT: vpxor %xmm6, %xmm4, %xmm4
; AVX1-NEXT: vextractf128 $1, %ymm0, %xmm3
; AVX1-NEXT: vpcmpgtd %xmm3, %xmm5, %xmm1
; AVX1-NEXT: vpxor %xmm4, %xmm1, %xmm1
; AVX1-NEXT: vpcmpeqd %xmm7, %xmm1, %xmm10
; AVX1-NEXT: vpcmpgtd %xmm2, %xmm5, %xmm7
; AVX1-NEXT: vpxor %xmm4, %xmm7, %xmm11
; AVX1-NEXT: vpxor %xmm6, %xmm1, %xmm1
; AVX1-NEXT: vpcmpeqd %xmm4, %xmm1, %xmm4
; AVX1-NEXT: vpaddd %xmm7, %xmm3, %xmm3
; AVX1-NEXT: vpcmpgtd %xmm3, %xmm5, %xmm7
; AVX1-NEXT: vpxor %xmm6, %xmm7, %xmm7
; AVX1-NEXT: vpcmpeqd %xmm7, %xmm1, %xmm1
; AVX1-NEXT: vpandn %xmm4, %xmm1, %xmm1
; AVX1-NEXT: vpcmpgtd %xmm2, %xmm5, %xmm4
; AVX1-NEXT: vpxor %xmm6, %xmm4, %xmm4
; AVX1-NEXT: vpcmpgtd %xmm0, %xmm5, %xmm7
; AVX1-NEXT: vpxor %xmm4, %xmm7, %xmm7
; AVX1-NEXT: vpcmpeqd %xmm11, %xmm7, %xmm11
; AVX1-NEXT: vinsertf128 $1, %xmm10, %ymm11, %ymm11
; AVX1-NEXT: vpaddd %xmm6, %xmm3, %xmm3
; AVX1-NEXT: vpcmpgtd %xmm3, %xmm5, %xmm6
; AVX1-NEXT: vpxor %xmm4, %xmm6, %xmm6
; AVX1-NEXT: vpcmpeqd %xmm6, %xmm1, %xmm1
; AVX1-NEXT: vpxor %xmm4, %xmm1, %xmm6
; AVX1-NEXT: vpxor %xmm6, %xmm7, %xmm7
; AVX1-NEXT: vpcmpeqd %xmm4, %xmm7, %xmm4
; AVX1-NEXT: vpaddd %xmm2, %xmm0, %xmm0
; AVX1-NEXT: vpcmpgtd %xmm0, %xmm5, %xmm2
; AVX1-NEXT: vpxor %xmm4, %xmm2, %xmm2
; AVX1-NEXT: vpxor %xmm6, %xmm2, %xmm2
; AVX1-NEXT: vpcmpeqd %xmm2, %xmm7, %xmm2
; AVX1-NEXT: vpxor %xmm4, %xmm2, %xmm2
; AVX1-NEXT: vinsertf128 $1, %xmm6, %ymm2, %ymm2
; AVX1-NEXT: vandps %ymm2, %ymm11, %ymm2
; AVX1-NEXT: vpandn %xmm10, %xmm1, %xmm1
; AVX1-NEXT: vpandn %xmm4, %xmm2, %xmm2
; AVX1-NEXT: vpackssdw %xmm1, %xmm2, %xmm1
; AVX1-NEXT: vpacksswb %xmm8, %xmm1, %xmm1
; AVX1-NEXT: vpshufb %xmm8, %xmm1, %xmm1
; AVX1-NEXT: vpunpcklqdq {{.*#+}} xmm1 = xmm1[0],xmm10[0]
; AVX1-NEXT: vinsertf128 $1, %xmm3, %ymm0, %ymm2
; AVX1-NEXT: vinsertf128 $1, %xmm9, %ymm12, %ymm3
; AVX1-NEXT: vinsertf128 $1, %xmm9, %ymm11, %ymm3
; AVX1-NEXT: vpmovsxbd %xmm1, %xmm0
; AVX1-NEXT: vpshufd {{.*#+}} xmm4 = xmm1[1,1,2,3]
; AVX1-NEXT: vpmovsxbd %xmm4, %xmm4
@ -892,19 +887,22 @@ define <16 x i32> @saddo_v16i32(<16 x i32> %a0, <16 x i32> %a1, <16 x i32>* %p2)
; AVX2-NEXT: vpandn %ymm5, %ymm1, %ymm1
; AVX2-NEXT: vextracti128 $1, %ymm1, %xmm5
; AVX2-NEXT: vpackssdw %xmm5, %xmm1, %xmm1
; AVX2-NEXT: vpcmpgtd %ymm2, %ymm4, %ymm5
; AVX2-NEXT: vpxor %ymm6, %ymm5, %ymm5
; AVX2-NEXT: vpcmpgtd %ymm0, %ymm4, %ymm7
; AVX2-NEXT: vmovdqa {{.*#+}} xmm5 = <0,2,4,6,8,10,12,14,u,u,u,u,u,u,u,u>
; AVX2-NEXT: vpshufb %xmm5, %xmm1, %xmm1
; AVX2-NEXT: vpcmpgtd %ymm2, %ymm4, %ymm7
; AVX2-NEXT: vpxor %ymm6, %ymm7, %ymm7
; AVX2-NEXT: vpcmpeqd %ymm5, %ymm7, %ymm5
; AVX2-NEXT: vpcmpgtd %ymm0, %ymm4, %ymm8
; AVX2-NEXT: vpxor %ymm6, %ymm8, %ymm8
; AVX2-NEXT: vpcmpeqd %ymm7, %ymm8, %ymm7
; AVX2-NEXT: vpaddd %ymm2, %ymm0, %ymm2
; AVX2-NEXT: vpcmpgtd %ymm2, %ymm4, %ymm0
; AVX2-NEXT: vpxor %ymm6, %ymm0, %ymm0
; AVX2-NEXT: vpcmpeqd %ymm0, %ymm7, %ymm0
; AVX2-NEXT: vpandn %ymm5, %ymm0, %ymm0
; AVX2-NEXT: vpcmpeqd %ymm0, %ymm8, %ymm0
; AVX2-NEXT: vpandn %ymm7, %ymm0, %ymm0
; AVX2-NEXT: vextracti128 $1, %ymm0, %xmm4
; AVX2-NEXT: vpackssdw %xmm4, %xmm0, %xmm0
; AVX2-NEXT: vpacksswb %xmm1, %xmm0, %xmm1
; AVX2-NEXT: vpshufb %xmm5, %xmm0, %xmm0
; AVX2-NEXT: vpunpcklqdq {{.*#+}} xmm1 = xmm0[0],xmm1[0]
; AVX2-NEXT: vpmovsxbd %xmm1, %ymm0
; AVX2-NEXT: vpshufd {{.*#+}} xmm1 = xmm1[2,3,0,1]
; AVX2-NEXT: vpmovsxbd %xmm1, %ymm1

154
llvm/test/CodeGen/X86/vec_ssubo.ll
View File

@ -830,80 +830,75 @@ define <16 x i32> @ssubo_v16i32(<16 x i32> %a0, <16 x i32> %a1, <16 x i32>* %p2)
;
; AVX1-LABEL: ssubo_v16i32:
; AVX1: # %bb.0:
; AVX1-NEXT: vextractf128 $1, %ymm3, %xmm8
; AVX1-NEXT: vpxor %xmm5, %xmm5, %xmm5
; AVX1-NEXT: vpcmpgtd %xmm8, %xmm5, %xmm7
; AVX1-NEXT: vpcmpeqd %xmm4, %xmm4, %xmm4
; AVX1-NEXT: vpxor %xmm4, %xmm7, %xmm9
; AVX1-NEXT: vextractf128 $1, %ymm1, %xmm13
; AVX1-NEXT: vpcmpgtd %xmm13, %xmm5, %xmm7
; AVX1-NEXT: vpxor %xmm4, %xmm7, %xmm11
; AVX1-NEXT: vpcmpeqd %xmm9, %xmm11, %xmm9
; AVX1-NEXT: vpxor %xmm4, %xmm9, %xmm10
; AVX1-NEXT: vpcmpgtd %xmm3, %xmm5, %xmm7
; AVX1-NEXT: vpxor %xmm4, %xmm7, %xmm12
; AVX1-NEXT: vpcmpgtd %xmm1, %xmm5, %xmm7
; AVX1-NEXT: vpxor %xmm4, %xmm7, %xmm7
; AVX1-NEXT: vpcmpeqd %xmm12, %xmm7, %xmm6
; AVX1-NEXT: vpxor %xmm4, %xmm6, %xmm6
; AVX1-NEXT: vinsertf128 $1, %xmm10, %ymm6, %ymm10
; AVX1-NEXT: vpsubd %xmm8, %xmm13, %xmm8
; AVX1-NEXT: vpcmpgtd %xmm8, %xmm5, %xmm6
; AVX1-NEXT: vpxor %xmm4, %xmm6, %xmm6
; AVX1-NEXT: vpcmpeqd %xmm6, %xmm11, %xmm6
; AVX1-NEXT: vpxor %xmm4, %xmm6, %xmm6
; AVX1-NEXT: vpsubd %xmm3, %xmm1, %xmm11
; AVX1-NEXT: vpcmpgtd %xmm11, %xmm5, %xmm3
; AVX1-NEXT: vpxor %xmm4, %xmm3, %xmm3
; AVX1-NEXT: vpcmpeqd %xmm3, %xmm7, %xmm3
; AVX1-NEXT: vpxor %xmm4, %xmm3, %xmm3
; AVX1-NEXT: vinsertf128 $1, %xmm6, %ymm3, %ymm3
; AVX1-NEXT: vandps %ymm3, %ymm10, %ymm3
; AVX1-NEXT: vpandn %xmm6, %xmm9, %xmm6
; AVX1-NEXT: vpackssdw %xmm6, %xmm3, %xmm9
; AVX1-NEXT: vextractf128 $1, %ymm2, %xmm14
; AVX1-NEXT: vpcmpgtd %xmm14, %xmm5, %xmm7
; AVX1-NEXT: vpxor %xmm4, %xmm7, %xmm7
; AVX1-NEXT: vextractf128 $1, %ymm0, %xmm3
; AVX1-NEXT: vpcmpgtd %xmm3, %xmm5, %xmm1
; AVX1-NEXT: vpxor %xmm4, %xmm1, %xmm1
; AVX1-NEXT: vpcmpeqd %xmm7, %xmm1, %xmm12
; AVX1-NEXT: vpxor %xmm4, %xmm12, %xmm10
; AVX1-NEXT: vpcmpgtd %xmm2, %xmm5, %xmm7
; AVX1-NEXT: vpxor %xmm4, %xmm7, %xmm13
; AVX1-NEXT: vpcmpgtd %xmm0, %xmm5, %xmm7
; AVX1-NEXT: vpxor %xmm4, %xmm7, %xmm7
; AVX1-NEXT: vpcmpeqd %xmm13, %xmm7, %xmm6
; AVX1-NEXT: vpxor %xmm4, %xmm6, %xmm6
; AVX1-NEXT: vinsertf128 $1, %xmm10, %ymm6, %ymm10
; AVX1-NEXT: vpsubd %xmm14, %xmm3, %xmm3
; AVX1-NEXT: vpcmpgtd %xmm3, %xmm5, %xmm6
; AVX1-NEXT: vpxor %xmm4, %xmm6, %xmm6
; AVX1-NEXT: vpcmpeqd %xmm6, %xmm1, %xmm1
; AVX1-NEXT: vpxor %xmm4, %xmm1, %xmm1
; AVX1-NEXT: vextractf128 $1, %ymm3, %xmm4
; AVX1-NEXT: vpxor %xmm9, %xmm9, %xmm9
; AVX1-NEXT: vpcmpgtd %xmm4, %xmm9, %xmm7
; AVX1-NEXT: vpcmpeqd %xmm5, %xmm5, %xmm5
; AVX1-NEXT: vpxor %xmm5, %xmm7, %xmm8
; AVX1-NEXT: vextractf128 $1, %ymm1, %xmm7
; AVX1-NEXT: vpcmpgtd %xmm7, %xmm9, %xmm6
; AVX1-NEXT: vpxor %xmm5, %xmm6, %xmm6
; AVX1-NEXT: vpcmpeqd %xmm8, %xmm6, %xmm8
; AVX1-NEXT: vpsubd %xmm4, %xmm7, %xmm10
; AVX1-NEXT: vpcmpgtd %xmm10, %xmm9, %xmm7
; AVX1-NEXT: vpxor %xmm5, %xmm7, %xmm7
; AVX1-NEXT: vpcmpeqd %xmm7, %xmm6, %xmm6
; AVX1-NEXT: vpxor %xmm5, %xmm6, %xmm6
; AVX1-NEXT: vpandn %xmm6, %xmm8, %xmm6
; AVX1-NEXT: vpcmpgtd %xmm3, %xmm9, %xmm7
; AVX1-NEXT: vpxor %xmm5, %xmm7, %xmm7
; AVX1-NEXT: vpcmpgtd %xmm1, %xmm9, %xmm4
; AVX1-NEXT: vpxor %xmm5, %xmm4, %xmm4
; AVX1-NEXT: vpcmpeqd %xmm7, %xmm4, %xmm7
; AVX1-NEXT: vpsubd %xmm3, %xmm1, %xmm1
; AVX1-NEXT: vpcmpgtd %xmm1, %xmm9, %xmm3
; AVX1-NEXT: vpxor %xmm5, %xmm3, %xmm3
; AVX1-NEXT: vpcmpeqd %xmm3, %xmm4, %xmm3
; AVX1-NEXT: vpxor %xmm5, %xmm3, %xmm3
; AVX1-NEXT: vpandn %xmm3, %xmm7, %xmm3
; AVX1-NEXT: vpackssdw %xmm6, %xmm3, %xmm3
; AVX1-NEXT: vmovdqa {{.*#+}} xmm8 = <0,2,4,6,8,10,12,14,u,u,u,u,u,u,u,u>
; AVX1-NEXT: vpshufb %xmm8, %xmm3, %xmm11
; AVX1-NEXT: vextractf128 $1, %ymm2, %xmm6
; AVX1-NEXT: vpcmpgtd %xmm6, %xmm9, %xmm7
; AVX1-NEXT: vpxor %xmm5, %xmm7, %xmm7
; AVX1-NEXT: vextractf128 $1, %ymm0, %xmm4
; AVX1-NEXT: vpcmpgtd %xmm4, %xmm9, %xmm3
; AVX1-NEXT: vpxor %xmm5, %xmm3, %xmm3
; AVX1-NEXT: vpcmpeqd %xmm7, %xmm3, %xmm7
; AVX1-NEXT: vpsubd %xmm6, %xmm4, %xmm4
; AVX1-NEXT: vpcmpgtd %xmm4, %xmm9, %xmm6
; AVX1-NEXT: vpxor %xmm5, %xmm6, %xmm6
; AVX1-NEXT: vpcmpeqd %xmm6, %xmm3, %xmm3
; AVX1-NEXT: vpxor %xmm5, %xmm3, %xmm3
; AVX1-NEXT: vpandn %xmm3, %xmm7, %xmm3
; AVX1-NEXT: vpcmpgtd %xmm2, %xmm9, %xmm6
; AVX1-NEXT: vpxor %xmm5, %xmm6, %xmm6
; AVX1-NEXT: vpcmpgtd %xmm0, %xmm9, %xmm7
; AVX1-NEXT: vpxor %xmm5, %xmm7, %xmm7
; AVX1-NEXT: vpcmpeqd %xmm6, %xmm7, %xmm6
; AVX1-NEXT: vpsubd %xmm2, %xmm0, %xmm0
; AVX1-NEXT: vpcmpgtd %xmm0, %xmm5, %xmm2
; AVX1-NEXT: vpxor %xmm4, %xmm2, %xmm2
; AVX1-NEXT: vpcmpgtd %xmm0, %xmm9, %xmm2
; AVX1-NEXT: vpxor %xmm5, %xmm2, %xmm2
; AVX1-NEXT: vpcmpeqd %xmm2, %xmm7, %xmm2
; AVX1-NEXT: vpxor %xmm4, %xmm2, %xmm2
; AVX1-NEXT: vinsertf128 $1, %xmm1, %ymm2, %ymm2
; AVX1-NEXT: vandps %ymm2, %ymm10, %ymm2
; AVX1-NEXT: vpandn %xmm1, %xmm12, %xmm1
; AVX1-NEXT: vpackssdw %xmm1, %xmm2, %xmm1
; AVX1-NEXT: vpacksswb %xmm9, %xmm1, %xmm1
; AVX1-NEXT: vinsertf128 $1, %xmm3, %ymm0, %ymm2
; AVX1-NEXT: vinsertf128 $1, %xmm8, %ymm11, %ymm3
; AVX1-NEXT: vpmovsxbd %xmm1, %xmm0
; AVX1-NEXT: vpshufd {{.*#+}} xmm4 = xmm1[1,1,2,3]
; AVX1-NEXT: vpmovsxbd %xmm4, %xmm4
; AVX1-NEXT: vinsertf128 $1, %xmm4, %ymm0, %ymm0
; AVX1-NEXT: vpshufd {{.*#+}} xmm4 = xmm1[2,3,0,1]
; AVX1-NEXT: vpmovsxbd %xmm4, %xmm4
; AVX1-NEXT: vpshufd {{.*#+}} xmm1 = xmm1[3,3,0,1]
; AVX1-NEXT: vpxor %xmm5, %xmm2, %xmm2
; AVX1-NEXT: vpandn %xmm2, %xmm6, %xmm2
; AVX1-NEXT: vpackssdw %xmm3, %xmm2, %xmm2
; AVX1-NEXT: vpshufb %xmm8, %xmm2, %xmm2
; AVX1-NEXT: vpunpcklqdq {{.*#+}} xmm2 = xmm2[0],xmm11[0]
; AVX1-NEXT: vinsertf128 $1, %xmm4, %ymm0, %ymm3
; AVX1-NEXT: vinsertf128 $1, %xmm10, %ymm1, %ymm4
; AVX1-NEXT: vpmovsxbd %xmm2, %xmm0
; AVX1-NEXT: vpshufd {{.*#+}} xmm1 = xmm2[1,1,2,3]
; AVX1-NEXT: vpmovsxbd %xmm1, %xmm1
; AVX1-NEXT: vinsertf128 $1, %xmm1, %ymm4, %ymm1
; AVX1-NEXT: vmovaps %ymm3, 32(%rdi)
; AVX1-NEXT: vmovaps %ymm2, (%rdi)
; AVX1-NEXT: vinsertf128 $1, %xmm1, %ymm0, %ymm0
; AVX1-NEXT: vpshufd {{.*#+}} xmm1 = xmm2[2,3,0,1]
; AVX1-NEXT: vpmovsxbd %xmm1, %xmm1
; AVX1-NEXT: vpshufd {{.*#+}} xmm2 = xmm2[3,3,0,1]
; AVX1-NEXT: vpmovsxbd %xmm2, %xmm2
; AVX1-NEXT: vinsertf128 $1, %xmm2, %ymm1, %ymm1
; AVX1-NEXT: vmovaps %ymm4, 32(%rdi)
; AVX1-NEXT: vmovaps %ymm3, (%rdi)
; AVX1-NEXT: retq
;
; AVX2-LABEL: ssubo_v16i32:
@ -923,20 +918,23 @@ define <16 x i32> @ssubo_v16i32(<16 x i32> %a0, <16 x i32> %a1, <16 x i32>* %p2)
; AVX2-NEXT: vpandn %ymm1, %ymm5, %ymm1
; AVX2-NEXT: vextracti128 $1, %ymm1, %xmm5
; AVX2-NEXT: vpackssdw %xmm5, %xmm1, %xmm1
; AVX2-NEXT: vpcmpgtd %ymm2, %ymm4, %ymm5
; AVX2-NEXT: vpxor %ymm6, %ymm5, %ymm5
; AVX2-NEXT: vpcmpgtd %ymm0, %ymm4, %ymm7
; AVX2-NEXT: vmovdqa {{.*#+}} xmm5 = <0,2,4,6,8,10,12,14,u,u,u,u,u,u,u,u>
; AVX2-NEXT: vpshufb %xmm5, %xmm1, %xmm1
; AVX2-NEXT: vpcmpgtd %ymm2, %ymm4, %ymm7
; AVX2-NEXT: vpxor %ymm6, %ymm7, %ymm7
; AVX2-NEXT: vpcmpeqd %ymm5, %ymm7, %ymm5
; AVX2-NEXT: vpcmpgtd %ymm0, %ymm4, %ymm8
; AVX2-NEXT: vpxor %ymm6, %ymm8, %ymm8
; AVX2-NEXT: vpcmpeqd %ymm7, %ymm8, %ymm7
; AVX2-NEXT: vpsubd %ymm2, %ymm0, %ymm2
; AVX2-NEXT: vpcmpgtd %ymm2, %ymm4, %ymm0
; AVX2-NEXT: vpxor %ymm6, %ymm0, %ymm0
; AVX2-NEXT: vpcmpeqd %ymm0, %ymm7, %ymm0
; AVX2-NEXT: vpcmpeqd %ymm0, %ymm8, %ymm0
; AVX2-NEXT: vpxor %ymm6, %ymm0, %ymm0
; AVX2-NEXT: vpandn %ymm0, %ymm5, %ymm0
; AVX2-NEXT: vpandn %ymm0, %ymm7, %ymm0
; AVX2-NEXT: vextracti128 $1, %ymm0, %xmm4
; AVX2-NEXT: vpackssdw %xmm4, %xmm0, %xmm0
; AVX2-NEXT: vpacksswb %xmm1, %xmm0, %xmm1
; AVX2-NEXT: vpshufb %xmm5, %xmm0, %xmm0
; AVX2-NEXT: vpunpcklqdq {{.*#+}} xmm1 = xmm0[0],xmm1[0]
; AVX2-NEXT: vpmovsxbd %xmm1, %ymm0
; AVX2-NEXT: vpshufd {{.*#+}} xmm1 = xmm1[2,3,0,1]
; AVX2-NEXT: vpmovsxbd %xmm1, %ymm1