llvmorg-github-actions[bot] wrote:
<!--LLVM PR SUMMARY COMMENT--> @llvm/pr-subscribers-backend-x86 Author: Zach Goldthorpe (zGoldthorpe) <details> <summary>Changes</summary> When a scalar operation has the same opcode and operands as a (potentially unrelated) vector operation, the scalar operation's flags get dropped. This patch preserves these lost flags. --- Patch is 27.54 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/239632.diff 5 Files Affected: - (modified) llvm/lib/CodeGen/SelectionDAG/DAGCombiner.cpp (+58-30) - (modified) llvm/lib/CodeGen/SelectionDAG/SelectionDAG.cpp (+1-1) - (modified) llvm/test/CodeGen/AArch64/fold-vector-lane-flags.ll (+1-4) - (modified) llvm/test/CodeGen/LoongArch/fold-vector-lane-flags.ll (+2-3) - (modified) llvm/test/CodeGen/X86/fold-vector-lane-flags.ll (+40-66) ``````````diff diff --git a/llvm/lib/CodeGen/SelectionDAG/DAGCombiner.cpp b/llvm/lib/CodeGen/SelectionDAG/DAGCombiner.cpp index 3fa73169d0d1a..cdc68e2c4c972 100644 --- a/llvm/lib/CodeGen/SelectionDAG/DAGCombiner.cpp +++ b/llvm/lib/CodeGen/SelectionDAG/DAGCombiner.cpp @@ -2987,7 +2987,10 @@ SDValue DAGCombiner::visitADDLike(SDNode *N) { return N1; // fold (add c1, c2) -> c1+c2 - if (SDValue C = DAG.FoldConstantArithmetic(ISD::ADD, DL, VT, {N0, N1})) + // only forward flags if operation was originally an add + if (SDValue C = DAG.FoldConstantArithmetic( + ISD::ADD, DL, VT, {N0, N1}, + N->getOpcode() == ISD::ADD ? N->getFlags() : SDNodeFlags())) return C; // canonicalize constant to RHS @@ -4332,7 +4335,8 @@ SDValue DAGCombiner::visitSUB(SDNode *N) { return tryFoldToZero(DL, TLI, VT, DAG, LegalOperations); // fold (sub c1, c2) -> c3 - if (SDValue C = DAG.FoldConstantArithmetic(ISD::SUB, DL, VT, {N0, N1})) + if (SDValue C = + DAG.FoldConstantArithmetic(ISD::SUB, DL, VT, {N0, N1}, N->getFlags())) return C; // fold vector ops @@ -4969,7 +4973,8 @@ SDValue DAGCombiner::visitMUL(SDNode *N) { return DAG.getConstant(0, DL, VT); // fold (mul c1, c2) -> c1*c2 - if (SDValue C = DAG.FoldConstantArithmetic(ISD::MUL, DL, VT, {N0, N1})) + if (SDValue C = + DAG.FoldConstantArithmetic(ISD::MUL, DL, VT, {N0, N1}, N->getFlags())) return C; // canonicalize constant to RHS (vector doesn't have to splat). An opaque @@ -5351,7 +5356,8 @@ SDValue DAGCombiner::visitSDIV(SDNode *N) { SDLoc DL(N); // fold (sdiv c1, c2) -> c1/c2 - if (SDValue C = DAG.FoldConstantArithmetic(ISD::SDIV, DL, VT, {N0, N1})) + if (SDValue C = DAG.FoldConstantArithmetic(ISD::SDIV, DL, VT, {N0, N1}, + N->getFlags())) return C; // fold vector ops @@ -5509,7 +5515,8 @@ SDValue DAGCombiner::visitUDIV(SDNode *N) { SDLoc DL(N); // fold (udiv c1, c2) -> c1/c2 - if (SDValue C = DAG.FoldConstantArithmetic(ISD::UDIV, DL, VT, {N0, N1})) + if (SDValue C = DAG.FoldConstantArithmetic(ISD::UDIV, DL, VT, {N0, N1}, + N->getFlags())) return C; // fold vector ops @@ -8992,7 +8999,8 @@ SDValue DAGCombiner::visitOR(SDNode *N) { return N0; // fold (or c1, c2) -> c1|c2 - if (SDValue C = DAG.FoldConstantArithmetic(ISD::OR, DL, VT, {N0, N1})) + if (SDValue C = + DAG.FoldConstantArithmetic(ISD::OR, DL, VT, {N0, N1}, N->getFlags())) return C; // canonicalize constant to RHS @@ -11169,7 +11177,8 @@ SDValue DAGCombiner::visitSHL(SDNode *N) { unsigned OpSizeInBits = VT.getScalarSizeInBits(); // fold (shl c1, c2) -> c1<<c2 - if (SDValue C = DAG.FoldConstantArithmetic(ISD::SHL, DL, VT, {N0, N1})) + if (SDValue C = + DAG.FoldConstantArithmetic(ISD::SHL, DL, VT, {N0, N1}, N->getFlags())) return C; // fold vector ops @@ -11631,7 +11640,8 @@ SDValue DAGCombiner::visitSRA(SDNode *N) { unsigned OpSizeInBits = VT.getScalarSizeInBits(); // fold (sra c1, c2) -> (sra c1, c2) - if (SDValue C = DAG.FoldConstantArithmetic(ISD::SRA, DL, VT, {N0, N1})) + if (SDValue C = + DAG.FoldConstantArithmetic(ISD::SRA, DL, VT, {N0, N1}, N->getFlags())) return C; // Arithmetic shifting an all-sign-bit value is a no-op. @@ -11866,7 +11876,8 @@ SDValue DAGCombiner::visitSRL(SDNode *N) { unsigned OpSizeInBits = VT.getScalarSizeInBits(); // fold (srl c1, c2) -> c1 >>u c2 - if (SDValue C = DAG.FoldConstantArithmetic(ISD::SRL, DL, VT, {N0, N1})) + if (SDValue C = + DAG.FoldConstantArithmetic(ISD::SRL, DL, VT, {N0, N1}, N->getFlags())) return C; // fold vector ops @@ -17936,7 +17947,8 @@ SDValue DAGCombiner::visitTRUNCATE(SDNode *N) { return SaturatedTR; // fold (truncate c1) -> c1 - if (SDValue C = DAG.FoldConstantArithmetic(ISD::TRUNCATE, DL, VT, {N0})) + if (SDValue C = DAG.FoldConstantArithmetic(ISD::TRUNCATE, DL, VT, {N0}, + N->getFlags())) return C; // fold (truncate (ext x)) -> (ext x) or (truncate x) or x @@ -19589,7 +19601,8 @@ SDValue DAGCombiner::visitFADD(SDNode *N) { return R; // fold (fadd c1, c2) -> c1 + c2 - if (SDValue C = DAG.FoldConstantArithmetic(ISD::FADD, DL, VT, {N0, N1})) + if (SDValue C = + DAG.FoldConstantArithmetic(ISD::FADD, DL, VT, {N0, N1}, Flags)) return C; // canonicalize constant to RHS @@ -19805,7 +19818,8 @@ SDValue DAGCombiner::visitFSUB(SDNode *N) { return R; // fold (fsub c1, c2) -> c1-c2 - if (SDValue C = DAG.FoldConstantArithmetic(ISD::FSUB, DL, VT, {N0, N1})) + if (SDValue C = + DAG.FoldConstantArithmetic(ISD::FSUB, DL, VT, {N0, N1}, Flags)) return C; // fold vector ops @@ -19995,7 +20009,8 @@ SDValue DAGCombiner::visitFMUL(SDNode *N) { return R; // fold (fmul c1, c2) -> c1*c2 - if (SDValue C = DAG.FoldConstantArithmetic(ISD::FMUL, DL, VT, {N0, N1})) + if (SDValue C = + DAG.FoldConstantArithmetic(ISD::FMUL, DL, VT, {N0, N1}, Flags)) return C; // canonicalize constant to RHS @@ -20141,8 +20156,8 @@ SDValue DAGCombiner::visitFMA(SDNode *N) { SelectionDAG::FlagInserter FlagsInserter(DAG, N); // Constant fold FMA. - if (SDValue C = - DAG.FoldConstantArithmetic(N->getOpcode(), DL, VT, {N0, N1, N2})) + if (SDValue C = DAG.FoldConstantArithmetic(N->getOpcode(), DL, VT, + {N0, N1, N2}, N->getFlags())) return C; // (-N0 * -N1) + N2 --> (N0 * N1) + N2 @@ -20255,7 +20270,8 @@ SDValue DAGCombiner::visitFMAD(SDNode *N) { SDLoc DL(N); // Constant fold FMAD. - if (SDValue C = DAG.FoldConstantArithmetic(ISD::FMAD, DL, VT, {N0, N1, N2})) + if (SDValue C = DAG.FoldConstantArithmetic(ISD::FMAD, DL, VT, {N0, N1, N2}, + N->getFlags())) return C; return SDValue(); @@ -20269,8 +20285,8 @@ SDValue DAGCombiner::visitFMULADD(SDNode *N) { SDLoc DL(N); // Constant fold FMULADD. - if (SDValue C = - DAG.FoldConstantArithmetic(ISD::FMULADD, DL, VT, {N0, N1, N2})) + if (SDValue C = DAG.FoldConstantArithmetic(ISD::FMULADD, DL, VT, {N0, N1, N2}, + N->getFlags())) return C; return SDValue(); @@ -20371,7 +20387,8 @@ SDValue DAGCombiner::visitFDIV(SDNode *N) { return R; // fold (fdiv c1, c2) -> c1/c2 - if (SDValue C = DAG.FoldConstantArithmetic(ISD::FDIV, DL, VT, {N0, N1})) + if (SDValue C = + DAG.FoldConstantArithmetic(ISD::FDIV, DL, VT, {N0, N1}, Flags)) return C; // fold vector ops @@ -20523,7 +20540,8 @@ SDValue DAGCombiner::visitFREM(SDNode *N) { return R; // fold (frem c1, c2) -> fmod(c1,c2) - if (SDValue C = DAG.FoldConstantArithmetic(ISD::FREM, DL, VT, {N0, N1})) + if (SDValue C = + DAG.FoldConstantArithmetic(ISD::FREM, DL, VT, {N0, N1}, Flags)) return C; if (SDValue NewSel = foldBinOpIntoSelect(N)) @@ -20611,7 +20629,8 @@ SDValue DAGCombiner::visitFCOPYSIGN(SDNode *N) { SDLoc DL(N); // fold (fcopysign c1, c2) -> fcopysign(c1,c2) - if (SDValue C = DAG.FoldConstantArithmetic(ISD::FCOPYSIGN, DL, VT, {N0, N1})) + if (SDValue C = DAG.FoldConstantArithmetic(ISD::FCOPYSIGN, DL, VT, {N0, N1}, + N->getFlags())) return C; // copysign(x, fp_extend(y)) -> copysign(x, y) @@ -20837,7 +20856,8 @@ SDValue DAGCombiner::visitSINT_TO_FP(SDNode *N) { // fold (sint_to_fp c1) -> c1fp // ...but only if the target supports immediate floating-point values if ((!LegalOperations || TLI.isOperationLegalOrCustom(ISD::ConstantFP, VT))) - if (SDValue C = DAG.FoldConstantArithmetic(ISD::SINT_TO_FP, DL, VT, {N0})) + if (SDValue C = DAG.FoldConstantArithmetic(ISD::SINT_TO_FP, DL, VT, {N0}, + N->getFlags())) return C; // If the input is a legal type, and SINT_TO_FP is not legal on this target, @@ -20920,7 +20940,8 @@ SDValue DAGCombiner::visitUINT_TO_FP(SDNode *N) { // fold (uint_to_fp c1) -> c1fp // ...but only if the target supports immediate floating-point values if ((!LegalOperations || TLI.isOperationLegalOrCustom(ISD::ConstantFP, VT))) - if (SDValue C = DAG.FoldConstantArithmetic(ISD::UINT_TO_FP, DL, VT, {N0})) + if (SDValue C = DAG.FoldConstantArithmetic(ISD::UINT_TO_FP, DL, VT, {N0}, + N->getFlags())) return C; // If the input is a legal type, and UINT_TO_FP is not legal on this target, @@ -21187,7 +21208,8 @@ SDValue DAGCombiner::visitFP_EXTEND(SDNode *N) { return SDValue(); // fold (fp_extend c1fp) -> c1fp - if (SDValue C = DAG.FoldConstantArithmetic(ISD::FP_EXTEND, DL, VT, {N0})) + if (SDValue C = DAG.FoldConstantArithmetic(ISD::FP_EXTEND, DL, VT, {N0}, + N->getFlags())) return C; // fold (fp_extend (fp16_to_fp op)) -> (fp16_to_fp op) @@ -21237,7 +21259,8 @@ SDValue DAGCombiner::visitFCEIL(SDNode *N) { EVT VT = N->getValueType(0); // fold (fceil c1) -> fceil(c1) - if (SDValue C = DAG.FoldConstantArithmetic(ISD::FCEIL, SDLoc(N), VT, {N0})) + if (SDValue C = DAG.FoldConstantArithmetic(ISD::FCEIL, SDLoc(N), VT, {N0}, + N->getFlags())) return C; return SDValue(); @@ -21248,7 +21271,8 @@ SDValue DAGCombiner::visitFTRUNC(SDNode *N) { EVT VT = N->getValueType(0); // fold (ftrunc c1) -> ftrunc(c1) - if (SDValue C = DAG.FoldConstantArithmetic(ISD::FTRUNC, SDLoc(N), VT, {N0})) + if (SDValue C = DAG.FoldConstantArithmetic(ISD::FTRUNC, SDLoc(N), VT, {N0}, + N->getFlags())) return C; // fold ftrunc (known rounded int x) -> x @@ -21283,7 +21307,8 @@ SDValue DAGCombiner::visitFFLOOR(SDNode *N) { EVT VT = N->getValueType(0); // fold (ffloor c1) -> ffloor(c1) - if (SDValue C = DAG.FoldConstantArithmetic(ISD::FFLOOR, SDLoc(N), VT, {N0})) + if (SDValue C = DAG.FoldConstantArithmetic(ISD::FFLOOR, SDLoc(N), VT, {N0}, + N->getFlags())) return C; return SDValue(); @@ -21295,7 +21320,8 @@ SDValue DAGCombiner::visitFNEG(SDNode *N) { SelectionDAG::FlagInserter FlagsInserter(DAG, N); // Constant fold FNEG. - if (SDValue C = DAG.FoldConstantArithmetic(ISD::FNEG, SDLoc(N), VT, {N0})) + if (SDValue C = DAG.FoldConstantArithmetic(ISD::FNEG, SDLoc(N), VT, {N0}, + N->getFlags())) return C; if (SDValue NegN0 = @@ -21334,7 +21360,8 @@ SDValue DAGCombiner::visitFMinMax(SDNode *N) { SelectionDAG::FlagInserter FlagsInserter(DAG, N); // Constant fold. - if (SDValue C = DAG.FoldConstantArithmetic(Opc, SDLoc(N), VT, {N0, N1})) + if (SDValue C = + DAG.FoldConstantArithmetic(Opc, SDLoc(N), VT, {N0, N1}, Flags)) return C; // Canonicalize to constant on RHS. @@ -21407,7 +21434,8 @@ SDValue DAGCombiner::visitFABS(SDNode *N) { SDLoc DL(N); // fold (fabs c1) -> fabs(c1) - if (SDValue C = DAG.FoldConstantArithmetic(ISD::FABS, DL, VT, {N0})) + if (SDValue C = + DAG.FoldConstantArithmetic(ISD::FABS, DL, VT, {N0}, N->getFlags())) return C; if (SimplifyDemandedBits(SDValue(N, 0))) diff --git a/llvm/lib/CodeGen/SelectionDAG/SelectionDAG.cpp b/llvm/lib/CodeGen/SelectionDAG/SelectionDAG.cpp index fad3e0c102bcd..888264ad2fc6d 100644 --- a/llvm/lib/CodeGen/SelectionDAG/SelectionDAG.cpp +++ b/llvm/lib/CodeGen/SelectionDAG/SelectionDAG.cpp @@ -7256,7 +7256,7 @@ SDValue SelectionDAG::getNode(unsigned Opcode, const SDLoc &DL, EVT VT, case ISD::VECREDUCE_XOR: case ISD::STEP_VECTOR: { SDValue Ops = {N1}; - if (SDValue Fold = FoldConstantArithmetic(Opcode, DL, VT, Ops)) + if (SDValue Fold = FoldConstantArithmetic(Opcode, DL, VT, Ops, Flags)) return Fold; } } diff --git a/llvm/test/CodeGen/AArch64/fold-vector-lane-flags.ll b/llvm/test/CodeGen/AArch64/fold-vector-lane-flags.ll index ac83d3dd6d754..e98e48839d9f4 100644 --- a/llvm/test/CodeGen/AArch64/fold-vector-lane-flags.ll +++ b/llvm/test/CodeGen/AArch64/fold-vector-lane-flags.ll @@ -6,7 +6,6 @@ define i64 @shl(i64 %a, i64 %c, ptr %p) { ; CHECK: // %bb.0: ; CHECK-NEXT: fmov d0, x0 ; CHECK-NEXT: adrp x8, .LCPI0_0 -; CHECK-NEXT: and x0, x0, #0x1fffffffffffffff ; CHECK-NEXT: ldr q1, [x8, :lo12:.LCPI0_0] ; CHECK-NEXT: mov v0.d[1], x1 ; CHECK-NEXT: ushl v0.2d, v0.2d, v1.2d @@ -26,7 +25,6 @@ define i64 @sra(i64 %a, i64 %c, ptr %p) { ; CHECK: // %bb.0: ; CHECK-NEXT: fmov d0, x0 ; CHECK-NEXT: adrp x8, .LCPI1_0 -; CHECK-NEXT: and x0, x0, #0xfffffffffffffff8 ; CHECK-NEXT: ldr q1, [x8, :lo12:.LCPI1_0] ; CHECK-NEXT: mov v0.d[1], x1 ; CHECK-NEXT: sshl v0.2d, v0.2d, v1.2d @@ -46,7 +44,6 @@ define i64 @srl(i64 %a, i64 %c, ptr %p) { ; CHECK: // %bb.0: ; CHECK-NEXT: fmov d0, x0 ; CHECK-NEXT: adrp x8, .LCPI2_0 -; CHECK-NEXT: and x0, x0, #0xfffffffffffffff8 ; CHECK-NEXT: ldr q1, [x8, :lo12:.LCPI2_0] ; CHECK-NEXT: mov v0.d[1], x1 ; CHECK-NEXT: ushl v0.2d, v0.2d, v1.2d @@ -66,10 +63,10 @@ define i32 @sdiv(i32 %a, i32 %b, i32 %c, i32 %d, ptr %p) { ; CHECK: // %bb.0: ; CHECK-NEXT: lsl w8, w0, #4 ; CHECK-NEXT: orr w9, w1, #0x1 +; CHECK-NEXT: mov w0, wzr ; CHECK-NEXT: sdiv w8, w8, w9 ; CHECK-NEXT: sdiv w9, w2, w3 ; CHECK-NEXT: fmov s0, w8 -; CHECK-NEXT: and w0, w8, #0xf ; CHECK-NEXT: mov v0.s[1], w9 ; CHECK-NEXT: str d0, [x4] ; CHECK-NEXT: ret diff --git a/llvm/test/CodeGen/LoongArch/fold-vector-lane-flags.ll b/llvm/test/CodeGen/LoongArch/fold-vector-lane-flags.ll index b70c86380b50a..d22cdd9904b97 100644 --- a/llvm/test/CodeGen/LoongArch/fold-vector-lane-flags.ll +++ b/llvm/test/CodeGen/LoongArch/fold-vector-lane-flags.ll @@ -4,13 +4,12 @@ define double @uitofp(i64 %a, i64 %c, ptr %p) { ; CHECK-LABEL: uitofp: ; CHECK: # %bb.0: +; CHECK-NEXT: movgr2fr.d $fa0, $a0 +; CHECK-NEXT: ffint.d.l $fa0, $fa0 ; CHECK-NEXT: vinsgr2vr.d $vr1, $a0, 0 -; CHECK-NEXT: vffint.d.lu $vr0, $vr1 -; CHECK-NEXT: vreplvei.d $vr0, $vr0, 0 ; CHECK-NEXT: vinsgr2vr.d $vr1, $a1, 1 ; CHECK-NEXT: vffint.d.lu $vr1, $vr1 ; CHECK-NEXT: vst $vr1, $a2, 0 -; CHECK-NEXT: # kill: def $f0_64 killed $f0_64 killed $vr0 ; CHECK-NEXT: ret %s = uitofp nneg i64 %a to double %va0 = insertelement <2 x i64> poison, i64 %a, i64 0 diff --git a/llvm/test/CodeGen/X86/fold-vector-lane-flags.ll b/llvm/test/CodeGen/X86/fold-vector-lane-flags.ll index 9782b12387b86..fe4e10235ebea 100644 --- a/llvm/test/CodeGen/X86/fold-vector-lane-flags.ll +++ b/llvm/test/CodeGen/X86/fold-vector-lane-flags.ll @@ -4,8 +4,7 @@ define float @fadd(float %a, float %c, float %d, float %y, ptr %p) { ; CHECK-LABEL: fadd: ; CHECK: # %bb.0: -; CHECK-NEXT: vaddss {{\.?LCPI[0-9]+_[0-9]+}}(%rip), %xmm0, %xmm4 -; CHECK-NEXT: vmulss %xmm3, %xmm4, %xmm3 +; CHECK-NEXT: vfmadd213ss {{.*#+}} xmm3 = (xmm0 * xmm3) + xmm3 ; CHECK-NEXT: vinsertps {{.*#+}} xmm0 = xmm0[0],xmm1[0],xmm0[2,3] ; CHECK-NEXT: vbroadcastss {{.*#+}} xmm1 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0] ; CHECK-NEXT: vinsertps {{.*#+}} xmm1 = xmm1[0],xmm2[0],xmm1[2,3] @@ -27,9 +26,7 @@ define float @fadd(float %a, float %c, float %d, float %y, ptr %p) { define float @fsub(float %a, float %c, float %d, float %y, ptr %p) { ; CHECK-LABEL: fsub: ; CHECK: # %bb.0: -; CHECK-NEXT: vmovss {{.*#+}} xmm4 = [1.0E+0,0.0E+0,0.0E+0,0.0E+0] -; CHECK-NEXT: vsubss %xmm0, %xmm4, %xmm4 -; CHECK-NEXT: vmulss %xmm4, %xmm3, %xmm3 +; CHECK-NEXT: vfnmadd213ss {{.*#+}} xmm3 = -(xmm0 * xmm3) + xmm3 ; CHECK-NEXT: vbroadcastss {{.*#+}} xmm4 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0] ; CHECK-NEXT: vinsertps {{.*#+}} xmm1 = xmm4[0],xmm1[0],xmm4[2,3] ; CHECK-NEXT: vinsertps {{.*#+}} xmm0 = xmm0[0],xmm2[0],xmm0[2,3] @@ -51,8 +48,7 @@ define float @fsub(float %a, float %c, float %d, float %y, ptr %p) { define float @fmul(float %a, float %b, float %c, float %d, float %e, ptr %p) { ; CHECK-LABEL: fmul: ; CHECK: # %bb.0: -; CHECK-NEXT: vmulss %xmm1, %xmm0, %xmm5 -; CHECK-NEXT: vaddss %xmm4, %xmm5, %xmm4 +; CHECK-NEXT: vfmadd231ss {{.*#+}} xmm4 = (xmm0 * xmm1) + xmm4 ; CHECK-NEXT: vinsertps {{.*#+}} xmm0 = xmm0[0],xmm2[0],xmm0[2,3] ; CHECK-NEXT: vinsertps {{.*#+}} xmm1 = xmm1[0],xmm3[0],xmm1[2,3] ; CHECK-NEXT: vmulps %xmm1, %xmm0, %xmm0 @@ -73,9 +69,11 @@ define float @fmul(float %a, float %b, float %c, float %d, float %e, ptr %p) { define float @fdiv(float %a, float %b, float %c, float %d, float %e, ptr %p) { ; CHECK-LABEL: fdiv: ; CHECK: # %bb.0: -; CHECK-NEXT: vdivss %xmm1, %xmm0, %xmm5 -; CHECK-NEXT: vdivss %xmm1, %xmm2, %xmm2 -; CHECK-NEXT: vaddss %xmm2, %xmm5, %xmm2 +; CHECK-NEXT: vmovss {{.*#+}} xmm5 = [1.0E+0,0.0E+0,0.0E+0,0.0E+0] +; CHECK-NEXT: vdivss %xmm1, %xmm5, %xmm5 +; CHECK-NEXT: vmulss %xmm5, %xmm0, %xmm6 +; CHECK-NEXT: vmulss %xmm5, %xmm2, %xmm2 +; CHECK-NEXT: vaddss %xmm2, %xmm6, %xmm2 ; CHECK-NEXT: vinsertps {{.*#+}} xmm0 = xmm0[0],xmm3[0],xmm0[2,3] ; CHECK-NEXT: vinsertps {{.*#+}} xmm1 = xmm1[0],xmm4[0],xmm1[2,3] ; CHECK-NEXT: vdivps %xmm1, %xmm0, %xmm0 @@ -108,19 +106,18 @@ define float @frem(float %a, float %c, float %d, float %y, ptr %p) { ; CHECK-NEXT: vfnmadd132ss {{.*#+}} xmm4 = -(xmm4 * mem) + xmm0 ; CHECK-NEXT: vandps {{\.?LCPI[0-9]+_[0-9]+}}(%rip), %xmm4, %xmm4 ; CHECK-NEXT: vandps {{\.?LCPI[0-9]+_[0-9]+}}(%rip), %xmm0, %xmm0 -; CHECK-NEXT: vorps %xmm0, %xmm4, %xmm4 -; CHECK-NEXT: vmovaps %xmm4, (%rsp) # 16-byte Spill -; CHECK-NEXT: vcmpunordss %xmm4, %xmm4, %xmm0 -; CHECK-NEXT: vmaxss %xmm4, %xmm3, %xmm4 -; CHECK-NEXT: vblendvps %xmm0, %xmm3, %xmm4, %xmm0 +; CHECK-NEXT: vorps %xmm0, %xmm4, %xmm0 ; CHECK-NEXT: vmovaps %xmm0, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill +; CHECK-NEXT: vmaxss %xmm0, %xmm3, %xmm0 +; CHECK-NEXT: vmovss %xmm0, {{[-0-9]+}}(%r{{[sb]}}p) # 4-byte Spill ; CHECK-NEXT: vmovaps %xmm1, %xmm0 ; CHECK-NEXT: vmovaps %xmm2, %xmm1 ; CHECK-NEXT: callq fmodf@PLT -; CHECK-NEXT: vmovaps (%rsp), %xmm1 # 16-byte Reload +; CHECK-NEXT: vmovaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm1 # 16-byte Reload ; CHECK-NEXT: vinsertps {{.*#+}} xmm0 = xmm1[0],xmm0[0],zero,zero ; CHECK-NEXT: vmovlps %xmm0, (%rbx) -; CHECK-NEXT: vmovaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 # 16-byte Reload +; CHECK-NEXT: vmovss {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 # 4-byte Reload +; CHECK-NEXT: # xmm0 = mem[0],zero,zero,zero ; CHECK-NEXT: addq $32, %rsp ; CHECK-NEXT: .cfi_def_cfa_offset 16 ; CHECK-NEXT: popq %rbx @@ -141,8 +138,7 @@ define float @fma(float %a, float %b, float %e, float %c, float %d, float %f, pt ; CHECK-LABEL: fma: ; CHECK: # %bb.0: ; CHECK-NEXT: vinsertps {{.*#+}} xmm4 = xmm1[0],xmm4[0],xmm1[2,3] -; CHECK-NEXT: vfmadd213ss {{.*#+}} xmm1 = (xmm0 * xmm1) + xmm2 -; CHECK-NEXT: vxorps {{\.?LCPI[0-9]+_[0-9]+}}(%rip), %xmm1, %xmm1 +; CHECK-NEXT: vfnmsub213ss {{.*#+}} xmm1 = -(xmm0 * xmm1) - xmm2 ; CHECK-NEXT: vinsertps {{.*#+}} xmm0 = xmm0[0],xmm3[0],xmm0[2,3] ; CHECK-NEXT: vinsertps {{.*#+}} xmm2 = xmm2[0],xmm5[0],xmm2[2,3] ; CHECK-NEXT: vfmadd231ps {{.*#+}} xmm2 = (xmm4 * xmm0) + xmm2 @@ -167,9 +163,7 @@ define float @fneg(float %a, float %c, float %y, ptr %p) { ; CHECK: # %bb.0: ; CHECK-NEXT: vbroadcastss {{.*#+}} xmm3 = [-0.0E+0,-0.0E+0,-0.0E+0,-0.0E+0] ; CHECK-NEXT: vxorps %xmm3, %xmm0, %xmm4 -; CHECK-NEXT: vcmpunordss %xmm4, %xmm4, %xmm5 -; CHECK-NEXT: vmaxss %xmm4, %xmm2, %xmm4 -; CHECK-NEXT: vblendvps %xmm5, %xmm2, %xmm4, %xmm2 +; CHECK-NEXT: vmaxss %xmm4, %xmm2, %xmm2 ; CHECK-NEXT: vinsertps {{.*#+}} xmm0 = xmm0[0],xmm1[0],xmm0[2,3] ; CHECK-NEXT: vxorps %xmm3, %xmm0, %xmm0 ; CHECK-NEXT: vmovlps %xmm0, (%rdi) @@ -189,9 +183,7 @@ define float @fneg_widen(float %a, float %c, float %y, ptr %p) { ; CHECK: # %bb.0: ; CHECK-NEXT: vbroadcastss {{.*#+}} xmm3 = [-0.0E+0,-0.0E+0,-0.0E+0,-0.0E+0] ; CHECK-NEXT: vxorps %xmm3, %xmm0, %xmm4 -; CHECK-NEXT: vcmpunordss %xmm4, %xmm4, %xmm5 ; CHECK-NEXT: vmaxss %xmm2, %xmm4, %xmm2 -; CHECK-NEXT: vblendvps %xmm5, %xmm4, %xmm2, %xmm2 ; CHECK-NEXT: ... [truncated] `````````` </details> https://github.com/llvm/llvm-project/pull/239632 _______________________________________________ llvm-branch-commits mailing list [email protected] https://lists.llvm.org/cgi-bin/mailman/listinfo/llvm-branch-commits
