[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