[InstCombine] try to fold insertelt + vector op into scalar op + insertelt

[spatel]

Summary

This is a transform suggested in PR37463:
https://bugs.llvm.org/show_bug.cgi?id=37463

This makes sense for IR because we should always have equal or better analysis for a scalar binop vs. a vector binop. It can also lead to follow-on transforms/simplifications as seen in some of the div/rem tests that change opcodes.

It's not as clearly a win for codegen (where keeping everything as vector ops might be better for perf), but I haven't seen any regressions yet, and it should be possible to reverse this if needed.

A couple of details worth pointing out:

1. This does not need to be limited with isSafeToSpeculativelyExecute() like the related shuffle transforms in this function. We're doing strictly less work by only operating on 1 lane of a vector, so there's no opportunity for executing on unknown bits. So div/rem are included in the diffs.
2. As noted in the last code comment, we can't just insert into an undef vector constant because that could be more undef than the original code was. But we'll probably end up inserting into an undef vector anyway in most cases because that's what the constants simplify to (as seen in the test results).

[efriedma]

I'm concerned the backend won't reliably reverse the transform. For integer operations, SelectionDAG heavily depends on IR types to decide whether to perform an operation in integer or SIMD registers, and transferring values between the two register files is slow. Yes, the second of an insertelement is a scalar, but many backends pattern-match a load+insertelement to a vector register load.

I agree this makes sense for IR.

[spatel]

In D50992#1206612, @efriedma wrote:

I'm concerned the backend won't reliably reverse the transform. For integer operations, SelectionDAG heavily depends on IR types to decide whether to perform an operation in integer or SIMD registers, and transferring values between the two register files is slow. Yes, the second of an insertelement is a scalar, but many backends pattern-match a load+insertelement to a vector register load.

If we add a load to the sequence, we have something like this:

define <4 x i32> @vector_add_constant(i32* %p) {
  %x = load i32, i32* %p
  %ins = insertelement <4 x i32> undef, i32 %x, i32 0
  %bo = add <4 x i32> %ins, <i32 42, i32 42, i32 42, i32 42>
  ret <4 x i32> %bo
}

define <4 x i32> @scalar_add_constant(i32* %p) {
  %x = load i32, i32* %p
  %b = add i32 %x, 42
  %bo = insertelement <4 x i32> undef, i32 %b, i32 0
  ret <4 x i32> %bo
}

And for x86, that's:

vmovd	(%rdi), %xmm0           ## xmm0 = mem[0],zero,zero,zero
vpaddd	LCPI4_0(%rip), %xmm0, %xmm0

vs.

movl	(%rdi), %eax
addl	$42, %eax
vmovd	%eax, %xmm0

Let me see about adding a DAG reversal...

[lebedev.ri]

Looks ok to me.

lib/Transforms/InstCombine/InstructionCombining.cpp

1362

I'd prefer ConstIsOp1

1372

Hm, why dyn_cast<>(), we did just use CreateBinOp()?

[spatel]

Note: this patch is on hold pending backend enhancements that try to avoid known codegen regressions.
The first 2 of those are D51186 and D51125.

lib/Transforms/InstCombine/InstructionCombining.cpp

1362

Yes, will fix.

1372

CreateBinOp() will return a Constant if it manages to constant fold, so we can't be sure that 'ScalarOp' is actually a BinaryOperator. I suppose that would mean X was a constant...which seems unlikely. But it's the kind of thing a fuzzer finds N months after commit. :)

[lebedev.ri]

In D50992#1212764, @spatel wrote:

Note: this patch is on hold pending backend enhancements that try to avoid known codegen regressions.
The first 2 of those are D51186 and D51125.

Yep, i noticed, thank you for doing these!

lib/Transforms/InstCombine/InstructionCombining.cpp

1372

Right, constant-folding again. I should try to keep that in mind.

[spatel]

I'm finally going to abandon this. D80885 would introduce the same transform, but it includes load-from-memory and cost model constraints, so should be safer. And I expect that we would still run -instcombine after -vector-combine in a typical opt pipeline, so there shouldn't be much chance of losing overall optimization power.

lib/Transforms/InstCombine/InstructionCombining.cpp

