[InstCombine] use demanded vector elements to eliminate partially redundant instructions

[spatel]

Summary

In issue #60632, we have vector math ops that differ because an operand is shuffled, but the math has limited demanded elements, so it can be replaced by another instruction:
https://alive2.llvm.org/ce/z/TKqq7H

I don't think we have anything like this yet - it's like a CSE/GVN fold, but driven by demanded elements of a vector op.
This is limited to splat-0 as a first step to keep it simple and to save time in case it would be better to try this somewhere else.

[goldstein.w.n]

llvm/lib/Transforms/InstCombine/InstCombineSimplifyDemanded.cpp

1740

Think this loop should be a lambda that takes Value * V so you don't need to dup code for X/Y.

1743

Think:
if(Commute ? match(U, m_c_BinOp(Opcode, m_Specific(X), Shuf)) : match(U, m_BinOp(Opcode, m_Specific(X), Shuf)) probably make more sense here.

[goldstein.w.n]

llvm/lib/Transforms/InstCombine/InstCombineSimplifyDemanded.cpp

1731

This also would work for unary operator? I.e you have Unary(X) and Unary(Shuf(X))?

[spatel]

llvm/lib/Transforms/InstCombine/InstCombineSimplifyDemanded.cpp

1731

fneg is the only true unary inst; the fabs intrinsic can be considered a pseudo unary inst.

But both of those have shuffle canonicalized after the op, so it doesn't seem like we'd encounter a pattern like this? Let me know if you see a pattern that escapes.

Eg, we also canonicalize fneg after extractelement, but that fold seems to be missing for fabs.

[spatel]

Patch updated:

1. Use lambda and m_c_Binop to reduce code duplication (I tried a few variations of juggling the conditions - this was the best I could find).
2. Added a pair of negative tests with mismatched demand/shuffle mask.

[goldstein.w.n]

llvm/lib/Transforms/InstCombine/InstCombineSimplifyDemanded.cpp

1715

Why doesn't this work for div/rem/shift?

[spatel]

llvm/lib/Transforms/InstCombine/InstCombineSimplifyDemanded.cpp

1715

This patch should be fine with any binop since we're not altering any instructions, but I left it inside this block as a first step to try to be safer. I can put a TODO comment on it.

The existing code is definitely not safe for div/rem because it can do this:

%u = udiv <2 x i32> %x, <i32 42, i32 1>
%s = shufflevector <2 x i32> %u, <2 x i32> poison, <2 x i32> zeroinitializer
-->
%u = udiv <2 x i32> %x, <i32 42, i32 poison>  ; we don't demand element 1, so replace constant 1
%s = shufflevector <2 x i32> %u, <2 x i32> poison, <2 x i32> zeroinitializer

...but now we have a divide-by-poison element which can be replaced by a divide-by-0 element which means the whole instruction is UB/poison, and that's wrong of course.

I need to look through the old patches to see if there's still potential to do bad things with shifts.

[goldstein.w.n]

llvm/lib/Transforms/InstCombine/InstCombineSimplifyDemanded.cpp

1715

This patch should be fine with any binop since we're not altering any instructions, but I left it inside this block as a first step to try to be safer. I can put a TODO comment on it.

The existing code is definitely not safe for div/rem because it can do this:

%u = udiv <2 x i32> %x, <i32 42, i32 1>
%s = shufflevector <2 x i32> %u, <2 x i32> poison, <2 x i32> zeroinitializer
-->
%u = udiv <2 x i32> %x, <i32 42, i32 poison>  ; we don't demand element 1, so replace constant 1
%s = shufflevector <2 x i32> %u, <2 x i32> poison, <2 x i32> zeroinitializer

...but now we have a divide-by-poison element which can be replaced by a divide-by-0 element which means the whole instruction is UB/poison, and that's wrong of course.

I need to look through the old patches to see if there's still potential to do bad things with shifts.

Okay, add TODO then patch lgtm.

[spatel]

Patch updated:
Added TODO comment to allow this for any binop (currently bails out on div/rem/shift).

[goldstein.w.n]

LGTM. (note i'm not maintainer so maybe sit a day or so incase anyone else wants to way in).

[RKSimon]

LGTM - cheers

llvm/lib/Transforms/InstCombine/InstCombineSimplifyDemanded.cpp

case Instruction::Call: {
     } // switch on IntrinsicID
     break;
   } // case Call
   } // switch on Opcode
 
   // TODO: We bail completely on integer div/rem and shifts because they have
   // UB/poison potential, but that should be refined.
   BinaryOperator *BO;
   if (match(I, m_BinOp(BO)) && !BO->isIntDivRem() && !BO->isShift()) {
+    Value *X = BO->getOperand(0);
+    Value *Y = BO->getOperand(1);
+
+    // Look for an equivalent binop except that one operand has been shuffled.
+    // If the demand for this binop only includes elements that are the same as
+    // the other binop, then we may be able to replace this binop with a use of
+    // the earlier one.
+    //
+    // Example:
+    // %other_bo = bo (shuf X, {0}), Y
+    // %this_extracted_bo = extelt (bo X, Y), 0
+    // -->
+    // %other_bo = bo (shuf X, {0}), Y
+    // %this_extracted_bo = extelt %other_bo, 0
+    //
+    // TODO: Handle demand of an arbitrary single element or more than one
+    //       element instead of just element 0.
+    if (DemandedElts == 1 && !X->hasOneUse() && !Y->hasOneUse() &&
+        BO->hasOneUse() ) {
+
+      auto findShufBO = [&](bool MatchShufAsOp0) -> User * {
+        // Try to use shuffle-of-operand in place of an operand:
+        // bo X, Y --> bo (shuf X), Y
+        // bo X, Y --> bo X, (shuf Y)
+        BinaryOperator::BinaryOps Opcode = BO->getOpcode();
+        Value *ShufOp = MatchShufAsOp0 ? X : Y;
+        Value *OtherOp = MatchShufAsOp0 ? Y : X;
+        for (User *U : OtherOp->users()) {
+          auto Shuf = m_Shuffle(m_Specific(ShufOp), m_Value(), m_ZeroMask());
+          if (BO->isCommutative()
+                  ? match(U, m_c_BinOp(Opcode, Shuf, m_Specific(OtherOp)))
+                  : MatchShufAsOp0
+                        ? match(U, m_BinOp(Opcode, Shuf, m_Specific(OtherOp)))
+                        : match(U, m_BinOp(Opcode, m_Specific(OtherOp), Shuf)))
+            if (DT.dominates(U, I))
+              return U;
+        }
+        return nullptr;
+      };
+
+      if (User *ShufBO = findShufBO(/* MatchShufAsOp0 */ true))
+        return ShufBO;
+      if (User *ShufBO = findShufBO(/* MatchShufAsOp0 */ false))
+        return ShufBO;
+    }
+
     simplifyAndSetOp(I, 0, DemandedElts, UndefElts);
     simplifyAndSetOp(I, 1, DemandedElts, UndefElts2);
 
     // Output elements are undefined if both are undefined. Consider things
     // like undef & 0. The result is known zero, not undef.
     UndefElts &= UndefElts2;
   }
 
   // If we've proven all of the lanes undef, return an undef value.
   // TODO: Intersect w/demanded lanes
   if (UndefElts.isAllOnes())
     return UndefValue::get(I->getType());;
 
   return MadeChange ? I : nullptr;
 }

