mirror of
https://github.com/capstone-engine/llvm-capstone.git
synced 2024-11-27 07:31:28 +00:00
[RISCV] Pre-process FP SPLAT_VECTOR to RISCVISD::VFMV_V_F_VL
This patch builds on top of D119197 to canonicalize floating-point SPLAT_VECTOR as RISCVISD::VFMV_V_F_VL as a pre-process ISel step. This primarily benefits scalable-vector VP code, where our VP patterns only match VFMV_V_F_VL to reduce the burden on our ISel patterns, but where at the same time, scalable-vector code doesn't custom-legalize SPLAT_VECTOR. Reviewed By: craig.topper Differential Revision: https://reviews.llvm.org/D117670
This commit is contained in:
Fraser Cormack
parent
a76620143c
commit
fd43d99c93
@ -48,15 +48,16 @@ void RISCVDAGToDAGISel::PreprocessISelDAG() {
|
||||
I != E;) {
|
||||
SDNode *N = &*I++; // Preincrement iterator to avoid invalidation issues.
|
||||
|
||||
// Convert integer SPLAT_VECTOR to VMV_V_X_VL to reduce isel burden.
|
||||
if (N->getOpcode() == ISD::SPLAT_VECTOR &&
|
||||
N->getSimpleValueType(0).isInteger()) {
|
||||
// Convert integer SPLAT_VECTOR to VMV_V_X_VL and floating-point
|
||||
// SPLAT_VECTOR to VFMV_V_F_VL to reduce isel burden.
|
||||
if (N->getOpcode() == ISD::SPLAT_VECTOR) {
|
||||
MVT VT = N->getSimpleValueType(0);
|
||||
unsigned Opc =
|
||||
VT.isInteger() ? RISCVISD::VMV_V_X_VL : RISCVISD::VFMV_V_F_VL;
|
||||
SDLoc DL(N);
|
||||
SDValue VL = CurDAG->getTargetConstant(RISCV::VLMaxSentinel, DL,
|
||||
Subtarget->getXLenVT());
|
||||
SDValue Result =
|
||||
CurDAG->getNode(RISCVISD::VMV_V_X_VL, DL, VT, N->getOperand(0), VL);
|
||||
SDValue Result = CurDAG->getNode(Opc, DL, VT, N->getOperand(0), VL);
|
||||
|
||||
--I;
|
||||
CurDAG->ReplaceAllUsesOfValueWith(SDValue(N, 0), Result);
|
||||
|
||||
@ -147,7 +147,7 @@ class VPatBinarySDNode_VF<SDNode vop,
|
||||
VReg vop_reg_class,
|
||||
DAGOperand xop_kind> :
|
||||
Pat<(result_type (vop (vop_type vop_reg_class:$rs1),
|
||||
(vop_type (splat_vector xop_kind:$rs2)))),
|
||||
(vop_type (SplatFPOp xop_kind:$rs2)))),
|
||||
(!cast<Instruction>(instruction_name#"_"#vlmul.MX)
|
||||
vop_reg_class:$rs1,
|
||||
(xop_type xop_kind:$rs2),
|
||||
@ -167,7 +167,7 @@ multiclass VPatBinaryFPSDNode_VV_VF<SDNode vop, string instruction_name> {
|
||||
|
||||
multiclass VPatBinaryFPSDNode_R_VF<SDNode vop, string instruction_name> {
|
||||
foreach fvti = AllFloatVectors in
|
||||
def : Pat<(fvti.Vector (vop (fvti.Vector (splat_vector fvti.Scalar:$rs2)),
|
||||
def : Pat<(fvti.Vector (vop (fvti.Vector (SplatFPOp fvti.Scalar:$rs2)),
|
||||
(fvti.Vector fvti.RegClass:$rs1))),
|
||||
(!cast<Instruction>(instruction_name#"_V"#fvti.ScalarSuffix#"_"#fvti.LMul.MX)
|
||||
fvti.RegClass:$rs1,
|
||||
@ -257,12 +257,12 @@ multiclass VPatFPSetCCSDNode_VV_VF_FV<CondCode cc,
|
||||
(!cast<Instruction>(inst_name#"_VV_"#fvti.LMul.MX)
|
||||
fvti.RegClass:$rs1, fvti.RegClass:$rs2, fvti.AVL, fvti.Log2SEW)>;
|
||||
def : Pat<(fvti.Mask (setcc (fvti.Vector fvti.RegClass:$rs1),
|
||||
(splat_vector fvti.ScalarRegClass:$rs2),
|
||||
(SplatFPOp fvti.ScalarRegClass:$rs2),
|
||||
cc)),
|
||||
(!cast<Instruction>(inst_name#"_V"#fvti.ScalarSuffix#"_"#fvti.LMul.MX)
|
||||
fvti.RegClass:$rs1, fvti.ScalarRegClass:$rs2,
|
||||
fvti.AVL, fvti.Log2SEW)>;
|
||||
def : Pat<(fvti.Mask (setcc (splat_vector fvti.ScalarRegClass:$rs2),
|
||||
def : Pat<(fvti.Mask (setcc (SplatFPOp fvti.ScalarRegClass:$rs2),
|
||||
(fvti.Vector fvti.RegClass:$rs1),
|
||||
cc)),
|
||||
(!cast<Instruction>(swapped_op_inst_name#"_V"#fvti.ScalarSuffix#"_"#fvti.LMul.MX)
|
||||
@ -399,7 +399,7 @@ multiclass VPatWidenBinaryFPSDNode_VV_VF<SDNode op, string instruction_name> {
|
||||
vti.Vti.RegClass:$rs2, vti.Vti.RegClass:$rs1,
|
||||
vti.Vti.AVL, vti.Vti.Log2SEW)>;
|
||||
def : Pat<(op (vti.Wti.Vector (fpext_oneuse (vti.Vti.Vector vti.Vti.RegClass:$rs2))),
|
||||
(vti.Wti.Vector (fpext_oneuse (vti.Vti.Vector (splat_vector vti.Vti.ScalarRegClass:$rs1))))),
|
||||
(vti.Wti.Vector (fpext_oneuse (vti.Vti.Vector (SplatFPOp vti.Vti.ScalarRegClass:$rs1))))),
|
||||
(!cast<Instruction>(instruction_name#"_V"#vti.Vti.ScalarSuffix#"_"#vti.Vti.LMul.MX)
|
||||
vti.Vti.RegClass:$rs2, vti.Vti.ScalarRegClass:$rs1,
|
||||
vti.Vti.AVL, vti.Vti.Log2SEW)>;
|
||||
@ -414,7 +414,7 @@ multiclass VPatWidenBinaryFPSDNode_WV_WF<SDNode op, string instruction_name> {
|
||||
vti.Wti.RegClass:$rs2, vti.Vti.RegClass:$rs1,
|
||||
vti.Vti.AVL, vti.Vti.Log2SEW)>;
|
||||
def : Pat<(op (vti.Wti.Vector vti.Wti.RegClass:$rs2),
|
||||
(vti.Wti.Vector (fpext_oneuse (vti.Vti.Vector (splat_vector vti.Vti.ScalarRegClass:$rs1))))),
|
||||
(vti.Wti.Vector (fpext_oneuse (vti.Vti.Vector (SplatFPOp vti.Vti.ScalarRegClass:$rs1))))),
|
||||
(!cast<Instruction>(instruction_name#"_W"#vti.Vti.ScalarSuffix#"_"#vti.Vti.LMul.MX)
|
||||
vti.Wti.RegClass:$rs2, vti.Vti.ScalarRegClass:$rs1,
|
||||
vti.Vti.AVL, vti.Vti.Log2SEW)>;
|
||||
@ -434,7 +434,7 @@ multiclass VPatWidenFPMulAccSDNode_VV_VF<string instruction_name> {
|
||||
(!cast<Instruction>(instruction_name#"_VV_"#vti.Vti.LMul.MX)
|
||||
vti.Wti.RegClass:$rd, vti.Vti.RegClass:$rs1, vti.Vti.RegClass:$rs2,
|
||||
vti.Vti.AVL, vti.Vti.Log2SEW, TAIL_AGNOSTIC)>;
|
||||
def : Pat<(fma (vti.Wti.Vector (fpext_oneuse (vti.Vti.Vector (splat_vector vti.Vti.ScalarRegClass:$rs1)))),
|
||||
def : Pat<(fma (vti.Wti.Vector (fpext_oneuse (vti.Vti.Vector (SplatFPOp vti.Vti.ScalarRegClass:$rs1)))),
|
||||
(vti.Wti.Vector (fpext_oneuse (vti.Vti.Vector vti.Vti.RegClass:$rs2))),
|
||||
(vti.Wti.Vector vti.Wti.RegClass:$rd)),
|
||||
(!cast<Instruction>(instruction_name#"_V"#vti.Vti.ScalarSuffix#"_"#vti.Vti.LMul.MX)
|
||||
@ -453,13 +453,13 @@ multiclass VPatWidenFPNegMulAccSDNode_VV_VF<string instruction_name> {
|
||||
(!cast<Instruction>(instruction_name#"_VV_"#vti.LMul.MX)
|
||||
wti.RegClass:$rd, vti.RegClass:$rs1, vti.RegClass:$rs2,
|
||||
vti.AVL, vti.Log2SEW, TAIL_AGNOSTIC)>;
|
||||
def : Pat<(fma (fpext_oneuse (vti.Vector (splat_vector vti.ScalarRegClass:$rs1))),
|
||||
def : Pat<(fma (fpext_oneuse (vti.Vector (SplatFPOp vti.ScalarRegClass:$rs1))),
|
||||
(fneg (wti.Vector (fpext_oneuse (vti.Vector vti.RegClass:$rs2)))),
|
||||
(fneg wti.RegClass:$rd)),
|
||||
(!cast<Instruction>(instruction_name#"_V"#vti.ScalarSuffix#"_"#vti.LMul.MX)
|
||||
wti.RegClass:$rd, vti.ScalarRegClass:$rs1, vti.RegClass:$rs2,
|
||||
vti.AVL, vti.Log2SEW, TAIL_AGNOSTIC)>;
|
||||
def : Pat<(fma (fneg (wti.Vector (fpext_oneuse (vti.Vector (splat_vector vti.ScalarRegClass:$rs1))))),
|
||||
def : Pat<(fma (fneg (wti.Vector (fpext_oneuse (vti.Vector (SplatFPOp vti.ScalarRegClass:$rs1))))),
|
||||
(fpext_oneuse (vti.Vector vti.RegClass:$rs2)),
|
||||
(fneg wti.RegClass:$rd)),
|
||||
(!cast<Instruction>(instruction_name#"_V"#vti.ScalarSuffix#"_"#vti.LMul.MX)
|
||||
@ -478,7 +478,7 @@ multiclass VPatWidenFPMulSacSDNode_VV_VF<string instruction_name> {
|
||||
(!cast<Instruction>(instruction_name#"_VV_"#vti.LMul.MX)
|
||||
wti.RegClass:$rd, vti.RegClass:$rs1, vti.RegClass:$rs2,
|
||||
vti.AVL, vti.Log2SEW, TAIL_AGNOSTIC)>;
|
||||
def : Pat<(fma (wti.Vector (fpext_oneuse (vti.Vector (splat_vector vti.ScalarRegClass:$rs1)))),
|
||||
def : Pat<(fma (wti.Vector (fpext_oneuse (vti.Vector (SplatFPOp vti.ScalarRegClass:$rs1)))),
|
||||
(fpext_oneuse (vti.Vector vti.RegClass:$rs2)),
|
||||
(fneg wti.RegClass:$rd)),
|
||||
(!cast<Instruction>(instruction_name#"_V"#vti.ScalarSuffix#"_"#vti.LMul.MX)
|
||||
@ -497,13 +497,13 @@ multiclass VPatWidenFPNegMulSacSDNode_VV_VF<string instruction_name> {
|
||||
(!cast<Instruction>(instruction_name#"_VV_"#vti.LMul.MX)
|
||||
wti.RegClass:$rd, vti.RegClass:$rs1, vti.RegClass:$rs2,
|
||||
vti.AVL, vti.Log2SEW, TAIL_AGNOSTIC)>;
|
||||
def : Pat<(fma (wti.Vector (fpext_oneuse (vti.Vector (splat_vector vti.ScalarRegClass:$rs1)))),
|
||||
def : Pat<(fma (wti.Vector (fpext_oneuse (vti.Vector (SplatFPOp vti.ScalarRegClass:$rs1)))),
|
||||
(fneg (wti.Vector (fpext_oneuse (vti.Vector vti.RegClass:$rs2)))),
|
||||
wti.RegClass:$rd),
|
||||
(!cast<Instruction>(instruction_name#"_V"#vti.ScalarSuffix#"_"#vti.LMul.MX)
|
||||
wti.RegClass:$rd, vti.ScalarRegClass:$rs1, vti.RegClass:$rs2,
|
||||
vti.AVL, vti.Log2SEW, TAIL_AGNOSTIC)>;
|
||||
def : Pat<(fma (fneg (wti.Vector (fpext_oneuse (vti.Vector (splat_vector vti.ScalarRegClass:$rs1))))),
|
||||
def : Pat<(fma (fneg (wti.Vector (fpext_oneuse (vti.Vector (SplatFPOp vti.ScalarRegClass:$rs1))))),
|
||||
(fpext_oneuse (vti.Vector vti.RegClass:$rs2)),
|
||||
wti.RegClass:$rd),
|
||||
(!cast<Instruction>(instruction_name#"_V"#vti.ScalarSuffix#"_"#vti.LMul.MX)
|
||||
@ -783,35 +783,35 @@ foreach fvti = AllFloatVectors in {
|
||||
|
||||
// The choice of VFMADD here is arbitrary, vfmadd.vf and vfmacc.vf are equally
|
||||
// commutable.
|
||||
def : Pat<(fvti.Vector (fma (splat_vector fvti.ScalarRegClass:$rs1),
|
||||
def : Pat<(fvti.Vector (fma (SplatFPOp fvti.ScalarRegClass:$rs1),
|
||||
fvti.RegClass:$rd, fvti.RegClass:$rs2)),
|
||||
(!cast<Instruction>("PseudoVFMADD_V" # fvti.ScalarSuffix # "_" # suffix)
|
||||
fvti.RegClass:$rd, fvti.ScalarRegClass:$rs1, fvti.RegClass:$rs2,
|
||||
fvti.AVL, fvti.Log2SEW, TAIL_AGNOSTIC)>;
|
||||
def : Pat<(fvti.Vector (fma (splat_vector fvti.ScalarRegClass:$rs1),
|
||||
def : Pat<(fvti.Vector (fma (SplatFPOp fvti.ScalarRegClass:$rs1),
|
||||
fvti.RegClass:$rd, (fneg fvti.RegClass:$rs2))),
|
||||
(!cast<Instruction>("PseudoVFMSUB_V" # fvti.ScalarSuffix # "_" # suffix)
|
||||
fvti.RegClass:$rd, fvti.ScalarRegClass:$rs1, fvti.RegClass:$rs2,
|
||||
fvti.AVL, fvti.Log2SEW, TAIL_AGNOSTIC)>;
|
||||
|
||||
def : Pat<(fvti.Vector (fma (splat_vector fvti.ScalarRegClass:$rs1),
|
||||
def : Pat<(fvti.Vector (fma (SplatFPOp fvti.ScalarRegClass:$rs1),
|
||||
(fneg fvti.RegClass:$rd), (fneg fvti.RegClass:$rs2))),
|
||||
(!cast<Instruction>("PseudoVFNMADD_V" # fvti.ScalarSuffix # "_" # suffix)
|
||||
fvti.RegClass:$rd, fvti.ScalarRegClass:$rs1, fvti.RegClass:$rs2,
|
||||
fvti.AVL, fvti.Log2SEW, TAIL_AGNOSTIC)>;
|
||||
def : Pat<(fvti.Vector (fma (splat_vector fvti.ScalarRegClass:$rs1),
|
||||
def : Pat<(fvti.Vector (fma (SplatFPOp fvti.ScalarRegClass:$rs1),
|
||||
(fneg fvti.RegClass:$rd), fvti.RegClass:$rs2)),
|
||||
(!cast<Instruction>("PseudoVFNMSUB_V" # fvti.ScalarSuffix # "_" # suffix)
|
||||
fvti.RegClass:$rd, fvti.ScalarRegClass:$rs1, fvti.RegClass:$rs2,
|
||||
fvti.AVL, fvti.Log2SEW, TAIL_AGNOSTIC)>;
|
||||
|
||||
// The splat might be negated.
|
||||
def : Pat<(fvti.Vector (fma (fneg (splat_vector fvti.ScalarRegClass:$rs1)),
|
||||
def : Pat<(fvti.Vector (fma (fneg (SplatFPOp fvti.ScalarRegClass:$rs1)),
|
||||
fvti.RegClass:$rd, (fneg fvti.RegClass:$rs2))),
|
||||
(!cast<Instruction>("PseudoVFNMADD_V" # fvti.ScalarSuffix # "_" # suffix)
|
||||
fvti.RegClass:$rd, fvti.ScalarRegClass:$rs1, fvti.RegClass:$rs2,
|
||||
fvti.AVL, fvti.Log2SEW, TAIL_AGNOSTIC)>;
|
||||
def : Pat<(fvti.Vector (fma (fneg (splat_vector fvti.ScalarRegClass:$rs1)),
|
||||
def : Pat<(fvti.Vector (fma (fneg (SplatFPOp fvti.ScalarRegClass:$rs1)),
|
||||
fvti.RegClass:$rd, fvti.RegClass:$rs2)),
|
||||
(!cast<Instruction>("PseudoVFNMSUB_V" # fvti.ScalarSuffix # "_" # suffix)
|
||||
fvti.RegClass:$rd, fvti.ScalarRegClass:$rs1, fvti.RegClass:$rs2,
|
||||
@ -844,7 +844,7 @@ foreach vti = AllFloatVectors in {
|
||||
(!cast<Instruction>("PseudoVFSGNJ_VV_"# vti.LMul.MX)
|
||||
vti.RegClass:$rs1, vti.RegClass:$rs2, vti.AVL, vti.Log2SEW)>;
|
||||
def : Pat<(vti.Vector (fcopysign (vti.Vector vti.RegClass:$rs1),
|
||||
(vti.Vector (splat_vector vti.ScalarRegClass:$rs2)))),
|
||||
(vti.Vector (SplatFPOp vti.ScalarRegClass:$rs2)))),
|
||||
(!cast<Instruction>("PseudoVFSGNJ_V"#vti.ScalarSuffix#"_"#vti.LMul.MX)
|
||||
vti.RegClass:$rs1, vti.ScalarRegClass:$rs2, vti.AVL, vti.Log2SEW)>;
|
||||
|
||||
@ -853,7 +853,7 @@ foreach vti = AllFloatVectors in {
|
||||
(!cast<Instruction>("PseudoVFSGNJN_VV_"# vti.LMul.MX)
|
||||
vti.RegClass:$rs1, vti.RegClass:$rs2, vti.AVL, vti.Log2SEW)>;
|
||||
def : Pat<(vti.Vector (fcopysign (vti.Vector vti.RegClass:$rs1),
|
||||
(vti.Vector (fneg (splat_vector vti.ScalarRegClass:$rs2))))),
|
||||
(vti.Vector (fneg (SplatFPOp vti.ScalarRegClass:$rs2))))),
|
||||
(!cast<Instruction>("PseudoVFSGNJN_V"#vti.ScalarSuffix#"_"#vti.LMul.MX)
|
||||
vti.RegClass:$rs1, vti.ScalarRegClass:$rs2, vti.AVL, vti.Log2SEW)>;
|
||||
}
|
||||
@ -886,7 +886,7 @@ foreach fvti = AllFloatVectors in {
|
||||
fvti.AVL, fvti.Log2SEW)>;
|
||||
|
||||
def : Pat<(fvti.Vector (vselect (fvti.Mask V0),
|
||||
(splat_vector fvti.ScalarRegClass:$rs1),
|
||||
(SplatFPOp fvti.ScalarRegClass:$rs1),
|
||||
fvti.RegClass:$rs2)),
|
||||
(!cast<Instruction>("PseudoVFMERGE_V"#fvti.ScalarSuffix#"M_"#fvti.LMul.MX)
|
||||
fvti.RegClass:$rs2,
|
||||
@ -894,7 +894,7 @@ foreach fvti = AllFloatVectors in {
|
||||
(fvti.Mask V0), fvti.AVL, fvti.Log2SEW)>;
|
||||
|
||||
def : Pat<(fvti.Vector (vselect (fvti.Mask V0),
|
||||
(splat_vector (fvti.Scalar fpimm0)),
|
||||
(SplatFPOp (fvti.Scalar fpimm0)),
|
||||
fvti.RegClass:$rs2)),
|
||||
(!cast<Instruction>("PseudoVMERGE_VIM_"#fvti.LMul.MX)
|
||||
fvti.RegClass:$rs2, 0, (fvti.Mask V0), fvti.AVL, fvti.Log2SEW)>;
|
||||
@ -939,12 +939,12 @@ foreach fvtiToFWti = AllWidenableFloatVectors in {
|
||||
|
||||
let Predicates = [HasVInstructionsAnyF] in {
|
||||
foreach fvti = AllFloatVectors in {
|
||||
def : Pat<(fvti.Vector (splat_vector fvti.ScalarRegClass:$rs1)),
|
||||
def : Pat<(fvti.Vector (SplatFPOp fvti.ScalarRegClass:$rs1)),
|
||||
(!cast<Instruction>("PseudoVFMV_V_"#fvti.ScalarSuffix#"_"#fvti.LMul.MX)
|
||||
(fvti.Scalar fvti.ScalarRegClass:$rs1),
|
||||
fvti.AVL, fvti.Log2SEW)>;
|
||||
|
||||
def : Pat<(fvti.Vector (splat_vector (fvti.Scalar fpimm0))),
|
||||
def : Pat<(fvti.Vector (SplatFPOp (fvti.Scalar fpimm0))),
|
||||
(!cast<Instruction>("PseudoVMV_V_I_"#fvti.LMul.MX)
|
||||
0, fvti.AVL, fvti.Log2SEW)>;
|
||||
}
|
||||
|
||||
@ -1163,21 +1163,6 @@ foreach vti = AllFloatVectors in {
|
||||
(!cast<Instruction>("PseudoVFMADD_V" # vti.ScalarSuffix # "_" # suffix # "_MASK")
|
||||
vti.RegClass:$rd, vti.ScalarRegClass:$rs1, vti.RegClass:$rs2,
|
||||
(vti.Mask V0), GPR:$vl, vti.Log2SEW)>;
|
||||
// Scalable length vector splats
|
||||
def : Pat<(vti.Vector (riscv_fma_vl (splat_vector vti.ScalarRegClass:$rs1),
|
||||
vti.RegClass:$rd, vti.RegClass:$rs2,
|
||||
(vti.Mask true_mask),
|
||||
VLOpFrag)),
|
||||
(!cast<Instruction>("PseudoVFMADD_V" # vti.ScalarSuffix # "_" # suffix)
|
||||
vti.RegClass:$rd, vti.ScalarRegClass:$rs1, vti.RegClass:$rs2,
|
||||
GPR:$vl, vti.Log2SEW, TAIL_AGNOSTIC)>;
|
||||
def : Pat<(vti.Vector (riscv_fma_vl (splat_vector vti.ScalarRegClass:$rs1),
|
||||
vti.RegClass:$rd, vti.RegClass:$rs2,
|
||||
(vti.Mask V0),
|
||||
VLOpFrag)),
|
||||
(!cast<Instruction>("PseudoVFMADD_V" # vti.ScalarSuffix # "_" # suffix # "_MASK")
|
||||
vti.RegClass:$rd, vti.ScalarRegClass:$rs1, vti.RegClass:$rs2,
|
||||
(vti.Mask V0), GPR:$vl, vti.Log2SEW)>;
|
||||
|
||||
def : Pat<(vti.Vector (riscv_fma_vl (SplatFPOp vti.ScalarRegClass:$rs1),
|
||||
vti.RegClass:$rd,
|
||||
|
||||
@ -31,10 +31,8 @@ define <vscale x 1 x half> @vfadd_vv_nxv1f16_unmasked(<vscale x 1 x half> %va, <
|
||||
define <vscale x 1 x half> @vfadd_vf_nxv1f16(<vscale x 1 x half> %va, half %b, <vscale x 1 x i1> %m, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfadd_vf_nxv1f16:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e16, mf4, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v9, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e16, mf4, ta, mu
|
||||
; CHECK-NEXT: vfadd.vv v8, v8, v9, v0.t
|
||||
; CHECK-NEXT: vfadd.vf v8, v8, fa0, v0.t
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 1 x half> poison, half %b, i32 0
|
||||
%vb = shufflevector <vscale x 1 x half> %elt.head, <vscale x 1 x half> poison, <vscale x 1 x i32> zeroinitializer
|
||||
@ -45,10 +43,8 @@ define <vscale x 1 x half> @vfadd_vf_nxv1f16(<vscale x 1 x half> %va, half %b, <
|
||||
define <vscale x 1 x half> @vfadd_vf_nxv1f16_commute(<vscale x 1 x half> %va, half %b, <vscale x 1 x i1> %m, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfadd_vf_nxv1f16_commute:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e16, mf4, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v9, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e16, mf4, ta, mu
|
||||
; CHECK-NEXT: vfadd.vv v8, v9, v8, v0.t
|
||||
; CHECK-NEXT: vfadd.vf v8, v8, fa0, v0.t
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 1 x half> poison, half %b, i32 0
|
||||
%vb = shufflevector <vscale x 1 x half> %elt.head, <vscale x 1 x half> poison, <vscale x 1 x i32> zeroinitializer
|
||||
@ -59,10 +55,8 @@ define <vscale x 1 x half> @vfadd_vf_nxv1f16_commute(<vscale x 1 x half> %va, ha
|
||||
define <vscale x 1 x half> @vfadd_vf_nxv1f16_unmasked(<vscale x 1 x half> %va, half %b, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfadd_vf_nxv1f16_unmasked:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e16, mf4, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v9, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e16, mf4, ta, mu
|
||||
; CHECK-NEXT: vfadd.vv v8, v8, v9
|
||||
; CHECK-NEXT: vfadd.vf v8, v8, fa0
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 1 x half> poison, half %b, i32 0
|
||||
%vb = shufflevector <vscale x 1 x half> %elt.head, <vscale x 1 x half> poison, <vscale x 1 x i32> zeroinitializer
|
||||
@ -75,10 +69,8 @@ define <vscale x 1 x half> @vfadd_vf_nxv1f16_unmasked(<vscale x 1 x half> %va, h
|
||||
define <vscale x 1 x half> @vfadd_vf_nxv1f16_unmasked_commute(<vscale x 1 x half> %va, half %b, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfadd_vf_nxv1f16_unmasked_commute:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e16, mf4, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v9, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e16, mf4, ta, mu
|
||||
; CHECK-NEXT: vfadd.vv v8, v9, v8
|
||||
; CHECK-NEXT: vfadd.vf v8, v8, fa0
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 1 x half> poison, half %b, i32 0
|
||||
%vb = shufflevector <vscale x 1 x half> %elt.head, <vscale x 1 x half> poison, <vscale x 1 x i32> zeroinitializer
|
||||
@ -115,10 +107,8 @@ define <vscale x 2 x half> @vfadd_vv_nxv2f16_unmasked(<vscale x 2 x half> %va, <
|
||||
define <vscale x 2 x half> @vfadd_vf_nxv2f16(<vscale x 2 x half> %va, half %b, <vscale x 2 x i1> %m, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfadd_vf_nxv2f16:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e16, mf2, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v9, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e16, mf2, ta, mu
|
||||
; CHECK-NEXT: vfadd.vv v8, v8, v9, v0.t
|
||||
; CHECK-NEXT: vfadd.vf v8, v8, fa0, v0.t
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 2 x half> poison, half %b, i32 0
|
||||
%vb = shufflevector <vscale x 2 x half> %elt.head, <vscale x 2 x half> poison, <vscale x 2 x i32> zeroinitializer
|
||||
@ -129,10 +119,8 @@ define <vscale x 2 x half> @vfadd_vf_nxv2f16(<vscale x 2 x half> %va, half %b, <
|
||||
define <vscale x 2 x half> @vfadd_vf_nxv2f16_unmasked(<vscale x 2 x half> %va, half %b, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfadd_vf_nxv2f16_unmasked:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e16, mf2, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v9, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e16, mf2, ta, mu
|
||||
; CHECK-NEXT: vfadd.vv v8, v8, v9
|
||||
; CHECK-NEXT: vfadd.vf v8, v8, fa0
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 2 x half> poison, half %b, i32 0
|
||||
%vb = shufflevector <vscale x 2 x half> %elt.head, <vscale x 2 x half> poison, <vscale x 2 x i32> zeroinitializer
|
||||
@ -169,10 +157,8 @@ define <vscale x 4 x half> @vfadd_vv_nxv4f16_unmasked(<vscale x 4 x half> %va, <
|
||||
define <vscale x 4 x half> @vfadd_vf_nxv4f16(<vscale x 4 x half> %va, half %b, <vscale x 4 x i1> %m, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfadd_vf_nxv4f16:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e16, m1, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v9, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e16, m1, ta, mu
|
||||
; CHECK-NEXT: vfadd.vv v8, v8, v9, v0.t
|
||||
; CHECK-NEXT: vfadd.vf v8, v8, fa0, v0.t
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 4 x half> poison, half %b, i32 0
|
||||
%vb = shufflevector <vscale x 4 x half> %elt.head, <vscale x 4 x half> poison, <vscale x 4 x i32> zeroinitializer
|
||||
@ -183,10 +169,8 @@ define <vscale x 4 x half> @vfadd_vf_nxv4f16(<vscale x 4 x half> %va, half %b, <
|
||||
define <vscale x 4 x half> @vfadd_vf_nxv4f16_unmasked(<vscale x 4 x half> %va, half %b, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfadd_vf_nxv4f16_unmasked:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e16, m1, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v9, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e16, m1, ta, mu
|
||||
; CHECK-NEXT: vfadd.vv v8, v8, v9
|
||||
; CHECK-NEXT: vfadd.vf v8, v8, fa0
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 4 x half> poison, half %b, i32 0
|
||||
%vb = shufflevector <vscale x 4 x half> %elt.head, <vscale x 4 x half> poison, <vscale x 4 x i32> zeroinitializer
|
||||
@ -223,10 +207,8 @@ define <vscale x 8 x half> @vfadd_vv_nxv8f16_unmasked(<vscale x 8 x half> %va, <
|
||||
define <vscale x 8 x half> @vfadd_vf_nxv8f16(<vscale x 8 x half> %va, half %b, <vscale x 8 x i1> %m, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfadd_vf_nxv8f16:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e16, m2, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v10, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e16, m2, ta, mu
|
||||
; CHECK-NEXT: vfadd.vv v8, v8, v10, v0.t
|
||||
; CHECK-NEXT: vfadd.vf v8, v8, fa0, v0.t
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 8 x half> poison, half %b, i32 0
|
||||
%vb = shufflevector <vscale x 8 x half> %elt.head, <vscale x 8 x half> poison, <vscale x 8 x i32> zeroinitializer
|
||||
@ -237,10 +219,8 @@ define <vscale x 8 x half> @vfadd_vf_nxv8f16(<vscale x 8 x half> %va, half %b, <
|
||||
define <vscale x 8 x half> @vfadd_vf_nxv8f16_unmasked(<vscale x 8 x half> %va, half %b, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfadd_vf_nxv8f16_unmasked:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e16, m2, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v10, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e16, m2, ta, mu
|
||||
; CHECK-NEXT: vfadd.vv v8, v8, v10
|
||||
; CHECK-NEXT: vfadd.vf v8, v8, fa0
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 8 x half> poison, half %b, i32 0
|
||||
%vb = shufflevector <vscale x 8 x half> %elt.head, <vscale x 8 x half> poison, <vscale x 8 x i32> zeroinitializer
|
||||
@ -277,10 +257,8 @@ define <vscale x 16 x half> @vfadd_vv_nxv16f16_unmasked(<vscale x 16 x half> %va
|
||||
define <vscale x 16 x half> @vfadd_vf_nxv16f16(<vscale x 16 x half> %va, half %b, <vscale x 16 x i1> %m, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfadd_vf_nxv16f16:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e16, m4, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v12, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e16, m4, ta, mu
|
||||
; CHECK-NEXT: vfadd.vv v8, v8, v12, v0.t
|
||||
; CHECK-NEXT: vfadd.vf v8, v8, fa0, v0.t
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 16 x half> poison, half %b, i32 0
|
||||
%vb = shufflevector <vscale x 16 x half> %elt.head, <vscale x 16 x half> poison, <vscale x 16 x i32> zeroinitializer
|
||||
@ -291,10 +269,8 @@ define <vscale x 16 x half> @vfadd_vf_nxv16f16(<vscale x 16 x half> %va, half %b
|
||||
define <vscale x 16 x half> @vfadd_vf_nxv16f16_unmasked(<vscale x 16 x half> %va, half %b, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfadd_vf_nxv16f16_unmasked:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e16, m4, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v12, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e16, m4, ta, mu
|
||||
; CHECK-NEXT: vfadd.vv v8, v8, v12
|
||||
; CHECK-NEXT: vfadd.vf v8, v8, fa0
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 16 x half> poison, half %b, i32 0
|
||||
%vb = shufflevector <vscale x 16 x half> %elt.head, <vscale x 16 x half> poison, <vscale x 16 x i32> zeroinitializer
|
||||
@ -331,10 +307,8 @@ define <vscale x 32 x half> @vfadd_vv_nxv32f16_unmasked(<vscale x 32 x half> %va
|
||||
define <vscale x 32 x half> @vfadd_vf_nxv32f16(<vscale x 32 x half> %va, half %b, <vscale x 32 x i1> %m, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfadd_vf_nxv32f16:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e16, m8, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v16, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e16, m8, ta, mu
|
||||
; CHECK-NEXT: vfadd.vv v8, v8, v16, v0.t
|
||||
; CHECK-NEXT: vfadd.vf v8, v8, fa0, v0.t
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 32 x half> poison, half %b, i32 0
|
||||
%vb = shufflevector <vscale x 32 x half> %elt.head, <vscale x 32 x half> poison, <vscale x 32 x i32> zeroinitializer
|
||||
@ -345,10 +319,8 @@ define <vscale x 32 x half> @vfadd_vf_nxv32f16(<vscale x 32 x half> %va, half %b
|
||||
define <vscale x 32 x half> @vfadd_vf_nxv32f16_unmasked(<vscale x 32 x half> %va, half %b, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfadd_vf_nxv32f16_unmasked:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e16, m8, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v16, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e16, m8, ta, mu
|
||||
; CHECK-NEXT: vfadd.vv v8, v8, v16
|
||||
; CHECK-NEXT: vfadd.vf v8, v8, fa0
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 32 x half> poison, half %b, i32 0
|
||||
%vb = shufflevector <vscale x 32 x half> %elt.head, <vscale x 32 x half> poison, <vscale x 32 x i32> zeroinitializer
|
||||
@ -385,10 +357,8 @@ define <vscale x 1 x float> @vfadd_vv_nxv1f32_unmasked(<vscale x 1 x float> %va,
|
||||
define <vscale x 1 x float> @vfadd_vf_nxv1f32(<vscale x 1 x float> %va, float %b, <vscale x 1 x i1> %m, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfadd_vf_nxv1f32:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e32, mf2, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v9, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e32, mf2, ta, mu
|
||||
; CHECK-NEXT: vfadd.vv v8, v8, v9, v0.t
|
||||
; CHECK-NEXT: vfadd.vf v8, v8, fa0, v0.t
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 1 x float> poison, float %b, i32 0
|
||||
%vb = shufflevector <vscale x 1 x float> %elt.head, <vscale x 1 x float> poison, <vscale x 1 x i32> zeroinitializer
|
||||
@ -399,10 +369,8 @@ define <vscale x 1 x float> @vfadd_vf_nxv1f32(<vscale x 1 x float> %va, float %b
|
||||
define <vscale x 1 x float> @vfadd_vf_nxv1f32_unmasked(<vscale x 1 x float> %va, float %b, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfadd_vf_nxv1f32_unmasked:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e32, mf2, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v9, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e32, mf2, ta, mu
|
||||
; CHECK-NEXT: vfadd.vv v8, v8, v9
|
||||
; CHECK-NEXT: vfadd.vf v8, v8, fa0
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 1 x float> poison, float %b, i32 0
|
||||
%vb = shufflevector <vscale x 1 x float> %elt.head, <vscale x 1 x float> poison, <vscale x 1 x i32> zeroinitializer
|
||||
@ -439,10 +407,8 @@ define <vscale x 2 x float> @vfadd_vv_nxv2f32_unmasked(<vscale x 2 x float> %va,
|
||||
define <vscale x 2 x float> @vfadd_vf_nxv2f32(<vscale x 2 x float> %va, float %b, <vscale x 2 x i1> %m, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfadd_vf_nxv2f32:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e32, m1, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v9, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e32, m1, ta, mu
|
||||
; CHECK-NEXT: vfadd.vv v8, v8, v9, v0.t
|
||||
; CHECK-NEXT: vfadd.vf v8, v8, fa0, v0.t
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 2 x float> poison, float %b, i32 0
|
||||
%vb = shufflevector <vscale x 2 x float> %elt.head, <vscale x 2 x float> poison, <vscale x 2 x i32> zeroinitializer
|
||||
@ -453,10 +419,8 @@ define <vscale x 2 x float> @vfadd_vf_nxv2f32(<vscale x 2 x float> %va, float %b
|
||||
define <vscale x 2 x float> @vfadd_vf_nxv2f32_unmasked(<vscale x 2 x float> %va, float %b, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfadd_vf_nxv2f32_unmasked:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e32, m1, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v9, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e32, m1, ta, mu
|
||||
; CHECK-NEXT: vfadd.vv v8, v8, v9
|
||||
; CHECK-NEXT: vfadd.vf v8, v8, fa0
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 2 x float> poison, float %b, i32 0
|
||||
%vb = shufflevector <vscale x 2 x float> %elt.head, <vscale x 2 x float> poison, <vscale x 2 x i32> zeroinitializer
|
||||
@ -493,10 +457,8 @@ define <vscale x 4 x float> @vfadd_vv_nxv4f32_unmasked(<vscale x 4 x float> %va,
|
||||
define <vscale x 4 x float> @vfadd_vf_nxv4f32(<vscale x 4 x float> %va, float %b, <vscale x 4 x i1> %m, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfadd_vf_nxv4f32:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e32, m2, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v10, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e32, m2, ta, mu
|
||||
; CHECK-NEXT: vfadd.vv v8, v8, v10, v0.t
|
||||
; CHECK-NEXT: vfadd.vf v8, v8, fa0, v0.t
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 4 x float> poison, float %b, i32 0
|
||||
%vb = shufflevector <vscale x 4 x float> %elt.head, <vscale x 4 x float> poison, <vscale x 4 x i32> zeroinitializer
|
||||
@ -507,10 +469,8 @@ define <vscale x 4 x float> @vfadd_vf_nxv4f32(<vscale x 4 x float> %va, float %b
|
||||
define <vscale x 4 x float> @vfadd_vf_nxv4f32_unmasked(<vscale x 4 x float> %va, float %b, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfadd_vf_nxv4f32_unmasked:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e32, m2, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v10, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e32, m2, ta, mu
|
||||
; CHECK-NEXT: vfadd.vv v8, v8, v10
|
||||
; CHECK-NEXT: vfadd.vf v8, v8, fa0
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 4 x float> poison, float %b, i32 0
|
||||
%vb = shufflevector <vscale x 4 x float> %elt.head, <vscale x 4 x float> poison, <vscale x 4 x i32> zeroinitializer
|
||||
@ -547,10 +507,8 @@ define <vscale x 8 x float> @vfadd_vv_nxv8f32_unmasked(<vscale x 8 x float> %va,
|
||||
define <vscale x 8 x float> @vfadd_vf_nxv8f32(<vscale x 8 x float> %va, float %b, <vscale x 8 x i1> %m, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfadd_vf_nxv8f32:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e32, m4, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v12, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e32, m4, ta, mu
|
||||
; CHECK-NEXT: vfadd.vv v8, v8, v12, v0.t
|
||||
; CHECK-NEXT: vfadd.vf v8, v8, fa0, v0.t
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 8 x float> poison, float %b, i32 0
|
||||
%vb = shufflevector <vscale x 8 x float> %elt.head, <vscale x 8 x float> poison, <vscale x 8 x i32> zeroinitializer
|
||||
@ -561,10 +519,8 @@ define <vscale x 8 x float> @vfadd_vf_nxv8f32(<vscale x 8 x float> %va, float %b
|
||||
define <vscale x 8 x float> @vfadd_vf_nxv8f32_unmasked(<vscale x 8 x float> %va, float %b, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfadd_vf_nxv8f32_unmasked:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e32, m4, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v12, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e32, m4, ta, mu
|
||||
; CHECK-NEXT: vfadd.vv v8, v8, v12
|
||||
; CHECK-NEXT: vfadd.vf v8, v8, fa0
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 8 x float> poison, float %b, i32 0
|
||||
%vb = shufflevector <vscale x 8 x float> %elt.head, <vscale x 8 x float> poison, <vscale x 8 x i32> zeroinitializer
|
||||
@ -601,10 +557,8 @@ define <vscale x 16 x float> @vfadd_vv_nxv16f32_unmasked(<vscale x 16 x float> %
|
||||
define <vscale x 16 x float> @vfadd_vf_nxv16f32(<vscale x 16 x float> %va, float %b, <vscale x 16 x i1> %m, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfadd_vf_nxv16f32:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e32, m8, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v16, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e32, m8, ta, mu
|
||||
; CHECK-NEXT: vfadd.vv v8, v8, v16, v0.t
|
||||
; CHECK-NEXT: vfadd.vf v8, v8, fa0, v0.t
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 16 x float> poison, float %b, i32 0
|
||||
%vb = shufflevector <vscale x 16 x float> %elt.head, <vscale x 16 x float> poison, <vscale x 16 x i32> zeroinitializer
|
||||
@ -615,10 +569,8 @@ define <vscale x 16 x float> @vfadd_vf_nxv16f32(<vscale x 16 x float> %va, float
|
||||
define <vscale x 16 x float> @vfadd_vf_nxv16f32_unmasked(<vscale x 16 x float> %va, float %b, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfadd_vf_nxv16f32_unmasked:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e32, m8, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v16, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e32, m8, ta, mu
|
||||
; CHECK-NEXT: vfadd.vv v8, v8, v16
|
||||
; CHECK-NEXT: vfadd.vf v8, v8, fa0
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 16 x float> poison, float %b, i32 0
|
||||
%vb = shufflevector <vscale x 16 x float> %elt.head, <vscale x 16 x float> poison, <vscale x 16 x i32> zeroinitializer
|
||||
@ -655,10 +607,8 @@ define <vscale x 1 x double> @vfadd_vv_nxv1f64_unmasked(<vscale x 1 x double> %v
|
||||
define <vscale x 1 x double> @vfadd_vf_nxv1f64(<vscale x 1 x double> %va, double %b, <vscale x 1 x i1> %m, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfadd_vf_nxv1f64:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e64, m1, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v9, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e64, m1, ta, mu
|
||||
; CHECK-NEXT: vfadd.vv v8, v8, v9, v0.t
|
||||
; CHECK-NEXT: vfadd.vf v8, v8, fa0, v0.t
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 1 x double> poison, double %b, i32 0
|
||||
%vb = shufflevector <vscale x 1 x double> %elt.head, <vscale x 1 x double> poison, <vscale x 1 x i32> zeroinitializer
|
||||
@ -669,10 +619,8 @@ define <vscale x 1 x double> @vfadd_vf_nxv1f64(<vscale x 1 x double> %va, double
|
||||
define <vscale x 1 x double> @vfadd_vf_nxv1f64_unmasked(<vscale x 1 x double> %va, double %b, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfadd_vf_nxv1f64_unmasked:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e64, m1, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v9, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e64, m1, ta, mu
|
||||
; CHECK-NEXT: vfadd.vv v8, v8, v9
|
||||
; CHECK-NEXT: vfadd.vf v8, v8, fa0
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 1 x double> poison, double %b, i32 0
|
||||
%vb = shufflevector <vscale x 1 x double> %elt.head, <vscale x 1 x double> poison, <vscale x 1 x i32> zeroinitializer
|
||||
@ -709,10 +657,8 @@ define <vscale x 2 x double> @vfadd_vv_nxv2f64_unmasked(<vscale x 2 x double> %v
|
||||
define <vscale x 2 x double> @vfadd_vf_nxv2f64(<vscale x 2 x double> %va, double %b, <vscale x 2 x i1> %m, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfadd_vf_nxv2f64:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e64, m2, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v10, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e64, m2, ta, mu
|
||||
; CHECK-NEXT: vfadd.vv v8, v8, v10, v0.t
|
||||
; CHECK-NEXT: vfadd.vf v8, v8, fa0, v0.t
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 2 x double> poison, double %b, i32 0
|
||||
%vb = shufflevector <vscale x 2 x double> %elt.head, <vscale x 2 x double> poison, <vscale x 2 x i32> zeroinitializer
|
||||
@ -723,10 +669,8 @@ define <vscale x 2 x double> @vfadd_vf_nxv2f64(<vscale x 2 x double> %va, double
|
||||
define <vscale x 2 x double> @vfadd_vf_nxv2f64_unmasked(<vscale x 2 x double> %va, double %b, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfadd_vf_nxv2f64_unmasked:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e64, m2, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v10, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e64, m2, ta, mu
|
||||
; CHECK-NEXT: vfadd.vv v8, v8, v10
|
||||
; CHECK-NEXT: vfadd.vf v8, v8, fa0
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 2 x double> poison, double %b, i32 0
|
||||
%vb = shufflevector <vscale x 2 x double> %elt.head, <vscale x 2 x double> poison, <vscale x 2 x i32> zeroinitializer
|
||||
@ -763,10 +707,8 @@ define <vscale x 4 x double> @vfadd_vv_nxv4f64_unmasked(<vscale x 4 x double> %v
|
||||
define <vscale x 4 x double> @vfadd_vf_nxv4f64(<vscale x 4 x double> %va, double %b, <vscale x 4 x i1> %m, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfadd_vf_nxv4f64:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e64, m4, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v12, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e64, m4, ta, mu
|
||||
; CHECK-NEXT: vfadd.vv v8, v8, v12, v0.t
|
||||
; CHECK-NEXT: vfadd.vf v8, v8, fa0, v0.t
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 4 x double> poison, double %b, i32 0
|
||||
%vb = shufflevector <vscale x 4 x double> %elt.head, <vscale x 4 x double> poison, <vscale x 4 x i32> zeroinitializer
|
||||
@ -777,10 +719,8 @@ define <vscale x 4 x double> @vfadd_vf_nxv4f64(<vscale x 4 x double> %va, double
|
||||
define <vscale x 4 x double> @vfadd_vf_nxv4f64_unmasked(<vscale x 4 x double> %va, double %b, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfadd_vf_nxv4f64_unmasked:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e64, m4, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v12, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e64, m4, ta, mu
|
||||
; CHECK-NEXT: vfadd.vv v8, v8, v12
|
||||
; CHECK-NEXT: vfadd.vf v8, v8, fa0
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 4 x double> poison, double %b, i32 0
|
||||
%vb = shufflevector <vscale x 4 x double> %elt.head, <vscale x 4 x double> poison, <vscale x 4 x i32> zeroinitializer
|
||||
@ -829,10 +769,8 @@ define <vscale x 8 x double> @vfadd_vv_nxv8f64_unmasked(<vscale x 8 x double> %v
|
||||
define <vscale x 8 x double> @vfadd_vf_nxv8f64(<vscale x 8 x double> %va, double %b, <vscale x 8 x i1> %m, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfadd_vf_nxv8f64:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e64, m8, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v16, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e64, m8, ta, mu
|
||||
; CHECK-NEXT: vfadd.vv v8, v8, v16, v0.t
|
||||
; CHECK-NEXT: vfadd.vf v8, v8, fa0, v0.t
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 8 x double> poison, double %b, i32 0
|
||||
%vb = shufflevector <vscale x 8 x double> %elt.head, <vscale x 8 x double> poison, <vscale x 8 x i32> zeroinitializer
|
||||
@ -843,10 +781,8 @@ define <vscale x 8 x double> @vfadd_vf_nxv8f64(<vscale x 8 x double> %va, double
|
||||
define <vscale x 8 x double> @vfadd_vf_nxv8f64_unmasked(<vscale x 8 x double> %va, double %b, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfadd_vf_nxv8f64_unmasked:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e64, m8, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v16, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e64, m8, ta, mu
|
||||
; CHECK-NEXT: vfadd.vv v8, v8, v16
|
||||
; CHECK-NEXT: vfadd.vf v8, v8, fa0
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 8 x double> poison, double %b, i32 0
|
||||
%vb = shufflevector <vscale x 8 x double> %elt.head, <vscale x 8 x double> poison, <vscale x 8 x i32> zeroinitializer
|
||||
|
||||
@ -31,10 +31,8 @@ define <vscale x 1 x half> @vfdiv_vv_nxv1f16_unmasked(<vscale x 1 x half> %va, <
|
||||
define <vscale x 1 x half> @vfdiv_vf_nxv1f16(<vscale x 1 x half> %va, half %b, <vscale x 1 x i1> %m, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfdiv_vf_nxv1f16:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e16, mf4, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v9, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e16, mf4, ta, mu
|
||||
; CHECK-NEXT: vfdiv.vv v8, v8, v9, v0.t
|
||||
; CHECK-NEXT: vfdiv.vf v8, v8, fa0, v0.t
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 1 x half> poison, half %b, i32 0
|
||||
%vb = shufflevector <vscale x 1 x half> %elt.head, <vscale x 1 x half> poison, <vscale x 1 x i32> zeroinitializer
|
||||
@ -45,10 +43,8 @@ define <vscale x 1 x half> @vfdiv_vf_nxv1f16(<vscale x 1 x half> %va, half %b, <
|
||||
define <vscale x 1 x half> @vfdiv_vf_nxv1f16_unmasked(<vscale x 1 x half> %va, half %b, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfdiv_vf_nxv1f16_unmasked:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e16, mf4, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v9, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e16, mf4, ta, mu
|
||||
; CHECK-NEXT: vfdiv.vv v8, v8, v9
|
||||
; CHECK-NEXT: vfdiv.vf v8, v8, fa0
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 1 x half> poison, half %b, i32 0
|
||||
%vb = shufflevector <vscale x 1 x half> %elt.head, <vscale x 1 x half> poison, <vscale x 1 x i32> zeroinitializer
|
||||
@ -85,10 +81,8 @@ define <vscale x 2 x half> @vfdiv_vv_nxv2f16_unmasked(<vscale x 2 x half> %va, <
|
||||
define <vscale x 2 x half> @vfdiv_vf_nxv2f16(<vscale x 2 x half> %va, half %b, <vscale x 2 x i1> %m, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfdiv_vf_nxv2f16:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e16, mf2, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v9, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e16, mf2, ta, mu
|
||||
; CHECK-NEXT: vfdiv.vv v8, v8, v9, v0.t
|
||||
; CHECK-NEXT: vfdiv.vf v8, v8, fa0, v0.t
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 2 x half> poison, half %b, i32 0
|
||||
%vb = shufflevector <vscale x 2 x half> %elt.head, <vscale x 2 x half> poison, <vscale x 2 x i32> zeroinitializer
|
||||
@ -99,10 +93,8 @@ define <vscale x 2 x half> @vfdiv_vf_nxv2f16(<vscale x 2 x half> %va, half %b, <
|
||||
define <vscale x 2 x half> @vfdiv_vf_nxv2f16_unmasked(<vscale x 2 x half> %va, half %b, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfdiv_vf_nxv2f16_unmasked:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e16, mf2, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v9, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e16, mf2, ta, mu
|
||||
; CHECK-NEXT: vfdiv.vv v8, v8, v9
|
||||
; CHECK-NEXT: vfdiv.vf v8, v8, fa0
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 2 x half> poison, half %b, i32 0
|
||||
%vb = shufflevector <vscale x 2 x half> %elt.head, <vscale x 2 x half> poison, <vscale x 2 x i32> zeroinitializer
|
||||
@ -139,10 +131,8 @@ define <vscale x 4 x half> @vfdiv_vv_nxv4f16_unmasked(<vscale x 4 x half> %va, <
|
||||
define <vscale x 4 x half> @vfdiv_vf_nxv4f16(<vscale x 4 x half> %va, half %b, <vscale x 4 x i1> %m, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfdiv_vf_nxv4f16:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e16, m1, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v9, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e16, m1, ta, mu
|
||||
; CHECK-NEXT: vfdiv.vv v8, v8, v9, v0.t
|
||||
; CHECK-NEXT: vfdiv.vf v8, v8, fa0, v0.t
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 4 x half> poison, half %b, i32 0
|
||||
%vb = shufflevector <vscale x 4 x half> %elt.head, <vscale x 4 x half> poison, <vscale x 4 x i32> zeroinitializer
|
||||
@ -153,10 +143,8 @@ define <vscale x 4 x half> @vfdiv_vf_nxv4f16(<vscale x 4 x half> %va, half %b, <
|
||||
define <vscale x 4 x half> @vfdiv_vf_nxv4f16_unmasked(<vscale x 4 x half> %va, half %b, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfdiv_vf_nxv4f16_unmasked:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e16, m1, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v9, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e16, m1, ta, mu
|
||||
; CHECK-NEXT: vfdiv.vv v8, v8, v9
|
||||
; CHECK-NEXT: vfdiv.vf v8, v8, fa0
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 4 x half> poison, half %b, i32 0
|
||||
%vb = shufflevector <vscale x 4 x half> %elt.head, <vscale x 4 x half> poison, <vscale x 4 x i32> zeroinitializer
|
||||
@ -193,10 +181,8 @@ define <vscale x 8 x half> @vfdiv_vv_nxv8f16_unmasked(<vscale x 8 x half> %va, <
|
||||
define <vscale x 8 x half> @vfdiv_vf_nxv8f16(<vscale x 8 x half> %va, half %b, <vscale x 8 x i1> %m, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfdiv_vf_nxv8f16:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e16, m2, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v10, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e16, m2, ta, mu
|
||||
; CHECK-NEXT: vfdiv.vv v8, v8, v10, v0.t
|
||||
; CHECK-NEXT: vfdiv.vf v8, v8, fa0, v0.t
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 8 x half> poison, half %b, i32 0
|
||||
%vb = shufflevector <vscale x 8 x half> %elt.head, <vscale x 8 x half> poison, <vscale x 8 x i32> zeroinitializer
|
||||
@ -207,10 +193,8 @@ define <vscale x 8 x half> @vfdiv_vf_nxv8f16(<vscale x 8 x half> %va, half %b, <
|
||||
define <vscale x 8 x half> @vfdiv_vf_nxv8f16_unmasked(<vscale x 8 x half> %va, half %b, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfdiv_vf_nxv8f16_unmasked:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e16, m2, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v10, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e16, m2, ta, mu
|
||||
; CHECK-NEXT: vfdiv.vv v8, v8, v10
|
||||
; CHECK-NEXT: vfdiv.vf v8, v8, fa0
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 8 x half> poison, half %b, i32 0
|
||||
%vb = shufflevector <vscale x 8 x half> %elt.head, <vscale x 8 x half> poison, <vscale x 8 x i32> zeroinitializer
|
||||
@ -247,10 +231,8 @@ define <vscale x 16 x half> @vfdiv_vv_nxv16f16_unmasked(<vscale x 16 x half> %va
|
||||
define <vscale x 16 x half> @vfdiv_vf_nxv16f16(<vscale x 16 x half> %va, half %b, <vscale x 16 x i1> %m, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfdiv_vf_nxv16f16:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e16, m4, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v12, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e16, m4, ta, mu
|
||||
; CHECK-NEXT: vfdiv.vv v8, v8, v12, v0.t
|
||||
; CHECK-NEXT: vfdiv.vf v8, v8, fa0, v0.t
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 16 x half> poison, half %b, i32 0
|
||||
%vb = shufflevector <vscale x 16 x half> %elt.head, <vscale x 16 x half> poison, <vscale x 16 x i32> zeroinitializer
|
||||
@ -261,10 +243,8 @@ define <vscale x 16 x half> @vfdiv_vf_nxv16f16(<vscale x 16 x half> %va, half %b
|
||||
define <vscale x 16 x half> @vfdiv_vf_nxv16f16_unmasked(<vscale x 16 x half> %va, half %b, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfdiv_vf_nxv16f16_unmasked:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e16, m4, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v12, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e16, m4, ta, mu
|
||||
; CHECK-NEXT: vfdiv.vv v8, v8, v12
|
||||
; CHECK-NEXT: vfdiv.vf v8, v8, fa0
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 16 x half> poison, half %b, i32 0
|
||||
%vb = shufflevector <vscale x 16 x half> %elt.head, <vscale x 16 x half> poison, <vscale x 16 x i32> zeroinitializer
|
||||
@ -301,10 +281,8 @@ define <vscale x 32 x half> @vfdiv_vv_nxv32f16_unmasked(<vscale x 32 x half> %va
|
||||
define <vscale x 32 x half> @vfdiv_vf_nxv32f16(<vscale x 32 x half> %va, half %b, <vscale x 32 x i1> %m, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfdiv_vf_nxv32f16:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e16, m8, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v16, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e16, m8, ta, mu
|
||||
; CHECK-NEXT: vfdiv.vv v8, v8, v16, v0.t
|
||||
; CHECK-NEXT: vfdiv.vf v8, v8, fa0, v0.t
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 32 x half> poison, half %b, i32 0
|
||||
%vb = shufflevector <vscale x 32 x half> %elt.head, <vscale x 32 x half> poison, <vscale x 32 x i32> zeroinitializer
|
||||
@ -315,10 +293,8 @@ define <vscale x 32 x half> @vfdiv_vf_nxv32f16(<vscale x 32 x half> %va, half %b
|
||||
define <vscale x 32 x half> @vfdiv_vf_nxv32f16_unmasked(<vscale x 32 x half> %va, half %b, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfdiv_vf_nxv32f16_unmasked:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e16, m8, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v16, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e16, m8, ta, mu
|
||||
; CHECK-NEXT: vfdiv.vv v8, v8, v16
|
||||
; CHECK-NEXT: vfdiv.vf v8, v8, fa0
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 32 x half> poison, half %b, i32 0
|
||||
%vb = shufflevector <vscale x 32 x half> %elt.head, <vscale x 32 x half> poison, <vscale x 32 x i32> zeroinitializer
|
||||
@ -355,10 +331,8 @@ define <vscale x 1 x float> @vfdiv_vv_nxv1f32_unmasked(<vscale x 1 x float> %va,
|
||||
define <vscale x 1 x float> @vfdiv_vf_nxv1f32(<vscale x 1 x float> %va, float %b, <vscale x 1 x i1> %m, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfdiv_vf_nxv1f32:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e32, mf2, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v9, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e32, mf2, ta, mu
|
||||
; CHECK-NEXT: vfdiv.vv v8, v8, v9, v0.t
|
||||
; CHECK-NEXT: vfdiv.vf v8, v8, fa0, v0.t
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 1 x float> poison, float %b, i32 0
|
||||
%vb = shufflevector <vscale x 1 x float> %elt.head, <vscale x 1 x float> poison, <vscale x 1 x i32> zeroinitializer
|
||||
@ -369,10 +343,8 @@ define <vscale x 1 x float> @vfdiv_vf_nxv1f32(<vscale x 1 x float> %va, float %b
|
||||
define <vscale x 1 x float> @vfdiv_vf_nxv1f32_unmasked(<vscale x 1 x float> %va, float %b, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfdiv_vf_nxv1f32_unmasked:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e32, mf2, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v9, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e32, mf2, ta, mu
|
||||
; CHECK-NEXT: vfdiv.vv v8, v8, v9
|
||||
; CHECK-NEXT: vfdiv.vf v8, v8, fa0
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 1 x float> poison, float %b, i32 0
|
||||
%vb = shufflevector <vscale x 1 x float> %elt.head, <vscale x 1 x float> poison, <vscale x 1 x i32> zeroinitializer
|
||||
@ -409,10 +381,8 @@ define <vscale x 2 x float> @vfdiv_vv_nxv2f32_unmasked(<vscale x 2 x float> %va,
|
||||
define <vscale x 2 x float> @vfdiv_vf_nxv2f32(<vscale x 2 x float> %va, float %b, <vscale x 2 x i1> %m, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfdiv_vf_nxv2f32:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e32, m1, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v9, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e32, m1, ta, mu
|
||||
; CHECK-NEXT: vfdiv.vv v8, v8, v9, v0.t
|
||||
; CHECK-NEXT: vfdiv.vf v8, v8, fa0, v0.t
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 2 x float> poison, float %b, i32 0
|
||||
%vb = shufflevector <vscale x 2 x float> %elt.head, <vscale x 2 x float> poison, <vscale x 2 x i32> zeroinitializer
|
||||
@ -423,10 +393,8 @@ define <vscale x 2 x float> @vfdiv_vf_nxv2f32(<vscale x 2 x float> %va, float %b
|
||||
define <vscale x 2 x float> @vfdiv_vf_nxv2f32_unmasked(<vscale x 2 x float> %va, float %b, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfdiv_vf_nxv2f32_unmasked:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e32, m1, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v9, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e32, m1, ta, mu
|
||||
; CHECK-NEXT: vfdiv.vv v8, v8, v9
|
||||
; CHECK-NEXT: vfdiv.vf v8, v8, fa0
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 2 x float> poison, float %b, i32 0
|
||||
%vb = shufflevector <vscale x 2 x float> %elt.head, <vscale x 2 x float> poison, <vscale x 2 x i32> zeroinitializer
|
||||
@ -463,10 +431,8 @@ define <vscale x 4 x float> @vfdiv_vv_nxv4f32_unmasked(<vscale x 4 x float> %va,
|
||||
define <vscale x 4 x float> @vfdiv_vf_nxv4f32(<vscale x 4 x float> %va, float %b, <vscale x 4 x i1> %m, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfdiv_vf_nxv4f32:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e32, m2, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v10, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e32, m2, ta, mu
|
||||
; CHECK-NEXT: vfdiv.vv v8, v8, v10, v0.t
|
||||
; CHECK-NEXT: vfdiv.vf v8, v8, fa0, v0.t
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 4 x float> poison, float %b, i32 0
|
||||
%vb = shufflevector <vscale x 4 x float> %elt.head, <vscale x 4 x float> poison, <vscale x 4 x i32> zeroinitializer
|
||||
@ -477,10 +443,8 @@ define <vscale x 4 x float> @vfdiv_vf_nxv4f32(<vscale x 4 x float> %va, float %b
|
||||
define <vscale x 4 x float> @vfdiv_vf_nxv4f32_unmasked(<vscale x 4 x float> %va, float %b, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfdiv_vf_nxv4f32_unmasked:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e32, m2, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v10, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e32, m2, ta, mu
|
||||
; CHECK-NEXT: vfdiv.vv v8, v8, v10
|
||||
; CHECK-NEXT: vfdiv.vf v8, v8, fa0
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 4 x float> poison, float %b, i32 0
|
||||
%vb = shufflevector <vscale x 4 x float> %elt.head, <vscale x 4 x float> poison, <vscale x 4 x i32> zeroinitializer
|
||||
@ -517,10 +481,8 @@ define <vscale x 8 x float> @vfdiv_vv_nxv8f32_unmasked(<vscale x 8 x float> %va,
|
||||
define <vscale x 8 x float> @vfdiv_vf_nxv8f32(<vscale x 8 x float> %va, float %b, <vscale x 8 x i1> %m, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfdiv_vf_nxv8f32:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e32, m4, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v12, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e32, m4, ta, mu
|
||||
; CHECK-NEXT: vfdiv.vv v8, v8, v12, v0.t
|
||||
; CHECK-NEXT: vfdiv.vf v8, v8, fa0, v0.t
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 8 x float> poison, float %b, i32 0
|
||||
%vb = shufflevector <vscale x 8 x float> %elt.head, <vscale x 8 x float> poison, <vscale x 8 x i32> zeroinitializer
|
||||
@ -531,10 +493,8 @@ define <vscale x 8 x float> @vfdiv_vf_nxv8f32(<vscale x 8 x float> %va, float %b
|
||||
define <vscale x 8 x float> @vfdiv_vf_nxv8f32_unmasked(<vscale x 8 x float> %va, float %b, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfdiv_vf_nxv8f32_unmasked:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e32, m4, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v12, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e32, m4, ta, mu
|
||||
; CHECK-NEXT: vfdiv.vv v8, v8, v12
|
||||
; CHECK-NEXT: vfdiv.vf v8, v8, fa0
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 8 x float> poison, float %b, i32 0
|
||||
%vb = shufflevector <vscale x 8 x float> %elt.head, <vscale x 8 x float> poison, <vscale x 8 x i32> zeroinitializer
|
||||
@ -571,10 +531,8 @@ define <vscale x 16 x float> @vfdiv_vv_nxv16f32_unmasked(<vscale x 16 x float> %
|
||||
define <vscale x 16 x float> @vfdiv_vf_nxv16f32(<vscale x 16 x float> %va, float %b, <vscale x 16 x i1> %m, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfdiv_vf_nxv16f32:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e32, m8, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v16, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e32, m8, ta, mu
|
||||
; CHECK-NEXT: vfdiv.vv v8, v8, v16, v0.t
|
||||
; CHECK-NEXT: vfdiv.vf v8, v8, fa0, v0.t
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 16 x float> poison, float %b, i32 0
|
||||
%vb = shufflevector <vscale x 16 x float> %elt.head, <vscale x 16 x float> poison, <vscale x 16 x i32> zeroinitializer
|
||||
@ -585,10 +543,8 @@ define <vscale x 16 x float> @vfdiv_vf_nxv16f32(<vscale x 16 x float> %va, float
|
||||
define <vscale x 16 x float> @vfdiv_vf_nxv16f32_unmasked(<vscale x 16 x float> %va, float %b, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfdiv_vf_nxv16f32_unmasked:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e32, m8, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v16, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e32, m8, ta, mu
|
||||
; CHECK-NEXT: vfdiv.vv v8, v8, v16
|
||||
; CHECK-NEXT: vfdiv.vf v8, v8, fa0
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 16 x float> poison, float %b, i32 0
|
||||
%vb = shufflevector <vscale x 16 x float> %elt.head, <vscale x 16 x float> poison, <vscale x 16 x i32> zeroinitializer
|
||||
@ -625,10 +581,8 @@ define <vscale x 1 x double> @vfdiv_vv_nxv1f64_unmasked(<vscale x 1 x double> %v
|
||||
define <vscale x 1 x double> @vfdiv_vf_nxv1f64(<vscale x 1 x double> %va, double %b, <vscale x 1 x i1> %m, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfdiv_vf_nxv1f64:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e64, m1, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v9, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e64, m1, ta, mu
|
||||
; CHECK-NEXT: vfdiv.vv v8, v8, v9, v0.t
|
||||
; CHECK-NEXT: vfdiv.vf v8, v8, fa0, v0.t
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 1 x double> poison, double %b, i32 0
|
||||
%vb = shufflevector <vscale x 1 x double> %elt.head, <vscale x 1 x double> poison, <vscale x 1 x i32> zeroinitializer
|
||||
@ -639,10 +593,8 @@ define <vscale x 1 x double> @vfdiv_vf_nxv1f64(<vscale x 1 x double> %va, double
|
||||
define <vscale x 1 x double> @vfdiv_vf_nxv1f64_unmasked(<vscale x 1 x double> %va, double %b, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfdiv_vf_nxv1f64_unmasked:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e64, m1, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v9, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e64, m1, ta, mu
|
||||
; CHECK-NEXT: vfdiv.vv v8, v8, v9
|
||||
; CHECK-NEXT: vfdiv.vf v8, v8, fa0
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 1 x double> poison, double %b, i32 0
|
||||
%vb = shufflevector <vscale x 1 x double> %elt.head, <vscale x 1 x double> poison, <vscale x 1 x i32> zeroinitializer
|
||||
@ -679,10 +631,8 @@ define <vscale x 2 x double> @vfdiv_vv_nxv2f64_unmasked(<vscale x 2 x double> %v
|
||||
define <vscale x 2 x double> @vfdiv_vf_nxv2f64(<vscale x 2 x double> %va, double %b, <vscale x 2 x i1> %m, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfdiv_vf_nxv2f64:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e64, m2, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v10, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e64, m2, ta, mu
|
||||
; CHECK-NEXT: vfdiv.vv v8, v8, v10, v0.t
|
||||
; CHECK-NEXT: vfdiv.vf v8, v8, fa0, v0.t
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 2 x double> poison, double %b, i32 0
|
||||
%vb = shufflevector <vscale x 2 x double> %elt.head, <vscale x 2 x double> poison, <vscale x 2 x i32> zeroinitializer
|
||||
@ -693,10 +643,8 @@ define <vscale x 2 x double> @vfdiv_vf_nxv2f64(<vscale x 2 x double> %va, double
|
||||
define <vscale x 2 x double> @vfdiv_vf_nxv2f64_unmasked(<vscale x 2 x double> %va, double %b, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfdiv_vf_nxv2f64_unmasked:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e64, m2, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v10, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e64, m2, ta, mu
|
||||
; CHECK-NEXT: vfdiv.vv v8, v8, v10
|
||||
; CHECK-NEXT: vfdiv.vf v8, v8, fa0
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 2 x double> poison, double %b, i32 0
|
||||
%vb = shufflevector <vscale x 2 x double> %elt.head, <vscale x 2 x double> poison, <vscale x 2 x i32> zeroinitializer
|
||||
@ -733,10 +681,8 @@ define <vscale x 4 x double> @vfdiv_vv_nxv4f64_unmasked(<vscale x 4 x double> %v
|
||||
define <vscale x 4 x double> @vfdiv_vf_nxv4f64(<vscale x 4 x double> %va, double %b, <vscale x 4 x i1> %m, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfdiv_vf_nxv4f64:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e64, m4, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v12, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e64, m4, ta, mu
|
||||
; CHECK-NEXT: vfdiv.vv v8, v8, v12, v0.t
|
||||
; CHECK-NEXT: vfdiv.vf v8, v8, fa0, v0.t
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 4 x double> poison, double %b, i32 0
|
||||
%vb = shufflevector <vscale x 4 x double> %elt.head, <vscale x 4 x double> poison, <vscale x 4 x i32> zeroinitializer
|
||||
@ -747,10 +693,8 @@ define <vscale x 4 x double> @vfdiv_vf_nxv4f64(<vscale x 4 x double> %va, double
|
||||
define <vscale x 4 x double> @vfdiv_vf_nxv4f64_unmasked(<vscale x 4 x double> %va, double %b, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfdiv_vf_nxv4f64_unmasked:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e64, m4, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v12, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e64, m4, ta, mu
|
||||
; CHECK-NEXT: vfdiv.vv v8, v8, v12
|
||||
; CHECK-NEXT: vfdiv.vf v8, v8, fa0
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 4 x double> poison, double %b, i32 0
|
||||
%vb = shufflevector <vscale x 4 x double> %elt.head, <vscale x 4 x double> poison, <vscale x 4 x i32> zeroinitializer
|
||||
@ -799,10 +743,8 @@ define <vscale x 8 x double> @vfdiv_vv_nxv8f64_unmasked(<vscale x 8 x double> %v
|
||||
define <vscale x 8 x double> @vfdiv_vf_nxv8f64(<vscale x 8 x double> %va, double %b, <vscale x 8 x i1> %m, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfdiv_vf_nxv8f64:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e64, m8, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v16, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e64, m8, ta, mu
|
||||
; CHECK-NEXT: vfdiv.vv v8, v8, v16, v0.t
|
||||
; CHECK-NEXT: vfdiv.vf v8, v8, fa0, v0.t
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 8 x double> poison, double %b, i32 0
|
||||
%vb = shufflevector <vscale x 8 x double> %elt.head, <vscale x 8 x double> poison, <vscale x 8 x i32> zeroinitializer
|
||||
@ -813,10 +755,8 @@ define <vscale x 8 x double> @vfdiv_vf_nxv8f64(<vscale x 8 x double> %va, double
|
||||
define <vscale x 8 x double> @vfdiv_vf_nxv8f64_unmasked(<vscale x 8 x double> %va, double %b, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfdiv_vf_nxv8f64_unmasked:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e64, m8, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v16, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e64, m8, ta, mu
|
||||
; CHECK-NEXT: vfdiv.vv v8, v8, v16
|
||||
; CHECK-NEXT: vfdiv.vf v8, v8, fa0
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 8 x double> poison, double %b, i32 0
|
||||
%vb = shufflevector <vscale x 8 x double> %elt.head, <vscale x 8 x double> poison, <vscale x 8 x i32> zeroinitializer
|
||||
|
||||
@ -31,10 +31,8 @@ define <vscale x 1 x half> @vfmul_vv_nxv1f16_unmasked(<vscale x 1 x half> %va, <
|
||||
define <vscale x 1 x half> @vfmul_vf_nxv1f16(<vscale x 1 x half> %va, half %b, <vscale x 1 x i1> %m, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfmul_vf_nxv1f16:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e16, mf4, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v9, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e16, mf4, ta, mu
|
||||
; CHECK-NEXT: vfmul.vv v8, v8, v9, v0.t
|
||||
; CHECK-NEXT: vfmul.vf v8, v8, fa0, v0.t
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 1 x half> poison, half %b, i32 0
|
||||
%vb = shufflevector <vscale x 1 x half> %elt.head, <vscale x 1 x half> poison, <vscale x 1 x i32> zeroinitializer
|
||||
@ -45,10 +43,8 @@ define <vscale x 1 x half> @vfmul_vf_nxv1f16(<vscale x 1 x half> %va, half %b, <
|
||||
define <vscale x 1 x half> @vfmul_vf_nxv1f16_unmasked(<vscale x 1 x half> %va, half %b, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfmul_vf_nxv1f16_unmasked:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e16, mf4, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v9, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e16, mf4, ta, mu
|
||||
; CHECK-NEXT: vfmul.vv v8, v8, v9
|
||||
; CHECK-NEXT: vfmul.vf v8, v8, fa0
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 1 x half> poison, half %b, i32 0
|
||||
%vb = shufflevector <vscale x 1 x half> %elt.head, <vscale x 1 x half> poison, <vscale x 1 x i32> zeroinitializer
|
||||
@ -85,10 +81,8 @@ define <vscale x 2 x half> @vfmul_vv_nxv2f16_unmasked(<vscale x 2 x half> %va, <
|
||||
define <vscale x 2 x half> @vfmul_vf_nxv2f16(<vscale x 2 x half> %va, half %b, <vscale x 2 x i1> %m, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfmul_vf_nxv2f16:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e16, mf2, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v9, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e16, mf2, ta, mu
|
||||
; CHECK-NEXT: vfmul.vv v8, v8, v9, v0.t
|
||||
; CHECK-NEXT: vfmul.vf v8, v8, fa0, v0.t
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 2 x half> poison, half %b, i32 0
|
||||
%vb = shufflevector <vscale x 2 x half> %elt.head, <vscale x 2 x half> poison, <vscale x 2 x i32> zeroinitializer
|
||||
@ -99,10 +93,8 @@ define <vscale x 2 x half> @vfmul_vf_nxv2f16(<vscale x 2 x half> %va, half %b, <
|
||||
define <vscale x 2 x half> @vfmul_vf_nxv2f16_unmasked(<vscale x 2 x half> %va, half %b, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfmul_vf_nxv2f16_unmasked:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e16, mf2, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v9, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e16, mf2, ta, mu
|
||||
; CHECK-NEXT: vfmul.vv v8, v8, v9
|
||||
; CHECK-NEXT: vfmul.vf v8, v8, fa0
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 2 x half> poison, half %b, i32 0
|
||||
%vb = shufflevector <vscale x 2 x half> %elt.head, <vscale x 2 x half> poison, <vscale x 2 x i32> zeroinitializer
|
||||
@ -139,10 +131,8 @@ define <vscale x 4 x half> @vfmul_vv_nxv4f16_unmasked(<vscale x 4 x half> %va, <
|
||||
define <vscale x 4 x half> @vfmul_vf_nxv4f16(<vscale x 4 x half> %va, half %b, <vscale x 4 x i1> %m, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfmul_vf_nxv4f16:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e16, m1, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v9, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e16, m1, ta, mu
|
||||
; CHECK-NEXT: vfmul.vv v8, v8, v9, v0.t
|
||||
; CHECK-NEXT: vfmul.vf v8, v8, fa0, v0.t
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 4 x half> poison, half %b, i32 0
|
||||
%vb = shufflevector <vscale x 4 x half> %elt.head, <vscale x 4 x half> poison, <vscale x 4 x i32> zeroinitializer
|
||||
@ -153,10 +143,8 @@ define <vscale x 4 x half> @vfmul_vf_nxv4f16(<vscale x 4 x half> %va, half %b, <
|
||||
define <vscale x 4 x half> @vfmul_vf_nxv4f16_unmasked(<vscale x 4 x half> %va, half %b, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfmul_vf_nxv4f16_unmasked:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e16, m1, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v9, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e16, m1, ta, mu
|
||||
; CHECK-NEXT: vfmul.vv v8, v8, v9
|
||||
; CHECK-NEXT: vfmul.vf v8, v8, fa0
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 4 x half> poison, half %b, i32 0
|
||||
%vb = shufflevector <vscale x 4 x half> %elt.head, <vscale x 4 x half> poison, <vscale x 4 x i32> zeroinitializer
|
||||
@ -193,10 +181,8 @@ define <vscale x 8 x half> @vfmul_vv_nxv8f16_unmasked(<vscale x 8 x half> %va, <
|
||||
define <vscale x 8 x half> @vfmul_vf_nxv8f16(<vscale x 8 x half> %va, half %b, <vscale x 8 x i1> %m, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfmul_vf_nxv8f16:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e16, m2, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v10, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e16, m2, ta, mu
|
||||
; CHECK-NEXT: vfmul.vv v8, v8, v10, v0.t
|
||||
; CHECK-NEXT: vfmul.vf v8, v8, fa0, v0.t
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 8 x half> poison, half %b, i32 0
|
||||
%vb = shufflevector <vscale x 8 x half> %elt.head, <vscale x 8 x half> poison, <vscale x 8 x i32> zeroinitializer
|
||||
@ -207,10 +193,8 @@ define <vscale x 8 x half> @vfmul_vf_nxv8f16(<vscale x 8 x half> %va, half %b, <
|
||||
define <vscale x 8 x half> @vfmul_vf_nxv8f16_unmasked(<vscale x 8 x half> %va, half %b, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfmul_vf_nxv8f16_unmasked:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e16, m2, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v10, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e16, m2, ta, mu
|
||||
; CHECK-NEXT: vfmul.vv v8, v8, v10
|
||||
; CHECK-NEXT: vfmul.vf v8, v8, fa0
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 8 x half> poison, half %b, i32 0
|
||||
%vb = shufflevector <vscale x 8 x half> %elt.head, <vscale x 8 x half> poison, <vscale x 8 x i32> zeroinitializer
|
||||
@ -247,10 +231,8 @@ define <vscale x 16 x half> @vfmul_vv_nxv16f16_unmasked(<vscale x 16 x half> %va
|
||||
define <vscale x 16 x half> @vfmul_vf_nxv16f16(<vscale x 16 x half> %va, half %b, <vscale x 16 x i1> %m, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfmul_vf_nxv16f16:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e16, m4, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v12, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e16, m4, ta, mu
|
||||
; CHECK-NEXT: vfmul.vv v8, v8, v12, v0.t
|
||||
; CHECK-NEXT: vfmul.vf v8, v8, fa0, v0.t
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 16 x half> poison, half %b, i32 0
|
||||
%vb = shufflevector <vscale x 16 x half> %elt.head, <vscale x 16 x half> poison, <vscale x 16 x i32> zeroinitializer
|
||||
@ -261,10 +243,8 @@ define <vscale x 16 x half> @vfmul_vf_nxv16f16(<vscale x 16 x half> %va, half %b
|
||||
define <vscale x 16 x half> @vfmul_vf_nxv16f16_unmasked(<vscale x 16 x half> %va, half %b, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfmul_vf_nxv16f16_unmasked:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e16, m4, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v12, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e16, m4, ta, mu
|
||||
; CHECK-NEXT: vfmul.vv v8, v8, v12
|
||||
; CHECK-NEXT: vfmul.vf v8, v8, fa0
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 16 x half> poison, half %b, i32 0
|
||||
%vb = shufflevector <vscale x 16 x half> %elt.head, <vscale x 16 x half> poison, <vscale x 16 x i32> zeroinitializer
|
||||
@ -301,10 +281,8 @@ define <vscale x 32 x half> @vfmul_vv_nxv32f16_unmasked(<vscale x 32 x half> %va
|
||||
define <vscale x 32 x half> @vfmul_vf_nxv32f16(<vscale x 32 x half> %va, half %b, <vscale x 32 x i1> %m, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfmul_vf_nxv32f16:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e16, m8, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v16, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e16, m8, ta, mu
|
||||
; CHECK-NEXT: vfmul.vv v8, v8, v16, v0.t
|
||||
; CHECK-NEXT: vfmul.vf v8, v8, fa0, v0.t
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 32 x half> poison, half %b, i32 0
|
||||
%vb = shufflevector <vscale x 32 x half> %elt.head, <vscale x 32 x half> poison, <vscale x 32 x i32> zeroinitializer
|
||||
@ -315,10 +293,8 @@ define <vscale x 32 x half> @vfmul_vf_nxv32f16(<vscale x 32 x half> %va, half %b
|
||||
define <vscale x 32 x half> @vfmul_vf_nxv32f16_unmasked(<vscale x 32 x half> %va, half %b, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfmul_vf_nxv32f16_unmasked:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e16, m8, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v16, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e16, m8, ta, mu
|
||||
; CHECK-NEXT: vfmul.vv v8, v8, v16
|
||||
; CHECK-NEXT: vfmul.vf v8, v8, fa0
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 32 x half> poison, half %b, i32 0
|
||||
%vb = shufflevector <vscale x 32 x half> %elt.head, <vscale x 32 x half> poison, <vscale x 32 x i32> zeroinitializer
|
||||
@ -355,10 +331,8 @@ define <vscale x 1 x float> @vfmul_vv_nxv1f32_unmasked(<vscale x 1 x float> %va,
|
||||
define <vscale x 1 x float> @vfmul_vf_nxv1f32(<vscale x 1 x float> %va, float %b, <vscale x 1 x i1> %m, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfmul_vf_nxv1f32:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e32, mf2, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v9, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e32, mf2, ta, mu
|
||||
; CHECK-NEXT: vfmul.vv v8, v8, v9, v0.t
|
||||
; CHECK-NEXT: vfmul.vf v8, v8, fa0, v0.t
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 1 x float> poison, float %b, i32 0
|
||||
%vb = shufflevector <vscale x 1 x float> %elt.head, <vscale x 1 x float> poison, <vscale x 1 x i32> zeroinitializer
|
||||
@ -369,10 +343,8 @@ define <vscale x 1 x float> @vfmul_vf_nxv1f32(<vscale x 1 x float> %va, float %b
|
||||
define <vscale x 1 x float> @vfmul_vf_nxv1f32_unmasked(<vscale x 1 x float> %va, float %b, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfmul_vf_nxv1f32_unmasked:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e32, mf2, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v9, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e32, mf2, ta, mu
|
||||
; CHECK-NEXT: vfmul.vv v8, v8, v9
|
||||
; CHECK-NEXT: vfmul.vf v8, v8, fa0
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 1 x float> poison, float %b, i32 0
|
||||
%vb = shufflevector <vscale x 1 x float> %elt.head, <vscale x 1 x float> poison, <vscale x 1 x i32> zeroinitializer
|
||||
@ -409,10 +381,8 @@ define <vscale x 2 x float> @vfmul_vv_nxv2f32_unmasked(<vscale x 2 x float> %va,
|
||||
define <vscale x 2 x float> @vfmul_vf_nxv2f32(<vscale x 2 x float> %va, float %b, <vscale x 2 x i1> %m, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfmul_vf_nxv2f32:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e32, m1, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v9, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e32, m1, ta, mu
|
||||
; CHECK-NEXT: vfmul.vv v8, v8, v9, v0.t
|
||||
; CHECK-NEXT: vfmul.vf v8, v8, fa0, v0.t
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 2 x float> poison, float %b, i32 0
|
||||
%vb = shufflevector <vscale x 2 x float> %elt.head, <vscale x 2 x float> poison, <vscale x 2 x i32> zeroinitializer
|
||||
@ -423,10 +393,8 @@ define <vscale x 2 x float> @vfmul_vf_nxv2f32(<vscale x 2 x float> %va, float %b
|
||||
define <vscale x 2 x float> @vfmul_vf_nxv2f32_unmasked(<vscale x 2 x float> %va, float %b, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfmul_vf_nxv2f32_unmasked:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e32, m1, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v9, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e32, m1, ta, mu
|
||||
; CHECK-NEXT: vfmul.vv v8, v8, v9
|
||||
; CHECK-NEXT: vfmul.vf v8, v8, fa0
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 2 x float> poison, float %b, i32 0
|
||||
%vb = shufflevector <vscale x 2 x float> %elt.head, <vscale x 2 x float> poison, <vscale x 2 x i32> zeroinitializer
|
||||
@ -463,10 +431,8 @@ define <vscale x 4 x float> @vfmul_vv_nxv4f32_unmasked(<vscale x 4 x float> %va,
|
||||
define <vscale x 4 x float> @vfmul_vf_nxv4f32(<vscale x 4 x float> %va, float %b, <vscale x 4 x i1> %m, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfmul_vf_nxv4f32:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e32, m2, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v10, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e32, m2, ta, mu
|
||||
; CHECK-NEXT: vfmul.vv v8, v8, v10, v0.t
|
||||
; CHECK-NEXT: vfmul.vf v8, v8, fa0, v0.t
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 4 x float> poison, float %b, i32 0
|
||||
%vb = shufflevector <vscale x 4 x float> %elt.head, <vscale x 4 x float> poison, <vscale x 4 x i32> zeroinitializer
|
||||
@ -477,10 +443,8 @@ define <vscale x 4 x float> @vfmul_vf_nxv4f32(<vscale x 4 x float> %va, float %b
|
||||
define <vscale x 4 x float> @vfmul_vf_nxv4f32_unmasked(<vscale x 4 x float> %va, float %b, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfmul_vf_nxv4f32_unmasked:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e32, m2, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v10, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e32, m2, ta, mu
|
||||
; CHECK-NEXT: vfmul.vv v8, v8, v10
|
||||
; CHECK-NEXT: vfmul.vf v8, v8, fa0
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 4 x float> poison, float %b, i32 0
|
||||
%vb = shufflevector <vscale x 4 x float> %elt.head, <vscale x 4 x float> poison, <vscale x 4 x i32> zeroinitializer
|
||||
@ -517,10 +481,8 @@ define <vscale x 8 x float> @vfmul_vv_nxv8f32_unmasked(<vscale x 8 x float> %va,
|
||||
define <vscale x 8 x float> @vfmul_vf_nxv8f32(<vscale x 8 x float> %va, float %b, <vscale x 8 x i1> %m, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfmul_vf_nxv8f32:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e32, m4, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v12, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e32, m4, ta, mu
|
||||
; CHECK-NEXT: vfmul.vv v8, v8, v12, v0.t
|
||||
; CHECK-NEXT: vfmul.vf v8, v8, fa0, v0.t
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 8 x float> poison, float %b, i32 0
|
||||
%vb = shufflevector <vscale x 8 x float> %elt.head, <vscale x 8 x float> poison, <vscale x 8 x i32> zeroinitializer
|
||||
@ -531,10 +493,8 @@ define <vscale x 8 x float> @vfmul_vf_nxv8f32(<vscale x 8 x float> %va, float %b
|
||||
define <vscale x 8 x float> @vfmul_vf_nxv8f32_unmasked(<vscale x 8 x float> %va, float %b, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfmul_vf_nxv8f32_unmasked:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e32, m4, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v12, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e32, m4, ta, mu
|
||||
; CHECK-NEXT: vfmul.vv v8, v8, v12
|
||||
; CHECK-NEXT: vfmul.vf v8, v8, fa0
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 8 x float> poison, float %b, i32 0
|
||||
%vb = shufflevector <vscale x 8 x float> %elt.head, <vscale x 8 x float> poison, <vscale x 8 x i32> zeroinitializer
|
||||
@ -571,10 +531,8 @@ define <vscale x 16 x float> @vfmul_vv_nxv16f32_unmasked(<vscale x 16 x float> %
|
||||
define <vscale x 16 x float> @vfmul_vf_nxv16f32(<vscale x 16 x float> %va, float %b, <vscale x 16 x i1> %m, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfmul_vf_nxv16f32:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e32, m8, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v16, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e32, m8, ta, mu
|
||||
; CHECK-NEXT: vfmul.vv v8, v8, v16, v0.t
|
||||
; CHECK-NEXT: vfmul.vf v8, v8, fa0, v0.t
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 16 x float> poison, float %b, i32 0
|
||||
%vb = shufflevector <vscale x 16 x float> %elt.head, <vscale x 16 x float> poison, <vscale x 16 x i32> zeroinitializer
|
||||
@ -585,10 +543,8 @@ define <vscale x 16 x float> @vfmul_vf_nxv16f32(<vscale x 16 x float> %va, float
|
||||
define <vscale x 16 x float> @vfmul_vf_nxv16f32_unmasked(<vscale x 16 x float> %va, float %b, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfmul_vf_nxv16f32_unmasked:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e32, m8, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v16, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e32, m8, ta, mu
|
||||
; CHECK-NEXT: vfmul.vv v8, v8, v16
|
||||
; CHECK-NEXT: vfmul.vf v8, v8, fa0
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 16 x float> poison, float %b, i32 0
|
||||
%vb = shufflevector <vscale x 16 x float> %elt.head, <vscale x 16 x float> poison, <vscale x 16 x i32> zeroinitializer
|
||||
@ -625,10 +581,8 @@ define <vscale x 1 x double> @vfmul_vv_nxv1f64_unmasked(<vscale x 1 x double> %v
|
||||
define <vscale x 1 x double> @vfmul_vf_nxv1f64(<vscale x 1 x double> %va, double %b, <vscale x 1 x i1> %m, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfmul_vf_nxv1f64:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e64, m1, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v9, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e64, m1, ta, mu
|
||||
; CHECK-NEXT: vfmul.vv v8, v8, v9, v0.t
|
||||
; CHECK-NEXT: vfmul.vf v8, v8, fa0, v0.t
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 1 x double> poison, double %b, i32 0
|
||||
%vb = shufflevector <vscale x 1 x double> %elt.head, <vscale x 1 x double> poison, <vscale x 1 x i32> zeroinitializer
|
||||
@ -639,10 +593,8 @@ define <vscale x 1 x double> @vfmul_vf_nxv1f64(<vscale x 1 x double> %va, double
|
||||
define <vscale x 1 x double> @vfmul_vf_nxv1f64_unmasked(<vscale x 1 x double> %va, double %b, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfmul_vf_nxv1f64_unmasked:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e64, m1, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v9, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e64, m1, ta, mu
|
||||
; CHECK-NEXT: vfmul.vv v8, v8, v9
|
||||
; CHECK-NEXT: vfmul.vf v8, v8, fa0
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 1 x double> poison, double %b, i32 0
|
||||
%vb = shufflevector <vscale x 1 x double> %elt.head, <vscale x 1 x double> poison, <vscale x 1 x i32> zeroinitializer
|
||||
@ -679,10 +631,8 @@ define <vscale x 2 x double> @vfmul_vv_nxv2f64_unmasked(<vscale x 2 x double> %v
|
||||
define <vscale x 2 x double> @vfmul_vf_nxv2f64(<vscale x 2 x double> %va, double %b, <vscale x 2 x i1> %m, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfmul_vf_nxv2f64:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e64, m2, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v10, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e64, m2, ta, mu
|
||||
; CHECK-NEXT: vfmul.vv v8, v8, v10, v0.t
|
||||
; CHECK-NEXT: vfmul.vf v8, v8, fa0, v0.t
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 2 x double> poison, double %b, i32 0
|
||||
%vb = shufflevector <vscale x 2 x double> %elt.head, <vscale x 2 x double> poison, <vscale x 2 x i32> zeroinitializer
|
||||
@ -693,10 +643,8 @@ define <vscale x 2 x double> @vfmul_vf_nxv2f64(<vscale x 2 x double> %va, double
|
||||
define <vscale x 2 x double> @vfmul_vf_nxv2f64_unmasked(<vscale x 2 x double> %va, double %b, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfmul_vf_nxv2f64_unmasked:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e64, m2, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v10, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e64, m2, ta, mu
|
||||
; CHECK-NEXT: vfmul.vv v8, v8, v10
|
||||
; CHECK-NEXT: vfmul.vf v8, v8, fa0
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 2 x double> poison, double %b, i32 0
|
||||
%vb = shufflevector <vscale x 2 x double> %elt.head, <vscale x 2 x double> poison, <vscale x 2 x i32> zeroinitializer
|
||||
@ -733,10 +681,8 @@ define <vscale x 4 x double> @vfmul_vv_nxv4f64_unmasked(<vscale x 4 x double> %v
|
||||
define <vscale x 4 x double> @vfmul_vf_nxv4f64(<vscale x 4 x double> %va, double %b, <vscale x 4 x i1> %m, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfmul_vf_nxv4f64:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e64, m4, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v12, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e64, m4, ta, mu
|
||||
; CHECK-NEXT: vfmul.vv v8, v8, v12, v0.t
|
||||
; CHECK-NEXT: vfmul.vf v8, v8, fa0, v0.t
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 4 x double> poison, double %b, i32 0
|
||||
%vb = shufflevector <vscale x 4 x double> %elt.head, <vscale x 4 x double> poison, <vscale x 4 x i32> zeroinitializer
|
||||
@ -747,10 +693,8 @@ define <vscale x 4 x double> @vfmul_vf_nxv4f64(<vscale x 4 x double> %va, double
|
||||
define <vscale x 4 x double> @vfmul_vf_nxv4f64_unmasked(<vscale x 4 x double> %va, double %b, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfmul_vf_nxv4f64_unmasked:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e64, m4, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v12, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e64, m4, ta, mu
|
||||
; CHECK-NEXT: vfmul.vv v8, v8, v12
|
||||
; CHECK-NEXT: vfmul.vf v8, v8, fa0
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 4 x double> poison, double %b, i32 0
|
||||
%vb = shufflevector <vscale x 4 x double> %elt.head, <vscale x 4 x double> poison, <vscale x 4 x i32> zeroinitializer
|
||||
@ -799,10 +743,8 @@ define <vscale x 8 x double> @vfmul_vv_nxv8f64_unmasked(<vscale x 8 x double> %v
|
||||
define <vscale x 8 x double> @vfmul_vf_nxv8f64(<vscale x 8 x double> %va, double %b, <vscale x 8 x i1> %m, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfmul_vf_nxv8f64:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e64, m8, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v16, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e64, m8, ta, mu
|
||||
; CHECK-NEXT: vfmul.vv v8, v8, v16, v0.t
|
||||
; CHECK-NEXT: vfmul.vf v8, v8, fa0, v0.t
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 8 x double> poison, double %b, i32 0
|
||||
%vb = shufflevector <vscale x 8 x double> %elt.head, <vscale x 8 x double> poison, <vscale x 8 x i32> zeroinitializer
|
||||
@ -813,10 +755,8 @@ define <vscale x 8 x double> @vfmul_vf_nxv8f64(<vscale x 8 x double> %va, double
|
||||
define <vscale x 8 x double> @vfmul_vf_nxv8f64_unmasked(<vscale x 8 x double> %va, double %b, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfmul_vf_nxv8f64_unmasked:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e64, m8, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v16, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e64, m8, ta, mu
|
||||
; CHECK-NEXT: vfmul.vv v8, v8, v16
|
||||
; CHECK-NEXT: vfmul.vf v8, v8, fa0
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 8 x double> poison, double %b, i32 0
|
||||
%vb = shufflevector <vscale x 8 x double> %elt.head, <vscale x 8 x double> poison, <vscale x 8 x i32> zeroinitializer
|
||||
|
||||
@ -9,10 +9,8 @@ declare <vscale x 1 x half> @llvm.vp.fdiv.nxv1f16(<vscale x 1 x half>, <vscale x
|
||||
define <vscale x 1 x half> @vfrdiv_vf_nxv1f16(<vscale x 1 x half> %va, half %b, <vscale x 1 x i1> %m, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfrdiv_vf_nxv1f16:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e16, mf4, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v9, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e16, mf4, ta, mu
|
||||
; CHECK-NEXT: vfdiv.vv v8, v9, v8, v0.t
|
||||
; CHECK-NEXT: vfrdiv.vf v8, v8, fa0, v0.t
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 1 x half> poison, half %b, i32 0
|
||||
%vb = shufflevector <vscale x 1 x half> %elt.head, <vscale x 1 x half> poison, <vscale x 1 x i32> zeroinitializer
|
||||
@ -23,10 +21,8 @@ define <vscale x 1 x half> @vfrdiv_vf_nxv1f16(<vscale x 1 x half> %va, half %b,
|
||||
define <vscale x 1 x half> @vfrdiv_vf_nxv1f16_unmasked(<vscale x 1 x half> %va, half %b, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfrdiv_vf_nxv1f16_unmasked:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e16, mf4, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v9, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e16, mf4, ta, mu
|
||||
; CHECK-NEXT: vfdiv.vv v8, v9, v8
|
||||
; CHECK-NEXT: vfrdiv.vf v8, v8, fa0
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 1 x half> poison, half %b, i32 0
|
||||
%vb = shufflevector <vscale x 1 x half> %elt.head, <vscale x 1 x half> poison, <vscale x 1 x i32> zeroinitializer
|
||||
@ -41,10 +37,8 @@ declare <vscale x 2 x half> @llvm.vp.fdiv.nxv2f16(<vscale x 2 x half>, <vscale x
|
||||
define <vscale x 2 x half> @vfrdiv_vf_nxv2f16(<vscale x 2 x half> %va, half %b, <vscale x 2 x i1> %m, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfrdiv_vf_nxv2f16:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e16, mf2, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v9, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e16, mf2, ta, mu
|
||||
; CHECK-NEXT: vfdiv.vv v8, v9, v8, v0.t
|
||||
; CHECK-NEXT: vfrdiv.vf v8, v8, fa0, v0.t
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 2 x half> poison, half %b, i32 0
|
||||
%vb = shufflevector <vscale x 2 x half> %elt.head, <vscale x 2 x half> poison, <vscale x 2 x i32> zeroinitializer
|
||||
@ -55,10 +49,8 @@ define <vscale x 2 x half> @vfrdiv_vf_nxv2f16(<vscale x 2 x half> %va, half %b,
|
||||
define <vscale x 2 x half> @vfrdiv_vf_nxv2f16_unmasked(<vscale x 2 x half> %va, half %b, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfrdiv_vf_nxv2f16_unmasked:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e16, mf2, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v9, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e16, mf2, ta, mu
|
||||
; CHECK-NEXT: vfdiv.vv v8, v9, v8
|
||||
; CHECK-NEXT: vfrdiv.vf v8, v8, fa0
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 2 x half> poison, half %b, i32 0
|
||||
%vb = shufflevector <vscale x 2 x half> %elt.head, <vscale x 2 x half> poison, <vscale x 2 x i32> zeroinitializer
|
||||
@ -73,10 +65,8 @@ declare <vscale x 4 x half> @llvm.vp.fdiv.nxv4f16(<vscale x 4 x half>, <vscale x
|
||||
define <vscale x 4 x half> @vfrdiv_vf_nxv4f16(<vscale x 4 x half> %va, half %b, <vscale x 4 x i1> %m, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfrdiv_vf_nxv4f16:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e16, m1, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v9, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e16, m1, ta, mu
|
||||
; CHECK-NEXT: vfdiv.vv v8, v9, v8, v0.t
|
||||
; CHECK-NEXT: vfrdiv.vf v8, v8, fa0, v0.t
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 4 x half> poison, half %b, i32 0
|
||||
%vb = shufflevector <vscale x 4 x half> %elt.head, <vscale x 4 x half> poison, <vscale x 4 x i32> zeroinitializer
|
||||
@ -87,10 +77,8 @@ define <vscale x 4 x half> @vfrdiv_vf_nxv4f16(<vscale x 4 x half> %va, half %b,
|
||||
define <vscale x 4 x half> @vfrdiv_vf_nxv4f16_unmasked(<vscale x 4 x half> %va, half %b, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfrdiv_vf_nxv4f16_unmasked:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e16, m1, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v9, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e16, m1, ta, mu
|
||||
; CHECK-NEXT: vfdiv.vv v8, v9, v8
|
||||
; CHECK-NEXT: vfrdiv.vf v8, v8, fa0
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 4 x half> poison, half %b, i32 0
|
||||
%vb = shufflevector <vscale x 4 x half> %elt.head, <vscale x 4 x half> poison, <vscale x 4 x i32> zeroinitializer
|
||||
@ -105,10 +93,8 @@ declare <vscale x 8 x half> @llvm.vp.fdiv.nxv8f16(<vscale x 8 x half>, <vscale x
|
||||
define <vscale x 8 x half> @vfrdiv_vf_nxv8f16(<vscale x 8 x half> %va, half %b, <vscale x 8 x i1> %m, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfrdiv_vf_nxv8f16:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e16, m2, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v10, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e16, m2, ta, mu
|
||||
; CHECK-NEXT: vfdiv.vv v8, v10, v8, v0.t
|
||||
; CHECK-NEXT: vfrdiv.vf v8, v8, fa0, v0.t
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 8 x half> poison, half %b, i32 0
|
||||
%vb = shufflevector <vscale x 8 x half> %elt.head, <vscale x 8 x half> poison, <vscale x 8 x i32> zeroinitializer
|
||||
@ -119,10 +105,8 @@ define <vscale x 8 x half> @vfrdiv_vf_nxv8f16(<vscale x 8 x half> %va, half %b,
|
||||
define <vscale x 8 x half> @vfrdiv_vf_nxv8f16_unmasked(<vscale x 8 x half> %va, half %b, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfrdiv_vf_nxv8f16_unmasked:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e16, m2, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v10, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e16, m2, ta, mu
|
||||
; CHECK-NEXT: vfdiv.vv v8, v10, v8
|
||||
; CHECK-NEXT: vfrdiv.vf v8, v8, fa0
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 8 x half> poison, half %b, i32 0
|
||||
%vb = shufflevector <vscale x 8 x half> %elt.head, <vscale x 8 x half> poison, <vscale x 8 x i32> zeroinitializer
|
||||
@ -137,10 +121,8 @@ declare <vscale x 16 x half> @llvm.vp.fdiv.nxv16f16(<vscale x 16 x half>, <vscal
|
||||
define <vscale x 16 x half> @vfrdiv_vf_nxv16f16(<vscale x 16 x half> %va, half %b, <vscale x 16 x i1> %m, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfrdiv_vf_nxv16f16:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e16, m4, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v12, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e16, m4, ta, mu
|
||||
; CHECK-NEXT: vfdiv.vv v8, v12, v8, v0.t
|
||||
; CHECK-NEXT: vfrdiv.vf v8, v8, fa0, v0.t
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 16 x half> poison, half %b, i32 0
|
||||
%vb = shufflevector <vscale x 16 x half> %elt.head, <vscale x 16 x half> poison, <vscale x 16 x i32> zeroinitializer
|
||||
@ -151,10 +133,8 @@ define <vscale x 16 x half> @vfrdiv_vf_nxv16f16(<vscale x 16 x half> %va, half %
|
||||
define <vscale x 16 x half> @vfrdiv_vf_nxv16f16_unmasked(<vscale x 16 x half> %va, half %b, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfrdiv_vf_nxv16f16_unmasked:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e16, m4, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v12, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e16, m4, ta, mu
|
||||
; CHECK-NEXT: vfdiv.vv v8, v12, v8
|
||||
; CHECK-NEXT: vfrdiv.vf v8, v8, fa0
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 16 x half> poison, half %b, i32 0
|
||||
%vb = shufflevector <vscale x 16 x half> %elt.head, <vscale x 16 x half> poison, <vscale x 16 x i32> zeroinitializer
|
||||
@ -169,10 +149,8 @@ declare <vscale x 32 x half> @llvm.vp.fdiv.nxv32f16(<vscale x 32 x half>, <vscal
|
||||
define <vscale x 32 x half> @vfrdiv_vf_nxv32f16(<vscale x 32 x half> %va, half %b, <vscale x 32 x i1> %m, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfrdiv_vf_nxv32f16:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e16, m8, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v16, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e16, m8, ta, mu
|
||||
; CHECK-NEXT: vfdiv.vv v8, v16, v8, v0.t
|
||||
; CHECK-NEXT: vfrdiv.vf v8, v8, fa0, v0.t
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 32 x half> poison, half %b, i32 0
|
||||
%vb = shufflevector <vscale x 32 x half> %elt.head, <vscale x 32 x half> poison, <vscale x 32 x i32> zeroinitializer
|
||||
@ -183,10 +161,8 @@ define <vscale x 32 x half> @vfrdiv_vf_nxv32f16(<vscale x 32 x half> %va, half %
|
||||
define <vscale x 32 x half> @vfrdiv_vf_nxv32f16_unmasked(<vscale x 32 x half> %va, half %b, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfrdiv_vf_nxv32f16_unmasked:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e16, m8, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v16, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e16, m8, ta, mu
|
||||
; CHECK-NEXT: vfdiv.vv v8, v16, v8
|
||||
; CHECK-NEXT: vfrdiv.vf v8, v8, fa0
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 32 x half> poison, half %b, i32 0
|
||||
%vb = shufflevector <vscale x 32 x half> %elt.head, <vscale x 32 x half> poison, <vscale x 32 x i32> zeroinitializer
|
||||
@ -201,10 +177,8 @@ declare <vscale x 1 x float> @llvm.vp.fdiv.nxv1f32(<vscale x 1 x float>, <vscale
|
||||
define <vscale x 1 x float> @vfrdiv_vf_nxv1f32(<vscale x 1 x float> %va, float %b, <vscale x 1 x i1> %m, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfrdiv_vf_nxv1f32:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e32, mf2, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v9, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e32, mf2, ta, mu
|
||||
; CHECK-NEXT: vfdiv.vv v8, v9, v8, v0.t
|
||||
; CHECK-NEXT: vfrdiv.vf v8, v8, fa0, v0.t
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 1 x float> poison, float %b, i32 0
|
||||
%vb = shufflevector <vscale x 1 x float> %elt.head, <vscale x 1 x float> poison, <vscale x 1 x i32> zeroinitializer
|
||||
@ -215,10 +189,8 @@ define <vscale x 1 x float> @vfrdiv_vf_nxv1f32(<vscale x 1 x float> %va, float %
|
||||
define <vscale x 1 x float> @vfrdiv_vf_nxv1f32_unmasked(<vscale x 1 x float> %va, float %b, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfrdiv_vf_nxv1f32_unmasked:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e32, mf2, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v9, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e32, mf2, ta, mu
|
||||
; CHECK-NEXT: vfdiv.vv v8, v9, v8
|
||||
; CHECK-NEXT: vfrdiv.vf v8, v8, fa0
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 1 x float> poison, float %b, i32 0
|
||||
%vb = shufflevector <vscale x 1 x float> %elt.head, <vscale x 1 x float> poison, <vscale x 1 x i32> zeroinitializer
|
||||
@ -233,10 +205,8 @@ declare <vscale x 2 x float> @llvm.vp.fdiv.nxv2f32(<vscale x 2 x float>, <vscale
|
||||
define <vscale x 2 x float> @vfrdiv_vf_nxv2f32(<vscale x 2 x float> %va, float %b, <vscale x 2 x i1> %m, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfrdiv_vf_nxv2f32:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e32, m1, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v9, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e32, m1, ta, mu
|
||||
; CHECK-NEXT: vfdiv.vv v8, v9, v8, v0.t
|
||||
; CHECK-NEXT: vfrdiv.vf v8, v8, fa0, v0.t
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 2 x float> poison, float %b, i32 0
|
||||
%vb = shufflevector <vscale x 2 x float> %elt.head, <vscale x 2 x float> poison, <vscale x 2 x i32> zeroinitializer
|
||||
@ -247,10 +217,8 @@ define <vscale x 2 x float> @vfrdiv_vf_nxv2f32(<vscale x 2 x float> %va, float %
|
||||
define <vscale x 2 x float> @vfrdiv_vf_nxv2f32_unmasked(<vscale x 2 x float> %va, float %b, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfrdiv_vf_nxv2f32_unmasked:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e32, m1, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v9, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e32, m1, ta, mu
|
||||
; CHECK-NEXT: vfdiv.vv v8, v9, v8
|
||||
; CHECK-NEXT: vfrdiv.vf v8, v8, fa0
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 2 x float> poison, float %b, i32 0
|
||||
%vb = shufflevector <vscale x 2 x float> %elt.head, <vscale x 2 x float> poison, <vscale x 2 x i32> zeroinitializer
|
||||
@ -265,10 +233,8 @@ declare <vscale x 4 x float> @llvm.vp.fdiv.nxv4f32(<vscale x 4 x float>, <vscale
|
||||
define <vscale x 4 x float> @vfrdiv_vf_nxv4f32(<vscale x 4 x float> %va, float %b, <vscale x 4 x i1> %m, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfrdiv_vf_nxv4f32:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e32, m2, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v10, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e32, m2, ta, mu
|
||||
; CHECK-NEXT: vfdiv.vv v8, v10, v8, v0.t
|
||||
; CHECK-NEXT: vfrdiv.vf v8, v8, fa0, v0.t
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 4 x float> poison, float %b, i32 0
|
||||
%vb = shufflevector <vscale x 4 x float> %elt.head, <vscale x 4 x float> poison, <vscale x 4 x i32> zeroinitializer
|
||||
@ -279,10 +245,8 @@ define <vscale x 4 x float> @vfrdiv_vf_nxv4f32(<vscale x 4 x float> %va, float %
|
||||
define <vscale x 4 x float> @vfrdiv_vf_nxv4f32_unmasked(<vscale x 4 x float> %va, float %b, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfrdiv_vf_nxv4f32_unmasked:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e32, m2, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v10, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e32, m2, ta, mu
|
||||
; CHECK-NEXT: vfdiv.vv v8, v10, v8
|
||||
; CHECK-NEXT: vfrdiv.vf v8, v8, fa0
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 4 x float> poison, float %b, i32 0
|
||||
%vb = shufflevector <vscale x 4 x float> %elt.head, <vscale x 4 x float> poison, <vscale x 4 x i32> zeroinitializer
|
||||
@ -297,10 +261,8 @@ declare <vscale x 8 x float> @llvm.vp.fdiv.nxv8f32(<vscale x 8 x float>, <vscale
|
||||
define <vscale x 8 x float> @vfrdiv_vf_nxv8f32(<vscale x 8 x float> %va, float %b, <vscale x 8 x i1> %m, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfrdiv_vf_nxv8f32:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e32, m4, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v12, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e32, m4, ta, mu
|
||||
; CHECK-NEXT: vfdiv.vv v8, v12, v8, v0.t
|
||||
; CHECK-NEXT: vfrdiv.vf v8, v8, fa0, v0.t
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 8 x float> poison, float %b, i32 0
|
||||
%vb = shufflevector <vscale x 8 x float> %elt.head, <vscale x 8 x float> poison, <vscale x 8 x i32> zeroinitializer
|
||||
@ -311,10 +273,8 @@ define <vscale x 8 x float> @vfrdiv_vf_nxv8f32(<vscale x 8 x float> %va, float %
|
||||
define <vscale x 8 x float> @vfrdiv_vf_nxv8f32_unmasked(<vscale x 8 x float> %va, float %b, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfrdiv_vf_nxv8f32_unmasked:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e32, m4, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v12, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e32, m4, ta, mu
|
||||
; CHECK-NEXT: vfdiv.vv v8, v12, v8
|
||||
; CHECK-NEXT: vfrdiv.vf v8, v8, fa0
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 8 x float> poison, float %b, i32 0
|
||||
%vb = shufflevector <vscale x 8 x float> %elt.head, <vscale x 8 x float> poison, <vscale x 8 x i32> zeroinitializer
|
||||
@ -329,10 +289,8 @@ declare <vscale x 16 x float> @llvm.vp.fdiv.nxv16f32(<vscale x 16 x float>, <vsc
|
||||
define <vscale x 16 x float> @vfrdiv_vf_nxv16f32(<vscale x 16 x float> %va, float %b, <vscale x 16 x i1> %m, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfrdiv_vf_nxv16f32:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e32, m8, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v16, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e32, m8, ta, mu
|
||||
; CHECK-NEXT: vfdiv.vv v8, v16, v8, v0.t
|
||||
; CHECK-NEXT: vfrdiv.vf v8, v8, fa0, v0.t
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 16 x float> poison, float %b, i32 0
|
||||
%vb = shufflevector <vscale x 16 x float> %elt.head, <vscale x 16 x float> poison, <vscale x 16 x i32> zeroinitializer
|
||||
@ -343,10 +301,8 @@ define <vscale x 16 x float> @vfrdiv_vf_nxv16f32(<vscale x 16 x float> %va, floa
|
||||
define <vscale x 16 x float> @vfrdiv_vf_nxv16f32_unmasked(<vscale x 16 x float> %va, float %b, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfrdiv_vf_nxv16f32_unmasked:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e32, m8, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v16, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e32, m8, ta, mu
|
||||
; CHECK-NEXT: vfdiv.vv v8, v16, v8
|
||||
; CHECK-NEXT: vfrdiv.vf v8, v8, fa0
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 16 x float> poison, float %b, i32 0
|
||||
%vb = shufflevector <vscale x 16 x float> %elt.head, <vscale x 16 x float> poison, <vscale x 16 x i32> zeroinitializer
|
||||
@ -361,10 +317,8 @@ declare <vscale x 1 x double> @llvm.vp.fdiv.nxv1f64(<vscale x 1 x double>, <vsca
|
||||
define <vscale x 1 x double> @vfrdiv_vf_nxv1f64(<vscale x 1 x double> %va, double %b, <vscale x 1 x i1> %m, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfrdiv_vf_nxv1f64:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e64, m1, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v9, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e64, m1, ta, mu
|
||||
; CHECK-NEXT: vfdiv.vv v8, v9, v8, v0.t
|
||||
; CHECK-NEXT: vfrdiv.vf v8, v8, fa0, v0.t
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 1 x double> poison, double %b, i32 0
|
||||
%vb = shufflevector <vscale x 1 x double> %elt.head, <vscale x 1 x double> poison, <vscale x 1 x i32> zeroinitializer
|
||||
@ -375,10 +329,8 @@ define <vscale x 1 x double> @vfrdiv_vf_nxv1f64(<vscale x 1 x double> %va, doubl
|
||||
define <vscale x 1 x double> @vfrdiv_vf_nxv1f64_unmasked(<vscale x 1 x double> %va, double %b, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfrdiv_vf_nxv1f64_unmasked:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e64, m1, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v9, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e64, m1, ta, mu
|
||||
; CHECK-NEXT: vfdiv.vv v8, v9, v8
|
||||
; CHECK-NEXT: vfrdiv.vf v8, v8, fa0
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 1 x double> poison, double %b, i32 0
|
||||
%vb = shufflevector <vscale x 1 x double> %elt.head, <vscale x 1 x double> poison, <vscale x 1 x i32> zeroinitializer
|
||||
@ -393,10 +345,8 @@ declare <vscale x 2 x double> @llvm.vp.fdiv.nxv2f64(<vscale x 2 x double>, <vsca
|
||||
define <vscale x 2 x double> @vfrdiv_vf_nxv2f64(<vscale x 2 x double> %va, double %b, <vscale x 2 x i1> %m, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfrdiv_vf_nxv2f64:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e64, m2, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v10, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e64, m2, ta, mu
|
||||
; CHECK-NEXT: vfdiv.vv v8, v10, v8, v0.t
|
||||
; CHECK-NEXT: vfrdiv.vf v8, v8, fa0, v0.t
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 2 x double> poison, double %b, i32 0
|
||||
%vb = shufflevector <vscale x 2 x double> %elt.head, <vscale x 2 x double> poison, <vscale x 2 x i32> zeroinitializer
|
||||
@ -407,10 +357,8 @@ define <vscale x 2 x double> @vfrdiv_vf_nxv2f64(<vscale x 2 x double> %va, doubl
|
||||
define <vscale x 2 x double> @vfrdiv_vf_nxv2f64_unmasked(<vscale x 2 x double> %va, double %b, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfrdiv_vf_nxv2f64_unmasked:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e64, m2, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v10, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e64, m2, ta, mu
|
||||
; CHECK-NEXT: vfdiv.vv v8, v10, v8
|
||||
; CHECK-NEXT: vfrdiv.vf v8, v8, fa0
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 2 x double> poison, double %b, i32 0
|
||||
%vb = shufflevector <vscale x 2 x double> %elt.head, <vscale x 2 x double> poison, <vscale x 2 x i32> zeroinitializer
|
||||
@ -425,10 +373,8 @@ declare <vscale x 4 x double> @llvm.vp.fdiv.nxv4f64(<vscale x 4 x double>, <vsca
|
||||
define <vscale x 4 x double> @vfrdiv_vf_nxv4f64(<vscale x 4 x double> %va, double %b, <vscale x 4 x i1> %m, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfrdiv_vf_nxv4f64:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e64, m4, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v12, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e64, m4, ta, mu
|
||||
; CHECK-NEXT: vfdiv.vv v8, v12, v8, v0.t
|
||||
; CHECK-NEXT: vfrdiv.vf v8, v8, fa0, v0.t
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 4 x double> poison, double %b, i32 0
|
||||
%vb = shufflevector <vscale x 4 x double> %elt.head, <vscale x 4 x double> poison, <vscale x 4 x i32> zeroinitializer
|
||||
@ -439,10 +385,8 @@ define <vscale x 4 x double> @vfrdiv_vf_nxv4f64(<vscale x 4 x double> %va, doubl
|
||||
define <vscale x 4 x double> @vfrdiv_vf_nxv4f64_unmasked(<vscale x 4 x double> %va, double %b, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfrdiv_vf_nxv4f64_unmasked:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e64, m4, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v12, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e64, m4, ta, mu
|
||||
; CHECK-NEXT: vfdiv.vv v8, v12, v8
|
||||
; CHECK-NEXT: vfrdiv.vf v8, v8, fa0
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 4 x double> poison, double %b, i32 0
|
||||
%vb = shufflevector <vscale x 4 x double> %elt.head, <vscale x 4 x double> poison, <vscale x 4 x i32> zeroinitializer
|
||||
@ -457,10 +401,8 @@ declare <vscale x 8 x double> @llvm.vp.fdiv.nxv8f64(<vscale x 8 x double>, <vsca
|
||||
define <vscale x 8 x double> @vfrdiv_vf_nxv8f64(<vscale x 8 x double> %va, double %b, <vscale x 8 x i1> %m, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfrdiv_vf_nxv8f64:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e64, m8, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v16, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e64, m8, ta, mu
|
||||
; CHECK-NEXT: vfdiv.vv v8, v16, v8, v0.t
|
||||
; CHECK-NEXT: vfrdiv.vf v8, v8, fa0, v0.t
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 8 x double> poison, double %b, i32 0
|
||||
%vb = shufflevector <vscale x 8 x double> %elt.head, <vscale x 8 x double> poison, <vscale x 8 x i32> zeroinitializer
|
||||
@ -471,10 +413,8 @@ define <vscale x 8 x double> @vfrdiv_vf_nxv8f64(<vscale x 8 x double> %va, doubl
|
||||
define <vscale x 8 x double> @vfrdiv_vf_nxv8f64_unmasked(<vscale x 8 x double> %va, double %b, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfrdiv_vf_nxv8f64_unmasked:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e64, m8, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v16, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e64, m8, ta, mu
|
||||
; CHECK-NEXT: vfdiv.vv v8, v16, v8
|
||||
; CHECK-NEXT: vfrdiv.vf v8, v8, fa0
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 8 x double> poison, double %b, i32 0
|
||||
%vb = shufflevector <vscale x 8 x double> %elt.head, <vscale x 8 x double> poison, <vscale x 8 x i32> zeroinitializer
|
||||
|
||||
@ -9,10 +9,8 @@ declare <vscale x 1 x half> @llvm.vp.fsub.nxv1f16(<vscale x 1 x half>, <vscale x
|
||||
define <vscale x 1 x half> @vfrsub_vf_nxv1f16(<vscale x 1 x half> %va, half %b, <vscale x 1 x i1> %m, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfrsub_vf_nxv1f16:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e16, mf4, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v9, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e16, mf4, ta, mu
|
||||
; CHECK-NEXT: vfsub.vv v8, v9, v8, v0.t
|
||||
; CHECK-NEXT: vfrsub.vf v8, v8, fa0, v0.t
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 1 x half> poison, half %b, i32 0
|
||||
%vb = shufflevector <vscale x 1 x half> %elt.head, <vscale x 1 x half> poison, <vscale x 1 x i32> zeroinitializer
|
||||
@ -23,10 +21,8 @@ define <vscale x 1 x half> @vfrsub_vf_nxv1f16(<vscale x 1 x half> %va, half %b,
|
||||
define <vscale x 1 x half> @vfrsub_vf_nxv1f16_unmasked(<vscale x 1 x half> %va, half %b, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfrsub_vf_nxv1f16_unmasked:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e16, mf4, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v9, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e16, mf4, ta, mu
|
||||
; CHECK-NEXT: vfsub.vv v8, v9, v8
|
||||
; CHECK-NEXT: vfrsub.vf v8, v8, fa0
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 1 x half> poison, half %b, i32 0
|
||||
%vb = shufflevector <vscale x 1 x half> %elt.head, <vscale x 1 x half> poison, <vscale x 1 x i32> zeroinitializer
|
||||
@ -41,10 +37,8 @@ declare <vscale x 2 x half> @llvm.vp.fsub.nxv2f16(<vscale x 2 x half>, <vscale x
|
||||
define <vscale x 2 x half> @vfrsub_vf_nxv2f16(<vscale x 2 x half> %va, half %b, <vscale x 2 x i1> %m, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfrsub_vf_nxv2f16:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e16, mf2, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v9, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e16, mf2, ta, mu
|
||||
; CHECK-NEXT: vfsub.vv v8, v9, v8, v0.t
|
||||
; CHECK-NEXT: vfrsub.vf v8, v8, fa0, v0.t
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 2 x half> poison, half %b, i32 0
|
||||
%vb = shufflevector <vscale x 2 x half> %elt.head, <vscale x 2 x half> poison, <vscale x 2 x i32> zeroinitializer
|
||||
@ -55,10 +49,8 @@ define <vscale x 2 x half> @vfrsub_vf_nxv2f16(<vscale x 2 x half> %va, half %b,
|
||||
define <vscale x 2 x half> @vfrsub_vf_nxv2f16_unmasked(<vscale x 2 x half> %va, half %b, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfrsub_vf_nxv2f16_unmasked:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e16, mf2, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v9, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e16, mf2, ta, mu
|
||||
; CHECK-NEXT: vfsub.vv v8, v9, v8
|
||||
; CHECK-NEXT: vfrsub.vf v8, v8, fa0
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 2 x half> poison, half %b, i32 0
|
||||
%vb = shufflevector <vscale x 2 x half> %elt.head, <vscale x 2 x half> poison, <vscale x 2 x i32> zeroinitializer
|
||||
@ -73,10 +65,8 @@ declare <vscale x 4 x half> @llvm.vp.fsub.nxv4f16(<vscale x 4 x half>, <vscale x
|
||||
define <vscale x 4 x half> @vfrsub_vf_nxv4f16(<vscale x 4 x half> %va, half %b, <vscale x 4 x i1> %m, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfrsub_vf_nxv4f16:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e16, m1, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v9, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e16, m1, ta, mu
|
||||
; CHECK-NEXT: vfsub.vv v8, v9, v8, v0.t
|
||||
; CHECK-NEXT: vfrsub.vf v8, v8, fa0, v0.t
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 4 x half> poison, half %b, i32 0
|
||||
%vb = shufflevector <vscale x 4 x half> %elt.head, <vscale x 4 x half> poison, <vscale x 4 x i32> zeroinitializer
|
||||
@ -87,10 +77,8 @@ define <vscale x 4 x half> @vfrsub_vf_nxv4f16(<vscale x 4 x half> %va, half %b,
|
||||
define <vscale x 4 x half> @vfrsub_vf_nxv4f16_unmasked(<vscale x 4 x half> %va, half %b, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfrsub_vf_nxv4f16_unmasked:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e16, m1, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v9, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e16, m1, ta, mu
|
||||
; CHECK-NEXT: vfsub.vv v8, v9, v8
|
||||
; CHECK-NEXT: vfrsub.vf v8, v8, fa0
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 4 x half> poison, half %b, i32 0
|
||||
%vb = shufflevector <vscale x 4 x half> %elt.head, <vscale x 4 x half> poison, <vscale x 4 x i32> zeroinitializer
|
||||
@ -105,10 +93,8 @@ declare <vscale x 8 x half> @llvm.vp.fsub.nxv8f16(<vscale x 8 x half>, <vscale x
|
||||
define <vscale x 8 x half> @vfrsub_vf_nxv8f16(<vscale x 8 x half> %va, half %b, <vscale x 8 x i1> %m, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfrsub_vf_nxv8f16:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e16, m2, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v10, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e16, m2, ta, mu
|
||||
; CHECK-NEXT: vfsub.vv v8, v10, v8, v0.t
|
||||
; CHECK-NEXT: vfrsub.vf v8, v8, fa0, v0.t
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 8 x half> poison, half %b, i32 0
|
||||
%vb = shufflevector <vscale x 8 x half> %elt.head, <vscale x 8 x half> poison, <vscale x 8 x i32> zeroinitializer
|
||||
@ -119,10 +105,8 @@ define <vscale x 8 x half> @vfrsub_vf_nxv8f16(<vscale x 8 x half> %va, half %b,
|
||||
define <vscale x 8 x half> @vfrsub_vf_nxv8f16_unmasked(<vscale x 8 x half> %va, half %b, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfrsub_vf_nxv8f16_unmasked:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e16, m2, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v10, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e16, m2, ta, mu
|
||||
; CHECK-NEXT: vfsub.vv v8, v10, v8
|
||||
; CHECK-NEXT: vfrsub.vf v8, v8, fa0
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 8 x half> poison, half %b, i32 0
|
||||
%vb = shufflevector <vscale x 8 x half> %elt.head, <vscale x 8 x half> poison, <vscale x 8 x i32> zeroinitializer
|
||||
@ -137,10 +121,8 @@ declare <vscale x 16 x half> @llvm.vp.fsub.nxv16f16(<vscale x 16 x half>, <vscal
|
||||
define <vscale x 16 x half> @vfrsub_vf_nxv16f16(<vscale x 16 x half> %va, half %b, <vscale x 16 x i1> %m, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfrsub_vf_nxv16f16:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e16, m4, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v12, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e16, m4, ta, mu
|
||||
; CHECK-NEXT: vfsub.vv v8, v12, v8, v0.t
|
||||
; CHECK-NEXT: vfrsub.vf v8, v8, fa0, v0.t
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 16 x half> poison, half %b, i32 0
|
||||
%vb = shufflevector <vscale x 16 x half> %elt.head, <vscale x 16 x half> poison, <vscale x 16 x i32> zeroinitializer
|
||||
@ -151,10 +133,8 @@ define <vscale x 16 x half> @vfrsub_vf_nxv16f16(<vscale x 16 x half> %va, half %
|
||||
define <vscale x 16 x half> @vfrsub_vf_nxv16f16_unmasked(<vscale x 16 x half> %va, half %b, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfrsub_vf_nxv16f16_unmasked:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e16, m4, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v12, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e16, m4, ta, mu
|
||||
; CHECK-NEXT: vfsub.vv v8, v12, v8
|
||||
; CHECK-NEXT: vfrsub.vf v8, v8, fa0
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 16 x half> poison, half %b, i32 0
|
||||
%vb = shufflevector <vscale x 16 x half> %elt.head, <vscale x 16 x half> poison, <vscale x 16 x i32> zeroinitializer
|
||||
@ -169,10 +149,8 @@ declare <vscale x 32 x half> @llvm.vp.fsub.nxv32f16(<vscale x 32 x half>, <vscal
|
||||
define <vscale x 32 x half> @vfrsub_vf_nxv32f16(<vscale x 32 x half> %va, half %b, <vscale x 32 x i1> %m, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfrsub_vf_nxv32f16:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e16, m8, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v16, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e16, m8, ta, mu
|
||||
; CHECK-NEXT: vfsub.vv v8, v16, v8, v0.t
|
||||
; CHECK-NEXT: vfrsub.vf v8, v8, fa0, v0.t
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 32 x half> poison, half %b, i32 0
|
||||
%vb = shufflevector <vscale x 32 x half> %elt.head, <vscale x 32 x half> poison, <vscale x 32 x i32> zeroinitializer
|
||||
@ -183,10 +161,8 @@ define <vscale x 32 x half> @vfrsub_vf_nxv32f16(<vscale x 32 x half> %va, half %
|
||||
define <vscale x 32 x half> @vfrsub_vf_nxv32f16_unmasked(<vscale x 32 x half> %va, half %b, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfrsub_vf_nxv32f16_unmasked:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e16, m8, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v16, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e16, m8, ta, mu
|
||||
; CHECK-NEXT: vfsub.vv v8, v16, v8
|
||||
; CHECK-NEXT: vfrsub.vf v8, v8, fa0
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 32 x half> poison, half %b, i32 0
|
||||
%vb = shufflevector <vscale x 32 x half> %elt.head, <vscale x 32 x half> poison, <vscale x 32 x i32> zeroinitializer
|
||||
@ -201,10 +177,8 @@ declare <vscale x 1 x float> @llvm.vp.fsub.nxv1f32(<vscale x 1 x float>, <vscale
|
||||
define <vscale x 1 x float> @vfrsub_vf_nxv1f32(<vscale x 1 x float> %va, float %b, <vscale x 1 x i1> %m, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfrsub_vf_nxv1f32:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e32, mf2, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v9, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e32, mf2, ta, mu
|
||||
; CHECK-NEXT: vfsub.vv v8, v9, v8, v0.t
|
||||
; CHECK-NEXT: vfrsub.vf v8, v8, fa0, v0.t
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 1 x float> poison, float %b, i32 0
|
||||
%vb = shufflevector <vscale x 1 x float> %elt.head, <vscale x 1 x float> poison, <vscale x 1 x i32> zeroinitializer
|
||||
@ -215,10 +189,8 @@ define <vscale x 1 x float> @vfrsub_vf_nxv1f32(<vscale x 1 x float> %va, float %
|
||||
define <vscale x 1 x float> @vfrsub_vf_nxv1f32_unmasked(<vscale x 1 x float> %va, float %b, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfrsub_vf_nxv1f32_unmasked:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e32, mf2, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v9, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e32, mf2, ta, mu
|
||||
; CHECK-NEXT: vfsub.vv v8, v9, v8
|
||||
; CHECK-NEXT: vfrsub.vf v8, v8, fa0
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 1 x float> poison, float %b, i32 0
|
||||
%vb = shufflevector <vscale x 1 x float> %elt.head, <vscale x 1 x float> poison, <vscale x 1 x i32> zeroinitializer
|
||||
@ -233,10 +205,8 @@ declare <vscale x 2 x float> @llvm.vp.fsub.nxv2f32(<vscale x 2 x float>, <vscale
|
||||
define <vscale x 2 x float> @vfrsub_vf_nxv2f32(<vscale x 2 x float> %va, float %b, <vscale x 2 x i1> %m, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfrsub_vf_nxv2f32:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e32, m1, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v9, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e32, m1, ta, mu
|
||||
; CHECK-NEXT: vfsub.vv v8, v9, v8, v0.t
|
||||
; CHECK-NEXT: vfrsub.vf v8, v8, fa0, v0.t
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 2 x float> poison, float %b, i32 0
|
||||
%vb = shufflevector <vscale x 2 x float> %elt.head, <vscale x 2 x float> poison, <vscale x 2 x i32> zeroinitializer
|
||||
@ -247,10 +217,8 @@ define <vscale x 2 x float> @vfrsub_vf_nxv2f32(<vscale x 2 x float> %va, float %
|
||||
define <vscale x 2 x float> @vfrsub_vf_nxv2f32_unmasked(<vscale x 2 x float> %va, float %b, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfrsub_vf_nxv2f32_unmasked:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e32, m1, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v9, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e32, m1, ta, mu
|
||||
; CHECK-NEXT: vfsub.vv v8, v9, v8
|
||||
; CHECK-NEXT: vfrsub.vf v8, v8, fa0
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 2 x float> poison, float %b, i32 0
|
||||
%vb = shufflevector <vscale x 2 x float> %elt.head, <vscale x 2 x float> poison, <vscale x 2 x i32> zeroinitializer
|
||||
@ -265,10 +233,8 @@ declare <vscale x 4 x float> @llvm.vp.fsub.nxv4f32(<vscale x 4 x float>, <vscale
|
||||
define <vscale x 4 x float> @vfrsub_vf_nxv4f32(<vscale x 4 x float> %va, float %b, <vscale x 4 x i1> %m, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfrsub_vf_nxv4f32:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e32, m2, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v10, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e32, m2, ta, mu
|
||||
; CHECK-NEXT: vfsub.vv v8, v10, v8, v0.t
|
||||
; CHECK-NEXT: vfrsub.vf v8, v8, fa0, v0.t
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 4 x float> poison, float %b, i32 0
|
||||
%vb = shufflevector <vscale x 4 x float> %elt.head, <vscale x 4 x float> poison, <vscale x 4 x i32> zeroinitializer
|
||||
@ -279,10 +245,8 @@ define <vscale x 4 x float> @vfrsub_vf_nxv4f32(<vscale x 4 x float> %va, float %
|
||||
define <vscale x 4 x float> @vfrsub_vf_nxv4f32_unmasked(<vscale x 4 x float> %va, float %b, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfrsub_vf_nxv4f32_unmasked:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e32, m2, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v10, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e32, m2, ta, mu
|
||||
; CHECK-NEXT: vfsub.vv v8, v10, v8
|
||||
; CHECK-NEXT: vfrsub.vf v8, v8, fa0
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 4 x float> poison, float %b, i32 0
|
||||
%vb = shufflevector <vscale x 4 x float> %elt.head, <vscale x 4 x float> poison, <vscale x 4 x i32> zeroinitializer
|
||||
@ -297,10 +261,8 @@ declare <vscale x 8 x float> @llvm.vp.fsub.nxv8f32(<vscale x 8 x float>, <vscale
|
||||
define <vscale x 8 x float> @vfrsub_vf_nxv8f32(<vscale x 8 x float> %va, float %b, <vscale x 8 x i1> %m, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfrsub_vf_nxv8f32:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e32, m4, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v12, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e32, m4, ta, mu
|
||||
; CHECK-NEXT: vfsub.vv v8, v12, v8, v0.t
|
||||
; CHECK-NEXT: vfrsub.vf v8, v8, fa0, v0.t
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 8 x float> poison, float %b, i32 0
|
||||
%vb = shufflevector <vscale x 8 x float> %elt.head, <vscale x 8 x float> poison, <vscale x 8 x i32> zeroinitializer
|
||||
@ -311,10 +273,8 @@ define <vscale x 8 x float> @vfrsub_vf_nxv8f32(<vscale x 8 x float> %va, float %
|
||||
define <vscale x 8 x float> @vfrsub_vf_nxv8f32_unmasked(<vscale x 8 x float> %va, float %b, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfrsub_vf_nxv8f32_unmasked:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e32, m4, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v12, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e32, m4, ta, mu
|
||||
; CHECK-NEXT: vfsub.vv v8, v12, v8
|
||||
; CHECK-NEXT: vfrsub.vf v8, v8, fa0
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 8 x float> poison, float %b, i32 0
|
||||
%vb = shufflevector <vscale x 8 x float> %elt.head, <vscale x 8 x float> poison, <vscale x 8 x i32> zeroinitializer
|
||||
@ -329,10 +289,8 @@ declare <vscale x 16 x float> @llvm.vp.fsub.nxv16f32(<vscale x 16 x float>, <vsc
|
||||
define <vscale x 16 x float> @vfrsub_vf_nxv16f32(<vscale x 16 x float> %va, float %b, <vscale x 16 x i1> %m, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfrsub_vf_nxv16f32:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e32, m8, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v16, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e32, m8, ta, mu
|
||||
; CHECK-NEXT: vfsub.vv v8, v16, v8, v0.t
|
||||
; CHECK-NEXT: vfrsub.vf v8, v8, fa0, v0.t
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 16 x float> poison, float %b, i32 0
|
||||
%vb = shufflevector <vscale x 16 x float> %elt.head, <vscale x 16 x float> poison, <vscale x 16 x i32> zeroinitializer
|
||||
@ -343,10 +301,8 @@ define <vscale x 16 x float> @vfrsub_vf_nxv16f32(<vscale x 16 x float> %va, floa
|
||||
define <vscale x 16 x float> @vfrsub_vf_nxv16f32_unmasked(<vscale x 16 x float> %va, float %b, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfrsub_vf_nxv16f32_unmasked:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e32, m8, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v16, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e32, m8, ta, mu
|
||||
; CHECK-NEXT: vfsub.vv v8, v16, v8
|
||||
; CHECK-NEXT: vfrsub.vf v8, v8, fa0
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 16 x float> poison, float %b, i32 0
|
||||
%vb = shufflevector <vscale x 16 x float> %elt.head, <vscale x 16 x float> poison, <vscale x 16 x i32> zeroinitializer
|
||||
@ -361,10 +317,8 @@ declare <vscale x 1 x double> @llvm.vp.fsub.nxv1f64(<vscale x 1 x double>, <vsca
|
||||
define <vscale x 1 x double> @vfrsub_vf_nxv1f64(<vscale x 1 x double> %va, double %b, <vscale x 1 x i1> %m, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfrsub_vf_nxv1f64:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e64, m1, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v9, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e64, m1, ta, mu
|
||||
; CHECK-NEXT: vfsub.vv v8, v9, v8, v0.t
|
||||
; CHECK-NEXT: vfrsub.vf v8, v8, fa0, v0.t
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 1 x double> poison, double %b, i32 0
|
||||
%vb = shufflevector <vscale x 1 x double> %elt.head, <vscale x 1 x double> poison, <vscale x 1 x i32> zeroinitializer
|
||||
@ -375,10 +329,8 @@ define <vscale x 1 x double> @vfrsub_vf_nxv1f64(<vscale x 1 x double> %va, doubl
|
||||
define <vscale x 1 x double> @vfrsub_vf_nxv1f64_unmasked(<vscale x 1 x double> %va, double %b, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfrsub_vf_nxv1f64_unmasked:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e64, m1, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v9, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e64, m1, ta, mu
|
||||
; CHECK-NEXT: vfsub.vv v8, v9, v8
|
||||
; CHECK-NEXT: vfrsub.vf v8, v8, fa0
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 1 x double> poison, double %b, i32 0
|
||||
%vb = shufflevector <vscale x 1 x double> %elt.head, <vscale x 1 x double> poison, <vscale x 1 x i32> zeroinitializer
|
||||
@ -393,10 +345,8 @@ declare <vscale x 2 x double> @llvm.vp.fsub.nxv2f64(<vscale x 2 x double>, <vsca
|
||||
define <vscale x 2 x double> @vfrsub_vf_nxv2f64(<vscale x 2 x double> %va, double %b, <vscale x 2 x i1> %m, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfrsub_vf_nxv2f64:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e64, m2, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v10, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e64, m2, ta, mu
|
||||
; CHECK-NEXT: vfsub.vv v8, v10, v8, v0.t
|
||||
; CHECK-NEXT: vfrsub.vf v8, v8, fa0, v0.t
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 2 x double> poison, double %b, i32 0
|
||||
%vb = shufflevector <vscale x 2 x double> %elt.head, <vscale x 2 x double> poison, <vscale x 2 x i32> zeroinitializer
|
||||
@ -407,10 +357,8 @@ define <vscale x 2 x double> @vfrsub_vf_nxv2f64(<vscale x 2 x double> %va, doubl
|
||||
define <vscale x 2 x double> @vfrsub_vf_nxv2f64_unmasked(<vscale x 2 x double> %va, double %b, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfrsub_vf_nxv2f64_unmasked:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e64, m2, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v10, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e64, m2, ta, mu
|
||||
; CHECK-NEXT: vfsub.vv v8, v10, v8
|
||||
; CHECK-NEXT: vfrsub.vf v8, v8, fa0
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 2 x double> poison, double %b, i32 0
|
||||
%vb = shufflevector <vscale x 2 x double> %elt.head, <vscale x 2 x double> poison, <vscale x 2 x i32> zeroinitializer
|
||||
@ -425,10 +373,8 @@ declare <vscale x 4 x double> @llvm.vp.fsub.nxv4f64(<vscale x 4 x double>, <vsca
|
||||
define <vscale x 4 x double> @vfrsub_vf_nxv4f64(<vscale x 4 x double> %va, double %b, <vscale x 4 x i1> %m, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfrsub_vf_nxv4f64:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e64, m4, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v12, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e64, m4, ta, mu
|
||||
; CHECK-NEXT: vfsub.vv v8, v12, v8, v0.t
|
||||
; CHECK-NEXT: vfrsub.vf v8, v8, fa0, v0.t
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 4 x double> poison, double %b, i32 0
|
||||
%vb = shufflevector <vscale x 4 x double> %elt.head, <vscale x 4 x double> poison, <vscale x 4 x i32> zeroinitializer
|
||||
@ -439,10 +385,8 @@ define <vscale x 4 x double> @vfrsub_vf_nxv4f64(<vscale x 4 x double> %va, doubl
|
||||
define <vscale x 4 x double> @vfrsub_vf_nxv4f64_unmasked(<vscale x 4 x double> %va, double %b, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfrsub_vf_nxv4f64_unmasked:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e64, m4, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v12, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e64, m4, ta, mu
|
||||
; CHECK-NEXT: vfsub.vv v8, v12, v8
|
||||
; CHECK-NEXT: vfrsub.vf v8, v8, fa0
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 4 x double> poison, double %b, i32 0
|
||||
%vb = shufflevector <vscale x 4 x double> %elt.head, <vscale x 4 x double> poison, <vscale x 4 x i32> zeroinitializer
|
||||
@ -457,10 +401,8 @@ declare <vscale x 8 x double> @llvm.vp.fsub.nxv8f64(<vscale x 8 x double>, <vsca
|
||||
define <vscale x 8 x double> @vfrsub_vf_nxv8f64(<vscale x 8 x double> %va, double %b, <vscale x 8 x i1> %m, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfrsub_vf_nxv8f64:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e64, m8, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v16, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e64, m8, ta, mu
|
||||
; CHECK-NEXT: vfsub.vv v8, v16, v8, v0.t
|
||||
; CHECK-NEXT: vfrsub.vf v8, v8, fa0, v0.t
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 8 x double> poison, double %b, i32 0
|
||||
%vb = shufflevector <vscale x 8 x double> %elt.head, <vscale x 8 x double> poison, <vscale x 8 x i32> zeroinitializer
|
||||
@ -471,10 +413,8 @@ define <vscale x 8 x double> @vfrsub_vf_nxv8f64(<vscale x 8 x double> %va, doubl
|
||||
define <vscale x 8 x double> @vfrsub_vf_nxv8f64_unmasked(<vscale x 8 x double> %va, double %b, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfrsub_vf_nxv8f64_unmasked:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e64, m8, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v16, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e64, m8, ta, mu
|
||||
; CHECK-NEXT: vfsub.vv v8, v16, v8
|
||||
; CHECK-NEXT: vfrsub.vf v8, v8, fa0
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 8 x double> poison, double %b, i32 0
|
||||
%vb = shufflevector <vscale x 8 x double> %elt.head, <vscale x 8 x double> poison, <vscale x 8 x i32> zeroinitializer
|
||||
|
||||
@ -31,10 +31,8 @@ define <vscale x 1 x half> @vfsub_vv_nxv1f16_unmasked(<vscale x 1 x half> %va, <
|
||||
define <vscale x 1 x half> @vfsub_vf_nxv1f16(<vscale x 1 x half> %va, half %b, <vscale x 1 x i1> %m, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfsub_vf_nxv1f16:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e16, mf4, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v9, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e16, mf4, ta, mu
|
||||
; CHECK-NEXT: vfsub.vv v8, v8, v9, v0.t
|
||||
; CHECK-NEXT: vfsub.vf v8, v8, fa0, v0.t
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 1 x half> poison, half %b, i32 0
|
||||
%vb = shufflevector <vscale x 1 x half> %elt.head, <vscale x 1 x half> poison, <vscale x 1 x i32> zeroinitializer
|
||||
@ -45,10 +43,8 @@ define <vscale x 1 x half> @vfsub_vf_nxv1f16(<vscale x 1 x half> %va, half %b, <
|
||||
define <vscale x 1 x half> @vfsub_vf_nxv1f16_unmasked(<vscale x 1 x half> %va, half %b, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfsub_vf_nxv1f16_unmasked:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e16, mf4, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v9, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e16, mf4, ta, mu
|
||||
; CHECK-NEXT: vfsub.vv v8, v8, v9
|
||||
; CHECK-NEXT: vfsub.vf v8, v8, fa0
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 1 x half> poison, half %b, i32 0
|
||||
%vb = shufflevector <vscale x 1 x half> %elt.head, <vscale x 1 x half> poison, <vscale x 1 x i32> zeroinitializer
|
||||
@ -85,10 +81,8 @@ define <vscale x 2 x half> @vfsub_vv_nxv2f16_unmasked(<vscale x 2 x half> %va, <
|
||||
define <vscale x 2 x half> @vfsub_vf_nxv2f16(<vscale x 2 x half> %va, half %b, <vscale x 2 x i1> %m, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfsub_vf_nxv2f16:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e16, mf2, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v9, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e16, mf2, ta, mu
|
||||
; CHECK-NEXT: vfsub.vv v8, v8, v9, v0.t
|
||||
; CHECK-NEXT: vfsub.vf v8, v8, fa0, v0.t
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 2 x half> poison, half %b, i32 0
|
||||
%vb = shufflevector <vscale x 2 x half> %elt.head, <vscale x 2 x half> poison, <vscale x 2 x i32> zeroinitializer
|
||||
@ -99,10 +93,8 @@ define <vscale x 2 x half> @vfsub_vf_nxv2f16(<vscale x 2 x half> %va, half %b, <
|
||||
define <vscale x 2 x half> @vfsub_vf_nxv2f16_unmasked(<vscale x 2 x half> %va, half %b, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfsub_vf_nxv2f16_unmasked:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e16, mf2, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v9, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e16, mf2, ta, mu
|
||||
; CHECK-NEXT: vfsub.vv v8, v8, v9
|
||||
; CHECK-NEXT: vfsub.vf v8, v8, fa0
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 2 x half> poison, half %b, i32 0
|
||||
%vb = shufflevector <vscale x 2 x half> %elt.head, <vscale x 2 x half> poison, <vscale x 2 x i32> zeroinitializer
|
||||
@ -139,10 +131,8 @@ define <vscale x 4 x half> @vfsub_vv_nxv4f16_unmasked(<vscale x 4 x half> %va, <
|
||||
define <vscale x 4 x half> @vfsub_vf_nxv4f16(<vscale x 4 x half> %va, half %b, <vscale x 4 x i1> %m, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfsub_vf_nxv4f16:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e16, m1, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v9, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e16, m1, ta, mu
|
||||
; CHECK-NEXT: vfsub.vv v8, v8, v9, v0.t
|
||||
; CHECK-NEXT: vfsub.vf v8, v8, fa0, v0.t
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 4 x half> poison, half %b, i32 0
|
||||
%vb = shufflevector <vscale x 4 x half> %elt.head, <vscale x 4 x half> poison, <vscale x 4 x i32> zeroinitializer
|
||||
@ -153,10 +143,8 @@ define <vscale x 4 x half> @vfsub_vf_nxv4f16(<vscale x 4 x half> %va, half %b, <
|
||||
define <vscale x 4 x half> @vfsub_vf_nxv4f16_unmasked(<vscale x 4 x half> %va, half %b, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfsub_vf_nxv4f16_unmasked:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e16, m1, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v9, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e16, m1, ta, mu
|
||||
; CHECK-NEXT: vfsub.vv v8, v8, v9
|
||||
; CHECK-NEXT: vfsub.vf v8, v8, fa0
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 4 x half> poison, half %b, i32 0
|
||||
%vb = shufflevector <vscale x 4 x half> %elt.head, <vscale x 4 x half> poison, <vscale x 4 x i32> zeroinitializer
|
||||
@ -193,10 +181,8 @@ define <vscale x 8 x half> @vfsub_vv_nxv8f16_unmasked(<vscale x 8 x half> %va, <
|
||||
define <vscale x 8 x half> @vfsub_vf_nxv8f16(<vscale x 8 x half> %va, half %b, <vscale x 8 x i1> %m, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfsub_vf_nxv8f16:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e16, m2, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v10, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e16, m2, ta, mu
|
||||
; CHECK-NEXT: vfsub.vv v8, v8, v10, v0.t
|
||||
; CHECK-NEXT: vfsub.vf v8, v8, fa0, v0.t
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 8 x half> poison, half %b, i32 0
|
||||
%vb = shufflevector <vscale x 8 x half> %elt.head, <vscale x 8 x half> poison, <vscale x 8 x i32> zeroinitializer
|
||||
@ -207,10 +193,8 @@ define <vscale x 8 x half> @vfsub_vf_nxv8f16(<vscale x 8 x half> %va, half %b, <
|
||||
define <vscale x 8 x half> @vfsub_vf_nxv8f16_unmasked(<vscale x 8 x half> %va, half %b, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfsub_vf_nxv8f16_unmasked:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e16, m2, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v10, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e16, m2, ta, mu
|
||||
; CHECK-NEXT: vfsub.vv v8, v8, v10
|
||||
; CHECK-NEXT: vfsub.vf v8, v8, fa0
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 8 x half> poison, half %b, i32 0
|
||||
%vb = shufflevector <vscale x 8 x half> %elt.head, <vscale x 8 x half> poison, <vscale x 8 x i32> zeroinitializer
|
||||
@ -247,10 +231,8 @@ define <vscale x 16 x half> @vfsub_vv_nxv16f16_unmasked(<vscale x 16 x half> %va
|
||||
define <vscale x 16 x half> @vfsub_vf_nxv16f16(<vscale x 16 x half> %va, half %b, <vscale x 16 x i1> %m, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfsub_vf_nxv16f16:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e16, m4, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v12, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e16, m4, ta, mu
|
||||
; CHECK-NEXT: vfsub.vv v8, v8, v12, v0.t
|
||||
; CHECK-NEXT: vfsub.vf v8, v8, fa0, v0.t
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 16 x half> poison, half %b, i32 0
|
||||
%vb = shufflevector <vscale x 16 x half> %elt.head, <vscale x 16 x half> poison, <vscale x 16 x i32> zeroinitializer
|
||||
@ -261,10 +243,8 @@ define <vscale x 16 x half> @vfsub_vf_nxv16f16(<vscale x 16 x half> %va, half %b
|
||||
define <vscale x 16 x half> @vfsub_vf_nxv16f16_unmasked(<vscale x 16 x half> %va, half %b, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfsub_vf_nxv16f16_unmasked:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e16, m4, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v12, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e16, m4, ta, mu
|
||||
; CHECK-NEXT: vfsub.vv v8, v8, v12
|
||||
; CHECK-NEXT: vfsub.vf v8, v8, fa0
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 16 x half> poison, half %b, i32 0
|
||||
%vb = shufflevector <vscale x 16 x half> %elt.head, <vscale x 16 x half> poison, <vscale x 16 x i32> zeroinitializer
|
||||
@ -301,10 +281,8 @@ define <vscale x 32 x half> @vfsub_vv_nxv32f16_unmasked(<vscale x 32 x half> %va
|
||||
define <vscale x 32 x half> @vfsub_vf_nxv32f16(<vscale x 32 x half> %va, half %b, <vscale x 32 x i1> %m, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfsub_vf_nxv32f16:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e16, m8, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v16, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e16, m8, ta, mu
|
||||
; CHECK-NEXT: vfsub.vv v8, v8, v16, v0.t
|
||||
; CHECK-NEXT: vfsub.vf v8, v8, fa0, v0.t
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 32 x half> poison, half %b, i32 0
|
||||
%vb = shufflevector <vscale x 32 x half> %elt.head, <vscale x 32 x half> poison, <vscale x 32 x i32> zeroinitializer
|
||||
@ -315,10 +293,8 @@ define <vscale x 32 x half> @vfsub_vf_nxv32f16(<vscale x 32 x half> %va, half %b
|
||||
define <vscale x 32 x half> @vfsub_vf_nxv32f16_unmasked(<vscale x 32 x half> %va, half %b, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfsub_vf_nxv32f16_unmasked:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e16, m8, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v16, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e16, m8, ta, mu
|
||||
; CHECK-NEXT: vfsub.vv v8, v8, v16
|
||||
; CHECK-NEXT: vfsub.vf v8, v8, fa0
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 32 x half> poison, half %b, i32 0
|
||||
%vb = shufflevector <vscale x 32 x half> %elt.head, <vscale x 32 x half> poison, <vscale x 32 x i32> zeroinitializer
|
||||
@ -355,10 +331,8 @@ define <vscale x 1 x float> @vfsub_vv_nxv1f32_unmasked(<vscale x 1 x float> %va,
|
||||
define <vscale x 1 x float> @vfsub_vf_nxv1f32(<vscale x 1 x float> %va, float %b, <vscale x 1 x i1> %m, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfsub_vf_nxv1f32:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e32, mf2, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v9, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e32, mf2, ta, mu
|
||||
; CHECK-NEXT: vfsub.vv v8, v8, v9, v0.t
|
||||
; CHECK-NEXT: vfsub.vf v8, v8, fa0, v0.t
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 1 x float> poison, float %b, i32 0
|
||||
%vb = shufflevector <vscale x 1 x float> %elt.head, <vscale x 1 x float> poison, <vscale x 1 x i32> zeroinitializer
|
||||
@ -369,10 +343,8 @@ define <vscale x 1 x float> @vfsub_vf_nxv1f32(<vscale x 1 x float> %va, float %b
|
||||
define <vscale x 1 x float> @vfsub_vf_nxv1f32_unmasked(<vscale x 1 x float> %va, float %b, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfsub_vf_nxv1f32_unmasked:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e32, mf2, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v9, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e32, mf2, ta, mu
|
||||
; CHECK-NEXT: vfsub.vv v8, v8, v9
|
||||
; CHECK-NEXT: vfsub.vf v8, v8, fa0
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 1 x float> poison, float %b, i32 0
|
||||
%vb = shufflevector <vscale x 1 x float> %elt.head, <vscale x 1 x float> poison, <vscale x 1 x i32> zeroinitializer
|
||||
@ -409,10 +381,8 @@ define <vscale x 2 x float> @vfsub_vv_nxv2f32_unmasked(<vscale x 2 x float> %va,
|
||||
define <vscale x 2 x float> @vfsub_vf_nxv2f32(<vscale x 2 x float> %va, float %b, <vscale x 2 x i1> %m, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfsub_vf_nxv2f32:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e32, m1, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v9, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e32, m1, ta, mu
|
||||
; CHECK-NEXT: vfsub.vv v8, v8, v9, v0.t
|
||||
; CHECK-NEXT: vfsub.vf v8, v8, fa0, v0.t
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 2 x float> poison, float %b, i32 0
|
||||
%vb = shufflevector <vscale x 2 x float> %elt.head, <vscale x 2 x float> poison, <vscale x 2 x i32> zeroinitializer
|
||||
@ -423,10 +393,8 @@ define <vscale x 2 x float> @vfsub_vf_nxv2f32(<vscale x 2 x float> %va, float %b
|
||||
define <vscale x 2 x float> @vfsub_vf_nxv2f32_unmasked(<vscale x 2 x float> %va, float %b, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfsub_vf_nxv2f32_unmasked:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e32, m1, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v9, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e32, m1, ta, mu
|
||||
; CHECK-NEXT: vfsub.vv v8, v8, v9
|
||||
; CHECK-NEXT: vfsub.vf v8, v8, fa0
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 2 x float> poison, float %b, i32 0
|
||||
%vb = shufflevector <vscale x 2 x float> %elt.head, <vscale x 2 x float> poison, <vscale x 2 x i32> zeroinitializer
|
||||
@ -463,10 +431,8 @@ define <vscale x 4 x float> @vfsub_vv_nxv4f32_unmasked(<vscale x 4 x float> %va,
|
||||
define <vscale x 4 x float> @vfsub_vf_nxv4f32(<vscale x 4 x float> %va, float %b, <vscale x 4 x i1> %m, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfsub_vf_nxv4f32:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e32, m2, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v10, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e32, m2, ta, mu
|
||||
; CHECK-NEXT: vfsub.vv v8, v8, v10, v0.t
|
||||
; CHECK-NEXT: vfsub.vf v8, v8, fa0, v0.t
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 4 x float> poison, float %b, i32 0
|
||||
%vb = shufflevector <vscale x 4 x float> %elt.head, <vscale x 4 x float> poison, <vscale x 4 x i32> zeroinitializer
|
||||
@ -477,10 +443,8 @@ define <vscale x 4 x float> @vfsub_vf_nxv4f32(<vscale x 4 x float> %va, float %b
|
||||
define <vscale x 4 x float> @vfsub_vf_nxv4f32_unmasked(<vscale x 4 x float> %va, float %b, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfsub_vf_nxv4f32_unmasked:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e32, m2, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v10, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e32, m2, ta, mu
|
||||
; CHECK-NEXT: vfsub.vv v8, v8, v10
|
||||
; CHECK-NEXT: vfsub.vf v8, v8, fa0
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 4 x float> poison, float %b, i32 0
|
||||
%vb = shufflevector <vscale x 4 x float> %elt.head, <vscale x 4 x float> poison, <vscale x 4 x i32> zeroinitializer
|
||||
@ -517,10 +481,8 @@ define <vscale x 8 x float> @vfsub_vv_nxv8f32_unmasked(<vscale x 8 x float> %va,
|
||||
define <vscale x 8 x float> @vfsub_vf_nxv8f32(<vscale x 8 x float> %va, float %b, <vscale x 8 x i1> %m, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfsub_vf_nxv8f32:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e32, m4, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v12, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e32, m4, ta, mu
|
||||
; CHECK-NEXT: vfsub.vv v8, v8, v12, v0.t
|
||||
; CHECK-NEXT: vfsub.vf v8, v8, fa0, v0.t
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 8 x float> poison, float %b, i32 0
|
||||
%vb = shufflevector <vscale x 8 x float> %elt.head, <vscale x 8 x float> poison, <vscale x 8 x i32> zeroinitializer
|
||||
@ -531,10 +493,8 @@ define <vscale x 8 x float> @vfsub_vf_nxv8f32(<vscale x 8 x float> %va, float %b
|
||||
define <vscale x 8 x float> @vfsub_vf_nxv8f32_unmasked(<vscale x 8 x float> %va, float %b, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfsub_vf_nxv8f32_unmasked:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e32, m4, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v12, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e32, m4, ta, mu
|
||||
; CHECK-NEXT: vfsub.vv v8, v8, v12
|
||||
; CHECK-NEXT: vfsub.vf v8, v8, fa0
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 8 x float> poison, float %b, i32 0
|
||||
%vb = shufflevector <vscale x 8 x float> %elt.head, <vscale x 8 x float> poison, <vscale x 8 x i32> zeroinitializer
|
||||
@ -571,10 +531,8 @@ define <vscale x 16 x float> @vfsub_vv_nxv16f32_unmasked(<vscale x 16 x float> %
|
||||
define <vscale x 16 x float> @vfsub_vf_nxv16f32(<vscale x 16 x float> %va, float %b, <vscale x 16 x i1> %m, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfsub_vf_nxv16f32:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e32, m8, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v16, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e32, m8, ta, mu
|
||||
; CHECK-NEXT: vfsub.vv v8, v8, v16, v0.t
|
||||
; CHECK-NEXT: vfsub.vf v8, v8, fa0, v0.t
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 16 x float> poison, float %b, i32 0
|
||||
%vb = shufflevector <vscale x 16 x float> %elt.head, <vscale x 16 x float> poison, <vscale x 16 x i32> zeroinitializer
|
||||
@ -585,10 +543,8 @@ define <vscale x 16 x float> @vfsub_vf_nxv16f32(<vscale x 16 x float> %va, float
|
||||
define <vscale x 16 x float> @vfsub_vf_nxv16f32_unmasked(<vscale x 16 x float> %va, float %b, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfsub_vf_nxv16f32_unmasked:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e32, m8, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v16, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e32, m8, ta, mu
|
||||
; CHECK-NEXT: vfsub.vv v8, v8, v16
|
||||
; CHECK-NEXT: vfsub.vf v8, v8, fa0
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 16 x float> poison, float %b, i32 0
|
||||
%vb = shufflevector <vscale x 16 x float> %elt.head, <vscale x 16 x float> poison, <vscale x 16 x i32> zeroinitializer
|
||||
@ -625,10 +581,8 @@ define <vscale x 1 x double> @vfsub_vv_nxv1f64_unmasked(<vscale x 1 x double> %v
|
||||
define <vscale x 1 x double> @vfsub_vf_nxv1f64(<vscale x 1 x double> %va, double %b, <vscale x 1 x i1> %m, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfsub_vf_nxv1f64:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e64, m1, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v9, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e64, m1, ta, mu
|
||||
; CHECK-NEXT: vfsub.vv v8, v8, v9, v0.t
|
||||
; CHECK-NEXT: vfsub.vf v8, v8, fa0, v0.t
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 1 x double> poison, double %b, i32 0
|
||||
%vb = shufflevector <vscale x 1 x double> %elt.head, <vscale x 1 x double> poison, <vscale x 1 x i32> zeroinitializer
|
||||
@ -639,10 +593,8 @@ define <vscale x 1 x double> @vfsub_vf_nxv1f64(<vscale x 1 x double> %va, double
|
||||
define <vscale x 1 x double> @vfsub_vf_nxv1f64_unmasked(<vscale x 1 x double> %va, double %b, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfsub_vf_nxv1f64_unmasked:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e64, m1, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v9, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e64, m1, ta, mu
|
||||
; CHECK-NEXT: vfsub.vv v8, v8, v9
|
||||
; CHECK-NEXT: vfsub.vf v8, v8, fa0
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 1 x double> poison, double %b, i32 0
|
||||
%vb = shufflevector <vscale x 1 x double> %elt.head, <vscale x 1 x double> poison, <vscale x 1 x i32> zeroinitializer
|
||||
@ -679,10 +631,8 @@ define <vscale x 2 x double> @vfsub_vv_nxv2f64_unmasked(<vscale x 2 x double> %v
|
||||
define <vscale x 2 x double> @vfsub_vf_nxv2f64(<vscale x 2 x double> %va, double %b, <vscale x 2 x i1> %m, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfsub_vf_nxv2f64:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e64, m2, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v10, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e64, m2, ta, mu
|
||||
; CHECK-NEXT: vfsub.vv v8, v8, v10, v0.t
|
||||
; CHECK-NEXT: vfsub.vf v8, v8, fa0, v0.t
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 2 x double> poison, double %b, i32 0
|
||||
%vb = shufflevector <vscale x 2 x double> %elt.head, <vscale x 2 x double> poison, <vscale x 2 x i32> zeroinitializer
|
||||
@ -693,10 +643,8 @@ define <vscale x 2 x double> @vfsub_vf_nxv2f64(<vscale x 2 x double> %va, double
|
||||
define <vscale x 2 x double> @vfsub_vf_nxv2f64_unmasked(<vscale x 2 x double> %va, double %b, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfsub_vf_nxv2f64_unmasked:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e64, m2, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v10, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e64, m2, ta, mu
|
||||
; CHECK-NEXT: vfsub.vv v8, v8, v10
|
||||
; CHECK-NEXT: vfsub.vf v8, v8, fa0
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 2 x double> poison, double %b, i32 0
|
||||
%vb = shufflevector <vscale x 2 x double> %elt.head, <vscale x 2 x double> poison, <vscale x 2 x i32> zeroinitializer
|
||||
@ -733,10 +681,8 @@ define <vscale x 4 x double> @vfsub_vv_nxv4f64_unmasked(<vscale x 4 x double> %v
|
||||
define <vscale x 4 x double> @vfsub_vf_nxv4f64(<vscale x 4 x double> %va, double %b, <vscale x 4 x i1> %m, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfsub_vf_nxv4f64:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e64, m4, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v12, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e64, m4, ta, mu
|
||||
; CHECK-NEXT: vfsub.vv v8, v8, v12, v0.t
|
||||
; CHECK-NEXT: vfsub.vf v8, v8, fa0, v0.t
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 4 x double> poison, double %b, i32 0
|
||||
%vb = shufflevector <vscale x 4 x double> %elt.head, <vscale x 4 x double> poison, <vscale x 4 x i32> zeroinitializer
|
||||
@ -747,10 +693,8 @@ define <vscale x 4 x double> @vfsub_vf_nxv4f64(<vscale x 4 x double> %va, double
|
||||
define <vscale x 4 x double> @vfsub_vf_nxv4f64_unmasked(<vscale x 4 x double> %va, double %b, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfsub_vf_nxv4f64_unmasked:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e64, m4, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v12, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e64, m4, ta, mu
|
||||
; CHECK-NEXT: vfsub.vv v8, v8, v12
|
||||
; CHECK-NEXT: vfsub.vf v8, v8, fa0
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 4 x double> poison, double %b, i32 0
|
||||
%vb = shufflevector <vscale x 4 x double> %elt.head, <vscale x 4 x double> poison, <vscale x 4 x i32> zeroinitializer
|
||||
@ -799,10 +743,8 @@ define <vscale x 8 x double> @vfsub_vv_nxv8f64_unmasked(<vscale x 8 x double> %v
|
||||
define <vscale x 8 x double> @vfsub_vf_nxv8f64(<vscale x 8 x double> %va, double %b, <vscale x 8 x i1> %m, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfsub_vf_nxv8f64:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e64, m8, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v16, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e64, m8, ta, mu
|
||||
; CHECK-NEXT: vfsub.vv v8, v8, v16, v0.t
|
||||
; CHECK-NEXT: vfsub.vf v8, v8, fa0, v0.t
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 8 x double> poison, double %b, i32 0
|
||||
%vb = shufflevector <vscale x 8 x double> %elt.head, <vscale x 8 x double> poison, <vscale x 8 x i32> zeroinitializer
|
||||
@ -813,10 +755,8 @@ define <vscale x 8 x double> @vfsub_vf_nxv8f64(<vscale x 8 x double> %va, double
|
||||
define <vscale x 8 x double> @vfsub_vf_nxv8f64_unmasked(<vscale x 8 x double> %va, double %b, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vfsub_vf_nxv8f64_unmasked:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e64, m8, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v16, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e64, m8, ta, mu
|
||||
; CHECK-NEXT: vfsub.vv v8, v8, v16
|
||||
; CHECK-NEXT: vfsub.vf v8, v8, fa0
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 8 x double> poison, double %b, i32 0
|
||||
%vb = shufflevector <vscale x 8 x double> %elt.head, <vscale x 8 x double> poison, <vscale x 8 x i32> zeroinitializer
|
||||
|
||||
@ -1126,10 +1126,8 @@ define <vscale x 1 x half> @vpmerge_vv_nxv1f16(<vscale x 1 x half> %va, <vscale
|
||||
define <vscale x 1 x half> @vpmerge_vf_nxv1f16(half %a, <vscale x 1 x half> %vb, <vscale x 1 x i1> %m, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vpmerge_vf_nxv1f16:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e16, mf4, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v9, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e16, mf4, tu, mu
|
||||
; CHECK-NEXT: vmerge.vvm v8, v8, v9, v0
|
||||
; CHECK-NEXT: vfmerge.vfm v8, v8, fa0, v0
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 1 x half> poison, half %a, i32 0
|
||||
%va = shufflevector <vscale x 1 x half> %elt.head, <vscale x 1 x half> poison, <vscale x 1 x i32> zeroinitializer
|
||||
@ -1153,10 +1151,8 @@ define <vscale x 2 x half> @vpmerge_vv_nxv2f16(<vscale x 2 x half> %va, <vscale
|
||||
define <vscale x 2 x half> @vpmerge_vf_nxv2f16(half %a, <vscale x 2 x half> %vb, <vscale x 2 x i1> %m, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vpmerge_vf_nxv2f16:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e16, mf2, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v9, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e16, mf2, tu, mu
|
||||
; CHECK-NEXT: vmerge.vvm v8, v8, v9, v0
|
||||
; CHECK-NEXT: vfmerge.vfm v8, v8, fa0, v0
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 2 x half> poison, half %a, i32 0
|
||||
%va = shufflevector <vscale x 2 x half> %elt.head, <vscale x 2 x half> poison, <vscale x 2 x i32> zeroinitializer
|
||||
@ -1180,10 +1176,8 @@ define <vscale x 4 x half> @vpmerge_vv_nxv4f16(<vscale x 4 x half> %va, <vscale
|
||||
define <vscale x 4 x half> @vpmerge_vf_nxv4f16(half %a, <vscale x 4 x half> %vb, <vscale x 4 x i1> %m, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vpmerge_vf_nxv4f16:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e16, m1, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v9, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e16, m1, tu, mu
|
||||
; CHECK-NEXT: vmerge.vvm v8, v8, v9, v0
|
||||
; CHECK-NEXT: vfmerge.vfm v8, v8, fa0, v0
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 4 x half> poison, half %a, i32 0
|
||||
%va = shufflevector <vscale x 4 x half> %elt.head, <vscale x 4 x half> poison, <vscale x 4 x i32> zeroinitializer
|
||||
@ -1207,10 +1201,8 @@ define <vscale x 8 x half> @vpmerge_vv_nxv8f16(<vscale x 8 x half> %va, <vscale
|
||||
define <vscale x 8 x half> @vpmerge_vf_nxv8f16(half %a, <vscale x 8 x half> %vb, <vscale x 8 x i1> %m, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vpmerge_vf_nxv8f16:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e16, m2, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v10, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e16, m2, tu, mu
|
||||
; CHECK-NEXT: vmerge.vvm v8, v8, v10, v0
|
||||
; CHECK-NEXT: vfmerge.vfm v8, v8, fa0, v0
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 8 x half> poison, half %a, i32 0
|
||||
%va = shufflevector <vscale x 8 x half> %elt.head, <vscale x 8 x half> poison, <vscale x 8 x i32> zeroinitializer
|
||||
@ -1234,10 +1226,8 @@ define <vscale x 16 x half> @vpmerge_vv_nxv16f16(<vscale x 16 x half> %va, <vsca
|
||||
define <vscale x 16 x half> @vpmerge_vf_nxv16f16(half %a, <vscale x 16 x half> %vb, <vscale x 16 x i1> %m, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vpmerge_vf_nxv16f16:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e16, m4, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v12, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e16, m4, tu, mu
|
||||
; CHECK-NEXT: vmerge.vvm v8, v8, v12, v0
|
||||
; CHECK-NEXT: vfmerge.vfm v8, v8, fa0, v0
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 16 x half> poison, half %a, i32 0
|
||||
%va = shufflevector <vscale x 16 x half> %elt.head, <vscale x 16 x half> poison, <vscale x 16 x i32> zeroinitializer
|
||||
@ -1261,10 +1251,8 @@ define <vscale x 32 x half> @vpmerge_vv_nxv32f16(<vscale x 32 x half> %va, <vsca
|
||||
define <vscale x 32 x half> @vpmerge_vf_nxv32f16(half %a, <vscale x 32 x half> %vb, <vscale x 32 x i1> %m, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vpmerge_vf_nxv32f16:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e16, m8, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v16, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e16, m8, tu, mu
|
||||
; CHECK-NEXT: vmerge.vvm v8, v8, v16, v0
|
||||
; CHECK-NEXT: vfmerge.vfm v8, v8, fa0, v0
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 32 x half> poison, half %a, i32 0
|
||||
%va = shufflevector <vscale x 32 x half> %elt.head, <vscale x 32 x half> poison, <vscale x 32 x i32> zeroinitializer
|
||||
@ -1288,10 +1276,8 @@ define <vscale x 1 x float> @vpmerge_vv_nxv1f32(<vscale x 1 x float> %va, <vscal
|
||||
define <vscale x 1 x float> @vpmerge_vf_nxv1f32(float %a, <vscale x 1 x float> %vb, <vscale x 1 x i1> %m, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vpmerge_vf_nxv1f32:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e32, mf2, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v9, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e32, mf2, tu, mu
|
||||
; CHECK-NEXT: vmerge.vvm v8, v8, v9, v0
|
||||
; CHECK-NEXT: vfmerge.vfm v8, v8, fa0, v0
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 1 x float> poison, float %a, i32 0
|
||||
%va = shufflevector <vscale x 1 x float> %elt.head, <vscale x 1 x float> poison, <vscale x 1 x i32> zeroinitializer
|
||||
@ -1315,10 +1301,8 @@ define <vscale x 2 x float> @vpmerge_vv_nxv2f32(<vscale x 2 x float> %va, <vscal
|
||||
define <vscale x 2 x float> @vpmerge_vf_nxv2f32(float %a, <vscale x 2 x float> %vb, <vscale x 2 x i1> %m, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vpmerge_vf_nxv2f32:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e32, m1, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v9, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e32, m1, tu, mu
|
||||
; CHECK-NEXT: vmerge.vvm v8, v8, v9, v0
|
||||
; CHECK-NEXT: vfmerge.vfm v8, v8, fa0, v0
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 2 x float> poison, float %a, i32 0
|
||||
%va = shufflevector <vscale x 2 x float> %elt.head, <vscale x 2 x float> poison, <vscale x 2 x i32> zeroinitializer
|
||||
@ -1342,10 +1326,8 @@ define <vscale x 4 x float> @vpmerge_vv_nxv4f32(<vscale x 4 x float> %va, <vscal
|
||||
define <vscale x 4 x float> @vpmerge_vf_nxv4f32(float %a, <vscale x 4 x float> %vb, <vscale x 4 x i1> %m, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vpmerge_vf_nxv4f32:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e32, m2, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v10, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e32, m2, tu, mu
|
||||
; CHECK-NEXT: vmerge.vvm v8, v8, v10, v0
|
||||
; CHECK-NEXT: vfmerge.vfm v8, v8, fa0, v0
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 4 x float> poison, float %a, i32 0
|
||||
%va = shufflevector <vscale x 4 x float> %elt.head, <vscale x 4 x float> poison, <vscale x 4 x i32> zeroinitializer
|
||||
@ -1369,10 +1351,8 @@ define <vscale x 8 x float> @vpmerge_vv_nxv8f32(<vscale x 8 x float> %va, <vscal
|
||||
define <vscale x 8 x float> @vpmerge_vf_nxv8f32(float %a, <vscale x 8 x float> %vb, <vscale x 8 x i1> %m, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vpmerge_vf_nxv8f32:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e32, m4, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v12, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e32, m4, tu, mu
|
||||
; CHECK-NEXT: vmerge.vvm v8, v8, v12, v0
|
||||
; CHECK-NEXT: vfmerge.vfm v8, v8, fa0, v0
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 8 x float> poison, float %a, i32 0
|
||||
%va = shufflevector <vscale x 8 x float> %elt.head, <vscale x 8 x float> poison, <vscale x 8 x i32> zeroinitializer
|
||||
@ -1396,10 +1376,8 @@ define <vscale x 16 x float> @vpmerge_vv_nxv16f32(<vscale x 16 x float> %va, <vs
|
||||
define <vscale x 16 x float> @vpmerge_vf_nxv16f32(float %a, <vscale x 16 x float> %vb, <vscale x 16 x i1> %m, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vpmerge_vf_nxv16f32:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e32, m8, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v16, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e32, m8, tu, mu
|
||||
; CHECK-NEXT: vmerge.vvm v8, v8, v16, v0
|
||||
; CHECK-NEXT: vfmerge.vfm v8, v8, fa0, v0
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 16 x float> poison, float %a, i32 0
|
||||
%va = shufflevector <vscale x 16 x float> %elt.head, <vscale x 16 x float> poison, <vscale x 16 x i32> zeroinitializer
|
||||
@ -1423,10 +1401,8 @@ define <vscale x 1 x double> @vpmerge_vv_nxv1f64(<vscale x 1 x double> %va, <vsc
|
||||
define <vscale x 1 x double> @vpmerge_vf_nxv1f64(double %a, <vscale x 1 x double> %vb, <vscale x 1 x i1> %m, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vpmerge_vf_nxv1f64:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e64, m1, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v9, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e64, m1, tu, mu
|
||||
; CHECK-NEXT: vmerge.vvm v8, v8, v9, v0
|
||||
; CHECK-NEXT: vfmerge.vfm v8, v8, fa0, v0
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 1 x double> poison, double %a, i32 0
|
||||
%va = shufflevector <vscale x 1 x double> %elt.head, <vscale x 1 x double> poison, <vscale x 1 x i32> zeroinitializer
|
||||
@ -1450,10 +1426,8 @@ define <vscale x 2 x double> @vpmerge_vv_nxv2f64(<vscale x 2 x double> %va, <vsc
|
||||
define <vscale x 2 x double> @vpmerge_vf_nxv2f64(double %a, <vscale x 2 x double> %vb, <vscale x 2 x i1> %m, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vpmerge_vf_nxv2f64:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e64, m2, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v10, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e64, m2, tu, mu
|
||||
; CHECK-NEXT: vmerge.vvm v8, v8, v10, v0
|
||||
; CHECK-NEXT: vfmerge.vfm v8, v8, fa0, v0
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 2 x double> poison, double %a, i32 0
|
||||
%va = shufflevector <vscale x 2 x double> %elt.head, <vscale x 2 x double> poison, <vscale x 2 x i32> zeroinitializer
|
||||
@ -1477,10 +1451,8 @@ define <vscale x 4 x double> @vpmerge_vv_nxv4f64(<vscale x 4 x double> %va, <vsc
|
||||
define <vscale x 4 x double> @vpmerge_vf_nxv4f64(double %a, <vscale x 4 x double> %vb, <vscale x 4 x i1> %m, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vpmerge_vf_nxv4f64:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e64, m4, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v12, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e64, m4, tu, mu
|
||||
; CHECK-NEXT: vmerge.vvm v8, v8, v12, v0
|
||||
; CHECK-NEXT: vfmerge.vfm v8, v8, fa0, v0
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 4 x double> poison, double %a, i32 0
|
||||
%va = shufflevector <vscale x 4 x double> %elt.head, <vscale x 4 x double> poison, <vscale x 4 x i32> zeroinitializer
|
||||
@ -1504,10 +1476,8 @@ define <vscale x 8 x double> @vpmerge_vv_nxv8f64(<vscale x 8 x double> %va, <vsc
|
||||
define <vscale x 8 x double> @vpmerge_vf_nxv8f64(double %a, <vscale x 8 x double> %vb, <vscale x 8 x i1> %m, i32 zeroext %evl) {
|
||||
; CHECK-LABEL: vpmerge_vf_nxv8f64:
|
||||
; CHECK: # %bb.0:
|
||||
; CHECK-NEXT: vsetvli a1, zero, e64, m8, ta, mu
|
||||
; CHECK-NEXT: vfmv.v.f v16, fa0
|
||||
; CHECK-NEXT: vsetvli zero, a0, e64, m8, tu, mu
|
||||
; CHECK-NEXT: vmerge.vvm v8, v8, v16, v0
|
||||
; CHECK-NEXT: vfmerge.vfm v8, v8, fa0, v0
|
||||
; CHECK-NEXT: ret
|
||||
%elt.head = insertelement <vscale x 8 x double> poison, double %a, i32 0
|
||||
%va = shufflevector <vscale x 8 x double> %elt.head, <vscale x 8 x double> poison, <vscale x 8 x i32> zeroinitializer
|
||||
|
||||
Loading…
Reference in New Issue
Block a user