mirror of
https://github.com/RPCS3/llvm-mirror.git
synced 2024-10-23 21:13:02 +02:00
32831df6b9
Regcall calling convention passes mask types arguments in x86 GPR registers. The review includes the changes required in order to support v32i1, v16i1 and v8i1. Differential Revision: https://reviews.llvm.org/D27148 llvm-svn: 289383
351 lines
12 KiB
LLVM
351 lines
12 KiB
LLVM
; RUN: llc < %s -mtriple=i386-pc-win32 -mattr=+avx512bw | FileCheck --check-prefix=CHECK --check-prefix=X32 %s
|
|
; RUN: llc < %s -mtriple=x86_64-win32 -mattr=+avx512bw | FileCheck --check-prefix=CHECK --check-prefix=CHECK64 --check-prefix=WIN64 %s
|
|
; RUN: llc < %s -mtriple=x86_64-linux-gnu -mattr=+avx512bw | FileCheck --check-prefix=CHECK --check-prefix=CHECK64 --check-prefix=LINUXOSX64 %s
|
|
|
|
; X32-LABEL: test_argv64i1:
|
|
; X32: kmovd %edx, %k0
|
|
; X32: kmovd %edi, %k1
|
|
; X32: kmovd %eax, %k1
|
|
; X32: kmovd %ecx, %k2
|
|
; X32: ad{{d|c}}l {{([0-9])*}}(%ebp), %e{{a|c}}x
|
|
; X32: ad{{d|c}}l {{([0-9])*}}(%ebp), %e{{a|c}}x
|
|
; X32: ad{{d|c}}l {{([0-9])*}}(%ebp), %e{{a|c}}x
|
|
; X32: ad{{d|c}}l {{([0-9])*}}(%ebp), %e{{a|c}}x
|
|
; X32: ad{{d|c}}l {{([0-9])*}}(%ebp), %e{{a|c}}x
|
|
; X32: ad{{d|c}}l {{([0-9])*}}(%ebp), %e{{a|c}}x
|
|
; X32: ad{{d|c}}l {{([0-9])*}}(%ebp), %e{{a|c}}x
|
|
; X32: ad{{d|c}}l {{([0-9])*}}(%ebp), %e{{a|c}}x
|
|
; X32: ad{{d|c}}l {{([0-9])*}}(%ebp), %e{{a|c}}x
|
|
; X32: ad{{d|c}}l {{([0-9])*}}(%ebp), %e{{a|c}}x
|
|
; X32: ad{{d|c}}l {{([0-9])*}}(%ebp), %e{{a|c}}x
|
|
; X32: ad{{d|c}}l {{([0-9])*}}(%ebp), %e{{a|c}}x
|
|
; X32: ad{{d|c}}l {{([0-9])*}}(%ebp), %e{{a|c}}x
|
|
; X32: ad{{d|c}}l {{([0-9])*}}(%ebp), %e{{a|c}}x
|
|
; X32: ad{{d|c}}l {{([0-9])*}}(%ebp), %e{{a|c}}x
|
|
; X32: ad{{d|c}}l {{([0-9])*}}(%ebp), %e{{a|c}}x
|
|
; X32: ad{{d|c}}l {{([0-9])*}}(%ebp), %e{{a|c}}x
|
|
; X32: ad{{d|c}}l {{([0-9])*}}(%ebp), %e{{a|c}}x
|
|
; X32: ad{{d|c}}l {{([0-9])*}}(%ebp), %e{{a|c}}x
|
|
; X32: ad{{d|c}}l {{([0-9])*}}(%ebp), %e{{a|c}}x
|
|
; X32: ad{{d|c}}l {{([0-9])*}}(%ebp), %e{{a|c}}x
|
|
; X32: ad{{d|c}}l {{([0-9])*}}(%ebp), %e{{a|c}}x
|
|
; X32: retl
|
|
|
|
; WIN64-LABEL: test_argv64i1:
|
|
; WIN64: addq %rcx, %rax
|
|
; WIN64: addq %rdx, %rax
|
|
; WIN64: addq %rdi, %rax
|
|
; WIN64: addq %rsi, %rax
|
|
; WIN64: addq %r8, %rax
|
|
; WIN64: addq %r9, %rax
|
|
; WIN64: addq %r10, %rax
|
|
; WIN64: addq %r11, %rax
|
|
; WIN64: addq %r12, %rax
|
|
; WIN64: addq %r14, %rax
|
|
; WIN64: addq %r15, %rax
|
|
; WIN64: addq {{([0-9])*}}(%rsp), %rax
|
|
; WIN64: retq
|
|
|
|
; LINUXOSX64-LABEL: test_argv64i1:
|
|
; LINUXOSX64: addq %rcx, %rax
|
|
; LINUXOSX64: addq %rdx, %rax
|
|
; LINUXOSX64: addq %rdi, %rax
|
|
; LINUXOSX64: addq %rsi, %rax
|
|
; LINUXOSX64: addq %r8, %rax
|
|
; LINUXOSX64: addq %r9, %rax
|
|
; LINUXOSX64: addq %r12, %rax
|
|
; LINUXOSX64: addq %r13, %rax
|
|
; LINUXOSX64: addq %r14, %rax
|
|
; LINUXOSX64: addq %r15, %rax
|
|
; LINUXOSX64: addq {{([0-9])*}}(%rsp), %rax
|
|
; LINUXOSX64: addq {{([0-9])*}}(%rsp), %rax
|
|
; LINUXOSX64: retq
|
|
|
|
; Test regcall when receiving arguments of v64i1 type
|
|
define x86_regcallcc i64 @test_argv64i1(<64 x i1> %x0, <64 x i1> %x1, <64 x i1> %x2,
|
|
<64 x i1> %x3, <64 x i1> %x4, <64 x i1> %x5,
|
|
<64 x i1> %x6, <64 x i1> %x7, <64 x i1> %x8,
|
|
<64 x i1> %x9, <64 x i1> %x10, <64 x i1> %x11,
|
|
<64 x i1> %x12) {
|
|
%y0 = bitcast <64 x i1> %x0 to i64
|
|
%y1 = bitcast <64 x i1> %x1 to i64
|
|
%y2 = bitcast <64 x i1> %x2 to i64
|
|
%y3 = bitcast <64 x i1> %x3 to i64
|
|
%y4 = bitcast <64 x i1> %x4 to i64
|
|
%y5 = bitcast <64 x i1> %x5 to i64
|
|
%y6 = bitcast <64 x i1> %x6 to i64
|
|
%y7 = bitcast <64 x i1> %x7 to i64
|
|
%y8 = bitcast <64 x i1> %x8 to i64
|
|
%y9 = bitcast <64 x i1> %x9 to i64
|
|
%y10 = bitcast <64 x i1> %x10 to i64
|
|
%y11 = bitcast <64 x i1> %x11 to i64
|
|
%y12 = bitcast <64 x i1> %x12 to i64
|
|
%add1 = add i64 %y0, %y1
|
|
%add2 = add i64 %add1, %y2
|
|
%add3 = add i64 %add2, %y3
|
|
%add4 = add i64 %add3, %y4
|
|
%add5 = add i64 %add4, %y5
|
|
%add6 = add i64 %add5, %y6
|
|
%add7 = add i64 %add6, %y7
|
|
%add8 = add i64 %add7, %y8
|
|
%add9 = add i64 %add8, %y9
|
|
%add10 = add i64 %add9, %y10
|
|
%add11 = add i64 %add10, %y11
|
|
%add12 = add i64 %add11, %y12
|
|
ret i64 %add12
|
|
}
|
|
|
|
; X32-LABEL: caller_argv64i1:
|
|
; X32: movl $2, %eax
|
|
; X32: movl $1, %ecx
|
|
; X32: movl $2, %edx
|
|
; X32: movl $1, %edi
|
|
; X32: pushl ${{1|2}}
|
|
; X32: pushl ${{1|2}}
|
|
; X32: pushl ${{1|2}}
|
|
; X32: pushl ${{1|2}}
|
|
; X32: pushl ${{1|2}}
|
|
; X32: pushl ${{1|2}}
|
|
; X32: pushl ${{1|2}}
|
|
; X32: pushl ${{1|2}}
|
|
; X32: pushl ${{1|2}}
|
|
; X32: pushl ${{1|2}}
|
|
; X32: pushl ${{1|2}}
|
|
; X32: pushl ${{1|2}}
|
|
; X32: pushl ${{1|2}}
|
|
; X32: pushl ${{1|2}}
|
|
; X32: pushl ${{1|2}}
|
|
; X32: pushl ${{1|2}}
|
|
; X32: pushl ${{1|2}}
|
|
; X32: pushl ${{1|2}}
|
|
; X32: pushl ${{1|2}}
|
|
; X32: pushl ${{1|2}}
|
|
; X32: pushl ${{1|2}}
|
|
; X32: pushl ${{1|2}}
|
|
; X32: call{{.*}} _test_argv64i1
|
|
|
|
; WIN64-LABEL: caller_argv64i1:
|
|
; WIN64: movabsq $4294967298, %rax
|
|
; WIN64: movq %rax, (%rsp)
|
|
; WIN64: movq %rax, %rcx
|
|
; WIN64: movq %rax, %rdx
|
|
; WIN64: movq %rax, %rdi
|
|
; WIN64: movq %rax, %rsi
|
|
; WIN64: movq %rax, %r8
|
|
; WIN64: movq %rax, %r9
|
|
; WIN64: movq %rax, %r10
|
|
; WIN64: movq %rax, %r11
|
|
; WIN64: movq %rax, %r12
|
|
; WIN64: movq %rax, %r14
|
|
; WIN64: movq %rax, %r15
|
|
; WIN64: callq test_argv64i1
|
|
|
|
; LINUXOSX64-LABEL: caller_argv64i1:
|
|
; LINUXOSX64: movabsq $4294967298, %rax
|
|
; LINUXOSX64: movq %rax, %rcx
|
|
; LINUXOSX64: movq %rax, %rdx
|
|
; LINUXOSX64: movq %rax, %rdi
|
|
; LINUXOSX64: movq %rax, %rsi
|
|
; LINUXOSX64: movq %rax, %r8
|
|
; LINUXOSX64: movq %rax, %r9
|
|
; LINUXOSX64: movq %rax, %r12
|
|
; LINUXOSX64: movq %rax, %r13
|
|
; LINUXOSX64: movq %rax, %r14
|
|
; LINUXOSX64: movq %rax, %r15
|
|
; LINUXOSX64: call{{.*}} test_argv64i1
|
|
|
|
; Test regcall when passing arguments of v64i1 type
|
|
define i64 @caller_argv64i1() #0 {
|
|
entry:
|
|
%v0 = bitcast i64 4294967298 to <64 x i1>
|
|
%call = call x86_regcallcc i64 @test_argv64i1(<64 x i1> %v0, <64 x i1> %v0, <64 x i1> %v0,
|
|
<64 x i1> %v0, <64 x i1> %v0, <64 x i1> %v0,
|
|
<64 x i1> %v0, <64 x i1> %v0, <64 x i1> %v0,
|
|
<64 x i1> %v0, <64 x i1> %v0, <64 x i1> %v0,
|
|
<64 x i1> %v0)
|
|
ret i64 %call
|
|
}
|
|
|
|
; X32-LABEL: test_retv64i1:
|
|
; X32: mov{{.*}} $2, %eax
|
|
; X32: mov{{.*}} $1, %ecx
|
|
; X32: ret{{.*}}
|
|
|
|
; CHECK64-LABEL: test_retv64i1:
|
|
; CHECK64: mov{{.*}} $4294967298, %rax
|
|
; CHECK64: ret{{.*}}
|
|
|
|
; Test regcall when returning v64i1 type
|
|
define x86_regcallcc <64 x i1> @test_retv64i1() {
|
|
%a = bitcast i64 4294967298 to <64 x i1>
|
|
ret <64 x i1> %a
|
|
}
|
|
|
|
; X32-LABEL: caller_retv64i1:
|
|
; X32: call{{.*}} _test_retv64i1
|
|
; X32: kmov{{.*}} %eax, %k0
|
|
; X32: kmov{{.*}} %ecx, %k1
|
|
; X32: kunpckdq %k0, %k1, %k0
|
|
|
|
; CHECK64-LABEL: caller_retv64i1:
|
|
; CHECK64: call{{.*}} {{_*}}test_retv64i1
|
|
; CHECK64: kmovq %rax, %k0
|
|
; CHECK64: ret{{.*}}
|
|
|
|
; Test regcall when processing result of v64i1 type
|
|
define <64 x i1> @caller_retv64i1() #0 {
|
|
entry:
|
|
%call = call x86_regcallcc <64 x i1> @test_retv64i1()
|
|
ret <64 x i1> %call
|
|
}
|
|
|
|
; CHECK-LABEL: test_argv32i1:
|
|
; CHECK: kmovd %edx, %k{{[0-9]+}}
|
|
; CHECK: kmovd %ecx, %k{{[0-9]+}}
|
|
; CHECK: kmovd %eax, %k{{[0-9]+}}
|
|
; CHECK: ret{{l|q}}
|
|
|
|
; Test regcall when receiving arguments of v32i1 type
|
|
declare i32 @test_argv32i1helper(<32 x i1> %x0, <32 x i1> %x1, <32 x i1> %x2)
|
|
define x86_regcallcc i32 @test_argv32i1(<32 x i1> %x0, <32 x i1> %x1, <32 x i1> %x2) {
|
|
entry:
|
|
%res = call i32 @test_argv32i1helper(<32 x i1> %x0, <32 x i1> %x1, <32 x i1> %x2)
|
|
ret i32 %res
|
|
}
|
|
|
|
; CHECK-LABEL: caller_argv32i1:
|
|
; CHECK: mov{{.*}} $1, %eax
|
|
; CHECK: mov{{.*}} $1, %ecx
|
|
; CHECK: mov{{.*}} $1, %edx
|
|
; CHECK: call{{.*}} {{_*}}test_argv32i1
|
|
|
|
; Test regcall when passing arguments of v32i1 type
|
|
define i32 @caller_argv32i1() #0 {
|
|
entry:
|
|
%v0 = bitcast i32 1 to <32 x i1>
|
|
%call = call x86_regcallcc i32 @test_argv32i1(<32 x i1> %v0, <32 x i1> %v0, <32 x i1> %v0)
|
|
ret i32 %call
|
|
}
|
|
|
|
; CHECK-LABEL: test_retv32i1:
|
|
; CHECK: movl $1, %eax
|
|
; CHECK: ret{{l|q}}
|
|
|
|
; Test regcall when returning v32i1 type
|
|
define x86_regcallcc <32 x i1> @test_retv32i1() {
|
|
%a = bitcast i32 1 to <32 x i1>
|
|
ret <32 x i1> %a
|
|
}
|
|
|
|
; CHECK-LABEL: caller_retv32i1:
|
|
; CHECK: call{{.*}} {{_*}}test_retv32i1
|
|
; CHECK: incl %eax
|
|
|
|
; Test regcall when processing result of v32i1 type
|
|
define i32 @caller_retv32i1() #0 {
|
|
entry:
|
|
%call = call x86_regcallcc <32 x i1> @test_retv32i1()
|
|
%c = bitcast <32 x i1> %call to i32
|
|
%add = add i32 %c, 1
|
|
ret i32 %add
|
|
}
|
|
|
|
; CHECK-LABEL: test_argv16i1:
|
|
; CHECK: kmovw %edx, %k{{[0-9]+}}
|
|
; CHECK: kmovw %ecx, %k{{[0-9]+}}
|
|
; CHECK: kmovw %eax, %k{{[0-9]+}}
|
|
; CHECK: ret{{l|q}}
|
|
|
|
; Test regcall when receiving arguments of v16i1 type
|
|
declare i16 @test_argv16i1helper(<16 x i1> %x0, <16 x i1> %x1, <16 x i1> %x2)
|
|
define x86_regcallcc i16 @test_argv16i1(<16 x i1> %x0, <16 x i1> %x1, <16 x i1> %x2) {
|
|
%res = call i16 @test_argv16i1helper(<16 x i1> %x0, <16 x i1> %x1, <16 x i1> %x2)
|
|
ret i16 %res
|
|
}
|
|
|
|
; CHECK-LABEL: caller_argv16i1:
|
|
; CHECK: movl $1, %eax
|
|
; CHECK: movl $1, %ecx
|
|
; CHECK: movl $1, %edx
|
|
; CHECK: call{{l|q}} {{_*}}test_argv16i1
|
|
|
|
; Test regcall when passing arguments of v16i1 type
|
|
define i16 @caller_argv16i1() #0 {
|
|
entry:
|
|
%v0 = bitcast i16 1 to <16 x i1>
|
|
%call = call x86_regcallcc i16 @test_argv16i1(<16 x i1> %v0, <16 x i1> %v0, <16 x i1> %v0)
|
|
ret i16 %call
|
|
}
|
|
|
|
; CHECK-LABEL: test_retv16i1:
|
|
; CHECK: movw $1, %ax
|
|
; CHECK: ret{{l|q}}
|
|
|
|
; Test regcall when returning v16i1 type
|
|
define x86_regcallcc <16 x i1> @test_retv16i1() {
|
|
%a = bitcast i16 1 to <16 x i1>
|
|
ret <16 x i1> %a
|
|
}
|
|
|
|
; CHECK-LABEL: caller_retv16i1:
|
|
; CHECK: call{{l|q}} {{_*}}test_retv16i1
|
|
; CHECK: incl %eax
|
|
|
|
; Test regcall when processing result of v16i1 type
|
|
define i16 @caller_retv16i1() #0 {
|
|
entry:
|
|
%call = call x86_regcallcc <16 x i1> @test_retv16i1()
|
|
%c = bitcast <16 x i1> %call to i16
|
|
%add = add i16 %c, 1
|
|
ret i16 %add
|
|
}
|
|
|
|
; CHECK-LABEL: test_argv8i1:
|
|
; CHECK: kmovw %edx, %k{{[0-9]+}}
|
|
; CHECK: kmovw %ecx, %k{{[0-9]+}}
|
|
; CHECK: kmovw %eax, %k{{[0-9]+}}
|
|
; CHECK: ret{{l|q}}
|
|
|
|
; Test regcall when receiving arguments of v8i1 type
|
|
declare i8 @test_argv8i1helper(<8 x i1> %x0, <8 x i1> %x1, <8 x i1> %x2)
|
|
define x86_regcallcc i8 @test_argv8i1(<8 x i1> %x0, <8 x i1> %x1, <8 x i1> %x2) {
|
|
%res = call i8 @test_argv8i1helper(<8 x i1> %x0, <8 x i1> %x1, <8 x i1> %x2)
|
|
ret i8 %res
|
|
}
|
|
|
|
; CHECK-LABEL: caller_argv8i1:
|
|
; CHECK: movl $1, %eax
|
|
; CHECK: movl $1, %ecx
|
|
; CHECK: movl $1, %edx
|
|
; CHECK: call{{l|q}} {{_*}}test_argv8i1
|
|
|
|
; Test regcall when passing arguments of v8i1 type
|
|
define i8 @caller_argv8i1() #0 {
|
|
entry:
|
|
%v0 = bitcast i8 1 to <8 x i1>
|
|
%call = call x86_regcallcc i8 @test_argv8i1(<8 x i1> %v0, <8 x i1> %v0, <8 x i1> %v0)
|
|
ret i8 %call
|
|
}
|
|
|
|
; CHECK-LABEL: test_retv8i1:
|
|
; CHECK: movb $1, %al
|
|
; CHECK: ret{{q|l}}
|
|
|
|
; Test regcall when returning v8i1 type
|
|
define x86_regcallcc <8 x i1> @test_retv8i1() {
|
|
%a = bitcast i8 1 to <8 x i1>
|
|
ret <8 x i1> %a
|
|
}
|
|
|
|
; CHECK-LABEL: caller_retv8i1:
|
|
; CHECK: call{{l|q}} {{_*}}test_retv8i1
|
|
; CHECK: kmovw %eax, %k{{[0-9]+}}
|
|
; CHECK: ret{{l|q}}
|
|
|
|
; Test regcall when processing result of v8i1 type
|
|
define <8 x i1> @caller_retv8i1() #0 {
|
|
entry:
|
|
%call = call x86_regcallcc <8 x i1> @test_retv8i1()
|
|
ret <8 x i1> %call
|
|
}
|