llvm/test/Transforms/InstCombine/vec_demanded_elts.ll

;
   %i21 = shufflevector <8 x i4> %i20, <8 x i4> %v, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 15>
   ret <8 x i4> %i21
 }
 
 define void @common_binop_demand_via_splat_op0(<2 x i4> %x, <2 x i4> %y) {
 ; CHECK-LABEL: @common_binop_demand_via_splat_op0(
 ; CHECK-NEXT:    [[XSHUF:%.*]] = shufflevector <2 x i4> [[X:%.*]], <2 x i4> poison, <2 x i32> zeroinitializer
 ; CHECK-NEXT:    [[B_XSHUF_Y:%.*]] = mul <2 x i4> [[XSHUF]], [[Y:%.*]]
-; CHECK-NEXT:    [[B_XY:%.*]] = mul <2 x i4> [[X]], [[Y]]
-; CHECK-NEXT:    [[B_XY_SPLAT:%.*]] = shufflevector <2 x i4> [[B_XY]], <2 x i4> poison, <2 x i32> zeroinitializer
+; CHECK-NEXT:    [[B_XY_SPLAT:%.*]] = shufflevector <2 x i4> [[B_XSHUF_Y]], <2 x i4> poison, <2 x i32> zeroinitializer
 ; CHECK-NEXT:    call void @use(<2 x i4> [[B_XSHUF_Y]])
 ; CHECK-NEXT:    call void @use(<2 x i4> [[B_XY_SPLAT]])
 ; CHECK-NEXT:    ret void
 ;
   %xshuf = shufflevector <2 x i4> %x, <2 x i4> poison, <2 x i32> zeroinitializer
   %b_xshuf_y = mul <2 x i4> %xshuf, %y
   %b_xy = mul <2 x i4> %x, %y
   %b_xy_splat = shufflevector <2 x i4> %b_xy, <2 x i4> poison, <2 x i32> zeroinitializer
   call void @use(<2 x i4> %b_xshuf_y)
   call void @use(<2 x i4> %b_xy_splat)
   ret void
 }
 
 define void @common_binop_demand_via_splat_op1(<2 x i4> %p, <2 x i4> %y) {
 ; CHECK-LABEL: @common_binop_demand_via_splat_op1(
 ; CHECK-NEXT:    [[X:%.*]] = sub <2 x i4> <i4 0, i4 1>, [[P:%.*]]
 ; CHECK-NEXT:    [[YSHUF:%.*]] = shufflevector <2 x i4> [[Y:%.*]], <2 x i4> poison, <2 x i32> zeroinitializer
 ; CHECK-NEXT:    [[B_X_YSHUF:%.*]] = mul <2 x i4> [[X]], [[YSHUF]]
-; CHECK-NEXT:    [[B_XY:%.*]] = mul <2 x i4> [[X]], [[Y]]
-; CHECK-NEXT:    [[B_XY_SPLAT:%.*]] = shufflevector <2 x i4> [[B_XY]], <2 x i4> poison, <2 x i32> zeroinitializer
+; CHECK-NEXT:    [[B_XY_SPLAT:%.*]] = shufflevector <2 x i4> [[B_X_YSHUF]], <2 x i4> poison, <2 x i32> zeroinitializer
 ; CHECK-NEXT:    call void @use(<2 x i4> [[B_XY_SPLAT]])
 ; CHECK-NEXT:    call void @use(<2 x i4> [[B_X_YSHUF]])
 ; CHECK-NEXT:    ret void
 ;
   %x = sub <2 x i4> <i4 0, i4 1>, %p ; thwart complexity-based canonicalization
   %yshuf = shufflevector <2 x i4> %y, <2 x i4> poison, <2 x i32> zeroinitializer
   %b_x_yshuf = mul <2 x i4> %x, %yshuf
   %b_xy = mul <2 x i4> %x, %y
   %b_xy_splat = shufflevector <2 x i4> %b_xy, <2 x i4> poison, <2 x i32> zeroinitializer
   call void @use(<2 x i4> %b_xy_splat)
   call void @use(<2 x i4> %b_x_yshuf)
   ret void
 }
 
 define void @common_binop_demand_via_splat_op0_commute(<2 x i4> %p, <2 x i4> %q) {
 ; CHECK-LABEL: @common_binop_demand_via_splat_op0_commute(
-; CHECK-NEXT:    [[X:%.*]] = sub <2 x i4> <i4 0, i4 1>, [[P:%.*]]
+; CHECK-NEXT:    [[X:%.*]] = sub <2 x i4> <i4 0, i4 poison>, [[P:%.*]]
 ; CHECK-NEXT:    [[Y:%.*]] = sub <2 x i4> <i4 1, i4 2>, [[Q:%.*]]
 ; CHECK-NEXT:    [[XSHUF:%.*]] = shufflevector <2 x i4> [[X]], <2 x i4> poison, <2 x i32> zeroinitializer
 ; CHECK-NEXT:    [[B_Y_XSHUF:%.*]] = mul <2 x i4> [[Y]], [[XSHUF]]
-; CHECK-NEXT:    [[B_XY:%.*]] = mul <2 x i4> [[X]], [[Y]]
-; CHECK-NEXT:    [[B_XY_SPLAT:%.*]] = shufflevector <2 x i4> [[B_XY]], <2 x i4> poison, <2 x i32> zeroinitializer
+; CHECK-NEXT:    [[B_XY_SPLAT:%.*]] = shufflevector <2 x i4> [[B_Y_XSHUF]], <2 x i4> poison, <2 x i32> zeroinitializer
 ; CHECK-NEXT:    call void @use(<2 x i4> [[B_XY_SPLAT]])
 ; CHECK-NEXT:    call void @use(<2 x i4> [[B_Y_XSHUF]])
 ; CHECK-NEXT:    ret void
 ;
   %x = sub <2 x i4> <i4 0, i4 1>, %p ; thwart complexity-based canonicalization
   %y = sub <2 x i4> <i4 1, i4 2>, %q ; thwart complexity-based canonicalization
   %xshuf = shufflevector <2 x i4> %x, <2 x i4> poison, <2 x i32> zeroinitializer
   %b_y_xshuf = mul <2 x i4> %y, %xshuf
   %b_xy = mul <2 x i4> %x, %y
   %b_xy_splat = shufflevector <2 x i4> %b_xy, <2 x i4> poison, <2 x i32> zeroinitializer
   call void @use(<2 x i4> %b_xy_splat)
   call void @use(<2 x i4> %b_y_xshuf)
   ret void
 }
 
 define void @common_binop_demand_via_splat_op1_commute(<2 x i4> %p, <2 x i4> %q) {
 ; CHECK-LABEL: @common_binop_demand_via_splat_op1_commute(
 ; CHECK-NEXT:    [[X:%.*]] = sub <2 x i4> <i4 0, i4 1>, [[P:%.*]]
-; CHECK-NEXT:    [[Y:%.*]] = sub <2 x i4> <i4 2, i4 3>, [[Q:%.*]]
+; CHECK-NEXT:    [[Y:%.*]] = sub <2 x i4> <i4 2, i4 poison>, [[Q:%.*]]
 ; CHECK-NEXT:    [[YSHUF:%.*]] = shufflevector <2 x i4> [[Y]], <2 x i4> poison, <2 x i32> zeroinitializer
 ; CHECK-NEXT:    [[B_Y_XSHUF:%.*]] = mul <2 x i4> [[YSHUF]], [[X]]
-; CHECK-NEXT:    [[B_XY:%.*]] = mul <2 x i4> [[X]], [[Y]]
-; CHECK-NEXT:    [[B_XY_SPLAT:%.*]] = shufflevector <2 x i4> [[B_XY]], <2 x i4> poison, <2 x i32> zeroinitializer
+; CHECK-NEXT:    [[B_XY_SPLAT:%.*]] = shufflevector <2 x i4> [[B_Y_XSHUF]], <2 x i4> poison, <2 x i32> zeroinitializer
 ; CHECK-NEXT:    call void @use(<2 x i4> [[B_XY_SPLAT]])
 ; CHECK-NEXT:    call void @use(<2 x i4> [[B_Y_XSHUF]])
 ; CHECK-NEXT:    ret void
 ;
   %x = sub <2 x i4> <i4 0, i4 1>, %p ; thwart complexity-based canonicalization
   %y = sub <2 x i4> <i4 2, i4 3>, %q ; thwart complexity-based canonicalization
   %yshuf = shufflevector <2 x i4> %y, <2 x i4> poison, <2 x i32> zeroinitializer
   %b_y_xshuf = mul <2 x i4> %yshuf, %x
   %b_xy = mul <2 x i4> %x, %y
   %b_xy_splat = shufflevector <2 x i4> %b_xy, <2 x i4> poison, <2 x i32> zeroinitializer
   call void @use(<2 x i4> %b_xy_splat)
   call void @use(<2 x i4> %b_y_xshuf)
   ret void
 }
 
+; negative test - wrong operands for sub
+
 define void @common_binop_demand_via_splat_op0_wrong_commute(<2 x i4> %x, <2 x i4> %y) {
 ; CHECK-LABEL: @common_binop_demand_via_splat_op0_wrong_commute(
 ; CHECK-NEXT:    [[XSHUF:%.*]] = shufflevector <2 x i4> [[X:%.*]], <2 x i4> poison, <2 x i32> zeroinitializer
 ; CHECK-NEXT:    [[B_Y_XSHUF:%.*]] = sub <2 x i4> [[Y:%.*]], [[XSHUF]]
 ; CHECK-NEXT:    [[B_XY:%.*]] = sub <2 x i4> [[X]], [[Y]]
 ; CHECK-NEXT:    [[B_XY_SPLAT:%.*]] = shufflevector <2 x i4> [[B_XY]], <2 x i4> poison, <2 x i32> zeroinitializer
 ; CHECK-NEXT:    call void @use(<2 x i4> [[B_XY_SPLAT]])
 ; CHECK-NEXT:    call void @use(<2 x i4> [[B_Y_XSHUF]])
 ; CHECK-NEXT:    ret void
 ;
   %xshuf = shufflevector <2 x i4> %x, <2 x i4> poison, <2 x i32> zeroinitializer
   %b_y_xshuf = sub <2 x i4> %y, %xshuf
   %b_xy = sub <2 x i4> %x, %y
   %b_xy_splat = shufflevector <2 x i4> %b_xy, <2 x i4> poison, <2 x i32> zeroinitializer
   call void @use(<2 x i4> %b_xy_splat)
   call void @use(<2 x i4> %b_y_xshuf)
   ret void
 }
 
+; negative test - need to reorder insts?
+
 define void @common_binop_demand_via_splat_op0_not_dominated1(<2 x i4> %x, <2 x i4> %y) {
 ; CHECK-LABEL: @common_binop_demand_via_splat_op0_not_dominated1(
 ; CHECK-NEXT:    [[B_XY:%.*]] = mul <2 x i4> [[X:%.*]], [[Y:%.*]]
 ; CHECK-NEXT:    [[XSHUF:%.*]] = shufflevector <2 x i4> [[X]], <2 x i4> poison, <2 x i32> zeroinitializer
 ; CHECK-NEXT:    [[B_XSHUF_Y:%.*]] = mul <2 x i4> [[XSHUF]], [[Y]]
 ; CHECK-NEXT:    [[B_XY_SPLAT:%.*]] = shufflevector <2 x i4> [[B_XY]], <2 x i4> poison, <2 x i32> zeroinitializer
 ; CHECK-NEXT:    call void @use(<2 x i4> [[B_XSHUF_Y]])
 ; CHECK-NEXT:    call void @use(<2 x i4> [[B_XY_SPLAT]])
 ; CHECK-NEXT:    ret void
 ;
   %b_xy = mul <2 x i4> %x, %y
   %xshuf = shufflevector <2 x i4> %x, <2 x i4> poison, <2 x i32> zeroinitializer
   %b_xshuf_y = mul <2 x i4> %xshuf, %y
   %b_xy_splat = shufflevector <2 x i4> %b_xy, <2 x i4> poison, <2 x i32> zeroinitializer
   call void @use(<2 x i4> %b_xshuf_y)
   call void @use(<2 x i4> %b_xy_splat)
   ret void
 }
 
+; negative test - need to reorder insts?
+
 define void @common_binop_demand_via_splat_op0_not_dominated2(<2 x i4> %x, <2 x i4> %y) {
 ; CHECK-LABEL: @common_binop_demand_via_splat_op0_not_dominated2(
 ; CHECK-NEXT:    [[B_XY:%.*]] = mul <2 x i4> [[X:%.*]], [[Y:%.*]]
 ; CHECK-NEXT:    [[B_XY_SPLAT:%.*]] = shufflevector <2 x i4> [[B_XY]], <2 x i4> poison, <2 x i32> zeroinitializer
 ; CHECK-NEXT:    [[XSHUF:%.*]] = shufflevector <2 x i4> [[X]], <2 x i4> poison, <2 x i32> zeroinitializer
 ; CHECK-NEXT:    [[B_XSHUF_Y:%.*]] = mul <2 x i4> [[XSHUF]], [[Y]]
 ; CHECK-NEXT:    call void @use(<2 x i4> [[B_XSHUF_Y]])
 ; CHECK-NEXT:    call void @use(<2 x i4> [[B_XY_SPLAT]])
 ; CHECK-NEXT:    ret void
 ;
   %b_xy = mul <2 x i4> %x, %y
   %b_xy_splat = shufflevector <2 x i4> %b_xy, <2 x i4> poison, <2 x i32> zeroinitializer
   %xshuf = shufflevector <2 x i4> %x, <2 x i4> poison, <2 x i32> zeroinitializer
   %b_xshuf_y = mul <2 x i4> %xshuf, %y
   call void @use(<2 x i4> %b_xshuf_y)
   call void @use(<2 x i4> %b_xy_splat)
   ret void
 }
 
 define i4 @common_binop_demand_via_extelt_op0(<2 x i4> %x, <2 x i4> %y) {
 ; CHECK-LABEL: @common_binop_demand_via_extelt_op0(
 ; CHECK-NEXT:    [[XSHUF:%.*]] = shufflevector <2 x i4> [[X:%.*]], <2 x i4> poison, <2 x i32> zeroinitializer
 ; CHECK-NEXT:    [[B_XSHUF_Y:%.*]] = sub <2 x i4> [[XSHUF]], [[Y:%.*]]
-; CHECK-NEXT:    [[B_XY:%.*]] = sub nsw <2 x i4> [[X]], [[Y]]
-; CHECK-NEXT:    [[B_XY0:%.*]] = extractelement <2 x i4> [[B_XY]], i64 0
+; CHECK-NEXT:    [[B_XY0:%.*]] = extractelement <2 x i4> [[B_XSHUF_Y]], i64 0
 ; CHECK-NEXT:    call void @use(<2 x i4> [[B_XSHUF_Y]])
 ; CHECK-NEXT:    ret i4 [[B_XY0]]
 ;
   %xshuf = shufflevector <2 x i4> %x, <2 x i4> poison, <2 x i32> zeroinitializer
   %b_xshuf_y = sub <2 x i4> %xshuf, %y
   %b_xy = sub nsw <2 x i4> %x, %y
   %b_xy0 = extractelement <2 x i4> %b_xy, i32 0
   call void @use(<2 x i4> %b_xshuf_y)
   ret i4 %b_xy0
 }
 
 define float @common_binop_demand_via_extelt_op1(<2 x float> %p, <2 x float> %y) {
 ; CHECK-LABEL: @common_binop_demand_via_extelt_op1(
 ; CHECK-NEXT:    [[X:%.*]] = fsub <2 x float> <float 0.000000e+00, float 1.000000e+00>, [[P:%.*]]
 ; CHECK-NEXT:    [[YSHUF:%.*]] = shufflevector <2 x float> [[Y:%.*]], <2 x float> poison, <2 x i32> zeroinitializer
 ; CHECK-NEXT:    [[B_X_YSHUF:%.*]] = fdiv <2 x float> [[X]], [[YSHUF]]
-; CHECK-NEXT:    [[B_XY:%.*]] = fdiv <2 x float> [[X]], [[Y]]
-; CHECK-NEXT:    [[B_XY0:%.*]] = extractelement <2 x float> [[B_XY]], i64 0
+; CHECK-NEXT:    [[B_XY0:%.*]] = extractelement <2 x float> [[B_X_YSHUF]], i64 0
 ; CHECK-NEXT:    call void @use_fp(<2 x float> [[B_X_YSHUF]])
 ; CHECK-NEXT:    ret float [[B_XY0]]
 ;
   %x = fsub <2 x float> <float 0.0, float 1.0>, %p ; thwart complexity-based canonicalization
   %yshuf = shufflevector <2 x float> %y, <2 x float> poison, <2 x i32> zeroinitializer
   %b_x_yshuf = fdiv <2 x float> %x, %yshuf
   %b_xy = fdiv <2 x float> %x, %y
   %b_xy0 = extractelement <2 x float> %b_xy, i32 0
   call void @use_fp(<2 x float> %b_x_yshuf)
   ret float %b_xy0
 }
 
 define float @common_binop_demand_via_extelt_op0_commute(<2 x float> %p, <2 x float> %q) {
 ; CHECK-LABEL: @common_binop_demand_via_extelt_op0_commute(
-; CHECK-NEXT:    [[X:%.*]] = fsub <2 x float> <float 0.000000e+00, float 1.000000e+00>, [[P:%.*]]
+; CHECK-NEXT:    [[X:%.*]] = fsub <2 x float> <float 0.000000e+00, float poison>, [[P:%.*]]
 ; CHECK-NEXT:    [[Y:%.*]] = fsub <2 x float> <float 3.000000e+00, float 2.000000e+00>, [[Q:%.*]]
 ; CHECK-NEXT:    [[XSHUF:%.*]] = shufflevector <2 x float> [[X]], <2 x float> poison, <2 x i32> zeroinitializer
 ; CHECK-NEXT:    [[B_Y_XSHUF:%.*]] = fmul nnan <2 x float> [[Y]], [[XSHUF]]
-; CHECK-NEXT:    [[B_XY:%.*]] = fmul ninf <2 x float> [[X]], [[Y]]
-; CHECK-NEXT:    [[B_XY0:%.*]] = extractelement <2 x float> [[B_XY]], i64 0
+; CHECK-NEXT:    [[B_XY0:%.*]] = extractelement <2 x float> [[B_Y_XSHUF]], i64 0
 ; CHECK-NEXT:    call void @use_fp(<2 x float> [[B_Y_XSHUF]])
 ; CHECK-NEXT:    ret float [[B_XY0]]
 ;
   %x = fsub <2 x float> <float 0.0, float 1.0>, %p ; thwart complexity-based canonicalization
   %y = fsub <2 x float> <float 3.0, float 2.0>, %q ; thwart complexity-based canonicalization
   %xshuf = shufflevector <2 x float> %x, <2 x float> poison, <2 x i32> zeroinitializer
   %b_y_xshuf = fmul nnan <2 x float> %y, %xshuf
   %b_xy = fmul ninf <2 x float> %x, %y
   %b_xy0 = extractelement <2 x float> %b_xy, i32 0
   call void @use_fp(<2 x float> %b_y_xshuf)
   ret float %b_xy0
 }
 
 define i4 @common_binop_demand_via_extelt_op1_commute(<2 x i4> %p, <2 x i4> %q) {
 ; CHECK-LABEL: @common_binop_demand_via_extelt_op1_commute(
 ; CHECK-NEXT:    [[X:%.*]] = sub <2 x i4> <i4 0, i4 1>, [[P:%.*]]
-; CHECK-NEXT:    [[Y:%.*]] = sub <2 x i4> <i4 2, i4 3>, [[Q:%.*]]
+; CHECK-NEXT:    [[Y:%.*]] = sub <2 x i4> <i4 2, i4 poison>, [[Q:%.*]]
 ; CHECK-NEXT:    [[YSHUF:%.*]] = shufflevector <2 x i4> [[Y]], <2 x i4> poison, <2 x i32> zeroinitializer
 ; CHECK-NEXT:    [[B_Y_XSHUF:%.*]] = or <2 x i4> [[YSHUF]], [[X]]
-; CHECK-NEXT:    [[B_XY:%.*]] = or <2 x i4> [[X]], [[Y]]
-; CHECK-NEXT:    [[B_XY0:%.*]] = extractelement <2 x i4> [[B_XY]], i64 0
+; CHECK-NEXT:    [[B_XY0:%.*]] = extractelement <2 x i4> [[B_Y_XSHUF]], i64 0
 ; CHECK-NEXT:    call void @use(<2 x i4> [[B_Y_XSHUF]])
 ; CHECK-NEXT:    ret i4 [[B_XY0]]
 ;
   %x = sub <2 x i4> <i4 0, i4 1>, %p ; thwart complexity-based canonicalization
   %y = sub <2 x i4> <i4 2, i4 3>, %q ; thwart complexity-based canonicalization
   %yshuf = shufflevector <2 x i4> %y, <2 x i4> poison, <2 x i32> zeroinitializer
   %b_y_xshuf = or <2 x i4> %yshuf, %x
   %b_xy = or <2 x i4> %x, %y
   %b_xy0 = extractelement <2 x i4> %b_xy, i32 0
   call void @use(<2 x i4> %b_y_xshuf)
   ret i4 %b_xy0
 }
 
+; negative test - wrong operands for sub
+
 define i4 @common_binop_demand_via_extelt_op0_wrong_commute(<2 x i4> %x, <2 x i4> %y) {
 ; CHECK-LABEL: @common_binop_demand_via_extelt_op0_wrong_commute(
 ; CHECK-NEXT:    [[XSHUF:%.*]] = shufflevector <2 x i4> [[X:%.*]], <2 x i4> poison, <2 x i32> zeroinitializer
 ; CHECK-NEXT:    [[B_Y_XSHUF:%.*]] = sub <2 x i4> [[Y:%.*]], [[XSHUF]]
 ; CHECK-NEXT:    [[B_XY:%.*]] = sub <2 x i4> [[X]], [[Y]]
 ; CHECK-NEXT:    [[B_XY0:%.*]] = extractelement <2 x i4> [[B_XY]], i64 0
 ; CHECK-NEXT:    call void @use(<2 x i4> [[B_Y_XSHUF]])
 ; CHECK-NEXT:    ret i4 [[B_XY0]]
 ;
   %xshuf = shufflevector <2 x i4> %x, <2 x i4> poison, <2 x i32> zeroinitializer
   %b_y_xshuf = sub <2 x i4> %y, %xshuf
   %b_xy = sub <2 x i4> %x, %y
   %b_xy0 = extractelement <2 x i4> %b_xy, i32 0
   call void @use(<2 x i4> %b_y_xshuf)
   ret i4 %b_xy0
 }
 
+; negative test - need to reorder insts?
+
 define i4 @common_binop_demand_via_extelt_op0_not_dominated1(<2 x i4> %x, <2 x i4> %y) {
 ; CHECK-LABEL: @common_binop_demand_via_extelt_op0_not_dominated1(
 ; CHECK-NEXT:    [[B_XY:%.*]] = xor <2 x i4> [[X:%.*]], [[Y:%.*]]
 ; CHECK-NEXT:    [[XSHUF:%.*]] = shufflevector <2 x i4> [[X]], <2 x i4> poison, <2 x i32> zeroinitializer
 ; CHECK-NEXT:    [[B_XSHUF_Y:%.*]] = xor <2 x i4> [[XSHUF]], [[Y]]
 ; CHECK-NEXT:    [[B_XY0:%.*]] = extractelement <2 x i4> [[B_XY]], i64 0
 ; CHECK-NEXT:    call void @use(<2 x i4> [[B_XSHUF_Y]])
 ; CHECK-NEXT:    ret i4 [[B_XY0]]
 ;
   %b_xy = xor <2 x i4> %x, %y
   %xshuf = shufflevector <2 x i4> %x, <2 x i4> poison, <2 x i32> zeroinitializer
   %b_xshuf_y = xor <2 x i4> %xshuf, %y
   %b_xy0 = extractelement <2 x i4> %b_xy, i32 0
   call void @use(<2 x i4> %b_xshuf_y)
   ret i4 %b_xy0
 }
 
+; negative test - need to reorder insts?
+
 define i4 @common_binop_demand_via_extelt_op0_not_dominated2(<2 x i4> %x, <2 x i4> %y) {
 ; CHECK-LABEL: @common_binop_demand_via_extelt_op0_not_dominated2(
 ; CHECK-NEXT:    [[B_XY:%.*]] = mul <2 x i4> [[X:%.*]], [[Y:%.*]]
 ; CHECK-NEXT:    [[B_XY0:%.*]] = extractelement <2 x i4> [[B_XY]], i64 0
 ; CHECK-NEXT:    [[XSHUF:%.*]] = shufflevector <2 x i4> [[X]], <2 x i4> poison, <2 x i32> zeroinitializer
 ; CHECK-NEXT:    [[B_XSHUF_Y:%.*]] = mul <2 x i4> [[XSHUF]], [[Y]]
 ; CHECK-NEXT:    call void @use(<2 x i4> [[B_XSHUF_Y]])
 ; CHECK-NEXT:    ret i4 [[B_XY0]]
 ;
   %b_xy = mul <2 x i4> %x, %y
   %b_xy0 = extractelement <2 x i4> %b_xy, i32 0
   %xshuf = shufflevector <2 x i4> %x, <2 x i4> poison, <2 x i32> zeroinitializer
   %b_xshuf_y = mul <2 x i4> %xshuf, %y
   call void @use(<2 x i4> %b_xshuf_y)
   ret i4 %b_xy0
 }
 
+; negative test - splat doesn't match demanded element
+
 define i4 @common_binop_demand_via_extelt_op0_mismatch_elt0(<2 x i4> %x, <2 x i4> %y) {
 ; CHECK-LABEL: @common_binop_demand_via_extelt_op0_mismatch_elt0(
 ; CHECK-NEXT:    [[XSHUF:%.*]] = shufflevector <2 x i4> [[X:%.*]], <2 x i4> poison, <2 x i32> <i32 1, i32 1>
 ; CHECK-NEXT:    [[B_XSHUF_Y:%.*]] = sub <2 x i4> [[XSHUF]], [[Y:%.*]]
 ; CHECK-NEXT:    [[B_XY:%.*]] = sub nsw <2 x i4> [[X]], [[Y]]
 ; CHECK-NEXT:    [[B_XY0:%.*]] = extractelement <2 x i4> [[B_XY]], i64 0
 ; CHECK-NEXT:    call void @use(<2 x i4> [[B_XSHUF_Y]])
 ; CHECK-NEXT:    ret i4 [[B_XY0]]
 ;
   %xshuf = shufflevector <2 x i4> %x, <2 x i4> poison, <2 x i32> <i32 1, i32 1>
   %b_xshuf_y = sub <2 x i4> %xshuf, %y
   %b_xy = sub nsw <2 x i4> %x, %y
   %b_xy0 = extractelement <2 x i4> %b_xy, i32 0
   call void @use(<2 x i4> %b_xshuf_y)
   ret i4 %b_xy0
 }
 
+; negative test - splat doesn't match demanded element
+
 define i4 @common_binop_demand_via_extelt_op0_mismatch_elt1(<2 x i4> %x, <2 x i4> %y) {
 ; CHECK-LABEL: @common_binop_demand_via_extelt_op0_mismatch_elt1(
 ; CHECK-NEXT:    [[XSHUF:%.*]] = shufflevector <2 x i4> [[X:%.*]], <2 x i4> poison, <2 x i32> zeroinitializer
 ; CHECK-NEXT:    [[B_XSHUF_Y:%.*]] = sub <2 x i4> [[XSHUF]], [[Y:%.*]]
 ; CHECK-NEXT:    [[B_XY:%.*]] = sub nsw <2 x i4> [[X]], [[Y]]
 ; CHECK-NEXT:    [[B_XY0:%.*]] = extractelement <2 x i4> [[B_XY]], i64 1
 ; CHECK-NEXT:    call void @use(<2 x i4> [[B_XSHUF_Y]])
 ; CHECK-NEXT:    ret i4 [[B_XY0]]
 ;
   %xshuf = shufflevector <2 x i4> %x, <2 x i4> poison, <2 x i32> zeroinitializer
   %b_xshuf_y = sub <2 x i4> %xshuf, %y
   %b_xy = sub nsw <2 x i4> %x, %y
   %b_xy0 = extractelement <2 x i4> %b_xy, i32 1
   call void @use(<2 x i4> %b_xshuf_y)
   ret i4 %b_xy0
 }