[DAG] make binops with undef operands consistent with IR

[spatel]

Summary

This started by noticing that scalar and vector types were producing different results with div ops in PR36305:
https://bugs.llvm.org/show_bug.cgi?id=36305

...but the problem is bigger. I couldn't keep it straight without a table, so I'm attaching that as a PDF to this review. The x86 tests in undef-ops.ll correspond to that table.

Green means that instsimplify and the DAG agree on the result for all types.
Red means the DAG was returning undef when IR was not.
Yellow means the DAG was returning a non-undef result when IR returned undef.

This patch assumes that we're doing the right thing in IR, but now's a good time to confirm that. :)

Note: I couldn't find any problems with creating vector constants as the code comments were warning, but those comments were written long ago in rL36413 .

undef in DAG.pdf40 KBDownload

[efriedma]

Some of the test changes are a little iffy... we might want to adjust the to stop using undef rather than just change the expected result, to try to preserve some of the original intent.

lib/CodeGen/SelectionDAG/SelectionDAG.cpp

4713

"For vectors, we can't easily build an all zero vector" doesn't mean that it's hard to construct a BUILD_VECTOR; the problem is ensuring we lower it before we run selection. But it might not be a problem anymore because DAGCombine calls the legalizer?

[spatel]

Patch updated:
Edited tests so they are not affected by this patch:
rL324814
rL324816
rL324817

I think the remaining x86 tests show the undef functional change from this patch as intended.
I'm not sure what to do with the Hexagon test - changing some constants as shown didn't restore the current CHECK. @kparzysz - suggestions?

[nlopes]

oh, wow, so many bugs in DAG combiner handling undef.. Nice table btw!

I wonder if the handling of nsw/nuw in SelectionDAG isn't buggy as well, but that's another question..

[kparzysz]

The change in the Hexagon test is fine. The original testcase crashed before the fix, so as long as it compiles successfully, any CHECK will work.

[efriedma]

LGTM

lib/CodeGen/SelectionDAG/SelectionDAG.cpp