do {
     assert(Ancestor->hasOneUse() && "Drilled down when more than one use!");
     Ancestor = Ancestor->user_back();
   } while (true);
 }
 
 Instruction *InstCombiner::foldShuffledBinop(BinaryOperator &Inst) {
   if (!Inst.getType()->isVectorTy()) return nullptr;
 
+  // Try to transform scalar insert + vector binop into scalar binop + insert.
+  BinaryOperator::BinaryOps Opcode = Inst.getOpcode();
+  Value *X;
+  Constant *C;
+  ConstantInt *Idx;
+  bool ConstOp1 = isa<Constant>(Inst.getOperand(1));
+  if (match(&Inst, m_c_BinOp(
+          m_OneUse(m_InsertElement(m_Undef(), m_Value(X), m_ConstantInt(Idx))),
+          m_Constant(C)))) {
+    // binop (inselt undef, X, Idx), C --> inselt C', (binop X, EltC), Idx
+    // binop C, (inselt undef, X, Idx) --> inselt C', (binop EltC, X), Idx
+    Constant *EltC = C->getAggregateElement(Idx);
+    Value *NewLHS = ConstOp1 ? X : EltC;
+    Value *NewRHS = ConstOp1 ? EltC : X;
+    Value *ScalarOp = Builder.CreateBinOp(Opcode, NewLHS, NewRHS);
+    if (auto *ScalarBO = dyn_cast<BinaryOperator>(ScalarOp))
+      ScalarBO->copyIRFlags(&Inst);
+
+    // The new constant vector that we are inserting into is not necessarily an
+    // undef vector. It is created by folding the constants in the original
+    // vector with undef using this binary opcode.
+    UndefValue *UndefVec = UndefValue::get(Inst.getType());
+    Constant *NewVecC = ConstOp1 ? ConstantExpr::get(Opcode, UndefVec, C)
+                                 : ConstantExpr::get(Opcode, C, UndefVec);
+    return InsertElementInst::Create(NewVecC, ScalarOp, Idx);
+  }
+
   // It may not be safe to reorder shuffles and things like div, urem, etc.
   // because we may trap when executing those ops on unknown vector elements.
   // See PR20059.
   if (!isSafeToSpeculativelyExecute(&Inst))
     return nullptr;
 
   unsigned VWidth = cast<VectorType>(Inst.getType())->getNumElements();
   Value *LHS = Inst.getOperand(0), *RHS = Inst.getOperand(1);
   assert(cast<VectorType>(LHS->getType())->getNumElements() == VWidth);
   assert(cast<VectorType>(RHS->getType())->getNumElements() == VWidth);
 
   auto createBinOpShuffle = [&](Value *X, Value *Y, Constant *M) {
-    Value *XY = Builder.CreateBinOp(Inst.getOpcode(), X, Y);
+    Value *XY = Builder.CreateBinOp(Opcode, X, Y);
     if (auto *BO = dyn_cast<BinaryOperator>(XY))
       BO->copyIRFlags(&Inst);
     return new ShuffleVectorInst(XY, UndefValue::get(XY->getType()), M);
   };
 
   // If both arguments of the binary operation are shuffles that use the same
   // mask and shuffle within a single vector, move the shuffle after the binop.
   Value *V1, *V2;
   Constant *Mask;
   if (match(LHS, m_ShuffleVector(m_Value(V1), m_Undef(), m_Constant(Mask))) &&
       match(RHS, m_ShuffleVector(m_Value(V2), m_Undef(), m_Specific(Mask))) &&
       V1->getType() == V2->getType() &&
       (LHS->hasOneUse() || RHS->hasOneUse() || LHS == RHS)) {
     // Op(shuffle(V1, Mask), shuffle(V2, Mask)) -> shuffle(Op(V1, V2), Mask)
     return createBinOpShuffle(V1, V2, Mask);
   }
 
   // If one argument is a shuffle within one vector and the other is a constant,
   // try moving the shuffle after the binary operation. This canonicalization
   // intends to move shuffles closer to other shuffles and binops closer to
   // other binops, so they can be folded. It may also enable demanded elements
   // transforms.
-  Constant *C;
   if (match(&Inst, m_c_BinOp(
           m_OneUse(m_ShuffleVector(m_Value(V1), m_Undef(), m_Constant(Mask))),
           m_Constant(C))) &&
       V1->getType() == Inst.getType()) {
     // Find constant NewC that has property:
     //   shuffle(NewC, ShMask) = C
     // If such constant does not exist (example: ShMask=<0,0> and C=<1,2>)
     // reorder is not possible. A 1-to-1 mapping is not required. Example:
for (unsigned I = 0; I < VWidth; ++I) {
         NewVecC[ShMask[I]] = CElt;
       }
     }
     if (MayChange) {
       Constant *NewC = ConstantVector::get(NewVecC);
       // It may not be safe to execute a binop on a vector with undef elements
       // because the entire instruction can be folded to undef or create poison
       // that did not exist in the original code.
-      bool ConstOp1 = isa<Constant>(Inst.getOperand(1));
       if (Inst.isIntDivRem() || (Inst.isShift() && ConstOp1))
-        NewC = getSafeVectorConstantForBinop(Inst.getOpcode(), NewC, ConstOp1);
+        NewC = getSafeVectorConstantForBinop(Opcode, NewC, ConstOp1);
 
       // Op(shuffle(V1, Mask), C) -> shuffle(Op(V1, NewC), Mask)
       // Op(C, shuffle(V1, Mask)) -> shuffle(Op(NewC, V1), Mask)
-      Value *NewLHS = isa<Constant>(LHS) ? NewC : V1;
-      Value *NewRHS = isa<Constant>(LHS) ? V1 : NewC;
+      Value *NewLHS = ConstOp1 ? V1 : NewC;
+      Value *NewRHS = ConstOp1 ? NewC : V1;
       return createBinOpShuffle(NewLHS, NewRHS, Mask);
     }
   }
 
   return nullptr;
 }
 
 Instruction *InstCombiner::visitGetElementPtrInst(GetElementPtrInst &GEP) {

test/Transforms/InstCombine/inselt-binop.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt -S -instcombine %s | FileCheck %s
 
 define <2 x i8> @add_constant(i8 %x) {
 ; CHECK-LABEL: @add_constant(
-; CHECK-NEXT:    [[INS:%.*]] = insertelement <2 x i8> undef, i8 [[X:%.*]], i32 0
-; CHECK-NEXT:    [[BO:%.*]] = add <2 x i8> [[INS]], <i8 42, i8 undef>
+; CHECK-NEXT:    [[TMP1:%.*]] = add i8 [[X:%.*]], 42
+; CHECK-NEXT:    [[BO:%.*]] = insertelement <2 x i8> undef, i8 [[TMP1]], i32 0
 ; CHECK-NEXT:    ret <2 x i8> [[BO]]
 ;
   %ins = insertelement <2 x i8> undef, i8 %x, i32 0
   %bo = add <2 x i8> %ins, <i8 42, i8 undef>
   ret <2 x i8> %bo
 }
 
 define <2 x i8> @add_constant_not_undef_lane(i8 %x) {
 ; CHECK-LABEL: @add_constant_not_undef_lane(
-; CHECK-NEXT:    [[INS:%.*]] = insertelement <2 x i8> undef, i8 [[X:%.*]], i32 0
-; CHECK-NEXT:    [[BO:%.*]] = add <2 x i8> [[INS]], <i8 42, i8 -42>
+; CHECK-NEXT:    [[TMP1:%.*]] = add i8 [[X:%.*]], 42
+; CHECK-NEXT:    [[BO:%.*]] = insertelement <2 x i8> undef, i8 [[TMP1]], i32 0
 ; CHECK-NEXT:    ret <2 x i8> [[BO]]
 ;
   %ins = insertelement <2 x i8> undef, i8 %x, i32 0
   %bo = add <2 x i8> %ins, <i8 42, i8 -42>
   ret <2 x i8> %bo
 }
 
 ; IR flags are not required, but they should propagate.
 
 define <2 x i8> @sub_constant_op0(i8 %x) {
 ; CHECK-LABEL: @sub_constant_op0(
-; CHECK-NEXT:    [[INS:%.*]] = insertelement <2 x i8> undef, i8 [[X:%.*]], i32 1
-; CHECK-NEXT:    [[BO:%.*]] = sub nuw nsw <2 x i8> <i8 undef, i8 -42>, [[INS]]
+; CHECK-NEXT:    [[TMP1:%.*]] = sub nuw nsw i8 -42, [[X:%.*]]
+; CHECK-NEXT:    [[BO:%.*]] = insertelement <2 x i8> undef, i8 [[TMP1]], i32 1
 ; CHECK-NEXT:    ret <2 x i8> [[BO]]
 ;
   %ins = insertelement <2 x i8> undef, i8 %x, i32 1
   %bo = sub nsw nuw <2 x i8> <i8 undef, i8 -42>, %ins
   ret <2 x i8> %bo
 }
 
 define <2 x i8> @sub_constant_op0_not_undef_lane(i8 %x) {
 ; CHECK-LABEL: @sub_constant_op0_not_undef_lane(
-; CHECK-NEXT:    [[INS:%.*]] = insertelement <2 x i8> undef, i8 [[X:%.*]], i32 1
-; CHECK-NEXT:    [[BO:%.*]] = sub nuw <2 x i8> <i8 42, i8 -42>, [[INS]]
+; CHECK-NEXT:    [[TMP1:%.*]] = sub nuw i8 -42, [[X:%.*]]
+; CHECK-NEXT:    [[BO:%.*]] = insertelement <2 x i8> undef, i8 [[TMP1]], i32 1
 ; CHECK-NEXT:    ret <2 x i8> [[BO]]
 ;
   %ins = insertelement <2 x i8> undef, i8 %x, i32 1
   %bo = sub nuw <2 x i8> <i8 42, i8 -42>, %ins
   ret <2 x i8> %bo
 }
 
 define <2 x i8> @sub_constant_op1(i8 %x) {
 ; CHECK-LABEL: @sub_constant_op1(
-; CHECK-NEXT:    [[INS:%.*]] = insertelement <2 x i8> undef, i8 [[X:%.*]], i32 0
-; CHECK-NEXT:    [[BO:%.*]] = add <2 x i8> [[INS]], <i8 -42, i8 undef>
+; CHECK-NEXT:    [[TMP1:%.*]] = add i8 [[X:%.*]], -42
+; CHECK-NEXT:    [[BO:%.*]] = insertelement <2 x i8> undef, i8 [[TMP1]], i32 0
 ; CHECK-NEXT:    ret <2 x i8> [[BO]]
 ;
   %ins = insertelement <2 x i8> undef, i8 %x, i32 0
   %bo = sub nuw <2 x i8> %ins, <i8 42, i8 undef>
   ret <2 x i8> %bo
 }
 
 define <2 x i8> @sub_constant_op1_not_undef_lane(i8 %x) {
 ; CHECK-LABEL: @sub_constant_op1_not_undef_lane(
-; CHECK-NEXT:    [[INS:%.*]] = insertelement <2 x i8> undef, i8 [[X:%.*]], i32 0
-; CHECK-NEXT:    [[BO:%.*]] = add <2 x i8> [[INS]], <i8 -42, i8 42>
+; CHECK-NEXT:    [[TMP1:%.*]] = add i8 [[X:%.*]], -42
+; CHECK-NEXT:    [[BO:%.*]] = insertelement <2 x i8> undef, i8 [[TMP1]], i32 0
 ; CHECK-NEXT:    ret <2 x i8> [[BO]]
 ;
   %ins = insertelement <2 x i8> undef, i8 %x, i32 0
   %bo = sub nuw <2 x i8> %ins, <i8 42, i8 -42>
   ret <2 x i8> %bo
 }
 
 define <3 x i8> @mul_constant(i8 %x) {
 ; CHECK-LABEL: @mul_constant(
-; CHECK-NEXT:    [[INS:%.*]] = insertelement <3 x i8> undef, i8 [[X:%.*]], i32 2
-; CHECK-NEXT:    [[BO:%.*]] = mul <3 x i8> [[INS]], <i8 undef, i8 undef, i8 -42>
+; CHECK-NEXT:    [[TMP1:%.*]] = mul i8 [[X:%.*]], -42
+; CHECK-NEXT:    [[BO:%.*]] = insertelement <3 x i8> undef, i8 [[TMP1]], i32 2
 ; CHECK-NEXT:    ret <3 x i8> [[BO]]
 ;
   %ins = insertelement <3 x i8> undef, i8 %x, i32 2
   %bo = mul <3 x i8> %ins, <i8 undef, i8 undef, i8 -42>
   ret <3 x i8> %bo
 }
 
 define <3 x i8> @mul_constant_not_undef_lane(i8 %x) {
 ; CHECK-LABEL: @mul_constant_not_undef_lane(
-; CHECK-NEXT:    [[INS:%.*]] = insertelement <3 x i8> undef, i8 [[X:%.*]], i32 2
-; CHECK-NEXT:    [[BO:%.*]] = mul <3 x i8> [[INS]], <i8 42, i8 undef, i8 -42>
+; CHECK-NEXT:    [[TMP1:%.*]] = mul i8 [[X:%.*]], -42
+; CHECK-NEXT:    [[BO:%.*]] = insertelement <3 x i8> <i8 0, i8 undef, i8 undef>, i8 [[TMP1]], i32 2
 ; CHECK-NEXT:    ret <3 x i8> [[BO]]
 ;
   %ins = insertelement <3 x i8> undef, i8 %x, i32 2
   %bo = mul <3 x i8> %ins, <i8 42, i8 undef, i8 -42>
   ret <3 x i8> %bo
 }
 
 define <2 x i8> @shl_constant_op0(i8 %x) {
 ; CHECK-LABEL: @shl_constant_op0(
-; CHECK-NEXT:    [[INS:%.*]] = insertelement <2 x i8> undef, i8 [[X:%.*]], i32 1
-; CHECK-NEXT:    [[BO:%.*]] = shl <2 x i8> <i8 undef, i8 2>, [[INS]]
+; CHECK-NEXT:    [[TMP1:%.*]] = shl i8 2, [[X:%.*]]
+; CHECK-NEXT:    [[BO:%.*]] = insertelement <2 x i8> undef, i8 [[TMP1]], i32 1
 ; CHECK-NEXT:    ret <2 x i8> [[BO]]
 ;
   %ins = insertelement <2 x i8> undef, i8 %x, i32 1
   %bo = shl <2 x i8> <i8 undef, i8 2>, %ins
   ret <2 x i8> %bo
 }
 
 define <2 x i8> @shl_constant_op0_not_undef_lane(i8 %x) {
 ; CHECK-LABEL: @shl_constant_op0_not_undef_lane(
-; CHECK-NEXT:    [[INS:%.*]] = insertelement <2 x i8> undef, i8 [[X:%.*]], i32 1
-; CHECK-NEXT:    [[BO:%.*]] = shl <2 x i8> <i8 5, i8 2>, [[INS]]
+; CHECK-NEXT:    [[TMP1:%.*]] = shl i8 2, [[X:%.*]]
+; CHECK-NEXT:    [[BO:%.*]] = insertelement <2 x i8> undef, i8 [[TMP1]], i32 1
 ; CHECK-NEXT:    ret <2 x i8> [[BO]]
 ;
   %ins = insertelement <2 x i8> undef, i8 %x, i32 1
   %bo = shl <2 x i8> <i8 5, i8 2>, %ins
   ret <2 x i8> %bo
 }
 
 define <2 x i8> @shl_constant_op1(i8 %x) {
 ; CHECK-LABEL: @shl_constant_op1(
-; CHECK-NEXT:    [[INS:%.*]] = insertelement <2 x i8> undef, i8 [[X:%.*]], i32 0
-; CHECK-NEXT:    [[BO:%.*]] = shl nuw <2 x i8> [[INS]], <i8 5, i8 undef>
+; CHECK-NEXT:    [[TMP1:%.*]] = shl nuw i8 [[X:%.*]], 5
+; CHECK-NEXT:    [[BO:%.*]] = insertelement <2 x i8> undef, i8 [[TMP1]], i32 0
 ; CHECK-NEXT:    ret <2 x i8> [[BO]]
 ;
   %ins = insertelement <2 x i8> undef, i8 %x, i32 0
   %bo = shl nuw <2 x i8> %ins, <i8 5, i8 undef>
   ret <2 x i8> %bo
 }
 
 define <2 x i8> @shl_constant_op1_not_undef_lane(i8 %x) {
 ; CHECK-LABEL: @shl_constant_op1_not_undef_lane(
-; CHECK-NEXT:    [[INS:%.*]] = insertelement <2 x i8> undef, i8 [[X:%.*]], i32 0
-; CHECK-NEXT:    [[BO:%.*]] = shl nuw <2 x i8> [[INS]], <i8 5, i8 2>
+; CHECK-NEXT:    [[TMP1:%.*]] = shl nuw i8 [[X:%.*]], 5
+; CHECK-NEXT:    [[BO:%.*]] = insertelement <2 x i8> <i8 undef, i8 0>, i8 [[TMP1]], i32 0
 ; CHECK-NEXT:    ret <2 x i8> [[BO]]
 ;
   %ins = insertelement <2 x i8> undef, i8 %x, i32 0
   %bo = shl nuw <2 x i8> %ins, <i8 5, i8 2>
   ret <2 x i8> %bo
 }
 
 define <2 x i8> @ashr_constant_op0(i8 %x) {
 ; CHECK-LABEL: @ashr_constant_op0(
-; CHECK-NEXT:    [[INS:%.*]] = insertelement <2 x i8> undef, i8 [[X:%.*]], i32 1
-; CHECK-NEXT:    [[BO:%.*]] = ashr exact <2 x i8> <i8 undef, i8 2>, [[INS]]
+; CHECK-NEXT:    [[TMP1:%.*]] = lshr i8 2, [[X:%.*]]
+; CHECK-NEXT:    [[BO:%.*]] = insertelement <2 x i8> undef, i8 [[TMP1]], i32 1
 ; CHECK-NEXT:    ret <2 x i8> [[BO]]
 ;
   %ins = insertelement <2 x i8> undef, i8 %x, i32 1
   %bo = ashr exact <2 x i8> <i8 undef, i8 2>, %ins
   ret <2 x i8> %bo
 }
 
 define <2 x i8> @ashr_constant_op0_not_undef_lane(i8 %x) {
 ; CHECK-LABEL: @ashr_constant_op0_not_undef_lane(
-; CHECK-NEXT:    [[INS:%.*]] = insertelement <2 x i8> undef, i8 [[X:%.*]], i32 1
-; CHECK-NEXT:    [[BO:%.*]] = lshr <2 x i8> <i8 5, i8 2>, [[INS]]
+; CHECK-NEXT:    [[TMP1:%.*]] = lshr i8 2, [[X:%.*]]
+; CHECK-NEXT:    [[BO:%.*]] = insertelement <2 x i8> undef, i8 [[TMP1]], i32 1
 ; CHECK-NEXT:    ret <2 x i8> [[BO]]
 ;
   %ins = insertelement <2 x i8> undef, i8 %x, i32 1
   %bo = ashr exact <2 x i8> <i8 5, i8 2>, %ins
   ret <2 x i8> %bo
 }
 
 define <2 x i8> @ashr_constant_op1(i8 %x) {
 ; CHECK-LABEL: @ashr_constant_op1(
-; CHECK-NEXT:    [[INS:%.*]] = insertelement <2 x i8> undef, i8 [[X:%.*]], i32 0
-; CHECK-NEXT:    [[BO:%.*]] = ashr <2 x i8> [[INS]], <i8 5, i8 undef>
+; CHECK-NEXT:    [[TMP1:%.*]] = ashr i8 [[X:%.*]], 5
+; CHECK-NEXT:    [[BO:%.*]] = insertelement <2 x i8> undef, i8 [[TMP1]], i32 0
 ; CHECK-NEXT:    ret <2 x i8> [[BO]]
 ;
   %ins = insertelement <2 x i8> undef, i8 %x, i32 0
   %bo = ashr <2 x i8> %ins, <i8 5, i8 undef>
   ret <2 x i8> %bo
 }
 
 define <2 x i8> @ashr_constant_op1_not_undef_lane(i8 %x) {
 ; CHECK-LABEL: @ashr_constant_op1_not_undef_lane(
-; CHECK-NEXT:    [[INS:%.*]] = insertelement <2 x i8> undef, i8 [[X:%.*]], i32 0
-; CHECK-NEXT:    [[BO:%.*]] = ashr <2 x i8> [[INS]], <i8 5, i8 2>
+; CHECK-NEXT:    [[TMP1:%.*]] = ashr i8 [[X:%.*]], 5
+; CHECK-NEXT:    [[BO:%.*]] = insertelement <2 x i8> <i8 undef, i8 0>, i8 [[TMP1]], i32 0
 ; CHECK-NEXT:    ret <2 x i8> [[BO]]
 ;
   %ins = insertelement <2 x i8> undef, i8 %x, i32 0
   %bo = ashr <2 x i8> %ins, <i8 5, i8 2>
   ret <2 x i8> %bo
 }
 
 define <2 x i8> @lshr_constant_op0(i8 %x) {
 ; CHECK-LABEL: @lshr_constant_op0(
-; CHECK-NEXT:    [[INS:%.*]] = insertelement <2 x i8> undef, i8 [[X:%.*]], i32 0
-; CHECK-NEXT:    [[BO:%.*]] = lshr <2 x i8> <i8 5, i8 undef>, [[INS]]
+; CHECK-NEXT:    [[TMP1:%.*]] = lshr i8 5, [[X:%.*]]
+; CHECK-NEXT:    [[BO:%.*]] = insertelement <2 x i8> undef, i8 [[TMP1]], i32 0
 ; CHECK-NEXT:    ret <2 x i8> [[BO]]
 ;
   %ins = insertelement <2 x i8> undef, i8 %x, i32 0
   %bo = lshr <2 x i8> <i8 5, i8 undef>, %ins
   ret <2 x i8> %bo
 }
 
 define <2 x i8> @lshr_constant_op0_not_undef_lane(i8 %x) {
 ; CHECK-LABEL: @lshr_constant_op0_not_undef_lane(
-; CHECK-NEXT:    [[INS:%.*]] = insertelement <2 x i8> undef, i8 [[X:%.*]], i32 0
-; CHECK-NEXT:    [[BO:%.*]] = lshr <2 x i8> <i8 5, i8 2>, [[INS]]
+; CHECK-NEXT:    [[TMP1:%.*]] = lshr i8 5, [[X:%.*]]
+; CHECK-NEXT:    [[BO:%.*]] = insertelement <2 x i8> undef, i8 [[TMP1]], i32 0
 ; CHECK-NEXT:    ret <2 x i8> [[BO]]
 ;
   %ins = insertelement <2 x i8> undef, i8 %x, i32 0
   %bo = lshr <2 x i8> <i8 5, i8 2>, %ins
   ret <2 x i8> %bo
 }
 
 define <2 x i8> @lshr_constant_op1(i8 %x) {
 ; CHECK-LABEL: @lshr_constant_op1(
-; CHECK-NEXT:    [[INS:%.*]] = insertelement <2 x i8> undef, i8 [[X:%.*]], i32 1
-; CHECK-NEXT:    [[BO:%.*]] = lshr exact <2 x i8> [[INS]], <i8 undef, i8 2>
+; CHECK-NEXT:    [[TMP1:%.*]] = lshr exact i8 [[X:%.*]], 2
+; CHECK-NEXT:    [[BO:%.*]] = insertelement <2 x i8> undef, i8 [[TMP1]], i32 1
 ; CHECK-NEXT:    ret <2 x i8> [[BO]]
 ;
   %ins = insertelement <2 x i8> undef, i8 %x, i32 1
   %bo = lshr exact <2 x i8> %ins, <i8 undef, i8 2>
   ret <2 x i8> %bo
 }
 
 define <2 x i8> @lshr_constant_op1_not_undef_lane(i8 %x) {
 ; CHECK-LABEL: @lshr_constant_op1_not_undef_lane(
-; CHECK-NEXT:    [[INS:%.*]] = insertelement <2 x i8> undef, i8 [[X:%.*]], i32 1
-; CHECK-NEXT:    [[BO:%.*]] = lshr exact <2 x i8> [[INS]], <i8 5, i8 2>
+; CHECK-NEXT:    [[TMP1:%.*]] = lshr exact i8 [[X:%.*]], 2
+; CHECK-NEXT:    [[BO:%.*]] = insertelement <2 x i8> <i8 0, i8 undef>, i8 [[TMP1]], i32 1
 ; CHECK-NEXT:    ret <2 x i8> [[BO]]
 ;
   %ins = insertelement <2 x i8> undef, i8 %x, i32 1
   %bo = lshr exact <2 x i8> %ins, <i8 5, i8 2>
   ret <2 x i8> %bo
 }
 
 define <2 x i8> @urem_constant_op0(i8 %x) {
 ; CHECK-LABEL: @urem_constant_op0(
-; CHECK-NEXT:    [[INS:%.*]] = insertelement <2 x i8> undef, i8 [[X:%.*]], i32 0
-; CHECK-NEXT:    [[BO:%.*]] = urem <2 x i8> <i8 5, i8 undef>, [[INS]]
+; CHECK-NEXT:    [[TMP1:%.*]] = urem i8 5, [[X:%.*]]
+; CHECK-NEXT:    [[BO:%.*]] = insertelement <2 x i8> undef, i8 [[TMP1]], i32 0
 ; CHECK-NEXT:    ret <2 x i8> [[BO]]
 ;
   %ins = insertelement <2 x i8> undef, i8 %x, i32 0
   %bo = urem <2 x i8> <i8 5, i8 undef>, %ins
   ret <2 x i8> %bo
 }
 
 define <2 x i8> @urem_constant_op0_not_undef_lane(i8 %x) {
 ; CHECK-LABEL: @urem_constant_op0_not_undef_lane(
-; CHECK-NEXT:    [[INS:%.*]] = insertelement <2 x i8> undef, i8 [[X:%.*]], i32 0
-; CHECK-NEXT:    [[BO:%.*]] = urem <2 x i8> <i8 5, i8 2>, [[INS]]
+; CHECK-NEXT:    [[TMP1:%.*]] = urem i8 5, [[X:%.*]]
+; CHECK-NEXT:    [[BO:%.*]] = insertelement <2 x i8> undef, i8 [[TMP1]], i32 0
 ; CHECK-NEXT:    ret <2 x i8> [[BO]]
 ;
   %ins = insertelement <2 x i8> undef, i8 %x, i32 0
   %bo = urem <2 x i8> <i8 5, i8 2>, %ins
   ret <2 x i8> %bo
 }
 
 define <2 x i8> @urem_constant_op1(i8 %x) {
 ; CHECK-LABEL: @urem_constant_op1(
 ; CHECK-NEXT:    ret <2 x i8> undef
 ;
   %ins = insertelement <2 x i8> undef, i8 %x, i32 1
   %bo = urem <2 x i8> %ins, <i8 undef, i8 2>
   ret <2 x i8> %bo
 }
 
 define <2 x i8> @urem_constant_op1_not_undef_lane(i8 %x) {
 ; CHECK-LABEL: @urem_constant_op1_not_undef_lane(
-; CHECK-NEXT:    [[INS:%.*]] = insertelement <2 x i8> undef, i8 [[X:%.*]], i32 1
-; CHECK-NEXT:    [[BO:%.*]] = urem <2 x i8> [[INS]], <i8 5, i8 2>
+; CHECK-NEXT:    [[TMP1:%.*]] = and i8 [[X:%.*]], 1
+; CHECK-NEXT:    [[BO:%.*]] = insertelement <2 x i8> <i8 0, i8 undef>, i8 [[TMP1]], i32 1
 ; CHECK-NEXT:    ret <2 x i8> [[BO]]
 ;
   %ins = insertelement <2 x i8> undef, i8 %x, i32 1
   %bo = urem <2 x i8> %ins, <i8 5, i8 2>
   ret <2 x i8> %bo
 }
 
 define <2 x i8> @srem_constant_op0(i8 %x) {
 ; CHECK-LABEL: @srem_constant_op0(
-; CHECK-NEXT:    [[INS:%.*]] = insertelement <2 x i8> undef, i8 [[X:%.*]], i32 0
-; CHECK-NEXT:    [[BO:%.*]] = srem <2 x i8> <i8 5, i8 undef>, [[INS]]
+; CHECK-NEXT:    [[TMP1:%.*]] = srem i8 5, [[X:%.*]]
+; CHECK-NEXT:    [[BO:%.*]] = insertelement <2 x i8> undef, i8 [[TMP1]], i32 0
 ; CHECK-NEXT:    ret <2 x i8> [[BO]]
 ;
   %ins = insertelement <2 x i8> undef, i8 %x, i32 0
   %bo = srem <2 x i8> <i8 5, i8 undef>, %ins
   ret <2 x i8> %bo
 }
 
 define <2 x i8> @srem_constant_op0_not_undef_lane(i8 %x) {
 ; CHECK-LABEL: @srem_constant_op0_not_undef_lane(
-; CHECK-NEXT:    [[INS:%.*]] = insertelement <2 x i8> undef, i8 [[X:%.*]], i32 0
-; CHECK-NEXT:    [[BO:%.*]] = srem <2 x i8> <i8 5, i8 2>, [[INS]]
+; CHECK-NEXT:    [[TMP1:%.*]] = srem i8 5, [[X:%.*]]
+; CHECK-NEXT:    [[BO:%.*]] = insertelement <2 x i8> undef, i8 [[TMP1]], i32 0
 ; CHECK-NEXT:    ret <2 x i8> [[BO]]
 ;
   %ins = insertelement <2 x i8> undef, i8 %x, i32 0
   %bo = srem <2 x i8> <i8 5, i8 2>, %ins
   ret <2 x i8> %bo
 }
 
 define <2 x i8> @srem_constant_op1(i8 %x) {
 ; CHECK-LABEL: @srem_constant_op1(
 ; CHECK-NEXT:    ret <2 x i8> undef
 ;
   %ins = insertelement <2 x i8> undef, i8 %x, i32 1
   %bo = srem <2 x i8> %ins, <i8 undef, i8 2>
   ret <2 x i8> %bo
 }
 
 define <2 x i8> @srem_constant_op1_not_undef_lane(i8 %x) {
 ; CHECK-LABEL: @srem_constant_op1_not_undef_lane(
-; CHECK-NEXT:    [[INS:%.*]] = insertelement <2 x i8> undef, i8 [[X:%.*]], i32 1
-; CHECK-NEXT:    [[BO:%.*]] = srem <2 x i8> [[INS]], <i8 5, i8 2>
+; CHECK-NEXT:    [[TMP1:%.*]] = srem i8 [[X:%.*]], 2
+; CHECK-NEXT:    [[BO:%.*]] = insertelement <2 x i8> <i8 0, i8 undef>, i8 [[TMP1]], i32 1
 ; CHECK-NEXT:    ret <2 x i8> [[BO]]
 ;
   %ins = insertelement <2 x i8> undef, i8 %x, i32 1
   %bo = srem <2 x i8> %ins, <i8 5, i8 2>
   ret <2 x i8> %bo
 }
 
 define <2 x i8> @udiv_constant_op0(i8 %x) {
 ; CHECK-LABEL: @udiv_constant_op0(
-; CHECK-NEXT:    [[INS:%.*]] = insertelement <2 x i8> undef, i8 [[X:%.*]], i32 0
-; CHECK-NEXT:    [[BO:%.*]] = udiv exact <2 x i8> <i8 5, i8 undef>, [[INS]]
+; CHECK-NEXT:    [[TMP1:%.*]] = udiv exact i8 5, [[X:%.*]]
+; CHECK-NEXT:    [[BO:%.*]] = insertelement <2 x i8> undef, i8 [[TMP1]], i32 0
 ; CHECK-NEXT:    ret <2 x i8> [[BO]]
 ;
   %ins = insertelement <2 x i8> undef, i8 %x, i32 0
   %bo = udiv exact <2 x i8> <i8 5, i8 undef>, %ins
   ret <2 x i8> %bo
 }
 
 define <2 x i8> @udiv_constant_op0_not_undef_lane(i8 %x) {
 ; CHECK-LABEL: @udiv_constant_op0_not_undef_lane(
-; CHECK-NEXT:    [[INS:%.*]] = insertelement <2 x i8> undef, i8 [[X:%.*]], i32 0
-; CHECK-NEXT:    [[BO:%.*]] = udiv exact <2 x i8> <i8 5, i8 2>, [[INS]]
+; CHECK-NEXT:    [[TMP1:%.*]] = udiv exact i8 5, [[X:%.*]]
+; CHECK-NEXT:    [[BO:%.*]] = insertelement <2 x i8> undef, i8 [[TMP1]], i32 0
 ; CHECK-NEXT:    ret <2 x i8> [[BO]]
 ;
   %ins = insertelement <2 x i8> undef, i8 %x, i32 0
   %bo = udiv exact <2 x i8> <i8 5, i8 2>, %ins
   ret <2 x i8> %bo
 }
 
 define <2 x i8> @udiv_constant_op1(i8 %x) {
 ; CHECK-LABEL: @udiv_constant_op1(
 ; CHECK-NEXT:    ret <2 x i8> undef
 ;
   %ins = insertelement <2 x i8> undef, i8 %x, i32 1
   %bo = udiv <2 x i8> %ins, <i8 undef, i8 2>
   ret <2 x i8> %bo
 }
 
 define <2 x i8> @udiv_constant_op1_not_undef_lane(i8 %x) {
 ; CHECK-LABEL: @udiv_constant_op1_not_undef_lane(
-; CHECK-NEXT:    [[INS:%.*]] = insertelement <2 x i8> undef, i8 [[X:%.*]], i32 1
-; CHECK-NEXT:    [[BO:%.*]] = udiv <2 x i8> [[INS]], <i8 5, i8 2>
+; CHECK-NEXT:    [[TMP1:%.*]] = lshr i8 [[X:%.*]], 1
+; CHECK-NEXT:    [[BO:%.*]] = insertelement <2 x i8> <i8 0, i8 undef>, i8 [[TMP1]], i32 1
 ; CHECK-NEXT:    ret <2 x i8> [[BO]]
 ;
   %ins = insertelement <2 x i8> undef, i8 %x, i32 1
   %bo = udiv <2 x i8> %ins, <i8 5, i8 2>
   ret <2 x i8> %bo
 }
 
 define <2 x i8> @sdiv_constant_op0(i8 %x) {
 ; CHECK-LABEL: @sdiv_constant_op0(
-; CHECK-NEXT:    [[INS:%.*]] = insertelement <2 x i8> undef, i8 [[X:%.*]], i32 0
-; CHECK-NEXT:    [[BO:%.*]] = sdiv <2 x i8> <i8 5, i8 undef>, [[INS]]
+; CHECK-NEXT:    [[TMP1:%.*]] = sdiv i8 5, [[X:%.*]]
+; CHECK-NEXT:    [[BO:%.*]] = insertelement <2 x i8> undef, i8 [[TMP1]], i32 0
 ; CHECK-NEXT:    ret <2 x i8> [[BO]]
 ;
   %ins = insertelement <2 x i8> undef, i8 %x, i32 0
   %bo = sdiv <2 x i8> <i8 5, i8 undef>, %ins
   ret <2 x i8> %bo
 }
 
 define <2 x i8> @sdiv_constant_op0_not_undef_lane(i8 %x) {
 ; CHECK-LABEL: @sdiv_constant_op0_not_undef_lane(
-; CHECK-NEXT:    [[INS:%.*]] = insertelement <2 x i8> undef, i8 [[X:%.*]], i32 0
-; CHECK-NEXT:    [[BO:%.*]] = sdiv <2 x i8> <i8 5, i8 2>, [[INS]]
+; CHECK-NEXT:    [[TMP1:%.*]] = sdiv i8 5, [[X:%.*]]
+; CHECK-NEXT:    [[BO:%.*]] = insertelement <2 x i8> undef, i8 [[TMP1]], i32 0
 ; CHECK-NEXT:    ret <2 x i8> [[BO]]
 ;
   %ins = insertelement <2 x i8> undef, i8 %x, i32 0
   %bo = sdiv <2 x i8> <i8 5, i8 2>, %ins
   ret <2 x i8> %bo
 }
 
 define <2 x i8> @sdiv_constant_op1(i8 %x) {
 ; CHECK-LABEL: @sdiv_constant_op1(
 ; CHECK-NEXT:    ret <2 x i8> undef
 ;
   %ins = insertelement <2 x i8> undef, i8 %x, i32 1
   %bo = sdiv exact <2 x i8> %ins, <i8 undef, i8 2>
   ret <2 x i8> %bo
 }
 
 define <2 x i8> @sdiv_constant_op1_not_undef_lane(i8 %x) {
 ; CHECK-LABEL: @sdiv_constant_op1_not_undef_lane(
-; CHECK-NEXT:    [[INS:%.*]] = insertelement <2 x i8> undef, i8 [[X:%.*]], i32 1
-; CHECK-NEXT:    [[BO:%.*]] = sdiv exact <2 x i8> [[INS]], <i8 5, i8 2>
+; CHECK-NEXT:    [[TMP1:%.*]] = ashr exact i8 [[X:%.*]], 1
+; CHECK-NEXT:    [[BO:%.*]] = insertelement <2 x i8> <i8 0, i8 undef>, i8 [[TMP1]], i32 1
 ; CHECK-NEXT:    ret <2 x i8> [[BO]]
 ;
   %ins = insertelement <2 x i8> undef, i8 %x, i32 1
   %bo = sdiv exact <2 x i8> %ins, <i8 5, i8 2>
   ret <2 x i8> %bo
 }
 
 define <2 x i8> @and_constant(i8 %x) {
 ; CHECK-LABEL: @and_constant(
-; CHECK-NEXT:    [[INS:%.*]] = insertelement <2 x i8> undef, i8 [[X:%.*]], i32 0
-; CHECK-NEXT:    [[BO:%.*]] = and <2 x i8> [[INS]], <i8 42, i8 undef>
+; CHECK-NEXT:    [[TMP1:%.*]] = and i8 [[X:%.*]], 42
+; CHECK-NEXT:    [[BO:%.*]] = insertelement <2 x i8> undef, i8 [[TMP1]], i32 0
 ; CHECK-NEXT:    ret <2 x i8> [[BO]]
 ;
   %ins = insertelement <2 x i8> undef, i8 %x, i32 0
   %bo = and <2 x i8> %ins, <i8 42, i8 undef>
   ret <2 x i8> %bo
 }
 
 define <2 x i8> @and_constant_not_undef_lane(i8 %x) {
 ; CHECK-LABEL: @and_constant_not_undef_lane(
-; CHECK-NEXT:    [[INS:%.*]] = insertelement <2 x i8> undef, i8 [[X:%.*]], i32 0
-; CHECK-NEXT:    [[BO:%.*]] = and <2 x i8> [[INS]], <i8 42, i8 -42>
+; CHECK-NEXT:    [[TMP1:%.*]] = and i8 [[X:%.*]], 42
+; CHECK-NEXT:    [[BO:%.*]] = insertelement <2 x i8> <i8 undef, i8 0>, i8 [[TMP1]], i32 0
 ; CHECK-NEXT:    ret <2 x i8> [[BO]]
 ;
   %ins = insertelement <2 x i8> undef, i8 %x, i32 0
   %bo = and <2 x i8> %ins, <i8 42, i8 -42>
   ret <2 x i8> %bo
 }
 
 define <2 x i8> @or_constant(i8 %x) {
 ; CHECK-LABEL: @or_constant(
-; CHECK-NEXT:    [[INS:%.*]] = insertelement <2 x i8> undef, i8 [[X:%.*]], i32 1
-; CHECK-NEXT:    [[BO:%.*]] = or <2 x i8> [[INS]], <i8 undef, i8 -42>
+; CHECK-NEXT:    [[TMP1:%.*]] = or i8 [[X:%.*]], -42
+; CHECK-NEXT:    [[BO:%.*]] = insertelement <2 x i8> undef, i8 [[TMP1]], i32 1
 ; CHECK-NEXT:    ret <2 x i8> [[BO]]
 ;
   %ins = insertelement <2 x i8> undef, i8 %x, i32 1
   %bo = or <2 x i8> %ins, <i8 undef, i8 -42>
   ret <2 x i8> %bo
 }
 
 define <2 x i8> @or_constant_not_undef_lane(i8 %x) {
 ; CHECK-LABEL: @or_constant_not_undef_lane(
-; CHECK-NEXT:    [[INS:%.*]] = insertelement <2 x i8> undef, i8 [[X:%.*]], i32 1
-; CHECK-NEXT:    [[BO:%.*]] = or <2 x i8> [[INS]], <i8 42, i8 -42>
+; CHECK-NEXT:    [[TMP1:%.*]] = or i8 [[X:%.*]], -42
+; CHECK-NEXT:    [[BO:%.*]] = insertelement <2 x i8> <i8 -1, i8 undef>, i8 [[TMP1]], i32 1
 ; CHECK-NEXT:    ret <2 x i8> [[BO]]
 ;
   %ins = insertelement <2 x i8> undef, i8 %x, i32 1
   %bo = or <2 x i8> %ins, <i8 42, i8 -42>
   ret <2 x i8> %bo
 }
 
 define <2 x i8> @xor_constant(i8 %x) {
 ; CHECK-LABEL: @xor_constant(
-; CHECK-NEXT:    [[INS:%.*]] = insertelement <2 x i8> undef, i8 [[X:%.*]], i32 0
-; CHECK-NEXT:    [[BO:%.*]] = xor <2 x i8> [[INS]], <i8 42, i8 undef>
+; CHECK-NEXT:    [[TMP1:%.*]] = xor i8 [[X:%.*]], 42
+; CHECK-NEXT:    [[BO:%.*]] = insertelement <2 x i8> <i8 undef, i8 0>, i8 [[TMP1]], i32 0
 ; CHECK-NEXT:    ret <2 x i8> [[BO]]
 ;
   %ins = insertelement <2 x i8> undef, i8 %x, i32 0
   %bo = xor <2 x i8> %ins, <i8 42, i8 undef>
   ret <2 x i8> %bo
 }
 
 define <2 x i8> @xor_constant_not_undef_lane(i8 %x) {
 ; CHECK-LABEL: @xor_constant_not_undef_lane(
-; CHECK-NEXT:    [[INS:%.*]] = insertelement <2 x i8> undef, i8 [[X:%.*]], i32 0
-; CHECK-NEXT:    [[BO:%.*]] = xor <2 x i8> [[INS]], <i8 42, i8 -42>
+; CHECK-NEXT:    [[TMP1:%.*]] = xor i8 [[X:%.*]], 42
+; CHECK-NEXT:    [[BO:%.*]] = insertelement <2 x i8> undef, i8 [[TMP1]], i32 0
 ; CHECK-NEXT:    ret <2 x i8> [[BO]]
 ;
   %ins = insertelement <2 x i8> undef, i8 %x, i32 0
   %bo = xor <2 x i8> %ins, <i8 42, i8 -42>
   ret <2 x i8> %bo
 }
 
 define <2 x float> @fadd_constant(float %x) {
 ; CHECK-LABEL: @fadd_constant(
-; CHECK-NEXT:    [[INS:%.*]] = insertelement <2 x float> undef, float [[X:%.*]], i32 0
-; CHECK-NEXT:    [[BO:%.*]] = fadd <2 x float> [[INS]], <float 4.200000e+01, float undef>
+; CHECK-NEXT:    [[TMP1:%.*]] = fadd float [[X:%.*]], 4.200000e+01
+; CHECK-NEXT:    [[BO:%.*]] = insertelement <2 x float> undef, float [[TMP1]], i32 0
 ; CHECK-NEXT:    ret <2 x float> [[BO]]
 ;
   %ins = insertelement <2 x float> undef, float %x, i32 0
   %bo = fadd <2 x float> %ins, <float 42.0, float undef>
   ret <2 x float> %bo
 }
 
 define <2 x float> @fadd_constant_not_undef_lane(float %x) {
 ; CHECK-LABEL: @fadd_constant_not_undef_lane(
-; CHECK-NEXT:    [[INS:%.*]] = insertelement <2 x float> undef, float [[X:%.*]], i32 1
-; CHECK-NEXT:    [[BO:%.*]] = fadd <2 x float> [[INS]], <float 4.200000e+01, float -4.200000e+01>
+; CHECK-NEXT:    [[TMP1:%.*]] = fadd float [[X:%.*]], -4.200000e+01
+; CHECK-NEXT:    [[BO:%.*]] = insertelement <2 x float> <float 0x7FF8000000000000, float undef>, float [[TMP1]], i32 1
 ; CHECK-NEXT:    ret <2 x float> [[BO]]
 ;
   %ins = insertelement <2 x float> undef, float %x, i32 1
   %bo = fadd <2 x float> %ins, <float 42.0, float -42.0>
   ret <2 x float> %bo
 }
 
 define <2 x float> @fsub_constant_op0(float %x) {
 ; CHECK-LABEL: @fsub_constant_op0(
-; CHECK-NEXT:    [[INS:%.*]] = insertelement <2 x float> undef, float [[X:%.*]], i32 0
-; CHECK-NEXT:    [[BO:%.*]] = fsub fast <2 x float> <float 4.200000e+01, float undef>, [[INS]]
+; CHECK-NEXT:    [[TMP1:%.*]] = fsub fast float 4.200000e+01, [[X:%.*]]
+; CHECK-NEXT:    [[BO:%.*]] = insertelement <2 x float> undef, float [[TMP1]], i32 0
 ; CHECK-NEXT:    ret <2 x float> [[BO]]
 ;
   %ins = insertelement <2 x float> undef, float %x, i32 0
   %bo = fsub fast <2 x float> <float 42.0, float undef>, %ins
   ret <2 x float> %bo
 }
 
 define <2 x float> @fsub_constant_op0_not_undef_lane(float %x) {
 ; CHECK-LABEL: @fsub_constant_op0_not_undef_lane(
-; CHECK-NEXT:    [[INS:%.*]] = insertelement <2 x float> undef, float [[X:%.*]], i32 1
-; CHECK-NEXT:    [[BO:%.*]] = fsub nsz <2 x float> <float 4.200000e+01, float -4.200000e+01>, [[INS]]
+; CHECK-NEXT:    [[TMP1:%.*]] = fsub nsz float -4.200000e+01, [[X:%.*]]
+; CHECK-NEXT:    [[BO:%.*]] = insertelement <2 x float> <float 0x7FF8000000000000, float undef>, float [[TMP1]], i32 1
 ; CHECK-NEXT:    ret <2 x float> [[BO]]
 ;
   %ins = insertelement <2 x float> undef, float %x, i32 1
   %bo = fsub nsz <2 x float> <float 42.0, float -42.0>, %ins
   ret <2 x float> %bo
 }
 
 define <2 x float> @fsub_constant_op1(float %x) {
 ; CHECK-LABEL: @fsub_constant_op1(
-; CHECK-NEXT:    [[INS:%.*]] = insertelement <2 x float> undef, float [[X:%.*]], i32 1
-; CHECK-NEXT:    [[BO:%.*]] = fadd <2 x float> [[INS]], <float 0x7FF8000000000000, float -4.200000e+01>
+; CHECK-NEXT:    [[TMP1:%.*]] = fadd float [[X:%.*]], -4.200000e+01
+; CHECK-NEXT:    [[BO:%.*]] = insertelement <2 x float> undef, float [[TMP1]], i32 1
 ; CHECK-NEXT:    ret <2 x float> [[BO]]
 ;
   %ins = insertelement <2 x float> undef, float %x, i32 1
   %bo = fsub <2 x float> %ins, <float undef, float 42.0>
   ret <2 x float> %bo
 }
 
 define <2 x float> @fsub_constant_op1_not_undef_lane(float %x) {
 ; CHECK-LABEL: @fsub_constant_op1_not_undef_lane(
-; CHECK-NEXT:    [[INS:%.*]] = insertelement <2 x float> undef, float [[X:%.*]], i32 0
-; CHECK-NEXT:    [[BO:%.*]] = fadd <2 x float> [[INS]], <float -4.200000e+01, float 4.200000e+01>
+; CHECK-NEXT:    [[TMP1:%.*]] = fadd float [[X:%.*]], -4.200000e+01
+; CHECK-NEXT:    [[BO:%.*]] = insertelement <2 x float> <float undef, float 0x7FF8000000000000>, float [[TMP1]], i32 0
 ; CHECK-NEXT:    ret <2 x float> [[BO]]
 ;
   %ins = insertelement <2 x float> undef, float %x, i32 0
   %bo = fsub <2 x float> %ins, <float 42.0, float -42.0>
   ret <2 x float> %bo
 }
 
 define <2 x float> @fmul_constant(float %x) {
 ; CHECK-LABEL: @fmul_constant(
-; CHECK-NEXT:    [[INS:%.*]] = insertelement <2 x float> undef, float [[X:%.*]], i32 0
-; CHECK-NEXT:    [[BO:%.*]] = fmul reassoc <2 x float> [[INS]], <float 4.200000e+01, float undef>
+; CHECK-NEXT:    [[TMP1:%.*]] = fmul reassoc float [[X:%.*]], 4.200000e+01
+; CHECK-NEXT:    [[BO:%.*]] = insertelement <2 x float> undef, float [[TMP1]], i32 0
 ; CHECK-NEXT:    ret <2 x float> [[BO]]
 ;
   %ins = insertelement <2 x float> undef, float %x, i32 0
   %bo = fmul reassoc <2 x float> %ins, <float 42.0, float undef>
   ret <2 x float> %bo
 }
 
 define <2 x float> @fmul_constant_not_undef_lane(float %x) {
 ; CHECK-LABEL: @fmul_constant_not_undef_lane(
-; CHECK-NEXT:    [[INS:%.*]] = insertelement <2 x float> undef, float [[X:%.*]], i32 1
-; CHECK-NEXT:    [[BO:%.*]] = fmul <2 x float> [[INS]], <float 4.200000e+01, float -4.200000e+01>
+; CHECK-NEXT:    [[TMP1:%.*]] = fmul float [[X:%.*]], -4.200000e+01
+; CHECK-NEXT:    [[BO:%.*]] = insertelement <2 x float> <float 0x7FF8000000000000, float undef>, float [[TMP1]], i32 1
 ; CHECK-NEXT:    ret <2 x float> [[BO]]
 ;
   %ins = insertelement <2 x float> undef, float %x, i32 1
   %bo = fmul <2 x float> %ins, <float 42.0, float -42.0>
   ret <2 x float> %bo
 }
 
 define <2 x float> @fdiv_constant_op0(float %x) {
 ; CHECK-LABEL: @fdiv_constant_op0(
-; CHECK-NEXT:    [[INS:%.*]] = insertelement <2 x float> undef, float [[X:%.*]], i32 1
-; CHECK-NEXT:    [[BO:%.*]] = fdiv nnan <2 x float> <float undef, float 4.200000e+01>, [[INS]]
+; CHECK-NEXT:    [[TMP1:%.*]] = fdiv nnan float 4.200000e+01, [[X:%.*]]
+; CHECK-NEXT:    [[BO:%.*]] = insertelement <2 x float> undef, float [[TMP1]], i32 1
 ; CHECK-NEXT:    ret <2 x float> [[BO]]
 ;
   %ins = insertelement <2 x float> undef, float %x, i32 1
   %bo = fdiv nnan <2 x float> <float undef, float 42.0>, %ins
   ret <2 x float> %bo
 }
 
 define <2 x float> @fdiv_constant_op0_not_undef_lane(float %x) {
 ; CHECK-LABEL: @fdiv_constant_op0_not_undef_lane(
-; CHECK-NEXT:    [[INS:%.*]] = insertelement <2 x float> undef, float [[X:%.*]], i32 0
-; CHECK-NEXT:    [[BO:%.*]] = fdiv ninf <2 x float> <float 4.200000e+01, float -4.200000e+01>, [[INS]]
+; CHECK-NEXT:    [[TMP1:%.*]] = fdiv ninf float 4.200000e+01, [[X:%.*]]
+; CHECK-NEXT:    [[BO:%.*]] = insertelement <2 x float> <float undef, float 0x7FF8000000000000>, float [[TMP1]], i32 0
 ; CHECK-NEXT:    ret <2 x float> [[BO]]
 ;
   %ins = insertelement <2 x float> undef, float %x, i32 0
   %bo = fdiv ninf <2 x float> <float 42.0, float -42.0>, %ins
   ret <2 x float> %bo
 }
 
 define <2 x float> @fdiv_constant_op1(float %x) {
 ; CHECK-LABEL: @fdiv_constant_op1(
-; CHECK-NEXT:    [[INS:%.*]] = insertelement <2 x float> undef, float [[X:%.*]], i32 0
-; CHECK-NEXT:    [[BO:%.*]] = fdiv <2 x float> [[INS]], <float 4.200000e+01, float undef>
+; CHECK-NEXT:    [[TMP1:%.*]] = fdiv float [[X:%.*]], 4.200000e+01
+; CHECK-NEXT:    [[BO:%.*]] = insertelement <2 x float> undef, float [[TMP1]], i32 0
 ; CHECK-NEXT:    ret <2 x float> [[BO]]
 ;
   %ins = insertelement <2 x float> undef, float %x, i32 0
   %bo = fdiv <2 x float> %ins, <float 42.0, float undef>
   ret <2 x float> %bo
 }
 
 define <2 x float> @fdiv_constant_op1_not_undef_lane(float %x) {
 ; CHECK-LABEL: @fdiv_constant_op1_not_undef_lane(
-; CHECK-NEXT:    [[INS:%.*]] = insertelement <2 x float> undef, float [[X:%.*]], i32 0
-; CHECK-NEXT:    [[BO:%.*]] = fdiv <2 x float> [[INS]], <float 4.200000e+01, float -4.200000e+01>
+; CHECK-NEXT:    [[TMP1:%.*]] = fdiv float [[X:%.*]], 4.200000e+01
+; CHECK-NEXT:    [[BO:%.*]] = insertelement <2 x float> <float undef, float 0x7FF8000000000000>, float [[TMP1]], i32 0
 ; CHECK-NEXT:    ret <2 x float> [[BO]]
 ;
   %ins = insertelement <2 x float> undef, float %x, i32 0
   %bo = fdiv <2 x float> %ins, <float 42.0, float -42.0>
   ret <2 x float> %bo
 }
 
 define <2 x float> @frem_constant_op0(float %x) {
 ; CHECK-LABEL: @frem_constant_op0(
-; CHECK-NEXT:    [[INS:%.*]] = insertelement <2 x float> undef, float [[X:%.*]], i32 0
-; CHECK-NEXT:    [[BO:%.*]] = frem fast <2 x float> <float 4.200000e+01, float undef>, [[INS]]
+; CHECK-NEXT:    [[TMP1:%.*]] = frem fast float 4.200000e+01, [[X:%.*]]
+; CHECK-NEXT:    [[BO:%.*]] = insertelement <2 x float> undef, float [[TMP1]], i32 0
 ; CHECK-NEXT:    ret <2 x float> [[BO]]
 ;
   %ins = insertelement <2 x float> undef, float %x, i32 0
   %bo = frem fast <2 x float> <float 42.0, float undef>, %ins
   ret <2 x float> %bo
 }
 
 define <2 x float> @frem_constant_op0_not_undef_lane(float %x) {
 ; CHECK-LABEL: @frem_constant_op0_not_undef_lane(
-; CHECK-NEXT:    [[INS:%.*]] = insertelement <2 x float> undef, float [[X:%.*]], i32 1
-; CHECK-NEXT:    [[BO:%.*]] = frem <2 x float> <float 4.200000e+01, float -4.200000e+01>, [[INS]]
+; CHECK-NEXT:    [[TMP1:%.*]] = frem float -4.200000e+01, [[X:%.*]]
+; CHECK-NEXT:    [[BO:%.*]] = insertelement <2 x float> <float 0x7FF8000000000000, float undef>, float [[TMP1]], i32 1
 ; CHECK-NEXT:    ret <2 x float> [[BO]]
 ;
   %ins = insertelement <2 x float> undef, float %x, i32 1
   %bo = frem <2 x float> <float 42.0, float -42.0>, %ins
   ret <2 x float> %bo
 }
 
 define <2 x float> @frem_constant_op1(float %x) {
 ; CHECK-LABEL: @frem_constant_op1(
-; CHECK-NEXT:    [[INS:%.*]] = insertelement <2 x float> undef, float [[X:%.*]], i32 1
-; CHECK-NEXT:    [[BO:%.*]] = frem ninf <2 x float> [[INS]], <float undef, float 4.200000e+01>
+; CHECK-NEXT:    [[TMP1:%.*]] = frem ninf float [[X:%.*]], 4.200000e+01
+; CHECK-NEXT:    [[BO:%.*]] = insertelement <2 x float> undef, float [[TMP1]], i32 1
 ; CHECK-NEXT:    ret <2 x float> [[BO]]
 ;
   %ins = insertelement <2 x float> undef, float %x, i32 1
   %bo = frem ninf <2 x float> %ins, <float undef, float 42.0>
   ret <2 x float> %bo
 }
 
 define <2 x float> @frem_constant_op1_not_undef_lane(float %x) {
 ; CHECK-LABEL: @frem_constant_op1_not_undef_lane(
-; CHECK-NEXT:    [[INS:%.*]] = insertelement <2 x float> undef, float [[X:%.*]], i32 0
-; CHECK-NEXT:    [[BO:%.*]] = frem nnan <2 x float> [[INS]], <float 4.200000e+01, float -4.200000e+01>
+; CHECK-NEXT:    [[TMP1:%.*]] = frem nnan float [[X:%.*]], 4.200000e+01
+; CHECK-NEXT:    [[BO:%.*]] = insertelement <2 x float> <float undef, float 0x7FF8000000000000>, float [[TMP1]], i32 0
 ; CHECK-NEXT:    ret <2 x float> [[BO]]
 ;
   %ins = insertelement <2 x float> undef, float %x, i32 0
   %bo = frem nnan <2 x float> %ins, <float 42.0, float -42.0>
   ret <2 x float> %bo
 }