Allow binop C1, (select cc, CF, CT) -> select folding

[rampitec]

Summary

Previously this folding was done only if select is a first operand.
However, for non-commutative operations constant may go before
select.

[msearles]

LGTM

[rampitec]

Rebase.

[lebedev.ri]

Would be good to have additional small test for some other target (e.g. x86), too.

[rampitec]

In D48223#1134457, @lebedev.ri wrote:

Would be good to have additional small test for some other target (e.g. x86), too.

Sure. It turns out x86 needs it even more probably. I have created the test and it turns out both andl and orl were present before the patch.

[rampitec]

Added x86 test.
Updated amdgcn test.

[lebedev.ri]

test/CodeGen/X86/dagcombine-select.ll

1

Most tests (and practically all new x86 tests) use utils/update_llc_test_checks.py script to auto-generate these check lines.

3–17

Hm, is there some omitted instruction, or is this actually better than what we currently normally do?
https://godbolt.org/g/7ULPfH

[rampitec]

Updated x86 asm to contain full ISA.

[rampitec]

test/CodeGen/X86/dagcombine-select.ll

3–17

Yes. I have updated the test to contain the full ISA. First xor to zero out eax was omitted.
I am not sure what compiler explorer does, but that is what trunk llc has produced:

xorl    %eax, %eax
cmpl    $11, %edi
setl    %al
decl    %eax
andl    %esi, %eax
retq

I assume difference comes from running or not running opt.

[rampitec]

test/CodeGen/X86/dagcombine-select.ll

3–17

E.g. compare w/o opt: https://godbolt.org/g/NMZ9he

[lebedev.ri]

test/CodeGen/X86/dagcombine-select.ll

1

(not actually done, that does not look like the utility's output, and the first line does not say the script was used)

3–17

Ok, so the only difference is that the strictness of the comparison is inverted (cmovg vs cmovge and the other way around).

[rampitec]

test/CodeGen/X86/dagcombine-select.ll

1

Oops, sorry. Clicked wrong checkbox. Now updated.

3–17

Do you see "and eax, esi" instruction on the second from the right tab using my link? This one was eliminated.

In general if you run opt that is not an issue. If you run llc only (as in the test) you can see it. Normally that shall not happen, as I wrote in the description InstCombine can get rid of it. However, amdgcn can produce it during lowering and InstCombine does not play.

[rampitec]

Updated x86 test with utils/update_llc_test_checks.py

[lebedev.ri]

Sounds reasonable.

test/CodeGen/X86/dagcombine-select.ll

3–17

Of course.

I was only talking about comparing the llc(D48223) test/CodeGen/X86/dagcombine-select.ll with the opt(trunk) test/CodeGen/X86/dagcombine-select.ll | llc(trunk) output.

[xbolva00]

What about
(X / Y) != 0 -> X >= Y ?

(X, Y are unsigned)

[spatel]

lib/CodeGen/SelectionDAG/DAGCombiner.cpp

1883–1889

This change is independent of the and/or enhancement. We're now allowing folding when the binop has a constant operand 0. That seems like a good enhancement for non-commutative binops, but it should have its own tests using opcodes besides 'and'/'or' and be split into its own patch.

Example based on one of the original tests from rL296699:

define <2 x double> @sel_constants_fmul_constant_vec(i1 %cond) {
  %sel = select i1 %cond, <2 x double> <double -4.0, double 12.0>, <2 x double> <double 23.3, double 11.0>
  %bo = fsub <2 x double> <double 5.1, double 3.14>, %sel
  ret <2 x double> %bo
}

[rampitec]

In D48223#1134505, @xbolva00 wrote:

What about
(X / Y) != 0 -> X >= Y ?

(X, Y are unsigned)

This might be a good idea, but seems a separate change.

lib/CodeGen/SelectionDAG/DAGCombiner.cpp

1883–1889

I am not sure why this would be beneficial. For example:

sub (select 0, -1), x -> select (sub 0, x), (sub -1, x)
add (select 0, -1), x -> select x, (add -1, x)

In this case select would remain and two subs instead of one, seems worse.
For add both select and add would remain, so the benefit is not obvious.

In turn and/or have clear benefit in this change because binop completely goes away, and
In fact the same can be done to xor, but I have decided not to since xor would be needed anyway with a non-zero operand (and one would never have a select with both sizes zero).

[spatel]

lib/CodeGen/SelectionDAG/DAGCombiner.cpp

1883–1889

It's beneficial for exactly the same reason as the existing fold - we eliminate the binop. The fact that the case with constant operand 0 isn't already folded was just an oversight in the original patch.

Currently, this patch miscompiles on these cases, so we need more tests and a code change whether we treat that difference as part of this patch or not.

Here's a scalar example for Aarch64 in case it makes it easier to see:

define i32 @sel_constants_sub_constant_op0(i1 %cond) {
  %sel = select i1 %cond, i32 12, i32 42
  %bo = sub i32 500, %sel
  ret i32 %bo
}

Current codegen:

	tst	w0, #0x1
	mov	w8, #42
	orr	w9, wzr, #0xc
	csel	w8, w9, w8, ne
	mov	w9, #500
	sub	w0, w9, w8
	ret

And with this patch applied (miscompile):

	tst	w0, #0x1
	mov	w8, #-458  ; 500 - 42 != -458
	mov	w9, #-488  ; 500 - 12 != -488
	csel	w0, w9, w8, ne
	ret

[rampitec]

lib/CodeGen/SelectionDAG/DAGCombiner.cpp

1883–1889

Yes, there is a bug. I will fix it.

[rampitec]

lib/CodeGen/SelectionDAG/DAGCombiner.cpp

1883–1889

Thanks for catching this! The confusion on my side was about "constant operand 0". I have misread it as "constant zero" instead of "operand zero". I will update diff shortly.

[rampitec]

• Fixed handling of non-commutative operations if arguments are swapped.
• Added tests for non-commutative operations with all-const value.
• Retitled patch accordingly.

[spatel]

lib/CodeGen/SelectionDAG/DAGCombiner.cpp

1883–1889

Ah...I can see how that was confusing. :)

I think this patch is correct now, but let me make a couple of requests:

1. Commit the new PPC and x86 tests with assertions based on trunk (ie, without this patch applied). It's easier to review if we can see the before/after changes directly in this review. I'd do the same for the AMDGPU tests too, but I'm not qualified to review those diffs anyway.
2. Split the and/or enhancement into a follow-up patch. IIUC, that's independent of allowing the more flexible constant matching.

[rampitec]