if (N1.isUndef()) {
     } else {
       switch (Opcode) {
       case ISD::FP_ROUND_INREG:
       case ISD::SIGN_EXTEND_INREG:
       case ISD::SUB:
       case ISD::FSUB:
       case ISD::FDIV:
       case ISD::FREM:
-      case ISD::SRA:
         return N1;     // fold op(undef, arg2) -> undef
       case ISD::UDIV:
       case ISD::SDIV:
       case ISD::UREM:
       case ISD::SREM:
+      case ISD::SRA:
       case ISD::SRL:
       case ISD::SHL:
-        if (!VT.isVector())
-          return getConstant(0, DL, VT);    // fold op(undef, arg2) -> 0
-        // For vectors, we can't easily build an all zero vector, just return
-        // the LHS.
-        return N2;
       }
     }
   }
 
   // Fold a bunch of operators when the RHS is undef.
   if (N2.isUndef()) {
     switch (Opcode) {
     case ISD::XOR:
       if (N1.isUndef())
         // Handle undef ^ undef -> 0 special case. This is a common
         // idiom (misuse).
         return getConstant(0, DL, VT);
       LLVM_FALLTHROUGH;
     case ISD::ADD:
     case ISD::ADDC:
     case ISD::ADDE:
     case ISD::SUB:
     case ISD::UDIV:
     case ISD::SDIV:
     case ISD::UREM:
     case ISD::SREM:
+    case ISD::SRA:
+    case ISD::SRL:
+    case ISD::SHL:
       return N2;       // fold op(arg1, undef) -> undef
     case ISD::FADD:
     case ISD::FSUB:
     case ISD::FMUL:
     case ISD::FDIV:
     case ISD::FREM:
       if (getTarget().Options.UnsafeFPMath)
         return N2;
       break;
     case ISD::MUL:
     case ISD::AND:
-    case ISD::SRL:
-    case ISD::SHL:
-      if (!VT.isVector())
-        return getConstant(0, DL, VT);  // fold op(arg1, undef) -> 0
-      // For vectors, we can't easily build an all zero vector, just return
-      // the LHS.
-      return N1;
     case ISD::OR:
-      if (!VT.isVector())
-        return getConstant(APInt::getAllOnesValue(VT.getSizeInBits()), DL, VT);
-      // For vectors, we can't easily build an all one vector, just return
-      // the LHS.
-      return N1;
-    case ISD::SRA:
-      return N1;
+      return getAllOnesConstant(DL, VT);
     }
   }
 
   // Memoize this node if possible.
   SDNode *N;
   SDVTList VTs = getVTList(VT);
   SDValue Ops[] = {N1, N2};
   if (VT != MVT::Glue) {

test/CodeGen/ARM/2013-07-29-vector-or-combine.ll

 ; RUN: llc < %s -mcpu=cortex-a8 -arm-atomic-cfg-tidy=0 | FileCheck %s
 ; ModuleID = 'bugpoint-reduced-simplified.bc'
 target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:64:128-a0:0:64-n32-S64"
 target triple = "armv7--linux-gnueabi"
 
 ; CHECK-LABEL: function
 define void @function() {
 ; CHECK: cmp r0, #0
 ; CHECK: bxne lr
-; CHECK: vmov.i32 q8, #0xff0000
+; CHECK: vmov.i8 q8, #0xff
 entry:
   br i1 undef, label %vector.body, label %for.end
 
-; CHECK: vld1.32 {d18, d19}, [r0]
-; CHECK: vand q10, q9, q8
-; CHECK: vbic.i16 q9, #0xff
-; CHECK: vorr q9, q9, q10
-; CHECK: vst1.32 {d18, d19}, [r0]
+; CHECK: vst1.32 {d16, d17}, [r0]
 vector.body:
   %wide.load = load <4 x i32>, <4 x i32>* undef, align 4
   %0 = and <4 x i32> %wide.load, <i32 -16711936, i32 -16711936, i32 -16711936, i32 -16711936>
   %1 = sub <4 x i32> %wide.load, zeroinitializer
   %2 = and <4 x i32> %1, <i32 16711680, i32 16711680, i32 16711680, i32 16711680>
   %3 = or <4 x i32> undef, %0
   %4 = or <4 x i32> %3, %2
   store <4 x i32> %4, <4 x i32>* undef, align 4
   br label %vector.body
 
 for.end:
   ret void
 }
 

test/CodeGen/Hexagon/tail-dup-subreg-map.ll

 ; RUN: llc -march=hexagon < %s | FileCheck %s
 ; REQUIRES: asserts
 
 ; When tail-duplicating a block with PHI nodes that use subregisters, the
 ; subregisters were dropped by the tail duplicator, resulting in invalid
 ; COPY instructions being generated.
 
-; CHECK: = extractu(r{{[0-9]+}},#15,#17)
+; CHECK: = asl(r{{[0-9]+}}:{{[0-9]+}},#15)
 
 target triple = "hexagon"
 
 %struct.0 = type { i64, i16 }
 %struct.1 = type { i64, i64 }
 
 declare hidden fastcc void @foo(%struct.0* noalias nocapture, i8 signext, i8 zeroext, i32, i64, i64) unnamed_addr #0
 

test/CodeGen/X86/legalize-shl-vec.ll

 ; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
 ; RUN: llc < %s -mtriple=i686-unknown-unknown | FileCheck %s --check-prefix=CHECK --check-prefix=X32
 ; RUN: llc < %s -mtriple=x86_64-unknown-unknown | FileCheck %s --check-prefix=CHECK --check-prefix=X64
 
 define <2 x i256> @test_shl(<2 x i256> %In) {
 ; X32-LABEL: test_shl:
 ; X32:       # %bb.0:
 ; X32-NEXT:    movl {{[0-9]+}}(%esp), %eax
-; X32-NEXT:    movl $0, 60(%eax)
-; X32-NEXT:    movl $0, 56(%eax)
-; X32-NEXT:    movl $0, 52(%eax)
-; X32-NEXT:    movl $0, 48(%eax)
-; X32-NEXT:    movl $0, 44(%eax)
-; X32-NEXT:    movl $0, 40(%eax)
-; X32-NEXT:    movl $0, 36(%eax)
-; X32-NEXT:    movl $0, 32(%eax)
 ; X32-NEXT:    movl $0, 28(%eax)
 ; X32-NEXT:    movl $0, 24(%eax)
 ; X32-NEXT:    movl $0, 20(%eax)
 ; X32-NEXT:    movl $0, 16(%eax)
 ; X32-NEXT:    movl $0, 12(%eax)
 ; X32-NEXT:    movl $0, 8(%eax)
 ; X32-NEXT:    movl $0, 4(%eax)
 ; X32-NEXT:    movl $0, (%eax)
 ; X32-NEXT:    retl $4
 ;
 ; X64-LABEL: test_shl:
 ; X64:       # %bb.0:
 ; X64-NEXT:    xorps %xmm0, %xmm0
-; X64-NEXT:    movaps %xmm0, 48(%rdi)
-; X64-NEXT:    movaps %xmm0, 32(%rdi)
 ; X64-NEXT:    movaps %xmm0, 16(%rdi)
 ; X64-NEXT:    movaps %xmm0, (%rdi)
 ; X64-NEXT:    movq %rdi, %rax
 ; X64-NEXT:    retq
   %Amt = insertelement <2 x i256> undef, i256 -1, i32 0
   %Out = shl <2 x i256> %In, %Amt
   ret <2 x i256> %Out
 }
 
 define <2 x i256> @test_srl(<2 x i256> %In) {
 ; X32-LABEL: test_srl:
 ; X32:       # %bb.0:
 ; X32-NEXT:    movl {{[0-9]+}}(%esp), %eax
-; X32-NEXT:    movl $0, 60(%eax)
-; X32-NEXT:    movl $0, 56(%eax)
-; X32-NEXT:    movl $0, 52(%eax)
-; X32-NEXT:    movl $0, 48(%eax)
-; X32-NEXT:    movl $0, 44(%eax)
-; X32-NEXT:    movl $0, 40(%eax)
-; X32-NEXT:    movl $0, 36(%eax)
-; X32-NEXT:    movl $0, 32(%eax)
 ; X32-NEXT:    movl $0, 28(%eax)
 ; X32-NEXT:    movl $0, 24(%eax)
 ; X32-NEXT:    movl $0, 20(%eax)
 ; X32-NEXT:    movl $0, 16(%eax)
 ; X32-NEXT:    movl $0, 12(%eax)
 ; X32-NEXT:    movl $0, 8(%eax)
 ; X32-NEXT:    movl $0, 4(%eax)
 ; X32-NEXT:    movl $0, (%eax)
 ; X32-NEXT:    retl $4
 ;
 ; X64-LABEL: test_srl:
 ; X64:       # %bb.0:
 ; X64-NEXT:    xorps %xmm0, %xmm0
-; X64-NEXT:    movaps %xmm0, 48(%rdi)
-; X64-NEXT:    movaps %xmm0, 32(%rdi)
 ; X64-NEXT:    movaps %xmm0, 16(%rdi)
 ; X64-NEXT:    movaps %xmm0, (%rdi)
 ; X64-NEXT:    movq %rdi, %rax
 ; X64-NEXT:    retq
   %Amt = insertelement <2 x i256> undef, i256 -1, i32 0
   %Out = lshr <2 x i256> %In, %Amt
   ret <2 x i256> %Out
 }
 
 define <2 x i256> @test_sra(<2 x i256> %In) {
 ; X32-LABEL: test_sra:
 ; X32:       # %bb.0:
 ; X32-NEXT:    movl {{[0-9]+}}(%esp), %eax
 ; X32-NEXT:    movl {{[0-9]+}}(%esp), %ecx
-; X32-NEXT:    movl %ecx, 60(%eax)
-; X32-NEXT:    movl {{[0-9]+}}(%esp), %ecx
-; X32-NEXT:    movl %ecx, 56(%eax)
-; X32-NEXT:    movl {{[0-9]+}}(%esp), %ecx
-; X32-NEXT:    movl %ecx, 52(%eax)
-; X32-NEXT:    movl {{[0-9]+}}(%esp), %ecx
-; X32-NEXT:    movl %ecx, 48(%eax)
-; X32-NEXT:    movl {{[0-9]+}}(%esp), %ecx
-; X32-NEXT:    movl %ecx, 44(%eax)
-; X32-NEXT:    movl {{[0-9]+}}(%esp), %ecx
-; X32-NEXT:    movl %ecx, 40(%eax)
-; X32-NEXT:    movl {{[0-9]+}}(%esp), %ecx
-; X32-NEXT:    movl %ecx, 36(%eax)
-; X32-NEXT:    movl {{[0-9]+}}(%esp), %ecx
-; X32-NEXT:    movl %ecx, 32(%eax)
-; X32-NEXT:    movl {{[0-9]+}}(%esp), %ecx
 ; X32-NEXT:    sarl $31, %ecx
 ; X32-NEXT:    movl %ecx, 28(%eax)
 ; X32-NEXT:    movl %ecx, 24(%eax)
 ; X32-NEXT:    movl %ecx, 20(%eax)
 ; X32-NEXT:    movl %ecx, 16(%eax)
 ; X32-NEXT:    movl %ecx, 12(%eax)
 ; X32-NEXT:    movl %ecx, 8(%eax)
 ; X32-NEXT:    movl %ecx, 4(%eax)
 ; X32-NEXT:    movl %ecx, (%eax)
 ; X32-NEXT:    retl $4
 ;
 ; X64-LABEL: test_sra:
 ; X64:       # %bb.0:
-; X64-NEXT:    movq {{[0-9]+}}(%rsp), %rax
-; X64-NEXT:    movq {{[0-9]+}}(%rsp), %rcx
-; X64-NEXT:    movq {{[0-9]+}}(%rsp), %rdx
 ; X64-NEXT:    sarq $63, %r8
-; X64-NEXT:    movq %rdx, 56(%rdi)
-; X64-NEXT:    movq %rcx, 48(%rdi)
-; X64-NEXT:    movq %rax, 40(%rdi)
-; X64-NEXT:    movq %r9, 32(%rdi)
 ; X64-NEXT:    movq %r8, 24(%rdi)
 ; X64-NEXT:    movq %r8, 16(%rdi)
 ; X64-NEXT:    movq %r8, 8(%rdi)
 ; X64-NEXT:    movq %r8, (%rdi)
 ; X64-NEXT:    movq %rdi, %rax
 ; X64-NEXT:    retq
   %Amt = insertelement <2 x i256> undef, i256 -1, i32 0
   %Out = ashr <2 x i256> %In, %Amt
   ret <2 x i256> %Out
 }

test/CodeGen/X86/machine-cp.ll

 
 ; Check that copy propagation does not kill thing like:
 ; dst = copy src <-- do not kill that.
 ; ... = op1 undef dst
 ; ... = op2 dst <-- this is used here.
 define <16 x float> @foo(<16 x float> %x) {
 ; CHECK-LABEL: foo:
 ; CHECK:       ## %bb.0: ## %bb
-; CHECK-NEXT:    movaps %xmm3, %xmm8
-; CHECK-NEXT:    xorps %xmm3, %xmm3
-; CHECK-NEXT:    pxor %xmm6, %xmm6
-; CHECK-NEXT:    pcmpgtd %xmm0, %xmm6
-; CHECK-NEXT:    movdqa {{.*#+}} xmm5 = [255,255,255,255]
-; CHECK-NEXT:    pand %xmm6, %xmm5
-; CHECK-NEXT:    packuswb %xmm5, %xmm5
-; CHECK-NEXT:    packuswb %xmm5, %xmm5
-; CHECK-NEXT:    cvttps2dq %xmm0, %xmm13
-; CHECK-NEXT:    movdqa %xmm0, %xmm10
-; CHECK-NEXT:    cmpltps %xmm3, %xmm10
-; CHECK-NEXT:    movdqa %xmm6, %xmm9
-; CHECK-NEXT:    pxor %xmm10, %xmm9
-; CHECK-NEXT:    cvttps2dq %xmm1, %xmm14
-; CHECK-NEXT:    movaps %xmm1, %xmm11
-; CHECK-NEXT:    cmpltps %xmm3, %xmm11
-; CHECK-NEXT:    movdqa %xmm6, %xmm7
-; CHECK-NEXT:    pxor %xmm11, %xmm7
-; CHECK-NEXT:    cvttps2dq %xmm2, %xmm1
-; CHECK-NEXT:    cmpltps %xmm3, %xmm2
-; CHECK-NEXT:    movdqa %xmm6, %xmm4
-; CHECK-NEXT:    pxor %xmm2, %xmm4
-; CHECK-NEXT:    cvttps2dq %xmm8, %xmm12
-; CHECK-NEXT:    cmpltps %xmm3, %xmm8
-; CHECK-NEXT:    pxor %xmm8, %xmm6
-; CHECK-NEXT:    movdqa {{.*#+}} xmm0 = [1,1,1,1]
-; CHECK-NEXT:    pand %xmm0, %xmm6
-; CHECK-NEXT:    pand %xmm0, %xmm4
-; CHECK-NEXT:    pand %xmm0, %xmm7
-; CHECK-NEXT:    pand %xmm0, %xmm9
-; CHECK-NEXT:    cvtdq2ps %xmm13, %xmm15
-; CHECK-NEXT:    cvtdq2ps %xmm14, %xmm14
-; CHECK-NEXT:    cvtdq2ps %xmm1, %xmm13
-; CHECK-NEXT:    cvtdq2ps %xmm12, %xmm12
-; CHECK-NEXT:    pxor %xmm0, %xmm0
-; CHECK-NEXT:    cmpltps %xmm12, %xmm0
-; CHECK-NEXT:    xorps %xmm1, %xmm1
-; CHECK-NEXT:    cmpltps %xmm13, %xmm1
-; CHECK-NEXT:    packssdw %xmm0, %xmm1
 ; CHECK-NEXT:    xorps %xmm0, %xmm0
-; CHECK-NEXT:    cmpltps %xmm14, %xmm0
-; CHECK-NEXT:    cmpltps %xmm15, %xmm3
-; CHECK-NEXT:    packssdw %xmm0, %xmm3
-; CHECK-NEXT:    packsswb %xmm1, %xmm3
-; CHECK-NEXT:    pand %xmm5, %xmm3
-; CHECK-NEXT:    movdqa %xmm3, %xmm1
-; CHECK-NEXT:    punpcklbw {{.*#+}} xmm1 = xmm1[0],xmm0[0],xmm1[1],xmm0[1],xmm1[2],xmm0[2],xmm1[3],xmm0[3],xmm1[4],xmm0[4],xmm1[5],xmm0[5],xmm1[6],xmm0[6],xmm1[7],xmm0[7]
-; CHECK-NEXT:    movdqa %xmm1, %xmm0
-; CHECK-NEXT:    punpcklwd {{.*#+}} xmm0 = xmm0[0,0,1,1,2,2,3,3]
-; CHECK-NEXT:    pslld $31, %xmm0
-; CHECK-NEXT:    psrad $31, %xmm0
-; CHECK-NEXT:    punpckhwd {{.*#+}} xmm1 = xmm1[4],xmm0[4],xmm1[5],xmm0[5],xmm1[6],xmm0[6],xmm1[7],xmm0[7]
-; CHECK-NEXT:    pslld $31, %xmm1
-; CHECK-NEXT:    psrad $31, %xmm1
-; CHECK-NEXT:    punpckhbw {{.*#+}} xmm3 = xmm3[8],xmm0[8],xmm3[9],xmm0[9],xmm3[10],xmm0[10],xmm3[11],xmm0[11],xmm3[12],xmm0[12],xmm3[13],xmm0[13],xmm3[14],xmm0[14],xmm3[15],xmm0[15]
-; CHECK-NEXT:    movdqa %xmm3, %xmm5
-; CHECK-NEXT:    punpcklwd {{.*#+}} xmm5 = xmm5[0],xmm0[0],xmm5[1],xmm0[1],xmm5[2],xmm0[2],xmm5[3],xmm0[3]
-; CHECK-NEXT:    pslld $31, %xmm5
-; CHECK-NEXT:    psrad $31, %xmm5
-; CHECK-NEXT:    punpckhwd {{.*#+}} xmm3 = xmm3[4],xmm0[4],xmm3[5],xmm0[5],xmm3[6],xmm0[6],xmm3[7],xmm0[7]
-; CHECK-NEXT:    pslld $31, %xmm3
-; CHECK-NEXT:    psrad $31, %xmm3
-; CHECK-NEXT:    pxor %xmm9, %xmm0
-; CHECK-NEXT:    pxor %xmm15, %xmm0
-; CHECK-NEXT:    pxor %xmm7, %xmm1
-; CHECK-NEXT:    pxor %xmm14, %xmm1
-; CHECK-NEXT:    pxor %xmm4, %xmm5
-; CHECK-NEXT:    pxor %xmm13, %xmm5
-; CHECK-NEXT:    pxor %xmm6, %xmm3
-; CHECK-NEXT:    pxor %xmm12, %xmm3
-; CHECK-NEXT:    pand %xmm8, %xmm3
-; CHECK-NEXT:    pand %xmm2, %xmm5
-; CHECK-NEXT:    pand %xmm11, %xmm1
-; CHECK-NEXT:    pand %xmm10, %xmm0
-; CHECK-NEXT:    pxor %xmm9, %xmm0
-; CHECK-NEXT:    pxor %xmm7, %xmm1
-; CHECK-NEXT:    pxor %xmm4, %xmm5
-; CHECK-NEXT:    pxor %xmm6, %xmm3
-; CHECK-NEXT:    movdqa %xmm5, %xmm2
+; CHECK-NEXT:    xorps %xmm1, %xmm1
+; CHECK-NEXT:    xorps %xmm2, %xmm2
+; CHECK-NEXT:    xorps %xmm3, %xmm3
 ; CHECK-NEXT:    retq
 bb:
   %v3 = icmp slt <16 x i32> undef, zeroinitializer
   %v14 = zext <16 x i1> %v3 to <16 x i32>
   %v16 = fcmp olt <16 x float> %x, zeroinitializer
   %v17 = sext <16 x i1> %v16 to <16 x i32>
   %v18 = zext <16 x i1> %v16 to <16 x i32>
   %v19 = xor <16 x i32> %v14, %v18

test/CodeGen/X86/pr13577.ll

 ; This would crash:
 ; https://llvm.org/bugs/show_bug.cgi?id=26070
 
 define float @pr26070() {
 ; CHECK-LABEL: pr26070:
 ; CHECK:       ## %bb.0:
 ; CHECK-NEXT:    movss {{.*#+}} xmm0 = mem[0],zero,zero,zero
 ; CHECK-NEXT:    shufps {{.*#+}} xmm0 = xmm0[0,0,0,0]
-; CHECK-NEXT:    orps {{.*}}(%rip), %xmm0
 ; CHECK-NEXT:    retq
   %c = call float @copysignf(float 1.0, float undef) readnone
   ret float %c
 }
 
 declare float @copysignf(float, float)
 

test/CodeGen/X86/pr33960.ll

 ; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
 ; RUN: llc < %s -mtriple=i686-unknown -mattr=+avx | FileCheck %s --check-prefix=X86
 ; RUN: llc < %s -mtriple=x86_64-unknown -mattr=+avx | FileCheck %s --check-prefix=X64
 
 @b = external local_unnamed_addr global i32, align 4
 
 define void @PR33960() {
 ; X86-LABEL: PR33960:
 ; X86:       # %bb.0: # %entry
-; X86-NEXT:    movl $0, b
+; X86-NEXT:    movl $-1, b
 ; X86-NEXT:    retl
 ;
 ; X64-LABEL: PR33960:
 ; X64:       # %bb.0: # %entry
-; X64-NEXT:    movl $0, {{.*}}(%rip)
+; X64-NEXT:    movl $-1, {{.*}}(%rip)
 ; X64-NEXT:    retq
 entry:
   %tmp = insertelement <4 x i32> <i32 undef, i32 -7, i32 -3, i32 undef>, i32 -2, i32 3
   %predphi26 = insertelement <4 x i32> %tmp, i32 -7, i32 0
   %tmp1 = trunc <4 x i32> %predphi26 to <4 x i16>
   %tmp2 = icmp eq <4 x i16> %tmp1, zeroinitializer
   %tmp3 = icmp eq <4 x i32> undef, zeroinitializer
   %tmp4 = and <4 x i1> %tmp2, %tmp3

test/CodeGen/X86/undef-ops.ll

 ; CHECK-NEXT:    retq
   %r = mul i32 %x, undef
   ret i32 %r
 }
 
 define <4 x i32> @mul_undef_rhs_vec(<4 x i32> %x) {
 ; CHECK-LABEL: mul_undef_rhs_vec:
 ; CHECK:       # %bb.0:
+; CHECK-NEXT:    xorps %xmm0, %xmm0
 ; CHECK-NEXT:    retq
   %r = mul <4 x i32> %x, undef
   ret <4 x i32> %r
 }
 
 define i32 @mul_undef_lhs(i32 %x) {
 ; CHECK-LABEL: mul_undef_lhs:
 ; CHECK:       # %bb.0:
 ; CHECK-NEXT:    xorl %eax, %eax
 ; CHECK-NEXT:    retq
   %r = mul i32 undef, %x
   ret i32 %r
 }
 
 define <4 x i32> @mul_undef_lhs_vec(<4 x i32> %x) {
 ; CHECK-LABEL: mul_undef_lhs_vec:
 ; CHECK:       # %bb.0:
+; CHECK-NEXT:    xorps %xmm0, %xmm0
 ; CHECK-NEXT:    retq
   %r = mul <4 x i32> undef, %x
   ret <4 x i32> %r
 }
 
 define i32 @sdiv_undef_rhs(i32 %x) {
 ; CHECK-LABEL: sdiv_undef_rhs:
 ; CHECK:       # %bb.0:

 ; CHECK-NEXT:    retq
   %r = sdiv i32 undef, %x
   ret i32 %r
 }
 
 define <4 x i32> @sdiv_undef_lhs_vec(<4 x i32> %x) {
 ; CHECK-LABEL: sdiv_undef_lhs_vec:
 ; CHECK:       # %bb.0:
+; CHECK-NEXT:    xorps %xmm0, %xmm0
 ; CHECK-NEXT:    retq
   %r = sdiv <4 x i32> undef, %x
   ret <4 x i32> %r
 }
 
 define i32 @udiv_undef_rhs(i32 %x) {
 ; CHECK-LABEL: udiv_undef_rhs:
 ; CHECK:       # %bb.0:

 ; CHECK-NEXT:    retq
   %r = udiv i32 undef, %x
   ret i32 %r
 }
 
 define <4 x i32> @udiv_undef_lhs_vec(<4 x i32> %x) {
 ; CHECK-LABEL: udiv_undef_lhs_vec:
 ; CHECK:       # %bb.0:
+; CHECK-NEXT:    xorps %xmm0, %xmm0
 ; CHECK-NEXT:    retq
   %r = udiv <4 x i32> undef, %x
   ret <4 x i32> %r
 }
 
 define i32 @srem_undef_rhs(i32 %x) {
 ; CHECK-LABEL: srem_undef_rhs:
 ; CHECK:       # %bb.0:

 ; CHECK-NEXT:    retq
   %r = srem i32 undef, %x
   ret i32 %r
 }
 
 define <4 x i32> @srem_undef_lhs_vec(<4 x i32> %x) {
 ; CHECK-LABEL: srem_undef_lhs_vec:
 ; CHECK:       # %bb.0:
+; CHECK-NEXT:    xorps %xmm0, %xmm0
 ; CHECK-NEXT:    retq
   %r = srem <4 x i32> undef, %x
   ret <4 x i32> %r
 }
 
 define i32 @urem_undef_rhs(i32 %x) {
 ; CHECK-LABEL: urem_undef_rhs:
 ; CHECK:       # %bb.0:

 ; CHECK-NEXT:    retq
   %r = urem i32 undef, %x
   ret i32 %r
 }
 
 define <4 x i32> @urem_undef_lhs_vec(<4 x i32> %x) {
 ; CHECK-LABEL: urem_undef_lhs_vec:
 ; CHECK:       # %bb.0:
+; CHECK-NEXT:    xorps %xmm0, %xmm0
 ; CHECK-NEXT:    retq
   %r = urem <4 x i32> undef, %x
   ret <4 x i32> %r
 }
 
 define i32 @ashr_undef_rhs(i32 %x) {
 ; CHECK-LABEL: ashr_undef_rhs:
 ; CHECK:       # %bb.0:
-; CHECK-NEXT:    movl %edi, %eax
 ; CHECK-NEXT:    retq
   %r = ashr i32 %x, undef
   ret i32 %r
 }
 
 define <4 x i32> @ashr_undef_rhs_vec(<4 x i32> %x) {
 ; CHECK-LABEL: ashr_undef_rhs_vec:
 ; CHECK:       # %bb.0:
 ; CHECK-NEXT:    retq
   %r = ashr <4 x i32> %x, undef
   ret <4 x i32> %r
 }
 
 define i32 @ashr_undef_lhs(i32 %x) {
 ; CHECK-LABEL: ashr_undef_lhs:
 ; CHECK:       # %bb.0:
+; CHECK-NEXT:    xorl %eax, %eax
 ; CHECK-NEXT:    retq
   %r = ashr i32 undef, %x
   ret i32 %r
 }
 
 define <4 x i32> @ashr_undef_lhs_vec(<4 x i32> %x) {
 ; CHECK-LABEL: ashr_undef_lhs_vec:
 ; CHECK:       # %bb.0:
+; CHECK-NEXT:    xorps %xmm0, %xmm0
 ; CHECK-NEXT:    retq
   %r = ashr <4 x i32> undef, %x
   ret <4 x i32> %r
 }
 
 define i32 @lshr_undef_rhs(i32 %x) {
 ; CHECK-LABEL: lshr_undef_rhs:
 ; CHECK:       # %bb.0:
-; CHECK-NEXT:    xorl %eax, %eax
 ; CHECK-NEXT:    retq
   %r = lshr i32 %x, undef
   ret i32 %r
 }
 
 define <4 x i32> @lshr_undef_rhs_vec(<4 x i32> %x) {
 ; CHECK-LABEL: lshr_undef_rhs_vec:
 ; CHECK:       # %bb.0:

 ; CHECK-NEXT:    retq
   %r = lshr i32 undef, %x
   ret i32 %r
 }
 
 define <4 x i32> @lshr_undef_lhs_vec(<4 x i32> %x) {
 ; CHECK-LABEL: lshr_undef_lhs_vec:
 ; CHECK:       # %bb.0:
+; CHECK-NEXT:    xorps %xmm0, %xmm0
 ; CHECK-NEXT:    retq
   %r = lshr <4 x i32> undef, %x
   ret <4 x i32> %r
 }
 
 define i32 @shl_undef_rhs(i32 %x) {
 ; CHECK-LABEL: shl_undef_rhs:
 ; CHECK:       # %bb.0:
-; CHECK-NEXT:    xorl %eax, %eax
 ; CHECK-NEXT:    retq
   %r = shl i32 %x, undef
   ret i32 %r
 }
 
 define <4 x i32> @shl_undef_rhs_vec(<4 x i32> %x) {
 ; CHECK-LABEL: shl_undef_rhs_vec:
 ; CHECK:       # %bb.0:

 ; CHECK-NEXT:    retq
   %r = shl i32 undef, %x
   ret i32 %r
 }
 
 define <4 x i32> @shl_undef_lhs_vec(<4 x i32> %x) {
 ; CHECK-LABEL: shl_undef_lhs_vec:
 ; CHECK:       # %bb.0:
+; CHECK-NEXT:    xorps %xmm0, %xmm0
 ; CHECK-NEXT:    retq
   %r = shl <4 x i32> undef, %x
   ret <4 x i32> %r
 }
 
 define i32 @and_undef_rhs(i32 %x) {
 ; CHECK-LABEL: and_undef_rhs:
 ; CHECK:       # %bb.0:
 ; CHECK-NEXT:    xorl %eax, %eax
 ; CHECK-NEXT:    retq
   %r = and i32 %x, undef
   ret i32 %r
 }
 
 define <4 x i32> @and_undef_rhs_vec(<4 x i32> %x) {
 ; CHECK-LABEL: and_undef_rhs_vec:
 ; CHECK:       # %bb.0:
+; CHECK-NEXT:    xorps %xmm0, %xmm0
 ; CHECK-NEXT:    retq
   %r = and <4 x i32> %x, undef
   ret <4 x i32> %r
 }
 
 define i32 @and_undef_lhs(i32 %x) {
 ; CHECK-LABEL: and_undef_lhs:
 ; CHECK:       # %bb.0:
 ; CHECK-NEXT:    xorl %eax, %eax
 ; CHECK-NEXT:    retq
   %r = and i32 undef, %x
   ret i32 %r
 }
 
 define <4 x i32> @and_undef_lhs_vec(<4 x i32> %x) {
 ; CHECK-LABEL: and_undef_lhs_vec:
 ; CHECK:       # %bb.0:
+; CHECK-NEXT:    xorps %xmm0, %xmm0
 ; CHECK-NEXT:    retq
   %r = and <4 x i32> undef, %x
   ret <4 x i32> %r
 }
 
 define i32 @or_undef_rhs(i32 %x) {
 ; CHECK-LABEL: or_undef_rhs:
 ; CHECK:       # %bb.0:
 ; CHECK-NEXT:    movl $-1, %eax
 ; CHECK-NEXT:    retq
   %r = or i32 %x, undef
   ret i32 %r
 }
 
 define <4 x i32> @or_undef_rhs_vec(<4 x i32> %x) {
 ; CHECK-LABEL: or_undef_rhs_vec:
 ; CHECK:       # %bb.0:
+; CHECK-NEXT:    pcmpeqd %xmm0, %xmm0
 ; CHECK-NEXT:    retq
   %r = or <4 x i32> %x, undef
   ret <4 x i32> %r
 }
 
 define i32 @or_undef_lhs(i32 %x) {
 ; CHECK-LABEL: or_undef_lhs:
 ; CHECK:       # %bb.0:
 ; CHECK-NEXT:    movl $-1, %eax
 ; CHECK-NEXT:    retq
   %r = or i32 undef, %x
   ret i32 %r
 }
 
 define <4 x i32> @or_undef_lhs_vec(<4 x i32> %x) {
 ; CHECK-LABEL: or_undef_lhs_vec:
 ; CHECK:       # %bb.0:
+; CHECK-NEXT:    pcmpeqd %xmm0, %xmm0
 ; CHECK-NEXT:    retq
   %r = or <4 x i32> undef, %x
   ret <4 x i32> %r
 }
 
 define i32 @xor_undef_rhs(i32 %x) {
 ; CHECK-LABEL: xor_undef_rhs:
 ; CHECK:       # %bb.0: