This is an archive of the discontinued LLVM Phabricator instance.

Differential D66053

[X86] Remove redundant ';' chars ending IR lines in lit tests. NFC
ClosedPublic

Authored by bjope on Aug 10 2019, 5:34 AM.

Details

Reviewers
RKSimon
craig.topper
Commits
rGcf9fa0b382d5: [X86] Remove redundant ';' chars ending IR lines in lit tests. NFC
rL368541: [X86] Remove redundant ';' chars ending IR lines in lit tests. NFC

Diff Detail

Repository
rL LLVM

Event Timeline

bjope created this revision.Aug 10 2019, 5:34 AM
Herald added a project: Restricted Project. · View Herald TranscriptAug 10 2019, 5:34 AM
Harbormaster completed remote builds in B36571: Diff 214522.Aug 10 2019, 5:34 AM
craig.topper accepted this revision.Aug 10 2019, 8:45 AM

LGTM

This revision is now accepted and ready to land.Aug 10 2019, 8:45 AM
Closed by commit rL368541: [X86] Remove redundant ';' chars ending IR lines in lit tests. NFC (authored by bjope). · Explain WhyAug 11 2019, 12:29 PM
This revision was automatically updated to reflect the committed changes.

Revision Contents

PathSize
llvm/
trunk/
test/
CodeGen/
X86/
40 lines
40 lines
20 lines
16 lines
16 lines
44 lines
16 lines

Diff 214562

llvm/trunk/test/CodeGen/X86/smul_fix.ll

