https://github.com/zGoldthorpe created https://github.com/llvm/llvm-project/pull/239632
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. >From 8763333688d4a05b435fb3075f81757995f004f1 Mon Sep 17 00:00:00 2001 From: Zach Goldthorpe <[email protected]> Date: Fri, 6 Nov 2026 08:47:48 -0600 Subject: [PATCH] [DAG] Preserve scalar flags when folding vector constants 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. --- llvm/lib/CodeGen/SelectionDAG/DAGCombiner.cpp | 88 ++++++++++----- .../lib/CodeGen/SelectionDAG/SelectionDAG.cpp | 2 +- .../CodeGen/AArch64/fold-vector-lane-flags.ll | 5 +- .../LoongArch/fold-vector-lane-flags.ll | 5 +- .../CodeGen/X86/fold-vector-lane-flags.ll | 106 +++++++----------- 5 files changed, 102 insertions(+), 104 deletions(-) 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: vinsertps {{.*#+}} xmm0 = xmm0[0],xmm1[0],xmm0[2,3] ; CHECK-NEXT: vxorps %xmm3, %xmm0, %xmm0 ; CHECK-NEXT: vmovlps %xmm0, (%rdi) @@ -211,9 +203,7 @@ define float @fabs(float %a, float %c, float %y, ptr %p) { ; CHECK: # %bb.0: ; CHECK-NEXT: vbroadcastss {{.*#+}} xmm3 = [NaN,NaN,NaN,NaN] ; CHECK-NEXT: vandps %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: vandps %xmm3, %xmm0, %xmm0 ; CHECK-NEXT: vmovlps %xmm0, (%rdi) @@ -232,9 +222,7 @@ define float @ceil(float %a, float %c, float %y, ptr %p) { ; CHECK-LABEL: ceil: ; CHECK: # %bb.0: ; CHECK-NEXT: vroundss $10, %xmm0, %xmm0, %xmm3 -; CHECK-NEXT: vcmpunordss %xmm3, %xmm3, %xmm4 -; CHECK-NEXT: vmaxss %xmm3, %xmm2, %xmm3 -; CHECK-NEXT: vblendvps %xmm4, %xmm2, %xmm3, %xmm2 +; CHECK-NEXT: vmaxss %xmm3, %xmm2, %xmm2 ; CHECK-NEXT: vinsertps {{.*#+}} xmm0 = xmm0[0],xmm1[0],xmm0[2,3] ; CHECK-NEXT: vroundps $10, %xmm0, %xmm0 ; CHECK-NEXT: vmovlps %xmm0, (%rdi) @@ -253,9 +241,7 @@ define float @floor(float %a, float %c, float %y, ptr %p) { ; CHECK-LABEL: floor: ; CHECK: # %bb.0: ; CHECK-NEXT: vroundss $9, %xmm0, %xmm0, %xmm3 -; CHECK-NEXT: vcmpunordss %xmm3, %xmm3, %xmm4 -; CHECK-NEXT: vmaxss %xmm3, %xmm2, %xmm3 -; CHECK-NEXT: vblendvps %xmm4, %xmm2, %xmm3, %xmm2 +; CHECK-NEXT: vmaxss %xmm3, %xmm2, %xmm2 ; CHECK-NEXT: vinsertps {{.*#+}} xmm0 = xmm0[0],xmm1[0],xmm0[2,3] ; CHECK-NEXT: vroundps $9, %xmm0, %xmm0 ; CHECK-NEXT: vmovlps %xmm0, (%rdi) @@ -274,9 +260,7 @@ define float @ftrunc(float %a, float %c, float %y, ptr %p) { ; CHECK-LABEL: ftrunc: ; CHECK: # %bb.0: ; CHECK-NEXT: vroundss $11, %xmm0, %xmm0, %xmm3 -; CHECK-NEXT: vcmpunordss %xmm3, %xmm3, %xmm4 -; CHECK-NEXT: vmaxss %xmm3, %xmm2, %xmm3 -; CHECK-NEXT: vblendvps %xmm4, %xmm2, %xmm3, %xmm2 +; CHECK-NEXT: vmaxss %xmm3, %xmm2, %xmm2 ; CHECK-NEXT: vinsertps {{.*#+}} xmm0 = xmm0[0],xmm1[0],xmm0[2,3] ; CHECK-NEXT: vroundps $11, %xmm0, %xmm0 ; CHECK-NEXT: vmovlps %xmm0, (%rdi) @@ -298,9 +282,7 @@ define float @copysign(float %a, float %b, float %c, float %d, float %y, ptr %p) ; CHECK-NEXT: vandnps %xmm1, %xmm5, %xmm6 ; CHECK-NEXT: vandps %xmm5, %xmm0, %xmm7 ; CHECK-NEXT: vorps %xmm6, %xmm7, %xmm6 -; CHECK-NEXT: vcmpunordss %xmm6, %xmm6, %xmm7 -; CHECK-NEXT: vmaxss %xmm6, %xmm4, %xmm6 -; CHECK-NEXT: vblendvps %xmm7, %xmm4, %xmm6, %xmm4 +; CHECK-NEXT: vmaxss %xmm6, %xmm4, %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: vandnps %xmm1, %xmm5, %xmm1 @@ -323,9 +305,7 @@ define float @copysign(float %a, float %b, float %c, float %d, float %y, ptr %p) define float @minnum(float %a, float %b, float %c, float %d, ptr %p) { ; CHECK-LABEL: minnum: ; CHECK: # %bb.0: -; CHECK-NEXT: vminss %xmm0, %xmm1, %xmm4 -; CHECK-NEXT: vcmpunordss %xmm0, %xmm0, %xmm5 -; CHECK-NEXT: vblendvps %xmm5, %xmm1, %xmm4, %xmm4 +; CHECK-NEXT: vminss %xmm1, %xmm0, %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: vminps %xmm1, %xmm0, %xmm0 @@ -346,9 +326,7 @@ define double @fpext(float %a, float %c, double %y, ptr %p) { ; CHECK-LABEL: fpext: ; CHECK: # %bb.0: ; CHECK-NEXT: vcvtss2sd %xmm0, %xmm0, %xmm3 -; CHECK-NEXT: vcmpunordsd %xmm3, %xmm3, %xmm4 -; CHECK-NEXT: vmaxsd %xmm3, %xmm2, %xmm3 -; CHECK-NEXT: vblendvpd %xmm4, %xmm2, %xmm3, %xmm2 +; CHECK-NEXT: vmaxsd %xmm3, %xmm2, %xmm2 ; CHECK-NEXT: vinsertps {{.*#+}} xmm0 = xmm0[0],xmm1[0],xmm0[2,3] ; CHECK-NEXT: vcvtps2pd %xmm0, %xmm0 ; CHECK-NEXT: vmovaps %xmm0, (%rdi) @@ -366,10 +344,8 @@ define double @fpext(float %a, float %c, double %y, ptr %p) { define i32 @add(ptr %q, i32 %a, i32 %c, ptr %p) { ; CHECK-LABEL: add: ; CHECK: # %bb.0: -; CHECK-NEXT: # kill: def $esi killed $esi def $rsi -; CHECK-NEXT: leal 7(%rsi), %eax -; CHECK-NEXT: cltq -; CHECK-NEXT: movl (%rdi,%rax,4), %eax +; CHECK-NEXT: movslq %esi, %rsi +; CHECK-NEXT: movl 28(%rdi,%rsi,4), %eax ; CHECK-NEXT: vmovd %esi, %xmm0 ; CHECK-NEXT: vpinsrd $1, %edx, %xmm0, %xmm0 ; CHECK-NEXT: vpaddd {{\.?LCPI[0-9]+_[0-9]+}}(%rip), %xmm0, %xmm0 # [7,9,u,u] @@ -389,14 +365,13 @@ define i32 @add(ptr %q, i32 %a, i32 %c, ptr %p) { define i32 @sub(i32 %a, i32 %c, i32 %d, ptr %p) { ; CHECK-LABEL: sub: ; CHECK: # %bb.0: -; CHECK-NEXT: movl %edi, %eax ; CHECK-NEXT: vmovd %esi, %xmm0 ; CHECK-NEXT: vpsllq $32, %xmm0, %xmm0 ; CHECK-NEXT: vmovd %edi, %xmm1 -; CHECK-NEXT: negl %eax ; CHECK-NEXT: vpinsrd $1, %edx, %xmm1, %xmm1 ; CHECK-NEXT: vpsubd %xmm1, %xmm0, %xmm0 ; CHECK-NEXT: vmovq %xmm0, (%rcx) +; CHECK-NEXT: xorl %eax, %eax ; CHECK-NEXT: retq %s = sub nuw i32 0, %a %va0 = insertelement <2 x i32> poison, i32 0, i64 0 @@ -411,10 +386,12 @@ define i32 @sub(i32 %a, i32 %c, i32 %d, ptr %p) { define i1 @mul(i32 %a, i32 %b, i32 %c, i32 %d, ptr %p) { ; CHECK-LABEL: mul: ; CHECK: # %bb.0: -; CHECK-NEXT: vmovd %edi, %xmm0 -; CHECK-NEXT: imull %esi, %edi +; CHECK-NEXT: testl %esi, %esi +; CHECK-NEXT: sete %r9b ; CHECK-NEXT: testl %edi, %edi ; CHECK-NEXT: sete %al +; CHECK-NEXT: orb %r9b, %al +; CHECK-NEXT: vmovd %edi, %xmm0 ; CHECK-NEXT: vpinsrd $1, %edx, %xmm0, %xmm0 ; CHECK-NEXT: vmovd %esi, %xmm1 ; CHECK-NEXT: vpinsrd $1, %ecx, %xmm1, %xmm1 @@ -437,9 +414,8 @@ define i32 @or(i32 %a, i32 %b, i32 %c, ptr %p) { ; CHECK: # %bb.0: ; CHECK-NEXT: # kill: def $esi killed $esi def $rsi ; CHECK-NEXT: # kill: def $edi killed $edi def $rdi +; CHECK-NEXT: leal 4(%rsi,%rdi), %eax ; CHECK-NEXT: vmovd %edi, %xmm0 -; CHECK-NEXT: orl $4, %edi -; CHECK-NEXT: leal (%rdi,%rsi), %eax ; CHECK-NEXT: vpinsrd $1, %edx, %xmm0, %xmm0 ; CHECK-NEXT: vpor {{\.?LCPI[0-9]+_[0-9]+}}(%rip), %xmm0, %xmm0 ; CHECK-NEXT: vmovq %xmm0, (%rcx) @@ -456,21 +432,19 @@ define i32 @or(i32 %a, i32 %b, i32 %c, ptr %p) { define i32 @udiv(i32 %a, i32 %b, i32 %c, i32 %d, ptr %p) { ; CHECK-LABEL: udiv: ; CHECK: # %bb.0: -; CHECK-NEXT: movl %edx, %r9d -; CHECK-NEXT: movl %edi, %eax -; CHECK-NEXT: shll $4, %eax +; CHECK-NEXT: movl %edx, %eax +; CHECK-NEXT: shll $4, %edi ; CHECK-NEXT: orl $1, %esi ; CHECK-NEXT: xorl %edx, %edx +; CHECK-NEXT: divl %ecx +; CHECK-NEXT: movl %eax, %ecx +; CHECK-NEXT: movl %edi, %eax +; CHECK-NEXT: xorl %edx, %edx ; CHECK-NEXT: divl %esi -; CHECK-NEXT: movl %eax, %esi ; CHECK-NEXT: vmovd %eax, %xmm0 -; CHECK-NEXT: movl %r9d, %eax -; CHECK-NEXT: xorl %edx, %edx -; CHECK-NEXT: divl %ecx -; CHECK-NEXT: vpinsrd $1, %eax, %xmm0, %xmm0 -; CHECK-NEXT: andl $15, %esi +; CHECK-NEXT: vpinsrd $1, %ecx, %xmm0, %xmm0 ; CHECK-NEXT: vmovq %xmm0, (%r8) -; CHECK-NEXT: movl %esi, %eax +; CHECK-NEXT: xorl %eax, %eax ; CHECK-NEXT: retq %x = shl i32 %a, 4 %y = or i32 %b, 1 @@ -488,7 +462,7 @@ define i32 @udiv(i32 %a, i32 %b, i32 %c, i32 %d, ptr %p) { define i32 @trunc(i32 %a, i32 %c, ptr %p) { ; CHECK-LABEL: trunc: ; CHECK: # %bb.0: -; CHECK-NEXT: movzwl %di, %eax +; CHECK-NEXT: movl %edi, %eax ; CHECK-NEXT: vmovd %edi, %xmm0 ; CHECK-NEXT: vpinsrw $1, %esi, %xmm0, %xmm0 ; CHECK-NEXT: vmovd %xmm0, (%rdx) _______________________________________________ llvm-branch-commits mailing list [email protected] https://lists.llvm.org/cgi-bin/mailman/listinfo/llvm-branch-commits