lib/CodeGen/SelectionDAG/DAGCombiner.cpp

1883–1889

Will do. I will not do so with amdgpu tests as these are not autogenerated, but will do it with x86 and PPC.

[rampitec]

lib/CodeGen/SelectionDAG/DAGCombiner.cpp

1883–1889

Baseline tests committed https://reviews.llvm.org/rL334987

[rampitec]

Only commute part of the change.

[spatel]

lib/CodeGen/SelectionDAG/DAGCombiner.cpp

1904

Nit: I'd call this 'C' or 'CBO' or 'CBinOp' since it's not always operand 1 now.

1923–1924

When does this happen (is there a test)? Why does this only happen when the select is operand 1 of the binop? Better to remove the 'SelOpNo' condition to be safer?

[rampitec]

lib/CodeGen/SelectionDAG/DAGCombiner.cpp

1923–1924

That is if shift value and amount have different types. On x86 shift amount is i8 regardless of LHS. The new test shl_constant_sel_constants does not fold on x86 but does on amdgpu. W/o the check this test asserts. At the same time old test does work on x86 and folds correctly, so I think it is only needed if I have swapped operands. In general that should be possible to write a piece of code to create correct VT for shifts, but I'd better leave that to x86 folks. I guess range checking will be also needed if such a code is about to be written.

[rampitec]

• Added comment about shift VTs
• Renamed C1 into CBO

[rampitec]

Added x86 test for shifts with not reversed operands (as before the change).

[arsenm]

test/CodeGen/AMDGPU/dagcombine-select.ll

1

Use an i16 target for i16 tests

5

Some tests with i16 would be useful (as well as vectors)

[spatel]

lib/CodeGen/SelectionDAG/DAGCombiner.cpp

1923–1924

Thanks - that was my guess, and the TODO + test makes it clear.

LGTM, but get final approval from @arsenm once the AMDGPU tests are updated.

[rampitec]

Added some i16/f16/vector tests.

[arsenm]

LGTM

[rampitec]

lib/CodeGen/SelectionDAG/DAGCombiner.cpp

1923–1924

So @arsenm has reviewed the tests. @spatel it looks like your previous vote technically holds the review now. Can this be submitted?

[spatel]

LGTM.

lib/CodeGen/SelectionDAG/DAGCombiner.cpp

assert((BinOpcode == ISD::ADD || BinOpcode == ISD::SUB ||
           BinOpcode == ISD::UREM || BinOpcode == ISD::AND ||
           BinOpcode == ISD::OR || BinOpcode == ISD::XOR ||
           BinOpcode == ISD::SHL || BinOpcode == ISD::SRL ||
           BinOpcode == ISD::SRA || BinOpcode == ISD::FADD ||
           BinOpcode == ISD::FSUB || BinOpcode == ISD::FMUL ||
           BinOpcode == ISD::FDIV || BinOpcode == ISD::FREM) &&
          "Unexpected binary operator");
 
-  // Bail out if any constants are opaque because we can't constant fold those.
-  SDValue C1 = BO->getOperand(1);
-  if (!isConstantOrConstantVector(C1, true) &&
-      !isConstantFPBuildVectorOrConstantFP(C1))
-    return SDValue();
-
   // Don't do this unless the old select is going away. We want to eliminate the
   // binary operator, not replace a binop with a select.
   // TODO: Handle ISD::SELECT_CC.
+  unsigned SelOpNo = 0;
   SDValue Sel = BO->getOperand(0);
+  if (Sel.getOpcode() != ISD::SELECT || !Sel.hasOneUse()) {
+    SelOpNo = 1;
+    Sel = BO->getOperand(1);
+  }
+
   if (Sel.getOpcode() != ISD::SELECT || !Sel.hasOneUse())
     return SDValue();
 
   SDValue CT = Sel.getOperand(1);
   if (!isConstantOrConstantVector(CT, true) &&
       !isConstantFPBuildVectorOrConstantFP(CT))
     return SDValue();
 
   SDValue CF = Sel.getOperand(2);
   if (!isConstantOrConstantVector(CF, true) &&
       !isConstantFPBuildVectorOrConstantFP(CF))
     return SDValue();
 
+  // Bail out if any constants are opaque because we can't constant fold those.
+  SDValue CBO = BO->getOperand(SelOpNo ^ 1);
+  if (!isConstantOrConstantVector(CBO, true) &&
+      !isConstantFPBuildVectorOrConstantFP(CBO))
+    return SDValue();
+
+  EVT VT = Sel.getValueType();
+
+  // In case of shift value and shift amount may have different VT. For instance
+  // on x86 shift amount is i8 regardles of LHS type. Bail out if we have
+  // swapped operands and value types do not match. NB: x86 is fine if operands
+  // are not swapped with shift amount VT being not bigger than shifted value.
+  // TODO: that is possible to check for a shift operation, correct VTs and
+  // still perform optimization on x86 if needed.
+  if (SelOpNo && VT != CBO.getValueType())
+    return SDValue();
+
   // We have a select-of-constants followed by a binary operator with a
   // constant. Eliminate the binop by pulling the constant math into the select.
-  // Example: add (select Cond, CT, CF), C1 --> select Cond, CT + C1, CF + C1
-  EVT VT = Sel.getValueType();
+  // Example: add (select Cond, CT, CF), CBO --> select Cond, CT + CBO, CF + CBO
   SDLoc DL(Sel);
-  SDValue NewCT = DAG.getNode(BinOpcode, DL, VT, CT, C1);
+  SDValue NewCT = SelOpNo ? DAG.getNode(BinOpcode, DL, VT, CBO, CT)
+                          : DAG.getNode(BinOpcode, DL, VT, CT, CBO);
   if (!NewCT.isUndef() &&
       !isConstantOrConstantVector(NewCT, true) &&
       !isConstantFPBuildVectorOrConstantFP(NewCT))
     return SDValue();
 
-  SDValue NewCF = DAG.getNode(BinOpcode, DL, VT, CF, C1);
+  SDValue NewCF = SelOpNo ? DAG.getNode(BinOpcode, DL, VT, CBO, CF)
+                          : DAG.getNode(BinOpcode, DL, VT, CF, CBO);
   if (!NewCF.isUndef() &&
       !isConstantOrConstantVector(NewCF, true) &&
       !isConstantFPBuildVectorOrConstantFP(NewCF))
     return SDValue();
 
   return DAG.getSelect(DL, VT, Sel.getOperand(0), NewCT, NewCF);
 }
 

test/CodeGen/AMDGPU/dagcombine-select.ll

+; RUN: llc -march=amdgcn -verify-machineinstrs < %s | FileCheck -enable-var-scope -check-prefix=GCN %s
+
+; GCN-LABEL: {{^}}sel_constants_sub_constant_sel_constants:
+; v_cndmask_b32_e64 v{{[0-9]+}}, 2, 9,
+define amdgpu_kernel void @sel_constants_sub_constant_sel_constants(i32 addrspace(1)* %p, i1 %cond) {
+  %sel = select i1 %cond, i32 -4, i32 3
+  %bo = sub i32 5, %sel
+  store i32 %bo, i32 addrspace(1)* %p, align 4
+  ret void
+}
+
+; GCN-LABEL: {{^}}sdiv_constant_sel_constants:
+; v_cndmask_b32_e64 v{{[0-9]+}}, 5, 0,
+define amdgpu_kernel void @sdiv_constant_sel_constants(i32 addrspace(1)* %p, i1 %cond) {
+  %sel = select i1 %cond, i32 121, i32 23
+  %bo = sdiv i32 120, %sel
+  store i32 %bo, i32 addrspace(1)* %p, align 4
+  ret void
+}
+
+; GCN-LABEL: {{^}}udiv_constant_sel_constants:
+; v_cndmask_b32_e64 v{{[0-9]+}}, 5, 0,
+define amdgpu_kernel void @udiv_constant_sel_constants(i32 addrspace(1)* %p, i1 %cond) {
+  %sel = select i1 %cond, i32 -4, i32 23
+  %bo = udiv i32 120, %sel
+  store i32 %bo, i32 addrspace(1)* %p, align 4
+  ret void
+}
+
+; GCN-LABEL: {{^}}srem_constant_sel_constants:
+; v_cndmask_b32_e64 v{{[0-9]+}}, 3, 33,
+define amdgpu_kernel void @srem_constant_sel_constants(i32 addrspace(1)* %p, i1 %cond) {
+  %sel = select i1 %cond, i32 34, i32 15
+  %bo = srem i32 33, %sel
+  store i32 %bo, i32 addrspace(1)* %p, align 4
+  ret void
+}
+
+; GCN-LABEL: {{^}}urem_constant_sel_constants:
+; v_cndmask_b32_e64 v{{[0-9]+}}, 3, 33,
+define amdgpu_kernel void @urem_constant_sel_constants(i32 addrspace(1)* %p, i1 %cond) {
+  %sel = select i1 %cond, i32 34, i32 15
+  %bo = urem i32 33, %sel
+  store i32 %bo, i32 addrspace(1)* %p, align 4
+  ret void
+}
+
+; GCN-LABEL: {{^}}shl_constant_sel_constants:
+; v_cndmask_b32_e64 v{{[0-9]+}}, 8, 4,
+define amdgpu_kernel void @shl_constant_sel_constants(i32 addrspace(1)* %p, i1 %cond) {
+  %sel = select i1 %cond, i32 2, i32 3
+  %bo = shl i32 1, %sel
+  store i32 %bo, i32 addrspace(1)* %p, align 4
+  ret void
+}
+
+; GCN-LABEL: {{^}}lshr_constant_sel_constants:
+; v_cndmask_b32_e64 v{{[0-9]+}}, 8, 16,
+define amdgpu_kernel void @lshr_constant_sel_constants(i32 addrspace(1)* %p, i1 %cond) {
+  %sel = select i1 %cond, i32 2, i32 3
+  %bo = lshr i32 64, %sel
+  store i32 %bo, i32 addrspace(1)* %p, align 4
+  ret void
+}
+
+; GCN-LABEL: {{^}}ashr_constant_sel_constants:
+; v_cndmask_b32_e64 v{{[0-9]+}}, 8, 32,
+define amdgpu_kernel void @ashr_constant_sel_constants(i32 addrspace(1)* %p, i1 %cond) {
+  %sel = select i1 %cond, i32 2, i32 3
+  %bo = ashr i32 128, %sel
+  store i32 %bo, i32 addrspace(1)* %p, align 4
+  ret void
+}
+
+; GCN-LABEL: {{^}}fsub_constant_sel_constants:
+; v_cndmask_b32_e64 v{{[0-9]+}}, -4.0, 1.0,
+define amdgpu_kernel void @fsub_constant_sel_constants(float addrspace(1)* %p, i1 %cond) {
+  %sel = select i1 %cond, float -2.0, float 3.0
+  %bo = fsub float -1.0, %sel
+  store float %bo, float addrspace(1)* %p, align 4
+  ret void
+}
+
+; GCN-LABEL: {{^}}fdiv_constant_sel_constants:
+; v_cndmask_b32_e64 v{{[0-9]+}}, 4.0, -2.0,
+define amdgpu_kernel void @fdiv_constant_sel_constants(float addrspace(1)* %p, i1 %cond) {
+  %sel = select i1 %cond, float -4.0, float 2.0
+  %bo = fdiv float 8.0, %sel
+  store float %bo, float addrspace(1)* %p, align 4
+  ret void
+}
+
+; GCN-LABEL: {{^}}frem_constant_sel_constants:
+; v_cndmask_b32_e64 v{{[0-9]+}}, 2.0, 1.0,
+define amdgpu_kernel void @frem_constant_sel_constants(float addrspace(1)* %p, i1 %cond) {
+  %sel = select i1 %cond, float -4.0, float 3.0
+  %bo = frem float 5.0, %sel
+  store float %bo, float addrspace(1)* %p, align 4
+  ret void
+}

test/CodeGen/PowerPC/select_const.ll

; NO_ISEL-NEXT:    blr
   %bo = sub i8 %sel, 5
   ret i8 %bo
 }
 
 define i8 @sel_constants_sub_constant_sel_constants(i1 %cond) {
 ; ISEL-LABEL: sel_constants_sub_constant_sel_constants:
 ; ISEL:       # %bb.0:
 ; ISEL-NEXT:    andi. 3, 3, 1
-; ISEL-NEXT:    li 4, -4
-; ISEL-NEXT:    li 3, 3
+; ISEL-NEXT:    li 4, 9
+; ISEL-NEXT:    li 3, 2
 ; ISEL-NEXT:    isel 3, 4, 3, 1
-; ISEL-NEXT:    subfic 3, 3, 5
 ; ISEL-NEXT:    blr
 ;
 ; NO_ISEL-LABEL: sel_constants_sub_constant_sel_constants:
 ; NO_ISEL:       # %bb.0:
 ; NO_ISEL-NEXT:    andi. 3, 3, 1
-; NO_ISEL-NEXT:    li 4, -4
-; NO_ISEL-NEXT:    li 3, 3
+; NO_ISEL-NEXT:    li 4, 9
+; NO_ISEL-NEXT:    li 3, 2
 ; NO_ISEL-NEXT:    bc 12, 1, .LBB23_1
-; NO_ISEL-NEXT:    b .LBB23_2
+; NO_ISEL-NEXT:    blr
 ; NO_ISEL-NEXT:  .LBB23_1:
 ; NO_ISEL-NEXT:    addi 3, 4, 0
-; NO_ISEL-NEXT:  .LBB23_2:
-; NO_ISEL-NEXT:    subfic 3, 3, 5
 ; NO_ISEL-NEXT:    blr
   %sel = select i1 %cond, i8 -4, i8 3
   %bo = sub i8 5, %sel
   ret i8 %bo
 }
 
 define i8 @sel_constants_mul_constant(i1 %cond) {
 ; ISEL-LABEL: sel_constants_mul_constant:
; NO_ISEL-NEXT:    blr
   %bo = sdiv i8 %sel, 5
   ret i8 %bo
 }
 
 define i8 @sdiv_constant_sel_constants(i1 %cond) {
 ; ISEL-LABEL: sdiv_constant_sel_constants:
 ; ISEL:       # %bb.0:
 ; ISEL-NEXT:    andi. 3, 3, 1
-; ISEL-NEXT:    li 4, 121
-; ISEL-NEXT:    li 12, 120
-; ISEL-NEXT:    li 3, 23
-; ISEL-NEXT:    isel 3, 4, 3, 1
-; ISEL-NEXT:    divwu 3, 12, 3
+; ISEL-NEXT:    li 3, 5
+; ISEL-NEXT:    isel 3, 0, 3, 1
 ; ISEL-NEXT:    blr
 ;
 ; NO_ISEL-LABEL: sdiv_constant_sel_constants:
 ; NO_ISEL:       # %bb.0:
 ; NO_ISEL-NEXT:    andi. 3, 3, 1
-; NO_ISEL-NEXT:    li 4, 121
-; NO_ISEL-NEXT:    li 12, 120
-; NO_ISEL-NEXT:    li 3, 23
+; NO_ISEL-NEXT:    li 3, 5
 ; NO_ISEL-NEXT:    bc 12, 1, .LBB26_1
-; NO_ISEL-NEXT:    b .LBB26_2
+; NO_ISEL-NEXT:    blr
 ; NO_ISEL-NEXT:  .LBB26_1:
-; NO_ISEL-NEXT:    addi 3, 4, 0
-; NO_ISEL-NEXT:  .LBB26_2:
-; NO_ISEL-NEXT:    divwu 3, 12, 3
+; NO_ISEL-NEXT:    addi 3, 0, 0
 ; NO_ISEL-NEXT:    blr
   %sel = select i1 %cond, i8 121, i8 23
   %bo = sdiv i8 120, %sel
   ret i8 %bo
 }
 
 define i8 @sel_constants_udiv_constant(i1 %cond) {
 ; ISEL-LABEL: sel_constants_udiv_constant:
; NO_ISEL-NEXT:    blr
   %bo = udiv i8 %sel, 5
   ret i8 %bo
 }
 
 define i8 @udiv_constant_sel_constants(i1 %cond) {
 ; ISEL-LABEL: udiv_constant_sel_constants:
 ; ISEL:       # %bb.0:
 ; ISEL-NEXT:    andi. 3, 3, 1
-; ISEL-NEXT:    li 4, 252
-; ISEL-NEXT:    li 12, 120
-; ISEL-NEXT:    li 3, 23
-; ISEL-NEXT:    isel 3, 4, 3, 1
-; ISEL-NEXT:    divwu 3, 12, 3
+; ISEL-NEXT:    li 3, 5
+; ISEL-NEXT:    isel 3, 0, 3, 1
 ; ISEL-NEXT:    blr
 ;
 ; NO_ISEL-LABEL: udiv_constant_sel_constants:
 ; NO_ISEL:       # %bb.0:
 ; NO_ISEL-NEXT:    andi. 3, 3, 1
-; NO_ISEL-NEXT:    li 4, 252
-; NO_ISEL-NEXT:    li 12, 120
-; NO_ISEL-NEXT:    li 3, 23
+; NO_ISEL-NEXT:    li 3, 5
 ; NO_ISEL-NEXT:    bc 12, 1, .LBB28_1
-; NO_ISEL-NEXT:    b .LBB28_2
+; NO_ISEL-NEXT:    blr
 ; NO_ISEL-NEXT:  .LBB28_1:
-; NO_ISEL-NEXT:    addi 3, 4, 0
-; NO_ISEL-NEXT:  .LBB28_2:
-; NO_ISEL-NEXT:    divwu 3, 12, 3
+; NO_ISEL-NEXT:    addi 3, 0, 0
 ; NO_ISEL-NEXT:    blr
   %sel = select i1 %cond, i8 -4, i8 23
   %bo = udiv i8 120, %sel
   ret i8 %bo
 }
 
 define i8 @sel_constants_srem_constant(i1 %cond) {
 ; ISEL-LABEL: sel_constants_srem_constant:
; NO_ISEL-NEXT:    blr
   %bo = srem i8 %sel, 5
   ret i8 %bo
 }
 
 define i8 @srem_constant_sel_constants(i1 %cond) {
 ; ISEL-LABEL: srem_constant_sel_constants:
 ; ISEL:       # %bb.0:
 ; ISEL-NEXT:    andi. 3, 3, 1
-; ISEL-NEXT:    li 4, 121
-; ISEL-NEXT:    li 12, 120
-; ISEL-NEXT:    li 3, 23
+; ISEL-NEXT:    li 4, 120
+; ISEL-NEXT:    li 3, 5
 ; ISEL-NEXT:    isel 3, 4, 3, 1
-; ISEL-NEXT:    divwu 4, 12, 3
-; ISEL-NEXT:    mullw 3, 4, 3
-; ISEL-NEXT:    subfic 3, 3, 120
 ; ISEL-NEXT:    blr
 ;
 ; NO_ISEL-LABEL: srem_constant_sel_constants:
 ; NO_ISEL:       # %bb.0:
 ; NO_ISEL-NEXT:    andi. 3, 3, 1
-; NO_ISEL-NEXT:    li 4, 121
-; NO_ISEL-NEXT:    li 12, 120
-; NO_ISEL-NEXT:    li 3, 23
+; NO_ISEL-NEXT:    li 4, 120
+; NO_ISEL-NEXT:    li 3, 5
 ; NO_ISEL-NEXT:    bc 12, 1, .LBB30_1
-; NO_ISEL-NEXT:    b .LBB30_2
+; NO_ISEL-NEXT:    blr
 ; NO_ISEL-NEXT:  .LBB30_1:
 ; NO_ISEL-NEXT:    addi 3, 4, 0
-; NO_ISEL-NEXT:  .LBB30_2:
-; NO_ISEL-NEXT:    divwu 4, 12, 3
-; NO_ISEL-NEXT:    mullw 3, 4, 3
-; NO_ISEL-NEXT:    subfic 3, 3, 120
 ; NO_ISEL-NEXT:    blr
   %sel = select i1 %cond, i8 121, i8 23
   %bo = srem i8 120, %sel
   ret i8 %bo
 }
 
 define i8 @sel_constants_urem_constant(i1 %cond) {
 ; ALL-LABEL: sel_constants_urem_constant:
 ; ALL:       # %bb.0:
 ; ALL-NEXT:    rlwinm 3, 3, 0, 31, 31
 ; ALL-NEXT:    subfic 3, 3, 3
 ; ALL-NEXT:    blr
   %sel = select i1 %cond, i8 -4, i8 23
   %bo = urem i8 %sel, 5
   ret i8 %bo
 }
 
 define i8 @urem_constant_sel_constants(i1 %cond) {
 ; ISEL-LABEL: urem_constant_sel_constants:
 ; ISEL:       # %bb.0:
 ; ISEL-NEXT:    andi. 3, 3, 1
-; ISEL-NEXT:    li 4, 252
-; ISEL-NEXT:    li 12, 120
-; ISEL-NEXT:    li 3, 23
+; ISEL-NEXT:    li 4, 120
+; ISEL-NEXT:    li 3, 5
 ; ISEL-NEXT:    isel 3, 4, 3, 1
-; ISEL-NEXT:    divwu 4, 12, 3
-; ISEL-NEXT:    mullw 3, 4, 3
-; ISEL-NEXT:    subfic 3, 3, 120
 ; ISEL-NEXT:    blr
 ;
 ; NO_ISEL-LABEL: urem_constant_sel_constants:
 ; NO_ISEL:       # %bb.0:
 ; NO_ISEL-NEXT:    andi. 3, 3, 1
-; NO_ISEL-NEXT:    li 4, 252
-; NO_ISEL-NEXT:    li 12, 120
-; NO_ISEL-NEXT:    li 3, 23
+; NO_ISEL-NEXT:    li 4, 120
+; NO_ISEL-NEXT:    li 3, 5
 ; NO_ISEL-NEXT:    bc 12, 1, .LBB32_1
-; NO_ISEL-NEXT:    b .LBB32_2
+; NO_ISEL-NEXT:    blr
 ; NO_ISEL-NEXT:  .LBB32_1:
 ; NO_ISEL-NEXT:    addi 3, 4, 0
-; NO_ISEL-NEXT:  .LBB32_2:
-; NO_ISEL-NEXT:    divwu 4, 12, 3
-; NO_ISEL-NEXT:    mullw 3, 4, 3
-; NO_ISEL-NEXT:    subfic 3, 3, 120
 ; NO_ISEL-NEXT:    blr
   %sel = select i1 %cond, i8 -4, i8 23
   %bo = urem i8 120, %sel
   ret i8 %bo
 }
 
 define i8 @sel_constants_and_constant(i1 %cond) {
 ; ALL-LABEL: sel_constants_and_constant:

 ; NO_ISEL-NEXT:    lfdx 1, 0, 3
 ; NO_ISEL-NEXT:    blr
   %sel = select i1 %cond, double -4.0, double 23.3
   %bo = fsub double %sel, 5.1
   ret double %bo
 }
 
 define double @fsub_constant_sel_constants(i1 %cond) {
-; ALL-LABEL: fsub_constant_sel_constants:
-; ALL:       # %bb.0:
-; ALL-NEXT:    andi. 3, 3, 1
-; ALL-NEXT:    bc 12, 1, .LBB44_2
-; ALL-NEXT:  # %bb.1:
-; ALL-NEXT:    addis 3, 2, .LCPI44_0@toc@ha
-; ALL-NEXT:    addi 3, 3, .LCPI44_0@toc@l
-; ALL-NEXT:    lfdx 0, 0, 3
-; ALL-NEXT:    b .LBB44_3
-; ALL-NEXT:  .LBB44_2:
-; ALL-NEXT:    addis 3, 2, .LCPI44_1@toc@ha
-; ALL-NEXT:    addi 3, 3, .LCPI44_1@toc@l
-; ALL-NEXT:    lfsx 0, 0, 3
-; ALL-NEXT:  .LBB44_3:
-; ALL-NEXT:    addis 3, 2, .LCPI44_2@toc@ha
-; ALL-NEXT:    addi 3, 3, .LCPI44_2@toc@l
-; ALL-NEXT:    lfdx 1, 0, 3
-; ALL-NEXT:    xssubdp 1, 1, 0
-; ALL-NEXT:    blr
+; ISEL-LABEL: fsub_constant_sel_constants:
+; ISEL:       # %bb.0:
+; ISEL-NEXT:    andi. 3, 3, 1
+; ISEL-NEXT:    addis 4, 2, .LCPI44_0@toc@ha
+; ISEL-NEXT:    addis 3, 2, .LCPI44_1@toc@ha
+; ISEL-NEXT:    addi 4, 4, .LCPI44_0@toc@l
+; ISEL-NEXT:    addi 3, 3, .LCPI44_1@toc@l
+; ISEL-NEXT:    isel 3, 3, 4, 1
+; ISEL-NEXT:    lfdx 1, 0, 3
+; ISEL-NEXT:    blr
+;
+; NO_ISEL-LABEL: fsub_constant_sel_constants:
+; NO_ISEL:       # %bb.0:
+; NO_ISEL-NEXT:    andi. 3, 3, 1
+; NO_ISEL-NEXT:    addis 4, 2, .LCPI44_0@toc@ha
+; NO_ISEL-NEXT:    addis 3, 2, .LCPI44_1@toc@ha
+; NO_ISEL-NEXT:    addi 4, 4, .LCPI44_0@toc@l
+; NO_ISEL-NEXT:    addi 3, 3, .LCPI44_1@toc@l
+; NO_ISEL-NEXT:    bc 12, 1, .LBB44_2
+; NO_ISEL-NEXT:  # %bb.1:
+; NO_ISEL-NEXT:    ori 3, 4, 0
+; NO_ISEL-NEXT:    b .LBB44_2
+; NO_ISEL-NEXT:  .LBB44_2:
+; NO_ISEL-NEXT:    lfdx 1, 0, 3
+; NO_ISEL-NEXT:    blr
   %sel = select i1 %cond, double -4.0, double 23.3
   %bo = fsub double 5.1, %sel
   ret double %bo
 }
 
 define double @sel_constants_fmul_constant(i1 %cond) {
 ; ISEL-LABEL: sel_constants_fmul_constant:
 ; ISEL:       # %bb.0:

 ; NO_ISEL-NEXT:    lfdx 1, 0, 3
 ; NO_ISEL-NEXT:    blr
   %sel = select i1 %cond, double -4.0, double 23.3
   %bo = fdiv double %sel, 5.1
   ret double %bo
 }
 
 define double @fdiv_constant_sel_constants(i1 %cond) {
-; ALL-LABEL: fdiv_constant_sel_constants:
-; ALL:       # %bb.0:
-; ALL-NEXT:    andi. 3, 3, 1
-; ALL-NEXT:    bc 12, 1, .LBB47_2
-; ALL-NEXT:  # %bb.1:
-; ALL-NEXT:    addis 3, 2, .LCPI47_0@toc@ha
-; ALL-NEXT:    addi 3, 3, .LCPI47_0@toc@l
-; ALL-NEXT:    lfdx 0, 0, 3
-; ALL-NEXT:    b .LBB47_3
-; ALL-NEXT:  .LBB47_2:
-; ALL-NEXT:    addis 3, 2, .LCPI47_1@toc@ha
-; ALL-NEXT:    addi 3, 3, .LCPI47_1@toc@l
-; ALL-NEXT:    lfsx 0, 0, 3
-; ALL-NEXT:  .LBB47_3:
-; ALL-NEXT:    addis 3, 2, .LCPI47_2@toc@ha
-; ALL-NEXT:    addi 3, 3, .LCPI47_2@toc@l
-; ALL-NEXT:    lfdx 1, 0, 3
-; ALL-NEXT:    xsdivdp 1, 1, 0
-; ALL-NEXT:    blr
+; ISEL-LABEL: fdiv_constant_sel_constants:
+; ISEL:       # %bb.0:
+; ISEL-NEXT:    andi. 3, 3, 1
+; ISEL-NEXT:    addis 4, 2, .LCPI47_0@toc@ha
+; ISEL-NEXT:    addis 3, 2, .LCPI47_1@toc@ha
+; ISEL-NEXT:    addi 4, 4, .LCPI47_0@toc@l
+; ISEL-NEXT:    addi 3, 3, .LCPI47_1@toc@l
+; ISEL-NEXT:    isel 3, 3, 4, 1
+; ISEL-NEXT:    lfdx 1, 0, 3
+; ISEL-NEXT:    blr
+;
+; NO_ISEL-LABEL: fdiv_constant_sel_constants:
+; NO_ISEL:       # %bb.0:
+; NO_ISEL-NEXT:    andi. 3, 3, 1
+; NO_ISEL-NEXT:    addis 4, 2, .LCPI47_0@toc@ha
+; NO_ISEL-NEXT:    addis 3, 2, .LCPI47_1@toc@ha
+; NO_ISEL-NEXT:    addi 4, 4, .LCPI47_0@toc@l
+; NO_ISEL-NEXT:    addi 3, 3, .LCPI47_1@toc@l
+; NO_ISEL-NEXT:    bc 12, 1, .LBB47_2
+; NO_ISEL-NEXT:  # %bb.1:
+; NO_ISEL-NEXT:    ori 3, 4, 0
+; NO_ISEL-NEXT:    b .LBB47_2
+; NO_ISEL-NEXT:  .LBB47_2:
+; NO_ISEL-NEXT:    lfdx 1, 0, 3
+; NO_ISEL-NEXT:    blr
   %sel = select i1 %cond, double -4.0, double 23.3
   %bo = fdiv double 5.1, %sel
   ret double %bo
 }
 
 define double @sel_constants_frem_constant(i1 %cond) {
 ; ALL-LABEL: sel_constants_frem_constant:
 ; ALL:       # %bb.0:

 ; ALL-NEXT:    lfsx 1, 0, 3
 ; ALL-NEXT:    blr
   %sel = select i1 %cond, double -4.0, double 23.3
   %bo = frem double %sel, 5.1
   ret double %bo
 }
 
 define double @frem_constant_sel_constants(i1 %cond) {
-; ALL-LABEL: frem_constant_sel_constants:
-; ALL:       # %bb.0:
-; ALL-NEXT:    mflr 0
-; ALL-NEXT:    std 0, 16(1)
-; ALL-NEXT:    stdu 1, -32(1)
-; ALL-NEXT:    .cfi_def_cfa_offset 32
-; ALL-NEXT:    .cfi_offset lr, 16
-; ALL-NEXT:    andi. 3, 3, 1
-; ALL-NEXT:    bc 12, 1, .LBB49_2
-; ALL-NEXT:  # %bb.1:
-; ALL-NEXT:    addis 3, 2, .LCPI49_0@toc@ha
-; ALL-NEXT:    addi 3, 3, .LCPI49_0@toc@l
-; ALL-NEXT:    lfdx 2, 0, 3
-; ALL-NEXT:    b .LBB49_3
-; ALL-NEXT:  .LBB49_2:
-; ALL-NEXT:    addis 3, 2, .LCPI49_1@toc@ha
-; ALL-NEXT:    addi 3, 3, .LCPI49_1@toc@l
-; ALL-NEXT:    lfsx 2, 0, 3
-; ALL-NEXT:  .LBB49_3:
-; ALL-NEXT:    addis 3, 2, .LCPI49_2@toc@ha
-; ALL-NEXT:    addi 3, 3, .LCPI49_2@toc@l
-; ALL-NEXT:    lfdx 1, 0, 3
-; ALL-NEXT:    bl fmod
-; ALL-NEXT:    nop
-; ALL-NEXT:    addi 1, 1, 32
-; ALL-NEXT:    ld 0, 16(1)
-; ALL-NEXT:    mtlr 0
-; ALL-NEXT:    blr
+; ISEL-LABEL: frem_constant_sel_constants:
+; ISEL:       # %bb.0:
+; ISEL-NEXT:    andi. 3, 3, 1
+; ISEL-NEXT:    addis 4, 2, .LCPI49_0@toc@ha
+; ISEL-NEXT:    addis 3, 2, .LCPI49_1@toc@ha
+; ISEL-NEXT:    addi 4, 4, .LCPI49_0@toc@l
+; ISEL-NEXT:    addi 3, 3, .LCPI49_1@toc@l
+; ISEL-NEXT:    isel 3, 3, 4, 1
+; ISEL-NEXT:    lfdx 1, 0, 3
+; ISEL-NEXT:    blr
+;
+; NO_ISEL-LABEL: frem_constant_sel_constants:
+; NO_ISEL:       # %bb.0:
+; NO_ISEL-NEXT:    andi. 3, 3, 1
+; NO_ISEL-NEXT:    addis 4, 2, .LCPI49_0@toc@ha
+; NO_ISEL-NEXT:    addis 3, 2, .LCPI49_1@toc@ha
+; NO_ISEL-NEXT:    addi 4, 4, .LCPI49_0@toc@l
+; NO_ISEL-NEXT:    addi 3, 3, .LCPI49_1@toc@l
+; NO_ISEL-NEXT:    bc 12, 1, .LBB49_2
+; NO_ISEL-NEXT:  # %bb.1:
+; NO_ISEL-NEXT:    ori 3, 4, 0
+; NO_ISEL-NEXT:    b .LBB49_2
+; NO_ISEL-NEXT:  .LBB49_2:
+; NO_ISEL-NEXT:    lfdx 1, 0, 3
+; NO_ISEL-NEXT:    blr
   %sel = select i1 %cond, double -4.0, double 23.3
   %bo = frem double 5.1, %sel
   ret double %bo
 }

test/CodeGen/X86/dagcombine-select.ll

 ; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
 ; RUN: llc -mtriple=x86_64-unknown-unknown -verify-machineinstrs < %s | FileCheck -enable-var-scope %s
 
 define i32 @select_and1(i32 %x, i32 %y) {
 ; CHECK-LABEL: select_and1:
 ; CHECK:       # %bb.0:
 ; CHECK-NEXT:    xorl %eax, %eax
 ; CHECK-NEXT:    cmpl $11, %edi
 ; CHECK-NEXT:    setl %al
 ; CHECK-NEXT:    decl %eax
 ; CHECK-NEXT:    andl %esi, %eax
 ; CHECK-NEXT:    retq
   %c = icmp slt i32 %x, 11
   %s = select i1 %c, i32 0, i32 -1
   %a = and i32 %y, %s
   ret i32 %a
 }
 
 define i32 @select_and2(i32 %x, i32 %y) {
 ; CHECK-LABEL: select_and2:
 ; CHECK:       # %bb.0:
 ; CHECK-NEXT:    xorl %eax, %eax
 ; CHECK-NEXT:    cmpl $11, %edi
 ; CHECK-NEXT:    setl %al
 ; CHECK-NEXT:    decl %eax
; CHECK-NEXT:    retq
   %a = or i32 %s, %y
   ret i32 %a
 }
 
 define i32 @sel_constants_sub_constant_sel_constants(i1 %cond) {
 ; CHECK-LABEL: sel_constants_sub_constant_sel_constants:
 ; CHECK:       # %bb.0:
 ; CHECK-NEXT:    testb $1, %dil
-; CHECK-NEXT:    movl $-4, %eax
-; CHECK-NEXT:    movl $3, %ecx
-; CHECK-NEXT:    cmovnel %eax, %ecx
-; CHECK-NEXT:    movl $5, %eax
-; CHECK-NEXT:    subl %ecx, %eax
+; CHECK-NEXT:    movl $9, %ecx
+; CHECK-NEXT:    movl $2, %eax
+; CHECK-NEXT:    cmovnel %ecx, %eax
 ; CHECK-NEXT:    retq
   %sel = select i1 %cond, i32 -4, i32 3
   %bo = sub i32 5, %sel
   ret i32 %bo
 }
 
 define i32 @sdiv_constant_sel_constants(i1 %cond) {
 ; CHECK-LABEL: sdiv_constant_sel_constants:
 ; CHECK:       # %bb.0:
-; CHECK-NEXT:    testb $1, %dil
-; CHECK-NEXT:    movl $121, %eax
-; CHECK-NEXT:    movl $23, %ecx
-; CHECK-NEXT:    cmovnel %eax, %ecx
-; CHECK-NEXT:    movl $120, %eax
-; CHECK-NEXT:    xorl %edx, %edx
-; CHECK-NEXT:    divl %ecx
+; CHECK-NEXT:    notb %dil
+; CHECK-NEXT:    movzbl %dil, %eax
+; CHECK-NEXT:    andl $1, %eax
+; CHECK-NEXT:    leal (%rax,%rax,4), %eax
 ; CHECK-NEXT:    retq
   %sel = select i1 %cond, i32 121, i32 23
   %bo = sdiv i32 120, %sel
   ret i32 %bo
 }
 
 define i32 @udiv_constant_sel_constants(i1 %cond) {
 ; CHECK-LABEL: udiv_constant_sel_constants:
 ; CHECK:       # %bb.0:
-; CHECK-NEXT:    testb $1, %dil
-; CHECK-NEXT:    movl $-4, %eax
-; CHECK-NEXT:    movl $23, %ecx
-; CHECK-NEXT:    cmovnel %eax, %ecx
-; CHECK-NEXT:    movl $120, %eax
-; CHECK-NEXT:    xorl %edx, %edx
-; CHECK-NEXT:    divl %ecx
+; CHECK-NEXT:    notb %dil
+; CHECK-NEXT:    movzbl %dil, %eax
+; CHECK-NEXT:    andl $1, %eax
+; CHECK-NEXT:    leal (%rax,%rax,4), %eax
 ; CHECK-NEXT:    retq
   %sel = select i1 %cond, i32 -4, i32 23
   %bo = udiv i32 120, %sel
   ret i32 %bo
 }
 
 define i32 @srem_constant_sel_constants(i1 %cond) {
 ; CHECK-LABEL: srem_constant_sel_constants:
 ; CHECK:       # %bb.0:
 ; CHECK-NEXT:    testb $1, %dil
-; CHECK-NEXT:    movl $121, %eax
-; CHECK-NEXT:    movl $23, %ecx
-; CHECK-NEXT:    cmovnel %eax, %ecx
-; CHECK-NEXT:    movl $120, %eax
-; CHECK-NEXT:    xorl %edx, %edx
-; CHECK-NEXT:    divl %ecx
-; CHECK-NEXT:    movl %edx, %eax
+; CHECK-NEXT:    movl $120, %ecx
+; CHECK-NEXT:    movl $5, %eax
+; CHECK-NEXT:    cmovnel %ecx, %eax
 ; CHECK-NEXT:    retq
   %sel = select i1 %cond, i32 121, i32 23
   %bo = srem i32 120, %sel
   ret i32 %bo
 }
 
 define i32 @urem_constant_sel_constants(i1 %cond) {
 ; CHECK-LABEL: urem_constant_sel_constants:
 ; CHECK:       # %bb.0:
 ; CHECK-NEXT:    testb $1, %dil
-; CHECK-NEXT:    movl $-4, %eax
-; CHECK-NEXT:    movl $23, %ecx
-; CHECK-NEXT:    cmovnel %eax, %ecx
-; CHECK-NEXT:    movl $120, %eax
-; CHECK-NEXT:    xorl %edx, %edx
-; CHECK-NEXT:    divl %ecx
-; CHECK-NEXT:    movl %edx, %eax
+; CHECK-NEXT:    movl $120, %ecx
+; CHECK-NEXT:    movl $5, %eax
+; CHECK-NEXT:    cmovnel %ecx, %eax
 ; CHECK-NEXT:    retq
   %sel = select i1 %cond, i32 -4, i32 23
   %bo = urem i32 120, %sel
   ret i32 %bo
 }
 
+define i32 @sel_constants_shl_constant(i1 %cond) {
+; CHECK-LABEL: sel_constants_shl_constant:
+; CHECK:       # %bb.0:
+; CHECK-NEXT:    notb %dil
+; CHECK-NEXT:    movzbl %dil, %eax
+; CHECK-NEXT:    andl $1, %eax
+; CHECK-NEXT:    orl $2, %eax
+; CHECK-NEXT:    shll $8, %eax
+; CHECK-NEXT:    retq
+  %sel = select i1 %cond, i32 2, i32 3
+  %bo = shl i32 %sel, 8
+  ret i32 %bo
+}
+
 define i32 @shl_constant_sel_constants(i1 %cond) {
 ; CHECK-LABEL: shl_constant_sel_constants:
 ; CHECK:       # %bb.0:
 ; CHECK-NEXT:    andb $1, %dil
 ; CHECK-NEXT:    movb $3, %cl
 ; CHECK-NEXT:    subb %dil, %cl
 ; CHECK-NEXT:    movl $1, %eax
 ; CHECK-NEXT:    shll %cl, %eax
; CHECK-NEXT:    retq
   %bo = ashr i32 128, %sel
   ret i32 %bo
 }
 
 define double @fsub_constant_sel_constants(i1 %cond) {
 ; CHECK-LABEL: fsub_constant_sel_constants:
 ; CHECK:       # %bb.0:
 ; CHECK-NEXT:    testb $1, %dil
-; CHECK-NEXT:    jne .LBB12_1
+; CHECK-NEXT:    jne .LBB13_1
 ; CHECK-NEXT:  # %bb.2:
-; CHECK-NEXT:    movsd {{.*#+}} xmm1 = mem[0],zero
-; CHECK-NEXT:    jmp .LBB12_3
-; CHECK-NEXT:  .LBB12_1:
-; CHECK-NEXT:    movsd {{.*#+}} xmm1 = mem[0],zero
-; CHECK-NEXT:  .LBB12_3:
 ; CHECK-NEXT:    movsd {{.*#+}} xmm0 = mem[0],zero
-; CHECK-NEXT:    subsd %xmm1, %xmm0
+; CHECK-NEXT:    retq
+; CHECK-NEXT:  .LBB13_1:
+; CHECK-NEXT:    movsd {{.*#+}} xmm0 = mem[0],zero
 ; CHECK-NEXT:    retq
   %sel = select i1 %cond, double -4.0, double 23.3
   %bo = fsub double 5.1, %sel
   ret double %bo
 }
 
 define double @fdiv_constant_sel_constants(i1 %cond) {
 ; CHECK-LABEL: fdiv_constant_sel_constants:
 ; CHECK:       # %bb.0:
 ; CHECK-NEXT:    testb $1, %dil
-; CHECK-NEXT:    jne .LBB13_1
+; CHECK-NEXT:    jne .LBB14_1
 ; CHECK-NEXT:  # %bb.2:
-; CHECK-NEXT:    movsd {{.*#+}} xmm1 = mem[0],zero
-; CHECK-NEXT:    jmp .LBB13_3
-; CHECK-NEXT:  .LBB13_1:
-; CHECK-NEXT:    movsd {{.*#+}} xmm1 = mem[0],zero
-; CHECK-NEXT:  .LBB13_3:
 ; CHECK-NEXT:    movsd {{.*#+}} xmm0 = mem[0],zero
-; CHECK-NEXT:    divsd %xmm1, %xmm0
+; CHECK-NEXT:    retq
+; CHECK-NEXT:  .LBB14_1:
+; CHECK-NEXT:    movsd {{.*#+}} xmm0 = mem[0],zero
 ; CHECK-NEXT:    retq
   %sel = select i1 %cond, double -4.0, double 23.3
   %bo = fdiv double 5.1, %sel
   ret double %bo
 }
 
 define double @frem_constant_sel_constants(i1 %cond) {
 ; CHECK-LABEL: frem_constant_sel_constants:
 ; CHECK:       # %bb.0:
 ; CHECK-NEXT:    testb $1, %dil
-; CHECK-NEXT:    jne .LBB14_1
+; CHECK-NEXT:    jne .LBB15_1
 ; CHECK-NEXT:  # %bb.2:
-; CHECK-NEXT:    movsd {{.*#+}} xmm1 = mem[0],zero
 ; CHECK-NEXT:    movsd {{.*#+}} xmm0 = mem[0],zero
-; CHECK-NEXT:    jmp fmod # TAILCALL
-; CHECK-NEXT:  .LBB14_1:
-; CHECK-NEXT:    movsd {{.*#+}} xmm1 = mem[0],zero
+; CHECK-NEXT:    retq
+; CHECK-NEXT:  .LBB15_1:
 ; CHECK-NEXT:    movsd {{.*#+}} xmm0 = mem[0],zero
-; CHECK-NEXT:    jmp fmod # TAILCALL
+; CHECK-NEXT:    retq
   %sel = select i1 %cond, double -4.0, double 23.3
   %bo = frem double 5.1, %sel
   ret double %bo
 }