Show All 19 Lines
; X64-NEXT: retq ; X64-NEXT: retq
; ;
; X86-LABEL: func: ; X86-LABEL: func:
; X86: # %bb.0: ; X86: # %bb.0:
; X86-NEXT: movl {{[0-9]+}}(%esp), %eax ; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
; X86-NEXT: imull {{[0-9]+}}(%esp) ; X86-NEXT: imull {{[0-9]+}}(%esp)
; X86-NEXT: shrdl $2, %edx, %eax ; X86-NEXT: shrdl $2, %edx, %eax
; X86-NEXT: retl ; X86-NEXT: retl
%tmp = call i32 @llvm.smul.fix.i32(i32 %x, i32 %y, i32 2); %tmp = call i32 @llvm.smul.fix.i32(i32 %x, i32 %y, i32 2)
ret i32 %tmp; ret i32 %tmp
} }
define i64 @func2(i64 %x, i64 %y) { define i64 @func2(i64 %x, i64 %y) {
; X64-LABEL: func2: ; X64-LABEL: func2:
; X64: # %bb.0: ; X64: # %bb.0:
; X64-NEXT: movq %rdi, %rax ; X64-NEXT: movq %rdi, %rax
; X64-NEXT: imulq %rsi ; X64-NEXT: imulq %rsi
; X64-NEXT: shrdq $2, %rdx, %rax ; X64-NEXT: shrdq $2, %rdx, %rax
▲ Show 20 Lines • Show All 47 Lines • ▼ Show 20 Lines
; X86-NEXT: .cfi_def_cfa_offset 16 ; X86-NEXT: .cfi_def_cfa_offset 16
; X86-NEXT: popl %edi ; X86-NEXT: popl %edi
; X86-NEXT: .cfi_def_cfa_offset 12 ; X86-NEXT: .cfi_def_cfa_offset 12
; X86-NEXT: popl %ebx ; X86-NEXT: popl %ebx
; X86-NEXT: .cfi_def_cfa_offset 8 ; X86-NEXT: .cfi_def_cfa_offset 8
; X86-NEXT: popl %ebp ; X86-NEXT: popl %ebp
; X86-NEXT: .cfi_def_cfa_offset 4 ; X86-NEXT: .cfi_def_cfa_offset 4
; X86-NEXT: retl ; X86-NEXT: retl
%tmp = call i64 @llvm.smul.fix.i64(i64 %x, i64 %y, i32 2); %tmp = call i64 @llvm.smul.fix.i64(i64 %x, i64 %y, i32 2)
ret i64 %tmp; ret i64 %tmp
} }
define i4 @func3(i4 %x, i4 %y) nounwind { define i4 @func3(i4 %x, i4 %y) nounwind {
; X64-LABEL: func3: ; X64-LABEL: func3:
; X64: # %bb.0: ; X64: # %bb.0:
; X64-NEXT: shlb $4, %dil ; X64-NEXT: shlb $4, %dil
; X64-NEXT: sarb $4, %dil ; X64-NEXT: sarb $4, %dil
; X64-NEXT: shlb $4, %sil ; X64-NEXT: shlb $4, %sil
Show All 20 Lines
; X86-NEXT: movsbl %cl, %ecx ; X86-NEXT: movsbl %cl, %ecx
; X86-NEXT: movsbl %al, %eax ; X86-NEXT: movsbl %al, %eax
; X86-NEXT: imull %ecx, %eax ; X86-NEXT: imull %ecx, %eax
; X86-NEXT: shlb $6, %ah ; X86-NEXT: shlb $6, %ah
; X86-NEXT: shrb $2, %al ; X86-NEXT: shrb $2, %al
; X86-NEXT: orb %ah, %al ; X86-NEXT: orb %ah, %al
; X86-NEXT: # kill: def $al killed $al killed $eax ; X86-NEXT: # kill: def $al killed $al killed $eax
; X86-NEXT: retl ; X86-NEXT: retl
%tmp = call i4 @llvm.smul.fix.i4(i4 %x, i4 %y, i32 2); %tmp = call i4 @llvm.smul.fix.i4(i4 %x, i4 %y, i32 2)
ret i4 %tmp; ret i4 %tmp
} }
define <4 x i32> @vec(<4 x i32> %x, <4 x i32> %y) nounwind { define <4 x i32> @vec(<4 x i32> %x, <4 x i32> %y) nounwind {
; X64-LABEL: vec: ; X64-LABEL: vec:
; X64: # %bb.0: ; X64: # %bb.0:
; X64-NEXT: pxor %xmm2, %xmm2 ; X64-NEXT: pxor %xmm2, %xmm2
; X64-NEXT: pxor %xmm3, %xmm3 ; X64-NEXT: pxor %xmm3, %xmm3
; X64-NEXT: pcmpgtd %xmm1, %xmm3 ; X64-NEXT: pcmpgtd %xmm1, %xmm3
▲ Show 20 Lines • Show All 47 Lines • ▼ Show 20 Lines
; X86-NEXT: movl %ebx, 4(%ecx) ; X86-NEXT: movl %ebx, 4(%ecx)
; X86-NEXT: movl %ebp, (%ecx) ; X86-NEXT: movl %ebp, (%ecx)
; X86-NEXT: movl %ecx, %eax ; X86-NEXT: movl %ecx, %eax
; X86-NEXT: popl %esi ; X86-NEXT: popl %esi
; X86-NEXT: popl %edi ; X86-NEXT: popl %edi
; X86-NEXT: popl %ebx ; X86-NEXT: popl %ebx
; X86-NEXT: popl %ebp ; X86-NEXT: popl %ebp
; X86-NEXT: retl $4 ; X86-NEXT: retl $4
%tmp = call <4 x i32> @llvm.smul.fix.v4i32(<4 x i32> %x, <4 x i32> %y, i32 2); %tmp = call <4 x i32> @llvm.smul.fix.v4i32(<4 x i32> %x, <4 x i32> %y, i32 2)
ret <4 x i32> %tmp; ret <4 x i32> %tmp
} }
; These result in regular integer multiplication ; These result in regular integer multiplication
define i32 @func4(i32 %x, i32 %y) nounwind { define i32 @func4(i32 %x, i32 %y) nounwind {
; X64-LABEL: func4: ; X64-LABEL: func4:
; X64: # %bb.0: ; X64: # %bb.0:
; X64-NEXT: movl %edi, %eax ; X64-NEXT: movl %edi, %eax
; X64-NEXT: imull %esi, %eax ; X64-NEXT: imull %esi, %eax
; X64-NEXT: retq ; X64-NEXT: retq
; ;
; X86-LABEL: func4: ; X86-LABEL: func4:
; X86: # %bb.0: ; X86: # %bb.0:
; X86-NEXT: movl {{[0-9]+}}(%esp), %eax ; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
; X86-NEXT: imull {{[0-9]+}}(%esp), %eax ; X86-NEXT: imull {{[0-9]+}}(%esp), %eax
; X86-NEXT: retl ; X86-NEXT: retl
%tmp = call i32 @llvm.smul.fix.i32(i32 %x, i32 %y, i32 0); %tmp = call i32 @llvm.smul.fix.i32(i32 %x, i32 %y, i32 0)
ret i32 %tmp; ret i32 %tmp
} }
define i64 @func5(i64 %x, i64 %y) { define i64 @func5(i64 %x, i64 %y) {
; X64-LABEL: func5: ; X64-LABEL: func5:
; X64: # %bb.0: ; X64: # %bb.0:
; X64-NEXT: movq %rdi, %rax ; X64-NEXT: movq %rdi, %rax
; X64-NEXT: imulq %rsi, %rax ; X64-NEXT: imulq %rsi, %rax
; X64-NEXT: retq ; X64-NEXT: retq
Show All 9 Lines
; X86-NEXT: mull %esi ; X86-NEXT: mull %esi
; X86-NEXT: imull {{[0-9]+}}(%esp), %ecx ; X86-NEXT: imull {{[0-9]+}}(%esp), %ecx
; X86-NEXT: addl %ecx, %edx ; X86-NEXT: addl %ecx, %edx
; X86-NEXT: imull {{[0-9]+}}(%esp), %esi ; X86-NEXT: imull {{[0-9]+}}(%esp), %esi
; X86-NEXT: addl %esi, %edx ; X86-NEXT: addl %esi, %edx
; X86-NEXT: popl %esi ; X86-NEXT: popl %esi
; X86-NEXT: .cfi_def_cfa_offset 4 ; X86-NEXT: .cfi_def_cfa_offset 4
; X86-NEXT: retl ; X86-NEXT: retl
%tmp = call i64 @llvm.smul.fix.i64(i64 %x, i64 %y, i32 0); %tmp = call i64 @llvm.smul.fix.i64(i64 %x, i64 %y, i32 0)
ret i64 %tmp; ret i64 %tmp
} }
define i4 @func6(i4 %x, i4 %y) nounwind { define i4 @func6(i4 %x, i4 %y) nounwind {
; X64-LABEL: func6: ; X64-LABEL: func6:
; X64: # %bb.0: ; X64: # %bb.0:
; X64-NEXT: movl %edi, %eax ; X64-NEXT: movl %edi, %eax
; X64-NEXT: shlb $4, %al ; X64-NEXT: shlb $4, %al
; X64-NEXT: sarb $4, %al ; X64-NEXT: sarb $4, %al
; X64-NEXT: shlb $4, %sil ; X64-NEXT: shlb $4, %sil
; X64-NEXT: sarb $4, %sil ; X64-NEXT: sarb $4, %sil
; X64-NEXT: # kill: def $al killed $al killed $eax ; X64-NEXT: # kill: def $al killed $al killed $eax
; X64-NEXT: mulb %sil ; X64-NEXT: mulb %sil
; X64-NEXT: retq ; X64-NEXT: retq
; ;
; X86-LABEL: func6: ; X86-LABEL: func6:
; X86: # %bb.0: ; X86: # %bb.0:
; X86-NEXT: movb {{[0-9]+}}(%esp), %al ; X86-NEXT: movb {{[0-9]+}}(%esp), %al
; X86-NEXT: shlb $4, %al ; X86-NEXT: shlb $4, %al
; X86-NEXT: sarb $4, %al ; X86-NEXT: sarb $4, %al
; X86-NEXT: movb {{[0-9]+}}(%esp), %cl ; X86-NEXT: movb {{[0-9]+}}(%esp), %cl
; X86-NEXT: shlb $4, %cl ; X86-NEXT: shlb $4, %cl
; X86-NEXT: sarb $4, %cl ; X86-NEXT: sarb $4, %cl
; X86-NEXT: mulb %cl ; X86-NEXT: mulb %cl
; X86-NEXT: retl ; X86-NEXT: retl
%tmp = call i4 @llvm.smul.fix.i4(i4 %x, i4 %y, i32 0); %tmp = call i4 @llvm.smul.fix.i4(i4 %x, i4 %y, i32 0)
ret i4 %tmp; ret i4 %tmp
} }
define <4 x i32> @vec2(<4 x i32> %x, <4 x i32> %y) nounwind { define <4 x i32> @vec2(<4 x i32> %x, <4 x i32> %y) nounwind {
; X64-LABEL: vec2: ; X64-LABEL: vec2:
; X64: # %bb.0: ; X64: # %bb.0:
; X64-NEXT: pshufd {{.*#+}} xmm2 = xmm0[1,1,3,3] ; X64-NEXT: pshufd {{.*#+}} xmm2 = xmm0[1,1,3,3]
; X64-NEXT: pmuludq %xmm1, %xmm0 ; X64-NEXT: pmuludq %xmm1, %xmm0
; X64-NEXT: pshufd {{.*#+}} xmm0 = xmm0[0,2,2,3] ; X64-NEXT: pshufd {{.*#+}} xmm0 = xmm0[0,2,2,3]
Show All 18 Lines
; X86-NEXT: imull {{[0-9]+}}(%esp), %ecx ; X86-NEXT: imull {{[0-9]+}}(%esp), %ecx
; X86-NEXT: movl %ecx, 12(%eax) ; X86-NEXT: movl %ecx, 12(%eax)
; X86-NEXT: movl %edx, 8(%eax) ; X86-NEXT: movl %edx, 8(%eax)
; X86-NEXT: movl %esi, 4(%eax) ; X86-NEXT: movl %esi, 4(%eax)
; X86-NEXT: movl %edi, (%eax) ; X86-NEXT: movl %edi, (%eax)
; X86-NEXT: popl %esi ; X86-NEXT: popl %esi
; X86-NEXT: popl %edi ; X86-NEXT: popl %edi
; X86-NEXT: retl $4 ; X86-NEXT: retl $4
%tmp = call <4 x i32> @llvm.smul.fix.v4i32(<4 x i32> %x, <4 x i32> %y, i32 0); %tmp = call <4 x i32> @llvm.smul.fix.v4i32(<4 x i32> %x, <4 x i32> %y, i32 0)
ret <4 x i32> %tmp; ret <4 x i32> %tmp
} }
define i64 @func7(i64 %x, i64 %y) nounwind { define i64 @func7(i64 %x, i64 %y) nounwind {
; X64-LABEL: func7: ; X64-LABEL: func7:
; X64: # %bb.0: ; X64: # %bb.0:
; X64-NEXT: movq %rdi, %rax ; X64-NEXT: movq %rdi, %rax
; X64-NEXT: imulq %rsi ; X64-NEXT: imulq %rsi
; X64-NEXT: shrdq $32, %rdx, %rax ; X64-NEXT: shrdq $32, %rdx, %rax
Show All 31 Lines
; X86-NEXT: subl %ecx, %edx ; X86-NEXT: subl %ecx, %edx
; X86-NEXT: cmpl $0, {{[0-9]+}}(%esp) ; X86-NEXT: cmpl $0, {{[0-9]+}}(%esp)
; X86-NEXT: cmovnsl %ebx, %edx ; X86-NEXT: cmovnsl %ebx, %edx
; X86-NEXT: popl %esi ; X86-NEXT: popl %esi
; X86-NEXT: popl %edi ; X86-NEXT: popl %edi
; X86-NEXT: popl %ebx ; X86-NEXT: popl %ebx
; X86-NEXT: popl %ebp ; X86-NEXT: popl %ebp
; X86-NEXT: retl ; X86-NEXT: retl
%tmp = call i64 @llvm.smul.fix.i64(i64 %x, i64 %y, i32 32); %tmp = call i64 @llvm.smul.fix.i64(i64 %x, i64 %y, i32 32)
ret i64 %tmp; ret i64 %tmp
} }
define i64 @func8(i64 %x, i64 %y) nounwind { define i64 @func8(i64 %x, i64 %y) nounwind {
; X64-LABEL: func8: ; X64-LABEL: func8:
; X64: # %bb.0: ; X64: # %bb.0:
; X64-NEXT: movq %rdi, %rax ; X64-NEXT: movq %rdi, %rax
; X64-NEXT: imulq %rsi ; X64-NEXT: imulq %rsi
; X64-NEXT: shrdq $63, %rdx, %rax ; X64-NEXT: shrdq $63, %rdx, %rax
▲ Show 20 Lines • Show All 43 Lines • ▼ Show 20 Lines
; X86-NEXT: cmovnsl %ecx, %edi ; X86-NEXT: cmovnsl %ecx, %edi
; X86-NEXT: shldl $1, %edi, %edx ; X86-NEXT: shldl $1, %edi, %edx
; X86-NEXT: shrdl $31, %edi, %eax ; X86-NEXT: shrdl $31, %edi, %eax
; X86-NEXT: popl %esi ; X86-NEXT: popl %esi
; X86-NEXT: popl %edi ; X86-NEXT: popl %edi
; X86-NEXT: popl %ebx ; X86-NEXT: popl %ebx
; X86-NEXT: popl %ebp ; X86-NEXT: popl %ebp
; X86-NEXT: retl ; X86-NEXT: retl
%tmp = call i64 @llvm.smul.fix.i64(i64 %x, i64 %y, i32 63); %tmp = call i64 @llvm.smul.fix.i64(i64 %x, i64 %y, i32 63)
ret i64 %tmp; ret i64 %tmp
} }

llvm/trunk/test/CodeGen/X86/smul_fix_sat.ll

Show All 30 Lines
; X86-NEXT: shrdl $2, %edx, %eax ; X86-NEXT: shrdl $2, %edx, %eax
; X86-NEXT: cmpl $1, %edx ; X86-NEXT: cmpl $1, %edx
; X86-NEXT: movl $2147483647, %ecx # imm = 0x7FFFFFFF ; X86-NEXT: movl $2147483647, %ecx # imm = 0x7FFFFFFF
; X86-NEXT: cmovgl %ecx, %eax ; X86-NEXT: cmovgl %ecx, %eax
; X86-NEXT: cmpl $-2, %edx ; X86-NEXT: cmpl $-2, %edx
; X86-NEXT: movl $-2147483648, %ecx # imm = 0x80000000 ; X86-NEXT: movl $-2147483648, %ecx # imm = 0x80000000
; X86-NEXT: cmovll %ecx, %eax ; X86-NEXT: cmovll %ecx, %eax
; X86-NEXT: retl ; X86-NEXT: retl
%tmp = call i32 @llvm.smul.fix.sat.i32(i32 %x, i32 %y, i32 2); %tmp = call i32 @llvm.smul.fix.sat.i32(i32 %x, i32 %y, i32 2)
ret i32 %tmp; ret i32 %tmp
} }
define i64 @func2(i64 %x, i64 %y) nounwind { define i64 @func2(i64 %x, i64 %y) nounwind {
; X64-LABEL: func2: ; X64-LABEL: func2:
; X64: # %bb.0: ; X64: # %bb.0:
; X64-NEXT: movq %rdi, %rax ; X64-NEXT: movq %rdi, %rax
; X64-NEXT: imulq %rsi ; X64-NEXT: imulq %rsi
; X64-NEXT: shrdq $2, %rdx, %rax ; X64-NEXT: shrdq $2, %rdx, %rax
▲ Show 20 Lines • Show All 78 Lines • ▼ Show 20 Lines
; X86-NEXT: movl $-2147483648, %ecx # imm = 0x80000000 ; X86-NEXT: movl $-2147483648, %ecx # imm = 0x80000000
; X86-NEXT: cmovnel %ecx, %edx ; X86-NEXT: cmovnel %ecx, %edx
; X86-NEXT: addl $8, %esp ; X86-NEXT: addl $8, %esp
; X86-NEXT: popl %esi ; X86-NEXT: popl %esi
; X86-NEXT: popl %edi ; X86-NEXT: popl %edi
; X86-NEXT: popl %ebx ; X86-NEXT: popl %ebx
; X86-NEXT: popl %ebp ; X86-NEXT: popl %ebp
; X86-NEXT: retl ; X86-NEXT: retl
%tmp = call i64 @llvm.smul.fix.sat.i64(i64 %x, i64 %y, i32 2); %tmp = call i64 @llvm.smul.fix.sat.i64(i64 %x, i64 %y, i32 2)
ret i64 %tmp; ret i64 %tmp
} }
define i4 @func3(i4 %x, i4 %y) nounwind { define i4 @func3(i4 %x, i4 %y) nounwind {
; X64-LABEL: func3: ; X64-LABEL: func3:
; X64: # %bb.0: ; X64: # %bb.0:
; X64-NEXT: shlb $4, %sil ; X64-NEXT: shlb $4, %sil
; X64-NEXT: sarb $4, %sil ; X64-NEXT: sarb $4, %sil
; X64-NEXT: shlb $4, %dil ; X64-NEXT: shlb $4, %dil
Show All 36 Lines
; X86-NEXT: movl $127, %edx ; X86-NEXT: movl $127, %edx
; X86-NEXT: cmovlel %ecx, %edx ; X86-NEXT: cmovlel %ecx, %edx
; X86-NEXT: cmpb $-2, %ah ; X86-NEXT: cmpb $-2, %ah
; X86-NEXT: movl $128, %eax ; X86-NEXT: movl $128, %eax
; X86-NEXT: cmovgel %edx, %eax ; X86-NEXT: cmovgel %edx, %eax
; X86-NEXT: sarb $4, %al ; X86-NEXT: sarb $4, %al
; X86-NEXT: # kill: def $al killed $al killed $eax ; X86-NEXT: # kill: def $al killed $al killed $eax
; X86-NEXT: retl ; X86-NEXT: retl
%tmp = call i4 @llvm.smul.fix.sat.i4(i4 %x, i4 %y, i32 2); %tmp = call i4 @llvm.smul.fix.sat.i4(i4 %x, i4 %y, i32 2)
ret i4 %tmp; ret i4 %tmp
} }
define <4 x i32> @vec(<4 x i32> %x, <4 x i32> %y) nounwind { define <4 x i32> @vec(<4 x i32> %x, <4 x i32> %y) nounwind {
; X64-LABEL: vec: ; X64-LABEL: vec:
; X64: # %bb.0: ; X64: # %bb.0:
; X64-NEXT: pshufd {{.*#+}} xmm2 = xmm1[3,1,2,3] ; X64-NEXT: pshufd {{.*#+}} xmm2 = xmm1[3,1,2,3]
; X64-NEXT: movd %xmm2, %eax ; X64-NEXT: movd %xmm2, %eax
; X64-NEXT: cltq ; X64-NEXT: cltq
▲ Show 20 Lines • Show All 107 Lines • ▼ Show 20 Lines
; X86-NEXT: movl %edi, 4(%edx) ; X86-NEXT: movl %edi, 4(%edx)
; X86-NEXT: movl %ecx, (%edx) ; X86-NEXT: movl %ecx, (%edx)
; X86-NEXT: movl %edx, %eax ; X86-NEXT: movl %edx, %eax
; X86-NEXT: popl %esi ; X86-NEXT: popl %esi
; X86-NEXT: popl %edi ; X86-NEXT: popl %edi
; X86-NEXT: popl %ebx ; X86-NEXT: popl %ebx
; X86-NEXT: popl %ebp ; X86-NEXT: popl %ebp
; X86-NEXT: retl $4 ; X86-NEXT: retl $4
%tmp = call <4 x i32> @llvm.smul.fix.sat.v4i32(<4 x i32> %x, <4 x i32> %y, i32 2); %tmp = call <4 x i32> @llvm.smul.fix.sat.v4i32(<4 x i32> %x, <4 x i32> %y, i32 2)
ret <4 x i32> %tmp; ret <4 x i32> %tmp
} }
; These result in regular integer multiplication ; These result in regular integer multiplication
define i32 @func4(i32 %x, i32 %y) nounwind { define i32 @func4(i32 %x, i32 %y) nounwind {
; X64-LABEL: func4: ; X64-LABEL: func4:
; X64: # %bb.0: ; X64: # %bb.0:
; X64-NEXT: movl %edi, %ecx ; X64-NEXT: movl %edi, %ecx
; X64-NEXT: imull %esi, %ecx ; X64-NEXT: imull %esi, %ecx
Show All 15 Lines
; X86-NEXT: xorl %ecx, %ecx ; X86-NEXT: xorl %ecx, %ecx
; X86-NEXT: testl %esi, %esi ; X86-NEXT: testl %esi, %esi
; X86-NEXT: setns %cl ; X86-NEXT: setns %cl
; X86-NEXT: addl $2147483647, %ecx # imm = 0x7FFFFFFF ; X86-NEXT: addl $2147483647, %ecx # imm = 0x7FFFFFFF
; X86-NEXT: imull %edx, %eax ; X86-NEXT: imull %edx, %eax
; X86-NEXT: cmovol %ecx, %eax ; X86-NEXT: cmovol %ecx, %eax
; X86-NEXT: popl %esi ; X86-NEXT: popl %esi
; X86-NEXT: retl ; X86-NEXT: retl
%tmp = call i32 @llvm.smul.fix.sat.i32(i32 %x, i32 %y, i32 0); %tmp = call i32 @llvm.smul.fix.sat.i32(i32 %x, i32 %y, i32 0)
ret i32 %tmp; ret i32 %tmp
} }
define i64 @func5(i64 %x, i64 %y) { define i64 @func5(i64 %x, i64 %y) {
; X64-LABEL: func5: ; X64-LABEL: func5:
; X64: # %bb.0: ; X64: # %bb.0:
; X64-NEXT: movq %rdi, %rax ; X64-NEXT: movq %rdi, %rax
; X64-NEXT: imulq %rsi, %rax ; X64-NEXT: imulq %rsi, %rax
; X64-NEXT: xorl %ecx, %ecx ; X64-NEXT: xorl %ecx, %ecx
▲ Show 20 Lines • Show All 45 Lines • ▼ Show 20 Lines
; X86-NEXT: cmovnel %ecx, %edx ; X86-NEXT: cmovnel %ecx, %edx
; X86-NEXT: addl $4, %esp ; X86-NEXT: addl $4, %esp
; X86-NEXT: .cfi_def_cfa_offset 12 ; X86-NEXT: .cfi_def_cfa_offset 12
; X86-NEXT: popl %esi ; X86-NEXT: popl %esi
; X86-NEXT: .cfi_def_cfa_offset 8 ; X86-NEXT: .cfi_def_cfa_offset 8
; X86-NEXT: popl %edi ; X86-NEXT: popl %edi
; X86-NEXT: .cfi_def_cfa_offset 4 ; X86-NEXT: .cfi_def_cfa_offset 4
; X86-NEXT: retl ; X86-NEXT: retl
%tmp = call i64 @llvm.smul.fix.sat.i64(i64 %x, i64 %y, i32 0); %tmp = call i64 @llvm.smul.fix.sat.i64(i64 %x, i64 %y, i32 0)
ret i64 %tmp; ret i64 %tmp
} }
define i4 @func6(i4 %x, i4 %y) nounwind { define i4 @func6(i4 %x, i4 %y) nounwind {
; X64-LABEL: func6: ; X64-LABEL: func6:
; X64: # %bb.0: ; X64: # %bb.0:
; X64-NEXT: movl %edi, %eax ; X64-NEXT: movl %edi, %eax
; X64-NEXT: shlb $4, %sil ; X64-NEXT: shlb $4, %sil
; X64-NEXT: sarb $4, %sil ; X64-NEXT: sarb $4, %sil
Show All 26 Lines
; X86-NEXT: setns %cl ; X86-NEXT: setns %cl
; X86-NEXT: addl $127, %ecx ; X86-NEXT: addl $127, %ecx
; X86-NEXT: movzbl %al, %eax ; X86-NEXT: movzbl %al, %eax
; X86-NEXT: testb %dl, %dl ; X86-NEXT: testb %dl, %dl
; X86-NEXT: cmovnel %ecx, %eax ; X86-NEXT: cmovnel %ecx, %eax
; X86-NEXT: sarb $4, %al ; X86-NEXT: sarb $4, %al
; X86-NEXT: # kill: def $al killed $al killed $eax ; X86-NEXT: # kill: def $al killed $al killed $eax
; X86-NEXT: retl ; X86-NEXT: retl
%tmp = call i4 @llvm.smul.fix.sat.i4(i4 %x, i4 %y, i32 0); %tmp = call i4 @llvm.smul.fix.sat.i4(i4 %x, i4 %y, i32 0)
ret i4 %tmp; ret i4 %tmp
} }
define <4 x i32> @vec2(<4 x i32> %x, <4 x i32> %y) nounwind { define <4 x i32> @vec2(<4 x i32> %x, <4 x i32> %y) nounwind {
; X64-LABEL: vec2: ; X64-LABEL: vec2:
; X64: # %bb.0: ; X64: # %bb.0:
; X64-NEXT: pshufd {{.*#+}} xmm2 = xmm1[1,1,2,3] ; X64-NEXT: pshufd {{.*#+}} xmm2 = xmm1[1,1,2,3]
; X64-NEXT: movd %xmm2, %ecx ; X64-NEXT: movd %xmm2, %ecx
; X64-NEXT: pshufd {{.*#+}} xmm2 = xmm0[1,1,2,3] ; X64-NEXT: pshufd {{.*#+}} xmm2 = xmm0[1,1,2,3]
▲ Show 20 Lines • Show All 100 Lines • ▼ Show 20 Lines
; X86-NEXT: movl %edx, 8(%eax) ; X86-NEXT: movl %edx, 8(%eax)
; X86-NEXT: movl %esi, 4(%eax) ; X86-NEXT: movl %esi, 4(%eax)
; X86-NEXT: movl %edi, (%eax) ; X86-NEXT: movl %edi, (%eax)
; X86-NEXT: popl %esi ; X86-NEXT: popl %esi
; X86-NEXT: popl %edi ; X86-NEXT: popl %edi
; X86-NEXT: popl %ebx ; X86-NEXT: popl %ebx
; X86-NEXT: popl %ebp ; X86-NEXT: popl %ebp
; X86-NEXT: retl $4 ; X86-NEXT: retl $4
%tmp = call <4 x i32> @llvm.smul.fix.sat.v4i32(<4 x i32> %x, <4 x i32> %y, i32 0); %tmp = call <4 x i32> @llvm.smul.fix.sat.v4i32(<4 x i32> %x, <4 x i32> %y, i32 0)
ret <4 x i32> %tmp; ret <4 x i32> %tmp
} }
define i64 @func7(i64 %x, i64 %y) nounwind { define i64 @func7(i64 %x, i64 %y) nounwind {
; X64-LABEL: func7: ; X64-LABEL: func7:
; X64: # %bb.0: ; X64: # %bb.0:
; X64-NEXT: movq %rdi, %rax ; X64-NEXT: movq %rdi, %rax
; X64-NEXT: imulq %rsi ; X64-NEXT: imulq %rsi
; X64-NEXT: shrdq $32, %rdx, %rax ; X64-NEXT: shrdq $32, %rdx, %rax
▲ Show 20 Lines • Show All 67 Lines • ▼ Show 20 Lines
; X86-NEXT: cmovnel %esi, %eax ; X86-NEXT: cmovnel %esi, %eax
; X86-NEXT: movl $-2147483648, %ecx # imm = 0x80000000 ; X86-NEXT: movl $-2147483648, %ecx # imm = 0x80000000
; X86-NEXT: cmovnel %ecx, %edx ; X86-NEXT: cmovnel %ecx, %edx
; X86-NEXT: popl %esi ; X86-NEXT: popl %esi
; X86-NEXT: popl %edi ; X86-NEXT: popl %edi
; X86-NEXT: popl %ebx ; X86-NEXT: popl %ebx
; X86-NEXT: popl %ebp ; X86-NEXT: popl %ebp
; X86-NEXT: retl ; X86-NEXT: retl
%tmp = call i64 @llvm.smul.fix.sat.i64(i64 %x, i64 %y, i32 32); %tmp = call i64 @llvm.smul.fix.sat.i64(i64 %x, i64 %y, i32 32)
ret i64 %tmp; ret i64 %tmp
} }
define i64 @func8(i64 %x, i64 %y) nounwind { define i64 @func8(i64 %x, i64 %y) nounwind {
; X64-LABEL: func8: ; X64-LABEL: func8:
; X64: # %bb.0: ; X64: # %bb.0:
; X64-NEXT: movq %rdi, %rax ; X64-NEXT: movq %rdi, %rax
; X64-NEXT: imulq %rsi ; X64-NEXT: imulq %rsi
; X64-NEXT: shrdq $63, %rdx, %rax ; X64-NEXT: shrdq $63, %rdx, %rax
▲ Show 20 Lines • Show All 62 Lines • ▼ Show 20 Lines
; X86-NEXT: cmovll %ecx, %eax ; X86-NEXT: cmovll %ecx, %eax
; X86-NEXT: movl $-2147483648, %ecx # imm = 0x80000000 ; X86-NEXT: movl $-2147483648, %ecx # imm = 0x80000000
; X86-NEXT: cmovll %ecx, %edx ; X86-NEXT: cmovll %ecx, %edx
; X86-NEXT: popl %esi ; X86-NEXT: popl %esi
; X86-NEXT: popl %edi ; X86-NEXT: popl %edi
; X86-NEXT: popl %ebx ; X86-NEXT: popl %ebx
; X86-NEXT: popl %ebp ; X86-NEXT: popl %ebp
; X86-NEXT: retl ; X86-NEXT: retl
%tmp = call i64 @llvm.smul.fix.sat.i64(i64 %x, i64 %y, i32 63); %tmp = call i64 @llvm.smul.fix.sat.i64(i64 %x, i64 %y, i32 63)
ret i64 %tmp; ret i64 %tmp
} }

llvm/trunk/test/CodeGen/X86/smul_fix_sat_constants.ll

Show All 17 Lines
; X64-NEXT: shrdq $2, %rdx, %rax ; X64-NEXT: shrdq $2, %rdx, %rax
; X64-NEXT: cmpq $1, %rdx ; X64-NEXT: cmpq $1, %rdx
; X64-NEXT: movabsq $9223372036854775807, %rcx # imm = 0x7FFFFFFFFFFFFFFF ; X64-NEXT: movabsq $9223372036854775807, %rcx # imm = 0x7FFFFFFFFFFFFFFF
; X64-NEXT: cmovgq %rcx, %rax ; X64-NEXT: cmovgq %rcx, %rax
; X64-NEXT: cmpq $-2, %rdx ; X64-NEXT: cmpq $-2, %rdx
; X64-NEXT: movabsq $-9223372036854775808, %rcx # imm = 0x8000000000000000 ; X64-NEXT: movabsq $-9223372036854775808, %rcx # imm = 0x8000000000000000
; X64-NEXT: cmovlq %rcx, %rax ; X64-NEXT: cmovlq %rcx, %rax
; X64-NEXT: retq ; X64-NEXT: retq
%tmp = call i64 @llvm.smul.fix.sat.i64(i64 3, i64 2, i32 2); %tmp = call i64 @llvm.smul.fix.sat.i64(i64 3, i64 2, i32 2)
ret i64 %tmp; ret i64 %tmp
} }
define i64 @func2() nounwind { define i64 @func2() nounwind {
; X64-LABEL: func2: ; X64-LABEL: func2:
; X64: # %bb.0: ; X64: # %bb.0:
; X64-NEXT: movl $3, %eax ; X64-NEXT: movl $3, %eax
; X64-NEXT: imulq $2, %rax, %rcx ; X64-NEXT: imulq $2, %rax, %rcx
; X64-NEXT: xorl %edx, %edx ; X64-NEXT: xorl %edx, %edx
; X64-NEXT: testq %rcx, %rcx ; X64-NEXT: testq %rcx, %rcx
; X64-NEXT: setns %dl ; X64-NEXT: setns %dl
; X64-NEXT: movabsq $9223372036854775807, %rcx # imm = 0x7FFFFFFFFFFFFFFF ; X64-NEXT: movabsq $9223372036854775807, %rcx # imm = 0x7FFFFFFFFFFFFFFF
; X64-NEXT: addq %rdx, %rcx ; X64-NEXT: addq %rdx, %rcx
; X64-NEXT: imulq $2, %rax, %rax ; X64-NEXT: imulq $2, %rax, %rax
; X64-NEXT: cmovoq %rcx, %rax ; X64-NEXT: cmovoq %rcx, %rax
; X64-NEXT: retq ; X64-NEXT: retq
%tmp = call i64 @llvm.smul.fix.sat.i64(i64 3, i64 2, i32 0); %tmp = call i64 @llvm.smul.fix.sat.i64(i64 3, i64 2, i32 0)
ret i64 %tmp; ret i64 %tmp
} }
define i64 @func3() nounwind { define i64 @func3() nounwind {
; X64-LABEL: func3: ; X64-LABEL: func3:
; X64: # %bb.0: ; X64: # %bb.0:
; X64-NEXT: movabsq $9223372036854775807, %rcx # imm = 0x7FFFFFFFFFFFFFFF ; X64-NEXT: movabsq $9223372036854775807, %rcx # imm = 0x7FFFFFFFFFFFFFFF
; X64-NEXT: movl $2, %edx ; X64-NEXT: movl $2, %edx
; X64-NEXT: movq %rcx, %rax ; X64-NEXT: movq %rcx, %rax
; X64-NEXT: imulq %rdx ; X64-NEXT: imulq %rdx
; X64-NEXT: shrdq $2, %rdx, %rax ; X64-NEXT: shrdq $2, %rdx, %rax
; X64-NEXT: cmpq $1, %rdx ; X64-NEXT: cmpq $1, %rdx
; X64-NEXT: cmovgq %rcx, %rax ; X64-NEXT: cmovgq %rcx, %rax
; X64-NEXT: cmpq $-2, %rdx ; X64-NEXT: cmpq $-2, %rdx
; X64-NEXT: movabsq $-9223372036854775808, %rcx # imm = 0x8000000000000000 ; X64-NEXT: movabsq $-9223372036854775808, %rcx # imm = 0x8000000000000000
; X64-NEXT: cmovlq %rcx, %rax ; X64-NEXT: cmovlq %rcx, %rax
; X64-NEXT: retq ; X64-NEXT: retq
%tmp = call i64 @llvm.smul.fix.sat.i64(i64 9223372036854775807, i64 2, i32 2); %tmp = call i64 @llvm.smul.fix.sat.i64(i64 9223372036854775807, i64 2, i32 2)
ret i64 %tmp; ret i64 %tmp
} }
define i64 @func4() nounwind { define i64 @func4() nounwind {
; X64-LABEL: func4: ; X64-LABEL: func4:
; X64: # %bb.0: ; X64: # %bb.0:
; X64-NEXT: movabsq $9223372036854775807, %rcx # imm = 0x7FFFFFFFFFFFFFFF ; X64-NEXT: movabsq $9223372036854775807, %rcx # imm = 0x7FFFFFFFFFFFFFFF
; X64-NEXT: movl $2, %edx ; X64-NEXT: movl $2, %edx
; X64-NEXT: movq %rcx, %rax ; X64-NEXT: movq %rcx, %rax
; X64-NEXT: imulq %rdx ; X64-NEXT: imulq %rdx
; X64-NEXT: shrdq $32, %rdx, %rax ; X64-NEXT: shrdq $32, %rdx, %rax
; X64-NEXT: cmpq $2147483647, %rdx # imm = 0x7FFFFFFF ; X64-NEXT: cmpq $2147483647, %rdx # imm = 0x7FFFFFFF
; X64-NEXT: cmovgq %rcx, %rax ; X64-NEXT: cmovgq %rcx, %rax
; X64-NEXT: cmpq $-2147483648, %rdx # imm = 0x80000000 ; X64-NEXT: cmpq $-2147483648, %rdx # imm = 0x80000000
; X64-NEXT: movabsq $-9223372036854775808, %rcx # imm = 0x8000000000000000 ; X64-NEXT: movabsq $-9223372036854775808, %rcx # imm = 0x8000000000000000
; X64-NEXT: cmovlq %rcx, %rax ; X64-NEXT: cmovlq %rcx, %rax
; X64-NEXT: retq ; X64-NEXT: retq
%tmp = call i64 @llvm.smul.fix.sat.i64(i64 9223372036854775807, i64 2, i32 32); %tmp = call i64 @llvm.smul.fix.sat.i64(i64 9223372036854775807, i64 2, i32 32)
ret i64 %tmp; ret i64 %tmp
} }
define i64 @func5() nounwind { define i64 @func5() nounwind {
; X64-LABEL: func5: ; X64-LABEL: func5:
; X64: # %bb.0: ; X64: # %bb.0:
; X64-NEXT: movabsq $9223372036854775807, %rcx # imm = 0x7FFFFFFFFFFFFFFF ; X64-NEXT: movabsq $9223372036854775807, %rcx # imm = 0x7FFFFFFFFFFFFFFF
; X64-NEXT: movl $2, %edx ; X64-NEXT: movl $2, %edx
; X64-NEXT: movq %rcx, %rax ; X64-NEXT: movq %rcx, %rax
; X64-NEXT: imulq %rdx ; X64-NEXT: imulq %rdx
; X64-NEXT: shrdq $63, %rdx, %rax ; X64-NEXT: shrdq $63, %rdx, %rax
; X64-NEXT: movabsq $4611686018427387903, %rsi # imm = 0x3FFFFFFFFFFFFFFF ; X64-NEXT: movabsq $4611686018427387903, %rsi # imm = 0x3FFFFFFFFFFFFFFF
; X64-NEXT: cmpq %rsi, %rdx ; X64-NEXT: cmpq %rsi, %rdx
; X64-NEXT: cmovgq %rcx, %rax ; X64-NEXT: cmovgq %rcx, %rax
; X64-NEXT: movabsq $-4611686018427387904, %rcx # imm = 0xC000000000000000 ; X64-NEXT: movabsq $-4611686018427387904, %rcx # imm = 0xC000000000000000
; X64-NEXT: cmpq %rcx, %rdx ; X64-NEXT: cmpq %rcx, %rdx
; X64-NEXT: movabsq $-9223372036854775808, %rcx # imm = 0x8000000000000000 ; X64-NEXT: movabsq $-9223372036854775808, %rcx # imm = 0x8000000000000000
; X64-NEXT: cmovlq %rcx, %rax ; X64-NEXT: cmovlq %rcx, %rax
; X64-NEXT: retq ; X64-NEXT: retq
%tmp = call i64 @llvm.smul.fix.sat.i64(i64 9223372036854775807, i64 2, i32 63); %tmp = call i64 @llvm.smul.fix.sat.i64(i64 9223372036854775807, i64 2, i32 63)
ret i64 %tmp; ret i64 %tmp
} }

llvm/trunk/test/CodeGen/X86/ssub_sat.ll

Show All 27 Lines
; X64-NEXT: xorl %eax, %eax ; X64-NEXT: xorl %eax, %eax
; X64-NEXT: movl %edi, %ecx ; X64-NEXT: movl %edi, %ecx
; X64-NEXT: subl %esi, %ecx ; X64-NEXT: subl %esi, %ecx
; X64-NEXT: setns %al ; X64-NEXT: setns %al
; X64-NEXT: addl $2147483647, %eax # imm = 0x7FFFFFFF ; X64-NEXT: addl $2147483647, %eax # imm = 0x7FFFFFFF
; X64-NEXT: subl %esi, %edi ; X64-NEXT: subl %esi, %edi
; X64-NEXT: cmovnol %edi, %eax ; X64-NEXT: cmovnol %edi, %eax
; X64-NEXT: retq ; X64-NEXT: retq
%tmp = call i32 @llvm.ssub.sat.i32(i32 %x, i32 %y); %tmp = call i32 @llvm.ssub.sat.i32(i32 %x, i32 %y)
ret i32 %tmp; ret i32 %tmp
} }
define i64 @func2(i64 %x, i64 %y) nounwind { define i64 @func2(i64 %x, i64 %y) nounwind {
; X86-LABEL: func2: ; X86-LABEL: func2:
; X86: # %bb.0: ; X86: # %bb.0:
; X86-NEXT: pushl %ebp ; X86-NEXT: pushl %ebp
; X86-NEXT: pushl %ebx ; X86-NEXT: pushl %ebx
; X86-NEXT: pushl %edi ; X86-NEXT: pushl %edi
Show All 34 Lines
; X64-NEXT: movq %rdi, %rax ; X64-NEXT: movq %rdi, %rax
; X64-NEXT: subq %rsi, %rax ; X64-NEXT: subq %rsi, %rax
; X64-NEXT: setns %cl ; X64-NEXT: setns %cl
; X64-NEXT: movabsq $9223372036854775807, %rax # imm = 0x7FFFFFFFFFFFFFFF ; X64-NEXT: movabsq $9223372036854775807, %rax # imm = 0x7FFFFFFFFFFFFFFF
; X64-NEXT: addq %rcx, %rax ; X64-NEXT: addq %rcx, %rax
; X64-NEXT: subq %rsi, %rdi ; X64-NEXT: subq %rsi, %rdi
; X64-NEXT: cmovnoq %rdi, %rax ; X64-NEXT: cmovnoq %rdi, %rax
; X64-NEXT: retq ; X64-NEXT: retq
%tmp = call i64 @llvm.ssub.sat.i64(i64 %x, i64 %y); %tmp = call i64 @llvm.ssub.sat.i64(i64 %x, i64 %y)
ret i64 %tmp; ret i64 %tmp
} }
define i4 @func3(i4 %x, i4 %y) nounwind { define i4 @func3(i4 %x, i4 %y) nounwind {
; X86-LABEL: func3: ; X86-LABEL: func3:
; X86: # %bb.0: ; X86: # %bb.0:
; X86-NEXT: movb {{[0-9]+}}(%esp), %al ; X86-NEXT: movb {{[0-9]+}}(%esp), %al
; X86-NEXT: movb {{[0-9]+}}(%esp), %dl ; X86-NEXT: movb {{[0-9]+}}(%esp), %dl
; X86-NEXT: shlb $4, %dl ; X86-NEXT: shlb $4, %dl
Show All 20 Lines
; X64-NEXT: setns %cl ; X64-NEXT: setns %cl
; X64-NEXT: addl $127, %ecx ; X64-NEXT: addl $127, %ecx
; X64-NEXT: subb %sil, %dil ; X64-NEXT: subb %sil, %dil
; X64-NEXT: movzbl %dil, %eax ; X64-NEXT: movzbl %dil, %eax
; X64-NEXT: cmovol %ecx, %eax ; X64-NEXT: cmovol %ecx, %eax
; X64-NEXT: sarb $4, %al ; X64-NEXT: sarb $4, %al
; X64-NEXT: # kill: def $al killed $al killed $eax ; X64-NEXT: # kill: def $al killed $al killed $eax
; X64-NEXT: retq ; X64-NEXT: retq
%tmp = call i4 @llvm.ssub.sat.i4(i4 %x, i4 %y); %tmp = call i4 @llvm.ssub.sat.i4(i4 %x, i4 %y)
ret i4 %tmp; ret i4 %tmp
} }
define <4 x i32> @vec(<4 x i32> %x, <4 x i32> %y) nounwind { define <4 x i32> @vec(<4 x i32> %x, <4 x i32> %y) nounwind {
; X86-LABEL: vec: ; X86-LABEL: vec:
; X86: # %bb.0: ; X86: # %bb.0:
; X86-NEXT: pushl %ebp ; X86-NEXT: pushl %ebp
; X86-NEXT: pushl %ebx ; X86-NEXT: pushl %ebx
; X86-NEXT: pushl %edi ; X86-NEXT: pushl %edi
▲ Show 20 Lines • Show All 67 Lines • ▼ Show 20 Lines
; X64-NEXT: movdqa %xmm3, %xmm1 ; X64-NEXT: movdqa %xmm3, %xmm1
; X64-NEXT: pandn {{.*}}(%rip), %xmm1 ; X64-NEXT: pandn {{.*}}(%rip), %xmm1
; X64-NEXT: psrld $1, %xmm3 ; X64-NEXT: psrld $1, %xmm3
; X64-NEXT: por %xmm1, %xmm3 ; X64-NEXT: por %xmm1, %xmm3
; X64-NEXT: pand %xmm0, %xmm3 ; X64-NEXT: pand %xmm0, %xmm3
; X64-NEXT: pandn %xmm2, %xmm0 ; X64-NEXT: pandn %xmm2, %xmm0
; X64-NEXT: por %xmm3, %xmm0 ; X64-NEXT: por %xmm3, %xmm0
; X64-NEXT: retq ; X64-NEXT: retq
%tmp = call <4 x i32> @llvm.ssub.sat.v4i32(<4 x i32> %x, <4 x i32> %y); %tmp = call <4 x i32> @llvm.ssub.sat.v4i32(<4 x i32> %x, <4 x i32> %y)
ret <4 x i32> %tmp; ret <4 x i32> %tmp
} }

llvm/trunk/test/CodeGen/X86/uadd_sat.ll

Show All 16 Lines
; X86-NEXT: retl ; X86-NEXT: retl
; ;
; X64-LABEL: func: ; X64-LABEL: func:
; X64: # %bb.0: ; X64: # %bb.0:
; X64-NEXT: addl %esi, %edi ; X64-NEXT: addl %esi, %edi
; X64-NEXT: movl $-1, %eax ; X64-NEXT: movl $-1, %eax
; X64-NEXT: cmovael %edi, %eax ; X64-NEXT: cmovael %edi, %eax
; X64-NEXT: retq ; X64-NEXT: retq
%tmp = call i32 @llvm.uadd.sat.i32(i32 %x, i32 %y); %tmp = call i32 @llvm.uadd.sat.i32(i32 %x, i32 %y)
ret i32 %tmp; ret i32 %tmp
} }
define i64 @func2(i64 %x, i64 %y) nounwind { define i64 @func2(i64 %x, i64 %y) nounwind {
; X86-LABEL: func2: ; X86-LABEL: func2:
; X86: # %bb.0: ; X86: # %bb.0:
; X86-NEXT: movl {{[0-9]+}}(%esp), %eax ; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
; X86-NEXT: movl {{[0-9]+}}(%esp), %edx ; X86-NEXT: movl {{[0-9]+}}(%esp), %edx
; X86-NEXT: addl {{[0-9]+}}(%esp), %eax ; X86-NEXT: addl {{[0-9]+}}(%esp), %eax
; X86-NEXT: adcl {{[0-9]+}}(%esp), %edx ; X86-NEXT: adcl {{[0-9]+}}(%esp), %edx
; X86-NEXT: movl $-1, %ecx ; X86-NEXT: movl $-1, %ecx
; X86-NEXT: cmovbl %ecx, %edx ; X86-NEXT: cmovbl %ecx, %edx
; X86-NEXT: cmovbl %ecx, %eax ; X86-NEXT: cmovbl %ecx, %eax
; X86-NEXT: retl ; X86-NEXT: retl
; ;
; X64-LABEL: func2: ; X64-LABEL: func2:
; X64: # %bb.0: ; X64: # %bb.0:
; X64-NEXT: addq %rsi, %rdi ; X64-NEXT: addq %rsi, %rdi
; X64-NEXT: movq $-1, %rax ; X64-NEXT: movq $-1, %rax
; X64-NEXT: cmovaeq %rdi, %rax ; X64-NEXT: cmovaeq %rdi, %rax
; X64-NEXT: retq ; X64-NEXT: retq
%tmp = call i64 @llvm.uadd.sat.i64(i64 %x, i64 %y); %tmp = call i64 @llvm.uadd.sat.i64(i64 %x, i64 %y)
ret i64 %tmp; ret i64 %tmp
} }
define i4 @func3(i4 %x, i4 %y) nounwind { define i4 @func3(i4 %x, i4 %y) nounwind {
; X86-LABEL: func3: ; X86-LABEL: func3:
; X86: # %bb.0: ; X86: # %bb.0:
; X86-NEXT: movb {{[0-9]+}}(%esp), %al ; X86-NEXT: movb {{[0-9]+}}(%esp), %al
; X86-NEXT: movb {{[0-9]+}}(%esp), %cl ; X86-NEXT: movb {{[0-9]+}}(%esp), %cl
; X86-NEXT: shlb $4, %cl ; X86-NEXT: shlb $4, %cl
Show All 12 Lines
; X64-NEXT: shlb $4, %dil ; X64-NEXT: shlb $4, %dil
; X64-NEXT: addb %sil, %dil ; X64-NEXT: addb %sil, %dil
; X64-NEXT: movzbl %dil, %ecx ; X64-NEXT: movzbl %dil, %ecx
; X64-NEXT: movl $255, %eax ; X64-NEXT: movl $255, %eax
; X64-NEXT: cmovael %ecx, %eax ; X64-NEXT: cmovael %ecx, %eax
; X64-NEXT: shrb $4, %al ; X64-NEXT: shrb $4, %al
; X64-NEXT: # kill: def $al killed $al killed $eax ; X64-NEXT: # kill: def $al killed $al killed $eax
; X64-NEXT: retq ; X64-NEXT: retq
%tmp = call i4 @llvm.uadd.sat.i4(i4 %x, i4 %y); %tmp = call i4 @llvm.uadd.sat.i4(i4 %x, i4 %y)
ret i4 %tmp; ret i4 %tmp
} }
define <4 x i32> @vec(<4 x i32> %x, <4 x i32> %y) nounwind { define <4 x i32> @vec(<4 x i32> %x, <4 x i32> %y) nounwind {
; X86-LABEL: vec: ; X86-LABEL: vec:
; X86: # %bb.0: ; X86: # %bb.0:
; X86-NEXT: pushl %ebx ; X86-NEXT: pushl %ebx
; X86-NEXT: pushl %edi ; X86-NEXT: pushl %edi
; X86-NEXT: pushl %esi ; X86-NEXT: pushl %esi
Show All 24 Lines
; X64: # %bb.0: ; X64: # %bb.0:
; X64-NEXT: movdqa {{.*#+}} xmm2 = [2147483648,2147483648,2147483648,2147483648] ; X64-NEXT: movdqa {{.*#+}} xmm2 = [2147483648,2147483648,2147483648,2147483648]
; X64-NEXT: paddd %xmm0, %xmm1 ; X64-NEXT: paddd %xmm0, %xmm1
; X64-NEXT: pxor %xmm2, %xmm0 ; X64-NEXT: pxor %xmm2, %xmm0
; X64-NEXT: pxor %xmm1, %xmm2 ; X64-NEXT: pxor %xmm1, %xmm2
; X64-NEXT: pcmpgtd %xmm2, %xmm0 ; X64-NEXT: pcmpgtd %xmm2, %xmm0
; X64-NEXT: por %xmm1, %xmm0 ; X64-NEXT: por %xmm1, %xmm0
; X64-NEXT: retq ; X64-NEXT: retq
%tmp = call <4 x i32> @llvm.uadd.sat.v4i32(<4 x i32> %x, <4 x i32> %y); %tmp = call <4 x i32> @llvm.uadd.sat.v4i32(<4 x i32> %x, <4 x i32> %y)
ret <4 x i32> %tmp; ret <4 x i32> %tmp
} }

llvm/trunk/test/CodeGen/X86/umul_fix.ll

Show All 19 Lines
; X64-NEXT: retq ; X64-NEXT: retq
; ;
; X86-LABEL: func: ; X86-LABEL: func:
; X86: # %bb.0: ; X86: # %bb.0:
; X86-NEXT: movl {{[0-9]+}}(%esp), %eax ; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
; X86-NEXT: mull {{[0-9]+}}(%esp) ; X86-NEXT: mull {{[0-9]+}}(%esp)
; X86-NEXT: shrdl $2, %edx, %eax ; X86-NEXT: shrdl $2, %edx, %eax
; X86-NEXT: retl ; X86-NEXT: retl
%tmp = call i32 @llvm.umul.fix.i32(i32 %x, i32 %y, i32 2); %tmp = call i32 @llvm.umul.fix.i32(i32 %x, i32 %y, i32 2)
ret i32 %tmp; ret i32 %tmp
} }
define i64 @func2(i64 %x, i64 %y) nounwind { define i64 @func2(i64 %x, i64 %y) nounwind {
; X64-LABEL: func2: ; X64-LABEL: func2:
; X64: # %bb.0: ; X64: # %bb.0:
; X64-NEXT: movq %rdi, %rax ; X64-NEXT: movq %rdi, %rax
; X64-NEXT: mulq %rsi ; X64-NEXT: mulq %rsi
; X64-NEXT: shrdq $2, %rdx, %rax ; X64-NEXT: shrdq $2, %rdx, %rax
Show All 25 Lines
; X86-NEXT: addl %esi, %edx ; X86-NEXT: addl %esi, %edx
; X86-NEXT: shldl $30, %eax, %edx ; X86-NEXT: shldl $30, %eax, %edx
; X86-NEXT: shldl $30, %ecx, %eax ; X86-NEXT: shldl $30, %ecx, %eax
; X86-NEXT: popl %esi ; X86-NEXT: popl %esi
; X86-NEXT: popl %edi ; X86-NEXT: popl %edi
; X86-NEXT: popl %ebx ; X86-NEXT: popl %ebx
; X86-NEXT: popl %ebp ; X86-NEXT: popl %ebp
; X86-NEXT: retl ; X86-NEXT: retl
%tmp = call i64 @llvm.umul.fix.i64(i64 %x, i64 %y, i32 2); %tmp = call i64 @llvm.umul.fix.i64(i64 %x, i64 %y, i32 2)
ret i64 %tmp; ret i64 %tmp
} }
define i4 @func3(i4 %x, i4 %y) nounwind { define i4 @func3(i4 %x, i4 %y) nounwind {
; X64-LABEL: func3: ; X64-LABEL: func3:
; X64: # %bb.0: ; X64: # %bb.0:
; X64-NEXT: movl %edi, %eax ; X64-NEXT: movl %edi, %eax
; X64-NEXT: andl $15, %esi ; X64-NEXT: andl $15, %esi
; X64-NEXT: andl $15, %eax ; X64-NEXT: andl $15, %eax
Show All 9 Lines
; X86-NEXT: movb {{[0-9]+}}(%esp), %cl ; X86-NEXT: movb {{[0-9]+}}(%esp), %cl
; X86-NEXT: andb $15, %cl ; X86-NEXT: andb $15, %cl
; X86-NEXT: movzbl %cl, %ecx ; X86-NEXT: movzbl %cl, %ecx
; X86-NEXT: movzbl %al, %eax ; X86-NEXT: movzbl %al, %eax
; X86-NEXT: imull %ecx, %eax ; X86-NEXT: imull %ecx, %eax
; X86-NEXT: shrb $2, %al ; X86-NEXT: shrb $2, %al
; X86-NEXT: # kill: def $al killed $al killed $eax ; X86-NEXT: # kill: def $al killed $al killed $eax
; X86-NEXT: retl ; X86-NEXT: retl
%tmp = call i4 @llvm.umul.fix.i4(i4 %x, i4 %y, i32 2); %tmp = call i4 @llvm.umul.fix.i4(i4 %x, i4 %y, i32 2)
ret i4 %tmp; ret i4 %tmp
} }
define <4 x i32> @vec(<4 x i32> %x, <4 x i32> %y) nounwind { define <4 x i32> @vec(<4 x i32> %x, <4 x i32> %y) nounwind {
; X64-LABEL: vec: ; X64-LABEL: vec:
; X64: # %bb.0: ; X64: # %bb.0:
; X64-NEXT: pshufd {{.*#+}} xmm2 = xmm0[1,1,3,3] ; X64-NEXT: pshufd {{.*#+}} xmm2 = xmm0[1,1,3,3]
; X64-NEXT: pmuludq %xmm1, %xmm0 ; X64-NEXT: pmuludq %xmm1, %xmm0
; X64-NEXT: pshufd {{.*#+}} xmm3 = xmm0[0,2,2,3] ; X64-NEXT: pshufd {{.*#+}} xmm3 = xmm0[0,2,2,3]
Show All 39 Lines
; X86-NEXT: movl %ebx, 4(%ecx) ; X86-NEXT: movl %ebx, 4(%ecx)
; X86-NEXT: movl %ebp, (%ecx) ; X86-NEXT: movl %ebp, (%ecx)
; X86-NEXT: movl %ecx, %eax ; X86-NEXT: movl %ecx, %eax
; X86-NEXT: popl %esi ; X86-NEXT: popl %esi
; X86-NEXT: popl %edi ; X86-NEXT: popl %edi
; X86-NEXT: popl %ebx ; X86-NEXT: popl %ebx
; X86-NEXT: popl %ebp ; X86-NEXT: popl %ebp
; X86-NEXT: retl $4 ; X86-NEXT: retl $4
%tmp = call <4 x i32> @llvm.umul.fix.v4i32(<4 x i32> %x, <4 x i32> %y, i32 2); %tmp = call <4 x i32> @llvm.umul.fix.v4i32(<4 x i32> %x, <4 x i32> %y, i32 2)
ret <4 x i32> %tmp; ret <4 x i32> %tmp
} }
; These result in regular integer multiplication ; These result in regular integer multiplication
define i32 @func4(i32 %x, i32 %y) nounwind { define i32 @func4(i32 %x, i32 %y) nounwind {
; X64-LABEL: func4: ; X64-LABEL: func4:
; X64: # %bb.0: ; X64: # %bb.0:
; X64-NEXT: movl %edi, %eax ; X64-NEXT: movl %edi, %eax
; X64-NEXT: imull %esi, %eax ; X64-NEXT: imull %esi, %eax
; X64-NEXT: retq ; X64-NEXT: retq
; ;
; X86-LABEL: func4: ; X86-LABEL: func4:
; X86: # %bb.0: ; X86: # %bb.0:
; X86-NEXT: movl {{[0-9]+}}(%esp), %eax ; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
; X86-NEXT: imull {{[0-9]+}}(%esp), %eax ; X86-NEXT: imull {{[0-9]+}}(%esp), %eax
; X86-NEXT: retl ; X86-NEXT: retl
%tmp = call i32 @llvm.umul.fix.i32(i32 %x, i32 %y, i32 0); %tmp = call i32 @llvm.umul.fix.i32(i32 %x, i32 %y, i32 0)
ret i32 %tmp; ret i32 %tmp
} }
define i64 @func5(i64 %x, i64 %y) nounwind { define i64 @func5(i64 %x, i64 %y) nounwind {
; X64-LABEL: func5: ; X64-LABEL: func5:
; X64: # %bb.0: ; X64: # %bb.0:
; X64-NEXT: movq %rdi, %rax ; X64-NEXT: movq %rdi, %rax
; X64-NEXT: imulq %rsi, %rax ; X64-NEXT: imulq %rsi, %rax
; X64-NEXT: retq ; X64-NEXT: retq
; ;
; X86-LABEL: func5: ; X86-LABEL: func5:
; X86: # %bb.0: ; X86: # %bb.0:
; X86-NEXT: pushl %esi ; X86-NEXT: pushl %esi
; X86-NEXT: movl {{[0-9]+}}(%esp), %ecx ; X86-NEXT: movl {{[0-9]+}}(%esp), %ecx
; X86-NEXT: movl {{[0-9]+}}(%esp), %esi ; X86-NEXT: movl {{[0-9]+}}(%esp), %esi
; X86-NEXT: movl %ecx, %eax ; X86-NEXT: movl %ecx, %eax
; X86-NEXT: mull %esi ; X86-NEXT: mull %esi
; X86-NEXT: imull {{[0-9]+}}(%esp), %ecx ; X86-NEXT: imull {{[0-9]+}}(%esp), %ecx
; X86-NEXT: addl %ecx, %edx ; X86-NEXT: addl %ecx, %edx
; X86-NEXT: imull {{[0-9]+}}(%esp), %esi ; X86-NEXT: imull {{[0-9]+}}(%esp), %esi
; X86-NEXT: addl %esi, %edx ; X86-NEXT: addl %esi, %edx
; X86-NEXT: popl %esi ; X86-NEXT: popl %esi
; X86-NEXT: retl ; X86-NEXT: retl
%tmp = call i64 @llvm.umul.fix.i64(i64 %x, i64 %y, i32 0); %tmp = call i64 @llvm.umul.fix.i64(i64 %x, i64 %y, i32 0)
ret i64 %tmp; ret i64 %tmp
} }
define i4 @func6(i4 %x, i4 %y) nounwind { define i4 @func6(i4 %x, i4 %y) nounwind {
; X64-LABEL: func6: ; X64-LABEL: func6:
; X64: # %bb.0: ; X64: # %bb.0:
; X64-NEXT: movl %edi, %eax ; X64-NEXT: movl %edi, %eax
; X64-NEXT: andb $15, %al ; X64-NEXT: andb $15, %al
; X64-NEXT: andb $15, %sil ; X64-NEXT: andb $15, %sil
; X64-NEXT: # kill: def $al killed $al killed $eax ; X64-NEXT: # kill: def $al killed $al killed $eax
; X64-NEXT: mulb %sil ; X64-NEXT: mulb %sil
; X64-NEXT: retq ; X64-NEXT: retq
; ;
; X86-LABEL: func6: ; X86-LABEL: func6:
; X86: # %bb.0: ; X86: # %bb.0:
; X86-NEXT: movb {{[0-9]+}}(%esp), %al ; X86-NEXT: movb {{[0-9]+}}(%esp), %al
; X86-NEXT: andb $15, %al ; X86-NEXT: andb $15, %al
; X86-NEXT: movb {{[0-9]+}}(%esp), %cl ; X86-NEXT: movb {{[0-9]+}}(%esp), %cl
; X86-NEXT: andb $15, %cl ; X86-NEXT: andb $15, %cl
; X86-NEXT: mulb %cl ; X86-NEXT: mulb %cl
; X86-NEXT: retl ; X86-NEXT: retl
%tmp = call i4 @llvm.umul.fix.i4(i4 %x, i4 %y, i32 0); %tmp = call i4 @llvm.umul.fix.i4(i4 %x, i4 %y, i32 0)
ret i4 %tmp; ret i4 %tmp
} }
define <4 x i32> @vec2(<4 x i32> %x, <4 x i32> %y) nounwind { define <4 x i32> @vec2(<4 x i32> %x, <4 x i32> %y) nounwind {
; X64-LABEL: vec2: ; X64-LABEL: vec2:
; X64: # %bb.0: ; X64: # %bb.0:
; X64-NEXT: pshufd {{.*#+}} xmm2 = xmm0[1,1,3,3] ; X64-NEXT: pshufd {{.*#+}} xmm2 = xmm0[1,1,3,3]
; X64-NEXT: pmuludq %xmm1, %xmm0 ; X64-NEXT: pmuludq %xmm1, %xmm0
; X64-NEXT: pshufd {{.*#+}} xmm0 = xmm0[0,2,2,3] ; X64-NEXT: pshufd {{.*#+}} xmm0 = xmm0[0,2,2,3]
Show All 18 Lines
; X86-NEXT: imull {{[0-9]+}}(%esp), %ecx ; X86-NEXT: imull {{[0-9]+}}(%esp), %ecx
; X86-NEXT: movl %ecx, 12(%eax) ; X86-NEXT: movl %ecx, 12(%eax)
; X86-NEXT: movl %edx, 8(%eax) ; X86-NEXT: movl %edx, 8(%eax)
; X86-NEXT: movl %esi, 4(%eax) ; X86-NEXT: movl %esi, 4(%eax)
; X86-NEXT: movl %edi, (%eax) ; X86-NEXT: movl %edi, (%eax)
; X86-NEXT: popl %esi ; X86-NEXT: popl %esi
; X86-NEXT: popl %edi ; X86-NEXT: popl %edi
; X86-NEXT: retl $4 ; X86-NEXT: retl $4
%tmp = call <4 x i32> @llvm.umul.fix.v4i32(<4 x i32> %x, <4 x i32> %y, i32 0); %tmp = call <4 x i32> @llvm.umul.fix.v4i32(<4 x i32> %x, <4 x i32> %y, i32 0)
ret <4 x i32> %tmp; ret <4 x i32> %tmp
} }
define i64 @func7(i64 %x, i64 %y) nounwind { define i64 @func7(i64 %x, i64 %y) nounwind {
; X64-LABEL: func7: ; X64-LABEL: func7:
; X64: # %bb.0: ; X64: # %bb.0:
; X64-NEXT: movq %rdi, %rax ; X64-NEXT: movq %rdi, %rax
; X64-NEXT: mulq %rsi ; X64-NEXT: mulq %rsi
; X64-NEXT: shrdq $32, %rdx, %rax ; X64-NEXT: shrdq $32, %rdx, %rax
Show All 22 Lines
; X86-NEXT: adcl %edi, %edx ; X86-NEXT: adcl %edi, %edx
; X86-NEXT: imull {{[0-9]+}}(%esp), %esi ; X86-NEXT: imull {{[0-9]+}}(%esp), %esi
; X86-NEXT: addl %esi, %edx ; X86-NEXT: addl %esi, %edx
; X86-NEXT: popl %esi ; X86-NEXT: popl %esi
; X86-NEXT: popl %edi ; X86-NEXT: popl %edi
; X86-NEXT: popl %ebx ; X86-NEXT: popl %ebx
; X86-NEXT: popl %ebp ; X86-NEXT: popl %ebp
; X86-NEXT: retl ; X86-NEXT: retl
%tmp = call i64 @llvm.umul.fix.i64(i64 %x, i64 %y, i32 32); %tmp = call i64 @llvm.umul.fix.i64(i64 %x, i64 %y, i32 32)
ret i64 %tmp; ret i64 %tmp
} }
define i64 @func8(i64 %x, i64 %y) nounwind { define i64 @func8(i64 %x, i64 %y) nounwind {
; X64-LABEL: func8: ; X64-LABEL: func8:
; X64: # %bb.0: ; X64: # %bb.0:
; X64-NEXT: movq %rdi, %rax ; X64-NEXT: movq %rdi, %rax
; X64-NEXT: mulq %rsi ; X64-NEXT: mulq %rsi
; X64-NEXT: shrdq $63, %rdx, %rax ; X64-NEXT: shrdq $63, %rdx, %rax
Show All 31 Lines
; X86-NEXT: shldl $1, %edx, %ebx ; X86-NEXT: shldl $1, %edx, %ebx
; X86-NEXT: shrdl $31, %edx, %eax ; X86-NEXT: shrdl $31, %edx, %eax
; X86-NEXT: movl %ebx, %edx ; X86-NEXT: movl %ebx, %edx
; X86-NEXT: popl %esi ; X86-NEXT: popl %esi
; X86-NEXT: popl %edi ; X86-NEXT: popl %edi
; X86-NEXT: popl %ebx ; X86-NEXT: popl %ebx
; X86-NEXT: popl %ebp ; X86-NEXT: popl %ebp
; X86-NEXT: retl ; X86-NEXT: retl
%tmp = call i64 @llvm.umul.fix.i64(i64 %x, i64 %y, i32 63); %tmp = call i64 @llvm.umul.fix.i64(i64 %x, i64 %y, i32 63)
ret i64 %tmp; ret i64 %tmp
} }
define i64 @func9(i64 %x, i64 %y) nounwind { define i64 @func9(i64 %x, i64 %y) nounwind {
; X64-LABEL: func9: ; X64-LABEL: func9:
; X64: # %bb.0: ; X64: # %bb.0:
; X64-NEXT: movq %rdi, %rax ; X64-NEXT: movq %rdi, %rax
; X64-NEXT: mulq %rsi ; X64-NEXT: mulq %rsi
; X64-NEXT: movq %rdx, %rax ; X64-NEXT: movq %rdx, %rax
Show All 30 Lines
; X86-NEXT: adcl $0, %ebx ; X86-NEXT: adcl $0, %ebx
; X86-NEXT: movl %ebp, %eax ; X86-NEXT: movl %ebp, %eax
; X86-NEXT: movl %ebx, %edx ; X86-NEXT: movl %ebx, %edx
; X86-NEXT: popl %esi ; X86-NEXT: popl %esi
; X86-NEXT: popl %edi ; X86-NEXT: popl %edi
; X86-NEXT: popl %ebx ; X86-NEXT: popl %ebx
; X86-NEXT: popl %ebp ; X86-NEXT: popl %ebp
; X86-NEXT: retl ; X86-NEXT: retl
%tmp = call i64 @llvm.umul.fix.i64(i64 %x, i64 %y, i32 64); %tmp = call i64 @llvm.umul.fix.i64(i64 %x, i64 %y, i32 64)
ret i64 %tmp; ret i64 %tmp
} }

llvm/trunk/test/CodeGen/X86/usub_sat.ll

Show All 16 Lines
; X86-NEXT: retl ; X86-NEXT: retl
; ;
; X64-LABEL: func: ; X64-LABEL: func:
; X64: # %bb.0: ; X64: # %bb.0:
; X64-NEXT: xorl %eax, %eax ; X64-NEXT: xorl %eax, %eax
; X64-NEXT: subl %esi, %edi ; X64-NEXT: subl %esi, %edi
; X64-NEXT: cmovael %edi, %eax ; X64-NEXT: cmovael %edi, %eax
; X64-NEXT: retq ; X64-NEXT: retq
%tmp = call i32 @llvm.usub.sat.i32(i32 %x, i32 %y); %tmp = call i32 @llvm.usub.sat.i32(i32 %x, i32 %y)
ret i32 %tmp; ret i32 %tmp
} }
define i64 @func2(i64 %x, i64 %y) nounwind { define i64 @func2(i64 %x, i64 %y) nounwind {
; X86-LABEL: func2: ; X86-LABEL: func2:
; X86: # %bb.0: ; X86: # %bb.0:
; X86-NEXT: movl {{[0-9]+}}(%esp), %eax ; X86-NEXT: movl {{[0-9]+}}(%esp), %eax
; X86-NEXT: movl {{[0-9]+}}(%esp), %edx ; X86-NEXT: movl {{[0-9]+}}(%esp), %edx
; X86-NEXT: xorl %ecx, %ecx ; X86-NEXT: xorl %ecx, %ecx
; X86-NEXT: subl {{[0-9]+}}(%esp), %eax ; X86-NEXT: subl {{[0-9]+}}(%esp), %eax
; X86-NEXT: sbbl {{[0-9]+}}(%esp), %edx ; X86-NEXT: sbbl {{[0-9]+}}(%esp), %edx
; X86-NEXT: cmovbl %ecx, %edx ; X86-NEXT: cmovbl %ecx, %edx
; X86-NEXT: cmovbl %ecx, %eax ; X86-NEXT: cmovbl %ecx, %eax
; X86-NEXT: retl ; X86-NEXT: retl
; ;
; X64-LABEL: func2: ; X64-LABEL: func2:
; X64: # %bb.0: ; X64: # %bb.0:
; X64-NEXT: xorl %eax, %eax ; X64-NEXT: xorl %eax, %eax
; X64-NEXT: subq %rsi, %rdi ; X64-NEXT: subq %rsi, %rdi
; X64-NEXT: cmovaeq %rdi, %rax ; X64-NEXT: cmovaeq %rdi, %rax
; X64-NEXT: retq ; X64-NEXT: retq
%tmp = call i64 @llvm.usub.sat.i64(i64 %x, i64 %y); %tmp = call i64 @llvm.usub.sat.i64(i64 %x, i64 %y)
ret i64 %tmp; ret i64 %tmp
} }
define i4 @func3(i4 %x, i4 %y) nounwind { define i4 @func3(i4 %x, i4 %y) nounwind {
; X86-LABEL: func3: ; X86-LABEL: func3:
; X86: # %bb.0: ; X86: # %bb.0:
; X86-NEXT: movb {{[0-9]+}}(%esp), %al ; X86-NEXT: movb {{[0-9]+}}(%esp), %al
; X86-NEXT: movb {{[0-9]+}}(%esp), %cl ; X86-NEXT: movb {{[0-9]+}}(%esp), %cl
; X86-NEXT: shlb $4, %cl ; X86-NEXT: shlb $4, %cl
Show All 12 Lines
; X64-NEXT: shlb $4, %dil ; X64-NEXT: shlb $4, %dil
; X64-NEXT: xorl %ecx, %ecx ; X64-NEXT: xorl %ecx, %ecx
; X64-NEXT: subb %sil, %dil ; X64-NEXT: subb %sil, %dil
; X64-NEXT: movzbl %dil, %eax ; X64-NEXT: movzbl %dil, %eax
; X64-NEXT: cmovbl %ecx, %eax ; X64-NEXT: cmovbl %ecx, %eax
; X64-NEXT: shrb $4, %al ; X64-NEXT: shrb $4, %al
; X64-NEXT: # kill: def $al killed $al killed $eax ; X64-NEXT: # kill: def $al killed $al killed $eax
; X64-NEXT: retq ; X64-NEXT: retq
%tmp = call i4 @llvm.usub.sat.i4(i4 %x, i4 %y); %tmp = call i4 @llvm.usub.sat.i4(i4 %x, i4 %y)
ret i4 %tmp; ret i4 %tmp
} }
define <4 x i32> @vec(<4 x i32> %x, <4 x i32> %y) nounwind { define <4 x i32> @vec(<4 x i32> %x, <4 x i32> %y) nounwind {
; X86-LABEL: vec: ; X86-LABEL: vec:
; X86: # %bb.0: ; X86: # %bb.0:
; X86-NEXT: pushl %ebx ; X86-NEXT: pushl %ebx
; X86-NEXT: pushl %edi ; X86-NEXT: pushl %edi
; X86-NEXT: pushl %esi ; X86-NEXT: pushl %esi
Show All 25 Lines
; X64-NEXT: movdqa {{.*#+}} xmm2 = [2147483648,2147483648,2147483648,2147483648] ; X64-NEXT: movdqa {{.*#+}} xmm2 = [2147483648,2147483648,2147483648,2147483648]
; X64-NEXT: movdqa %xmm1, %xmm3 ; X64-NEXT: movdqa %xmm1, %xmm3
; X64-NEXT: pxor %xmm2, %xmm3 ; X64-NEXT: pxor %xmm2, %xmm3
; X64-NEXT: pxor %xmm0, %xmm2 ; X64-NEXT: pxor %xmm0, %xmm2
; X64-NEXT: pcmpgtd %xmm3, %xmm2 ; X64-NEXT: pcmpgtd %xmm3, %xmm2
; X64-NEXT: psubd %xmm1, %xmm0 ; X64-NEXT: psubd %xmm1, %xmm0
; X64-NEXT: pand %xmm2, %xmm0 ; X64-NEXT: pand %xmm2, %xmm0
; X64-NEXT: retq ; X64-NEXT: retq
%tmp = call <4 x i32> @llvm.usub.sat.v4i32(<4 x i32> %x, <4 x i32> %y); %tmp = call <4 x i32> @llvm.usub.sat.v4i32(<4 x i32> %x, <4 x i32> %y)
ret <4 x i32> %tmp; ret <4 x i32> %tmp
} }