[llvm-branch-commits] [llvm] [DAG] Preserve scalar flags when folding vector constants (PR #239632)
Zach Goldthorpe via llvm-branch-commits
llvm-branch-commits at lists.llvm.org
Fri Nov 6 06:59:16 PST 2026
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 <Zach.Goldthorpe at amd.com>
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 at 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)
More information about the llvm-branch-commits
mailing list