mirror of
https://github.com/RPCS3/llvm-mirror.git
synced 2025-01-31 20:51:52 +01:00
2dd345a5d8
All FP0-6 operands should be removed by the FP stackifier. By removing these we fix the machine verifier error in PR39437. I've also made it so that only defs are counted for STReturns which removes what I think were extra stack cleanup instructions. And I've removed the regcall assert because it was checking the attributes of the caller, but here we're concerned with the attributes of the callee. But I don't know how to get that information from this level.
1391 lines
47 KiB
LLVM
1391 lines
47 KiB
LLVM
; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
|
|
; RUN: llc < %s -mtriple=i386-pc-win32 -mattr=+avx512f -mattr=+avx512vl -mattr=+avx512bw -mattr=+avx512dq -verify-machineinstrs | FileCheck %s --check-prefix=X32
|
|
; RUN: llc < %s -mtriple=x86_64-win32 -mattr=+avx512f -mattr=+avx512vl -mattr=+avx512bw -mattr=+avx512dq -verify-machineinstrs | FileCheck %s --check-prefix=WIN64
|
|
; RUN: llc < %s -mtriple=x86_64-linux-gnu -mattr=+avx512f -mattr=+avx512vl -mattr=+avx512bw -mattr=+avx512dq -verify-machineinstrs | FileCheck %s --check-prefix=LINUXOSX64
|
|
|
|
; Test regcall when receiving/returning i1
|
|
define x86_regcallcc i1 @test_argReti1(i1 %a) {
|
|
; X32-LABEL: test_argReti1:
|
|
; X32: # %bb.0:
|
|
; X32-NEXT: incb %al
|
|
; X32-NEXT: # kill: def $al killed $al killed $eax
|
|
; X32-NEXT: retl
|
|
;
|
|
; WIN64-LABEL: test_argReti1:
|
|
; WIN64: # %bb.0:
|
|
; WIN64-NEXT: incb %al
|
|
; WIN64-NEXT: # kill: def $al killed $al killed $eax
|
|
; WIN64-NEXT: retq
|
|
;
|
|
; LINUXOSX64-LABEL: test_argReti1:
|
|
; LINUXOSX64: # %bb.0:
|
|
; LINUXOSX64-NEXT: incb %al
|
|
; LINUXOSX64-NEXT: # kill: def $al killed $al killed $eax
|
|
; LINUXOSX64-NEXT: retq
|
|
%add = add i1 %a, 1
|
|
ret i1 %add
|
|
}
|
|
|
|
; Test regcall when passing/retrieving i1
|
|
define x86_regcallcc i1 @test_CallargReti1(i1 %a) {
|
|
; X32-LABEL: test_CallargReti1:
|
|
; X32: # %bb.0:
|
|
; X32-NEXT: pushl %esp
|
|
; X32-NEXT: incb %al
|
|
; X32-NEXT: movzbl %al, %eax
|
|
; X32-NEXT: calll _test_argReti1
|
|
; X32-NEXT: incb %al
|
|
; X32-NEXT: popl %esp
|
|
; X32-NEXT: retl
|
|
;
|
|
; WIN64-LABEL: test_CallargReti1:
|
|
; WIN64: # %bb.0:
|
|
; WIN64-NEXT: pushq %rsp
|
|
; WIN64-NEXT: .seh_pushreg %rsp
|
|
; WIN64-NEXT: .seh_endprologue
|
|
; WIN64-NEXT: incb %al
|
|
; WIN64-NEXT: movzbl %al, %eax
|
|
; WIN64-NEXT: callq test_argReti1
|
|
; WIN64-NEXT: incb %al
|
|
; WIN64-NEXT: popq %rsp
|
|
; WIN64-NEXT: retq
|
|
; WIN64-NEXT: .seh_handlerdata
|
|
; WIN64-NEXT: .text
|
|
; WIN64-NEXT: .seh_endproc
|
|
;
|
|
; LINUXOSX64-LABEL: test_CallargReti1:
|
|
; LINUXOSX64: # %bb.0:
|
|
; LINUXOSX64-NEXT: pushq %rsp
|
|
; LINUXOSX64-NEXT: .cfi_def_cfa_offset 16
|
|
; LINUXOSX64-NEXT: .cfi_offset %rsp, -16
|
|
; LINUXOSX64-NEXT: incb %al
|
|
; LINUXOSX64-NEXT: movzbl %al, %eax
|
|
; LINUXOSX64-NEXT: callq test_argReti1
|
|
; LINUXOSX64-NEXT: incb %al
|
|
; LINUXOSX64-NEXT: popq %rsp
|
|
; LINUXOSX64-NEXT: .cfi_def_cfa_offset 8
|
|
; LINUXOSX64-NEXT: retq
|
|
%b = add i1 %a, 1
|
|
%c = call x86_regcallcc i1 @test_argReti1(i1 %b)
|
|
%d = add i1 %c, 1
|
|
ret i1 %d
|
|
}
|
|
|
|
; Test regcall when receiving/returning i8
|
|
define x86_regcallcc i8 @test_argReti8(i8 %a) {
|
|
; X32-LABEL: test_argReti8:
|
|
; X32: # %bb.0:
|
|
; X32-NEXT: incb %al
|
|
; X32-NEXT: # kill: def $al killed $al killed $eax
|
|
; X32-NEXT: retl
|
|
;
|
|
; WIN64-LABEL: test_argReti8:
|
|
; WIN64: # %bb.0:
|
|
; WIN64-NEXT: incb %al
|
|
; WIN64-NEXT: # kill: def $al killed $al killed $eax
|
|
; WIN64-NEXT: retq
|
|
;
|
|
; LINUXOSX64-LABEL: test_argReti8:
|
|
; LINUXOSX64: # %bb.0:
|
|
; LINUXOSX64-NEXT: incb %al
|
|
; LINUXOSX64-NEXT: # kill: def $al killed $al killed $eax
|
|
; LINUXOSX64-NEXT: retq
|
|
%add = add i8 %a, 1
|
|
ret i8 %add
|
|
}
|
|
|
|
; Test regcall when passing/retrieving i8
|
|
define x86_regcallcc i8 @test_CallargReti8(i8 %a) {
|
|
; X32-LABEL: test_CallargReti8:
|
|
; X32: # %bb.0:
|
|
; X32-NEXT: pushl %esp
|
|
; X32-NEXT: incb %al
|
|
; X32-NEXT: movzbl %al, %eax
|
|
; X32-NEXT: calll _test_argReti8
|
|
; X32-NEXT: incb %al
|
|
; X32-NEXT: popl %esp
|
|
; X32-NEXT: retl
|
|
;
|
|
; WIN64-LABEL: test_CallargReti8:
|
|
; WIN64: # %bb.0:
|
|
; WIN64-NEXT: pushq %rsp
|
|
; WIN64-NEXT: .seh_pushreg %rsp
|
|
; WIN64-NEXT: .seh_endprologue
|
|
; WIN64-NEXT: incb %al
|
|
; WIN64-NEXT: movzbl %al, %eax
|
|
; WIN64-NEXT: callq test_argReti8
|
|
; WIN64-NEXT: incb %al
|
|
; WIN64-NEXT: popq %rsp
|
|
; WIN64-NEXT: retq
|
|
; WIN64-NEXT: .seh_handlerdata
|
|
; WIN64-NEXT: .text
|
|
; WIN64-NEXT: .seh_endproc
|
|
;
|
|
; LINUXOSX64-LABEL: test_CallargReti8:
|
|
; LINUXOSX64: # %bb.0:
|
|
; LINUXOSX64-NEXT: pushq %rsp
|
|
; LINUXOSX64-NEXT: .cfi_def_cfa_offset 16
|
|
; LINUXOSX64-NEXT: .cfi_offset %rsp, -16
|
|
; LINUXOSX64-NEXT: incb %al
|
|
; LINUXOSX64-NEXT: movzbl %al, %eax
|
|
; LINUXOSX64-NEXT: callq test_argReti8
|
|
; LINUXOSX64-NEXT: incb %al
|
|
; LINUXOSX64-NEXT: popq %rsp
|
|
; LINUXOSX64-NEXT: .cfi_def_cfa_offset 8
|
|
; LINUXOSX64-NEXT: retq
|
|
%b = add i8 %a, 1
|
|
%c = call x86_regcallcc i8 @test_argReti8(i8 %b)
|
|
%d = add i8 %c, 1
|
|
ret i8 %d
|
|
}
|
|
|
|
; Test regcall when receiving/returning i16
|
|
define x86_regcallcc i16 @test_argReti16(i16 %a) {
|
|
; X32-LABEL: test_argReti16:
|
|
; X32: # %bb.0:
|
|
; X32-NEXT: incl %eax
|
|
; X32-NEXT: # kill: def $ax killed $ax killed $eax
|
|
; X32-NEXT: retl
|
|
;
|
|
; WIN64-LABEL: test_argReti16:
|
|
; WIN64: # %bb.0:
|
|
; WIN64-NEXT: incl %eax
|
|
; WIN64-NEXT: # kill: def $ax killed $ax killed $eax
|
|
; WIN64-NEXT: retq
|
|
;
|
|
; LINUXOSX64-LABEL: test_argReti16:
|
|
; LINUXOSX64: # %bb.0:
|
|
; LINUXOSX64-NEXT: incl %eax
|
|
; LINUXOSX64-NEXT: # kill: def $ax killed $ax killed $eax
|
|
; LINUXOSX64-NEXT: retq
|
|
%add = add i16 %a, 1
|
|
ret i16 %add
|
|
}
|
|
|
|
; Test regcall when passing/retrieving i16
|
|
define x86_regcallcc i16 @test_CallargReti16(i16 %a) {
|
|
; X32-LABEL: test_CallargReti16:
|
|
; X32: # %bb.0:
|
|
; X32-NEXT: pushl %esp
|
|
; X32-NEXT: incl %eax
|
|
; X32-NEXT: calll _test_argReti16
|
|
; X32-NEXT: # kill: def $ax killed $ax def $eax
|
|
; X32-NEXT: incl %eax
|
|
; X32-NEXT: # kill: def $ax killed $ax killed $eax
|
|
; X32-NEXT: popl %esp
|
|
; X32-NEXT: retl
|
|
;
|
|
; WIN64-LABEL: test_CallargReti16:
|
|
; WIN64: # %bb.0:
|
|
; WIN64-NEXT: pushq %rsp
|
|
; WIN64-NEXT: .seh_pushreg %rsp
|
|
; WIN64-NEXT: .seh_endprologue
|
|
; WIN64-NEXT: incl %eax
|
|
; WIN64-NEXT: callq test_argReti16
|
|
; WIN64-NEXT: # kill: def $ax killed $ax def $eax
|
|
; WIN64-NEXT: incl %eax
|
|
; WIN64-NEXT: # kill: def $ax killed $ax killed $eax
|
|
; WIN64-NEXT: popq %rsp
|
|
; WIN64-NEXT: retq
|
|
; WIN64-NEXT: .seh_handlerdata
|
|
; WIN64-NEXT: .text
|
|
; WIN64-NEXT: .seh_endproc
|
|
;
|
|
; LINUXOSX64-LABEL: test_CallargReti16:
|
|
; LINUXOSX64: # %bb.0:
|
|
; LINUXOSX64-NEXT: pushq %rsp
|
|
; LINUXOSX64-NEXT: .cfi_def_cfa_offset 16
|
|
; LINUXOSX64-NEXT: .cfi_offset %rsp, -16
|
|
; LINUXOSX64-NEXT: incl %eax
|
|
; LINUXOSX64-NEXT: callq test_argReti16
|
|
; LINUXOSX64-NEXT: # kill: def $ax killed $ax def $eax
|
|
; LINUXOSX64-NEXT: incl %eax
|
|
; LINUXOSX64-NEXT: # kill: def $ax killed $ax killed $eax
|
|
; LINUXOSX64-NEXT: popq %rsp
|
|
; LINUXOSX64-NEXT: .cfi_def_cfa_offset 8
|
|
; LINUXOSX64-NEXT: retq
|
|
%b = add i16 %a, 1
|
|
%c = call x86_regcallcc i16 @test_argReti16(i16 %b)
|
|
%d = add i16 %c, 1
|
|
ret i16 %d
|
|
}
|
|
|
|
; Test regcall when receiving/returning i32
|
|
define x86_regcallcc i32 @test_argReti32(i32 %a) {
|
|
; X32-LABEL: test_argReti32:
|
|
; X32: # %bb.0:
|
|
; X32-NEXT: incl %eax
|
|
; X32-NEXT: retl
|
|
;
|
|
; WIN64-LABEL: test_argReti32:
|
|
; WIN64: # %bb.0:
|
|
; WIN64-NEXT: incl %eax
|
|
; WIN64-NEXT: retq
|
|
;
|
|
; LINUXOSX64-LABEL: test_argReti32:
|
|
; LINUXOSX64: # %bb.0:
|
|
; LINUXOSX64-NEXT: incl %eax
|
|
; LINUXOSX64-NEXT: retq
|
|
%add = add i32 %a, 1
|
|
ret i32 %add
|
|
}
|
|
|
|
; Test regcall when passing/retrieving i32
|
|
define x86_regcallcc i32 @test_CallargReti32(i32 %a) {
|
|
; X32-LABEL: test_CallargReti32:
|
|
; X32: # %bb.0:
|
|
; X32-NEXT: pushl %esp
|
|
; X32-NEXT: incl %eax
|
|
; X32-NEXT: calll _test_argReti32
|
|
; X32-NEXT: incl %eax
|
|
; X32-NEXT: popl %esp
|
|
; X32-NEXT: retl
|
|
;
|
|
; WIN64-LABEL: test_CallargReti32:
|
|
; WIN64: # %bb.0:
|
|
; WIN64-NEXT: pushq %rsp
|
|
; WIN64-NEXT: .seh_pushreg %rsp
|
|
; WIN64-NEXT: .seh_endprologue
|
|
; WIN64-NEXT: incl %eax
|
|
; WIN64-NEXT: callq test_argReti32
|
|
; WIN64-NEXT: incl %eax
|
|
; WIN64-NEXT: popq %rsp
|
|
; WIN64-NEXT: retq
|
|
; WIN64-NEXT: .seh_handlerdata
|
|
; WIN64-NEXT: .text
|
|
; WIN64-NEXT: .seh_endproc
|
|
;
|
|
; LINUXOSX64-LABEL: test_CallargReti32:
|
|
; LINUXOSX64: # %bb.0:
|
|
; LINUXOSX64-NEXT: pushq %rsp
|
|
; LINUXOSX64-NEXT: .cfi_def_cfa_offset 16
|
|
; LINUXOSX64-NEXT: .cfi_offset %rsp, -16
|
|
; LINUXOSX64-NEXT: incl %eax
|
|
; LINUXOSX64-NEXT: callq test_argReti32
|
|
; LINUXOSX64-NEXT: incl %eax
|
|
; LINUXOSX64-NEXT: popq %rsp
|
|
; LINUXOSX64-NEXT: .cfi_def_cfa_offset 8
|
|
; LINUXOSX64-NEXT: retq
|
|
%b = add i32 %a, 1
|
|
%c = call x86_regcallcc i32 @test_argReti32(i32 %b)
|
|
%d = add i32 %c, 1
|
|
ret i32 %d
|
|
}
|
|
|
|
; Test regcall when receiving/returning i64
|
|
define x86_regcallcc i64 @test_argReti64(i64 %a) {
|
|
; X32-LABEL: test_argReti64:
|
|
; X32: # %bb.0:
|
|
; X32-NEXT: addl $3, %eax
|
|
; X32-NEXT: adcl $1, %ecx
|
|
; X32-NEXT: retl
|
|
;
|
|
; WIN64-LABEL: test_argReti64:
|
|
; WIN64: # %bb.0:
|
|
; WIN64-NEXT: movabsq $4294967299, %rcx # imm = 0x100000003
|
|
; WIN64-NEXT: addq %rcx, %rax
|
|
; WIN64-NEXT: retq
|
|
;
|
|
; LINUXOSX64-LABEL: test_argReti64:
|
|
; LINUXOSX64: # %bb.0:
|
|
; LINUXOSX64-NEXT: movabsq $4294967299, %rcx # imm = 0x100000003
|
|
; LINUXOSX64-NEXT: addq %rcx, %rax
|
|
; LINUXOSX64-NEXT: retq
|
|
%add = add i64 %a, 4294967299
|
|
ret i64 %add
|
|
}
|
|
|
|
; Test regcall when passing/retrieving i64
|
|
define x86_regcallcc i64 @test_CallargReti64(i64 %a) {
|
|
; X32-LABEL: test_CallargReti64:
|
|
; X32: # %bb.0:
|
|
; X32-NEXT: pushl %esp
|
|
; X32-NEXT: addl $1, %eax
|
|
; X32-NEXT: adcl $0, %ecx
|
|
; X32-NEXT: calll _test_argReti64
|
|
; X32-NEXT: addl $1, %eax
|
|
; X32-NEXT: adcl $0, %ecx
|
|
; X32-NEXT: popl %esp
|
|
; X32-NEXT: retl
|
|
;
|
|
; WIN64-LABEL: test_CallargReti64:
|
|
; WIN64: # %bb.0:
|
|
; WIN64-NEXT: pushq %rsp
|
|
; WIN64-NEXT: .seh_pushreg %rsp
|
|
; WIN64-NEXT: .seh_endprologue
|
|
; WIN64-NEXT: incq %rax
|
|
; WIN64-NEXT: callq test_argReti64
|
|
; WIN64-NEXT: incq %rax
|
|
; WIN64-NEXT: popq %rsp
|
|
; WIN64-NEXT: retq
|
|
; WIN64-NEXT: .seh_handlerdata
|
|
; WIN64-NEXT: .text
|
|
; WIN64-NEXT: .seh_endproc
|
|
;
|
|
; LINUXOSX64-LABEL: test_CallargReti64:
|
|
; LINUXOSX64: # %bb.0:
|
|
; LINUXOSX64-NEXT: pushq %rsp
|
|
; LINUXOSX64-NEXT: .cfi_def_cfa_offset 16
|
|
; LINUXOSX64-NEXT: .cfi_offset %rsp, -16
|
|
; LINUXOSX64-NEXT: incq %rax
|
|
; LINUXOSX64-NEXT: callq test_argReti64
|
|
; LINUXOSX64-NEXT: incq %rax
|
|
; LINUXOSX64-NEXT: popq %rsp
|
|
; LINUXOSX64-NEXT: .cfi_def_cfa_offset 8
|
|
; LINUXOSX64-NEXT: retq
|
|
%b = add i64 %a, 1
|
|
%c = call x86_regcallcc i64 @test_argReti64(i64 %b)
|
|
%d = add i64 %c, 1
|
|
ret i64 %d
|
|
}
|
|
|
|
; Test regcall when receiving/returning float
|
|
define x86_regcallcc float @test_argRetFloat(float %a) {
|
|
; X32-LABEL: test_argRetFloat:
|
|
; X32: # %bb.0:
|
|
; X32-NEXT: vaddss __real@3f800000, %xmm0, %xmm0
|
|
; X32-NEXT: retl
|
|
;
|
|
; WIN64-LABEL: test_argRetFloat:
|
|
; WIN64: # %bb.0:
|
|
; WIN64-NEXT: vaddss __real@{{.*}}(%rip), %xmm0, %xmm0
|
|
; WIN64-NEXT: retq
|
|
;
|
|
; LINUXOSX64-LABEL: test_argRetFloat:
|
|
; LINUXOSX64: # %bb.0:
|
|
; LINUXOSX64-NEXT: vaddss {{.*}}(%rip), %xmm0, %xmm0
|
|
; LINUXOSX64-NEXT: retq
|
|
%add = fadd float 1.0, %a
|
|
ret float %add
|
|
}
|
|
|
|
; Test regcall when passing/retrieving float
|
|
define x86_regcallcc float @test_CallargRetFloat(float %a) {
|
|
; X32-LABEL: test_CallargRetFloat:
|
|
; X32: # %bb.0:
|
|
; X32-NEXT: pushl %esp
|
|
; X32-NEXT: subl $24, %esp
|
|
; X32-NEXT: vmovups %xmm4, (%esp) # 16-byte Spill
|
|
; X32-NEXT: vmovss {{.*#+}} xmm4 = mem[0],zero,zero,zero
|
|
; X32-NEXT: vaddss %xmm4, %xmm0, %xmm0
|
|
; X32-NEXT: calll _test_argRetFloat
|
|
; X32-NEXT: vaddss %xmm4, %xmm0, %xmm0
|
|
; X32-NEXT: vmovups (%esp), %xmm4 # 16-byte Reload
|
|
; X32-NEXT: addl $24, %esp
|
|
; X32-NEXT: popl %esp
|
|
; X32-NEXT: retl
|
|
;
|
|
; WIN64-LABEL: test_CallargRetFloat:
|
|
; WIN64: # %bb.0:
|
|
; WIN64-NEXT: pushq %rsp
|
|
; WIN64-NEXT: .seh_pushreg %rsp
|
|
; WIN64-NEXT: subq $16, %rsp
|
|
; WIN64-NEXT: .seh_stackalloc 16
|
|
; WIN64-NEXT: vmovaps %xmm8, (%rsp) # 16-byte Spill
|
|
; WIN64-NEXT: .seh_savexmm %xmm8, 0
|
|
; WIN64-NEXT: .seh_endprologue
|
|
; WIN64-NEXT: vmovss {{.*#+}} xmm8 = mem[0],zero,zero,zero
|
|
; WIN64-NEXT: vaddss %xmm0, %xmm8, %xmm0
|
|
; WIN64-NEXT: callq test_argRetFloat
|
|
; WIN64-NEXT: vaddss %xmm0, %xmm8, %xmm0
|
|
; WIN64-NEXT: vmovaps (%rsp), %xmm8 # 16-byte Reload
|
|
; WIN64-NEXT: addq $16, %rsp
|
|
; WIN64-NEXT: popq %rsp
|
|
; WIN64-NEXT: retq
|
|
; WIN64-NEXT: .seh_handlerdata
|
|
; WIN64-NEXT: .text
|
|
; WIN64-NEXT: .seh_endproc
|
|
;
|
|
; LINUXOSX64-LABEL: test_CallargRetFloat:
|
|
; LINUXOSX64: # %bb.0:
|
|
; LINUXOSX64-NEXT: pushq %rsp
|
|
; LINUXOSX64-NEXT: .cfi_def_cfa_offset 16
|
|
; LINUXOSX64-NEXT: subq $16, %rsp
|
|
; LINUXOSX64-NEXT: vmovaps %xmm8, (%rsp) # 16-byte Spill
|
|
; LINUXOSX64-NEXT: .cfi_def_cfa_offset 32
|
|
; LINUXOSX64-NEXT: .cfi_offset %rsp, -16
|
|
; LINUXOSX64-NEXT: .cfi_offset %xmm8, -32
|
|
; LINUXOSX64-NEXT: vmovss {{.*#+}} xmm8 = mem[0],zero,zero,zero
|
|
; LINUXOSX64-NEXT: vaddss %xmm0, %xmm8, %xmm0
|
|
; LINUXOSX64-NEXT: callq test_argRetFloat
|
|
; LINUXOSX64-NEXT: vaddss %xmm0, %xmm8, %xmm0
|
|
; LINUXOSX64-NEXT: vmovaps (%rsp), %xmm8 # 16-byte Reload
|
|
; LINUXOSX64-NEXT: addq $16, %rsp
|
|
; LINUXOSX64-NEXT: .cfi_def_cfa_offset 16
|
|
; LINUXOSX64-NEXT: popq %rsp
|
|
; LINUXOSX64-NEXT: .cfi_def_cfa_offset 8
|
|
; LINUXOSX64-NEXT: retq
|
|
%b = fadd float 1.0, %a
|
|
%c = call x86_regcallcc float @test_argRetFloat(float %b)
|
|
%d = fadd float 1.0, %c
|
|
ret float %d
|
|
}
|
|
|
|
; Test regcall when receiving/returning double
|
|
define x86_regcallcc double @test_argRetDouble(double %a) {
|
|
; X32-LABEL: test_argRetDouble:
|
|
; X32: # %bb.0:
|
|
; X32-NEXT: vaddsd __real@3ff0000000000000, %xmm0, %xmm0
|
|
; X32-NEXT: retl
|
|
;
|
|
; WIN64-LABEL: test_argRetDouble:
|
|
; WIN64: # %bb.0:
|
|
; WIN64-NEXT: vaddsd __real@{{.*}}(%rip), %xmm0, %xmm0
|
|
; WIN64-NEXT: retq
|
|
;
|
|
; LINUXOSX64-LABEL: test_argRetDouble:
|
|
; LINUXOSX64: # %bb.0:
|
|
; LINUXOSX64-NEXT: vaddsd {{.*}}(%rip), %xmm0, %xmm0
|
|
; LINUXOSX64-NEXT: retq
|
|
%add = fadd double %a, 1.0
|
|
ret double %add
|
|
}
|
|
|
|
; Test regcall when passing/retrieving double
|
|
define x86_regcallcc double @test_CallargRetDouble(double %a) {
|
|
; X32-LABEL: test_CallargRetDouble:
|
|
; X32: # %bb.0:
|
|
; X32-NEXT: pushl %esp
|
|
; X32-NEXT: subl $24, %esp
|
|
; X32-NEXT: vmovups %xmm4, (%esp) # 16-byte Spill
|
|
; X32-NEXT: vmovsd {{.*#+}} xmm4 = mem[0],zero
|
|
; X32-NEXT: vaddsd %xmm4, %xmm0, %xmm0
|
|
; X32-NEXT: calll _test_argRetDouble
|
|
; X32-NEXT: vaddsd %xmm4, %xmm0, %xmm0
|
|
; X32-NEXT: vmovups (%esp), %xmm4 # 16-byte Reload
|
|
; X32-NEXT: addl $24, %esp
|
|
; X32-NEXT: popl %esp
|
|
; X32-NEXT: retl
|
|
;
|
|
; WIN64-LABEL: test_CallargRetDouble:
|
|
; WIN64: # %bb.0:
|
|
; WIN64-NEXT: pushq %rsp
|
|
; WIN64-NEXT: .seh_pushreg %rsp
|
|
; WIN64-NEXT: subq $16, %rsp
|
|
; WIN64-NEXT: .seh_stackalloc 16
|
|
; WIN64-NEXT: vmovaps %xmm8, (%rsp) # 16-byte Spill
|
|
; WIN64-NEXT: .seh_savexmm %xmm8, 0
|
|
; WIN64-NEXT: .seh_endprologue
|
|
; WIN64-NEXT: vmovsd {{.*#+}} xmm8 = mem[0],zero
|
|
; WIN64-NEXT: vaddsd %xmm0, %xmm8, %xmm0
|
|
; WIN64-NEXT: callq test_argRetDouble
|
|
; WIN64-NEXT: vaddsd %xmm0, %xmm8, %xmm0
|
|
; WIN64-NEXT: vmovaps (%rsp), %xmm8 # 16-byte Reload
|
|
; WIN64-NEXT: addq $16, %rsp
|
|
; WIN64-NEXT: popq %rsp
|
|
; WIN64-NEXT: retq
|
|
; WIN64-NEXT: .seh_handlerdata
|
|
; WIN64-NEXT: .text
|
|
; WIN64-NEXT: .seh_endproc
|
|
;
|
|
; LINUXOSX64-LABEL: test_CallargRetDouble:
|
|
; LINUXOSX64: # %bb.0:
|
|
; LINUXOSX64-NEXT: pushq %rsp
|
|
; LINUXOSX64-NEXT: .cfi_def_cfa_offset 16
|
|
; LINUXOSX64-NEXT: subq $16, %rsp
|
|
; LINUXOSX64-NEXT: vmovaps %xmm8, (%rsp) # 16-byte Spill
|
|
; LINUXOSX64-NEXT: .cfi_def_cfa_offset 32
|
|
; LINUXOSX64-NEXT: .cfi_offset %rsp, -16
|
|
; LINUXOSX64-NEXT: .cfi_offset %xmm8, -32
|
|
; LINUXOSX64-NEXT: vmovsd {{.*#+}} xmm8 = mem[0],zero
|
|
; LINUXOSX64-NEXT: vaddsd %xmm0, %xmm8, %xmm0
|
|
; LINUXOSX64-NEXT: callq test_argRetDouble
|
|
; LINUXOSX64-NEXT: vaddsd %xmm0, %xmm8, %xmm0
|
|
; LINUXOSX64-NEXT: vmovaps (%rsp), %xmm8 # 16-byte Reload
|
|
; LINUXOSX64-NEXT: addq $16, %rsp
|
|
; LINUXOSX64-NEXT: .cfi_def_cfa_offset 16
|
|
; LINUXOSX64-NEXT: popq %rsp
|
|
; LINUXOSX64-NEXT: .cfi_def_cfa_offset 8
|
|
; LINUXOSX64-NEXT: retq
|
|
%b = fadd double 1.0, %a
|
|
%c = call x86_regcallcc double @test_argRetDouble(double %b)
|
|
%d = fadd double 1.0, %c
|
|
ret double %d
|
|
}
|
|
|
|
; Test regcall when receiving/returning long double
|
|
define x86_regcallcc x86_fp80 @test_argRetf80(x86_fp80 %a0) nounwind {
|
|
; X32-LABEL: test_argRetf80:
|
|
; X32: # %bb.0:
|
|
; X32-NEXT: fadd %st, %st(0)
|
|
; X32-NEXT: retl
|
|
;
|
|
; WIN64-LABEL: test_argRetf80:
|
|
; WIN64: # %bb.0:
|
|
; WIN64-NEXT: fadd %st, %st(0)
|
|
; WIN64-NEXT: retq
|
|
;
|
|
; LINUXOSX64-LABEL: test_argRetf80:
|
|
; LINUXOSX64: # %bb.0:
|
|
; LINUXOSX64-NEXT: fadd %st, %st(0)
|
|
; LINUXOSX64-NEXT: retq
|
|
%r0 = fadd x86_fp80 %a0, %a0
|
|
ret x86_fp80 %r0
|
|
}
|
|
|
|
; Test regcall when receiving/returning long double
|
|
define x86_regcallcc double @test_argParamf80(x86_fp80 %a0) nounwind {
|
|
; X32-LABEL: test_argParamf80:
|
|
; X32: # %bb.0:
|
|
; X32-NEXT: pushl %ebp
|
|
; X32-NEXT: movl %esp, %ebp
|
|
; X32-NEXT: andl $-8, %esp
|
|
; X32-NEXT: subl $8, %esp
|
|
; X32-NEXT: fstpl (%esp)
|
|
; X32-NEXT: vmovsd {{.*#+}} xmm0 = mem[0],zero
|
|
; X32-NEXT: movl %ebp, %esp
|
|
; X32-NEXT: popl %ebp
|
|
; X32-NEXT: retl
|
|
;
|
|
; WIN64-LABEL: test_argParamf80:
|
|
; WIN64: # %bb.0:
|
|
; WIN64-NEXT: pushq %rax
|
|
; WIN64-NEXT: fstpl (%rsp)
|
|
; WIN64-NEXT: vmovsd {{.*#+}} xmm0 = mem[0],zero
|
|
; WIN64-NEXT: popq %rax
|
|
; WIN64-NEXT: retq
|
|
;
|
|
; LINUXOSX64-LABEL: test_argParamf80:
|
|
; LINUXOSX64: # %bb.0:
|
|
; LINUXOSX64-NEXT: fstpl -{{[0-9]+}}(%rsp)
|
|
; LINUXOSX64-NEXT: vmovsd {{.*#+}} xmm0 = mem[0],zero
|
|
; LINUXOSX64-NEXT: retq
|
|
%r0 = fptrunc x86_fp80 %a0 to double
|
|
ret double %r0
|
|
}
|
|
|
|
; Test regcall when passing/retrieving long double
|
|
define x86_regcallcc x86_fp80 @test_CallargRetf80(x86_fp80 %a) {
|
|
; X32-LABEL: test_CallargRetf80:
|
|
; X32: # %bb.0:
|
|
; X32-NEXT: pushl %esp
|
|
; X32-NEXT: fadd %st, %st(0)
|
|
; X32-NEXT: calll _test_argRetf80
|
|
; X32-NEXT: fadd %st, %st(0)
|
|
; X32-NEXT: popl %esp
|
|
; X32-NEXT: retl
|
|
;
|
|
; WIN64-LABEL: test_CallargRetf80:
|
|
; WIN64: # %bb.0:
|
|
; WIN64-NEXT: pushq %rsp
|
|
; WIN64-NEXT: .seh_pushreg %rsp
|
|
; WIN64-NEXT: .seh_endprologue
|
|
; WIN64-NEXT: fadd %st, %st(0)
|
|
; WIN64-NEXT: callq test_argRetf80
|
|
; WIN64-NEXT: fadd %st, %st(0)
|
|
; WIN64-NEXT: popq %rsp
|
|
; WIN64-NEXT: retq
|
|
; WIN64-NEXT: .seh_handlerdata
|
|
; WIN64-NEXT: .text
|
|
; WIN64-NEXT: .seh_endproc
|
|
;
|
|
; LINUXOSX64-LABEL: test_CallargRetf80:
|
|
; LINUXOSX64: # %bb.0:
|
|
; LINUXOSX64-NEXT: pushq %rsp
|
|
; LINUXOSX64-NEXT: .cfi_def_cfa_offset 16
|
|
; LINUXOSX64-NEXT: .cfi_offset %rsp, -16
|
|
; LINUXOSX64-NEXT: fadd %st, %st(0)
|
|
; LINUXOSX64-NEXT: callq test_argRetf80
|
|
; LINUXOSX64-NEXT: fadd %st, %st(0)
|
|
; LINUXOSX64-NEXT: popq %rsp
|
|
; LINUXOSX64-NEXT: .cfi_def_cfa_offset 8
|
|
; LINUXOSX64-NEXT: retq
|
|
%b = fadd x86_fp80 %a, %a
|
|
%c = call x86_regcallcc x86_fp80 @test_argRetf80(x86_fp80 %b)
|
|
%d = fadd x86_fp80 %c, %c
|
|
ret x86_fp80 %d
|
|
}
|
|
|
|
define x86_regcallcc double @test_CallargParamf80(x86_fp80 %a) {
|
|
; X32-LABEL: test_CallargParamf80:
|
|
; X32: # %bb.0:
|
|
; X32-NEXT: pushl %esp
|
|
; X32-NEXT: fadd %st, %st(0)
|
|
; X32-NEXT: calll _test_argParamf80
|
|
; X32-NEXT: vaddsd %xmm0, %xmm0, %xmm0
|
|
; X32-NEXT: popl %esp
|
|
; X32-NEXT: retl
|
|
;
|
|
; WIN64-LABEL: test_CallargParamf80:
|
|
; WIN64: # %bb.0:
|
|
; WIN64-NEXT: pushq %rsp
|
|
; WIN64-NEXT: .seh_pushreg %rsp
|
|
; WIN64-NEXT: .seh_endprologue
|
|
; WIN64-NEXT: fadd %st, %st(0)
|
|
; WIN64-NEXT: callq test_argParamf80
|
|
; WIN64-NEXT: vaddsd %xmm0, %xmm0, %xmm0
|
|
; WIN64-NEXT: popq %rsp
|
|
; WIN64-NEXT: retq
|
|
; WIN64-NEXT: .seh_handlerdata
|
|
; WIN64-NEXT: .text
|
|
; WIN64-NEXT: .seh_endproc
|
|
;
|
|
; LINUXOSX64-LABEL: test_CallargParamf80:
|
|
; LINUXOSX64: # %bb.0:
|
|
; LINUXOSX64-NEXT: pushq %rsp
|
|
; LINUXOSX64-NEXT: .cfi_def_cfa_offset 16
|
|
; LINUXOSX64-NEXT: .cfi_offset %rsp, -16
|
|
; LINUXOSX64-NEXT: fadd %st, %st(0)
|
|
; LINUXOSX64-NEXT: callq test_argParamf80
|
|
; LINUXOSX64-NEXT: vaddsd %xmm0, %xmm0, %xmm0
|
|
; LINUXOSX64-NEXT: popq %rsp
|
|
; LINUXOSX64-NEXT: .cfi_def_cfa_offset 8
|
|
; LINUXOSX64-NEXT: retq
|
|
%b = fadd x86_fp80 %a, %a
|
|
%c = call x86_regcallcc double @test_argParamf80(x86_fp80 %b)
|
|
%d = fadd double %c, %c
|
|
ret double %d
|
|
}
|
|
|
|
; Test regcall when receiving/returning pointer
|
|
define x86_regcallcc [4 x i32]* @test_argRetPointer([4 x i32]* %a) {
|
|
; X32-LABEL: test_argRetPointer:
|
|
; X32: # %bb.0:
|
|
; X32-NEXT: incl %eax
|
|
; X32-NEXT: retl
|
|
;
|
|
; WIN64-LABEL: test_argRetPointer:
|
|
; WIN64: # %bb.0:
|
|
; WIN64-NEXT: incl %eax
|
|
; WIN64-NEXT: retq
|
|
;
|
|
; LINUXOSX64-LABEL: test_argRetPointer:
|
|
; LINUXOSX64: # %bb.0:
|
|
; LINUXOSX64-NEXT: incl %eax
|
|
; LINUXOSX64-NEXT: retq
|
|
%b = ptrtoint [4 x i32]* %a to i32
|
|
%c = add i32 %b, 1
|
|
%d = inttoptr i32 %c to [4 x i32]*
|
|
ret [4 x i32]* %d
|
|
}
|
|
|
|
; Test regcall when passing/retrieving pointer
|
|
define x86_regcallcc [4 x i32]* @test_CallargRetPointer([4 x i32]* %a) {
|
|
; X32-LABEL: test_CallargRetPointer:
|
|
; X32: # %bb.0:
|
|
; X32-NEXT: pushl %esp
|
|
; X32-NEXT: incl %eax
|
|
; X32-NEXT: calll _test_argRetPointer
|
|
; X32-NEXT: incl %eax
|
|
; X32-NEXT: popl %esp
|
|
; X32-NEXT: retl
|
|
;
|
|
; WIN64-LABEL: test_CallargRetPointer:
|
|
; WIN64: # %bb.0:
|
|
; WIN64-NEXT: pushq %rsp
|
|
; WIN64-NEXT: .seh_pushreg %rsp
|
|
; WIN64-NEXT: .seh_endprologue
|
|
; WIN64-NEXT: incl %eax
|
|
; WIN64-NEXT: callq test_argRetPointer
|
|
; WIN64-NEXT: incl %eax
|
|
; WIN64-NEXT: popq %rsp
|
|
; WIN64-NEXT: retq
|
|
; WIN64-NEXT: .seh_handlerdata
|
|
; WIN64-NEXT: .text
|
|
; WIN64-NEXT: .seh_endproc
|
|
;
|
|
; LINUXOSX64-LABEL: test_CallargRetPointer:
|
|
; LINUXOSX64: # %bb.0:
|
|
; LINUXOSX64-NEXT: pushq %rsp
|
|
; LINUXOSX64-NEXT: .cfi_def_cfa_offset 16
|
|
; LINUXOSX64-NEXT: .cfi_offset %rsp, -16
|
|
; LINUXOSX64-NEXT: incl %eax
|
|
; LINUXOSX64-NEXT: callq test_argRetPointer
|
|
; LINUXOSX64-NEXT: incl %eax
|
|
; LINUXOSX64-NEXT: popq %rsp
|
|
; LINUXOSX64-NEXT: .cfi_def_cfa_offset 8
|
|
; LINUXOSX64-NEXT: retq
|
|
%b = ptrtoint [4 x i32]* %a to i32
|
|
%c = add i32 %b, 1
|
|
%d = inttoptr i32 %c to [4 x i32]*
|
|
%e = call x86_regcallcc [4 x i32]* @test_argRetPointer([4 x i32]* %d)
|
|
%f = ptrtoint [4 x i32]* %e to i32
|
|
%g = add i32 %f, 1
|
|
%h = inttoptr i32 %g to [4 x i32]*
|
|
ret [4 x i32]* %h
|
|
}
|
|
|
|
; Test regcall when receiving/returning 128 bit vector
|
|
define x86_regcallcc <4 x i32> @test_argRet128Vector(<4 x i1> %x, <4 x i32> %a, <4 x i32> %b) {
|
|
; X32-LABEL: test_argRet128Vector:
|
|
; X32: # %bb.0:
|
|
; X32-NEXT: vpslld $31, %xmm0, %xmm0
|
|
; X32-NEXT: vpmovd2m %xmm0, %k1
|
|
; X32-NEXT: vpblendmd %xmm1, %xmm2, %xmm0 {%k1}
|
|
; X32-NEXT: retl
|
|
;
|
|
; WIN64-LABEL: test_argRet128Vector:
|
|
; WIN64: # %bb.0:
|
|
; WIN64-NEXT: vpslld $31, %xmm0, %xmm0
|
|
; WIN64-NEXT: vpmovd2m %xmm0, %k1
|
|
; WIN64-NEXT: vpblendmd %xmm1, %xmm2, %xmm0 {%k1}
|
|
; WIN64-NEXT: retq
|
|
;
|
|
; LINUXOSX64-LABEL: test_argRet128Vector:
|
|
; LINUXOSX64: # %bb.0:
|
|
; LINUXOSX64-NEXT: vpslld $31, %xmm0, %xmm0
|
|
; LINUXOSX64-NEXT: vpmovd2m %xmm0, %k1
|
|
; LINUXOSX64-NEXT: vpblendmd %xmm1, %xmm2, %xmm0 {%k1}
|
|
; LINUXOSX64-NEXT: retq
|
|
%d = select <4 x i1> %x, <4 x i32> %a, <4 x i32> %b
|
|
ret <4 x i32> %d
|
|
}
|
|
|
|
; Test regcall when passing/retrieving 128 bit vector
|
|
define x86_regcallcc <4 x i32> @test_CallargRet128Vector(<4 x i1> %x, <4 x i32> %a) {
|
|
; X32-LABEL: test_CallargRet128Vector:
|
|
; X32: # %bb.0:
|
|
; X32-NEXT: pushl %esp
|
|
; X32-NEXT: subl $40, %esp
|
|
; X32-NEXT: vmovups %xmm4, {{[-0-9]+}}(%e{{[sb]}}p) # 16-byte Spill
|
|
; X32-NEXT: vmovdqa %xmm1, %xmm4
|
|
; X32-NEXT: vpslld $31, %xmm0, %xmm1
|
|
; X32-NEXT: vpmovd2m %xmm1, %k1
|
|
; X32-NEXT: kmovw %k1, {{[-0-9]+}}(%e{{[sb]}}p) # 2-byte Spill
|
|
; X32-NEXT: vmovdqa %xmm4, %xmm1
|
|
; X32-NEXT: vmovdqa %xmm4, %xmm2
|
|
; X32-NEXT: calll _test_argRet128Vector
|
|
; X32-NEXT: kmovw {{[-0-9]+}}(%e{{[sb]}}p), %k1 # 2-byte Reload
|
|
; X32-NEXT: vmovdqa32 %xmm4, %xmm0 {%k1}
|
|
; X32-NEXT: vmovups {{[-0-9]+}}(%e{{[sb]}}p), %xmm4 # 16-byte Reload
|
|
; X32-NEXT: addl $40, %esp
|
|
; X32-NEXT: popl %esp
|
|
; X32-NEXT: retl
|
|
;
|
|
; WIN64-LABEL: test_CallargRet128Vector:
|
|
; WIN64: # %bb.0:
|
|
; WIN64-NEXT: pushq %rsp
|
|
; WIN64-NEXT: .seh_pushreg %rsp
|
|
; WIN64-NEXT: subq $32, %rsp
|
|
; WIN64-NEXT: .seh_stackalloc 32
|
|
; WIN64-NEXT: vmovaps %xmm8, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
|
|
; WIN64-NEXT: .seh_savexmm %xmm8, 16
|
|
; WIN64-NEXT: .seh_endprologue
|
|
; WIN64-NEXT: vmovdqa %xmm1, %xmm8
|
|
; WIN64-NEXT: vpslld $31, %xmm0, %xmm1
|
|
; WIN64-NEXT: vpmovd2m %xmm1, %k1
|
|
; WIN64-NEXT: kmovw %k1, {{[-0-9]+}}(%r{{[sb]}}p) # 2-byte Spill
|
|
; WIN64-NEXT: vmovdqa %xmm8, %xmm1
|
|
; WIN64-NEXT: vmovdqa %xmm8, %xmm2
|
|
; WIN64-NEXT: callq test_argRet128Vector
|
|
; WIN64-NEXT: kmovw {{[-0-9]+}}(%r{{[sb]}}p), %k1 # 2-byte Reload
|
|
; WIN64-NEXT: vmovdqa32 %xmm8, %xmm0 {%k1}
|
|
; WIN64-NEXT: vmovaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm8 # 16-byte Reload
|
|
; WIN64-NEXT: addq $32, %rsp
|
|
; WIN64-NEXT: popq %rsp
|
|
; WIN64-NEXT: retq
|
|
; WIN64-NEXT: .seh_handlerdata
|
|
; WIN64-NEXT: .text
|
|
; WIN64-NEXT: .seh_endproc
|
|
;
|
|
; LINUXOSX64-LABEL: test_CallargRet128Vector:
|
|
; LINUXOSX64: # %bb.0:
|
|
; LINUXOSX64-NEXT: pushq %rsp
|
|
; LINUXOSX64-NEXT: .cfi_def_cfa_offset 16
|
|
; LINUXOSX64-NEXT: subq $32, %rsp
|
|
; LINUXOSX64-NEXT: vmovaps %xmm8, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
|
|
; LINUXOSX64-NEXT: .cfi_def_cfa_offset 48
|
|
; LINUXOSX64-NEXT: .cfi_offset %rsp, -16
|
|
; LINUXOSX64-NEXT: .cfi_offset %xmm8, -32
|
|
; LINUXOSX64-NEXT: vmovdqa %xmm1, %xmm8
|
|
; LINUXOSX64-NEXT: vpslld $31, %xmm0, %xmm1
|
|
; LINUXOSX64-NEXT: vpmovd2m %xmm1, %k1
|
|
; LINUXOSX64-NEXT: kmovw %k1, {{[-0-9]+}}(%r{{[sb]}}p) # 2-byte Spill
|
|
; LINUXOSX64-NEXT: vmovdqa %xmm8, %xmm1
|
|
; LINUXOSX64-NEXT: vmovdqa %xmm8, %xmm2
|
|
; LINUXOSX64-NEXT: callq test_argRet128Vector
|
|
; LINUXOSX64-NEXT: kmovw {{[-0-9]+}}(%r{{[sb]}}p), %k1 # 2-byte Reload
|
|
; LINUXOSX64-NEXT: vmovdqa32 %xmm8, %xmm0 {%k1}
|
|
; LINUXOSX64-NEXT: vmovaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm8 # 16-byte Reload
|
|
; LINUXOSX64-NEXT: addq $32, %rsp
|
|
; LINUXOSX64-NEXT: .cfi_def_cfa_offset 16
|
|
; LINUXOSX64-NEXT: popq %rsp
|
|
; LINUXOSX64-NEXT: .cfi_def_cfa_offset 8
|
|
; LINUXOSX64-NEXT: retq
|
|
%b = call x86_regcallcc <4 x i32> @test_argRet128Vector(<4 x i1> %x, <4 x i32> %a, <4 x i32> %a)
|
|
%c = select <4 x i1> %x, <4 x i32> %a, <4 x i32> %b
|
|
ret <4 x i32> %c
|
|
}
|
|
|
|
; Test regcall when receiving/returning 256 bit vector
|
|
define x86_regcallcc <8 x i32> @test_argRet256Vector(<8 x i1> %x, <8 x i32> %a, <8 x i32> %b) {
|
|
; X32-LABEL: test_argRet256Vector:
|
|
; X32: # %bb.0:
|
|
; X32-NEXT: kmovd %eax, %k1
|
|
; X32-NEXT: vpblendmd %ymm0, %ymm1, %ymm0 {%k1}
|
|
; X32-NEXT: retl
|
|
;
|
|
; WIN64-LABEL: test_argRet256Vector:
|
|
; WIN64: # %bb.0:
|
|
; WIN64-NEXT: kmovd %eax, %k1
|
|
; WIN64-NEXT: vpblendmd %ymm0, %ymm1, %ymm0 {%k1}
|
|
; WIN64-NEXT: retq
|
|
;
|
|
; LINUXOSX64-LABEL: test_argRet256Vector:
|
|
; LINUXOSX64: # %bb.0:
|
|
; LINUXOSX64-NEXT: kmovd %eax, %k1
|
|
; LINUXOSX64-NEXT: vpblendmd %ymm0, %ymm1, %ymm0 {%k1}
|
|
; LINUXOSX64-NEXT: retq
|
|
%d = select <8 x i1> %x, <8 x i32> %a, <8 x i32> %b
|
|
ret <8 x i32> %d
|
|
}
|
|
|
|
; Test regcall when passing/retrieving 256 bit vector
|
|
define x86_regcallcc <8 x i32> @test_CallargRet256Vector(<8 x i1> %x, <8 x i32> %a) {
|
|
; X32-LABEL: test_CallargRet256Vector:
|
|
; X32: # %bb.0:
|
|
; X32-NEXT: pushl %esp
|
|
; X32-NEXT: subl $88, %esp
|
|
; X32-NEXT: vmovdqu %ymm0, {{[-0-9]+}}(%e{{[sb]}}p) # 32-byte Spill
|
|
; X32-NEXT: kmovd %eax, %k1
|
|
; X32-NEXT: kmovw %k1, {{[-0-9]+}}(%e{{[sb]}}p) # 2-byte Spill
|
|
; X32-NEXT: vmovdqa %ymm0, %ymm1
|
|
; X32-NEXT: calll _test_argRet256Vector
|
|
; X32-NEXT: kmovw {{[-0-9]+}}(%e{{[sb]}}p), %k1 # 2-byte Reload
|
|
; X32-NEXT: vmovdqu {{[-0-9]+}}(%e{{[sb]}}p), %ymm1 # 32-byte Reload
|
|
; X32-NEXT: vmovdqa32 %ymm1, %ymm0 {%k1}
|
|
; X32-NEXT: addl $88, %esp
|
|
; X32-NEXT: popl %esp
|
|
; X32-NEXT: retl
|
|
;
|
|
; WIN64-LABEL: test_CallargRet256Vector:
|
|
; WIN64: # %bb.0:
|
|
; WIN64-NEXT: pushq %rsp
|
|
; WIN64-NEXT: .seh_pushreg %rsp
|
|
; WIN64-NEXT: subq $80, %rsp
|
|
; WIN64-NEXT: .seh_stackalloc 80
|
|
; WIN64-NEXT: .seh_endprologue
|
|
; WIN64-NEXT: vmovdqu %ymm0, {{[-0-9]+}}(%r{{[sb]}}p) # 32-byte Spill
|
|
; WIN64-NEXT: kmovd %eax, %k1
|
|
; WIN64-NEXT: kmovw %k1, {{[-0-9]+}}(%r{{[sb]}}p) # 2-byte Spill
|
|
; WIN64-NEXT: vmovdqa %ymm0, %ymm1
|
|
; WIN64-NEXT: callq test_argRet256Vector
|
|
; WIN64-NEXT: kmovw {{[-0-9]+}}(%r{{[sb]}}p), %k1 # 2-byte Reload
|
|
; WIN64-NEXT: vmovdqu {{[-0-9]+}}(%r{{[sb]}}p), %ymm1 # 32-byte Reload
|
|
; WIN64-NEXT: vmovdqa32 %ymm1, %ymm0 {%k1}
|
|
; WIN64-NEXT: addq $80, %rsp
|
|
; WIN64-NEXT: popq %rsp
|
|
; WIN64-NEXT: retq
|
|
; WIN64-NEXT: .seh_handlerdata
|
|
; WIN64-NEXT: .text
|
|
; WIN64-NEXT: .seh_endproc
|
|
;
|
|
; LINUXOSX64-LABEL: test_CallargRet256Vector:
|
|
; LINUXOSX64: # %bb.0:
|
|
; LINUXOSX64-NEXT: pushq %rsp
|
|
; LINUXOSX64-NEXT: .cfi_def_cfa_offset 16
|
|
; LINUXOSX64-NEXT: subq $80, %rsp
|
|
; LINUXOSX64-NEXT: .cfi_def_cfa_offset 96
|
|
; LINUXOSX64-NEXT: .cfi_offset %rsp, -16
|
|
; LINUXOSX64-NEXT: vmovdqu %ymm0, {{[-0-9]+}}(%r{{[sb]}}p) # 32-byte Spill
|
|
; LINUXOSX64-NEXT: kmovd %eax, %k1
|
|
; LINUXOSX64-NEXT: kmovw %k1, {{[-0-9]+}}(%r{{[sb]}}p) # 2-byte Spill
|
|
; LINUXOSX64-NEXT: vmovdqa %ymm0, %ymm1
|
|
; LINUXOSX64-NEXT: callq test_argRet256Vector
|
|
; LINUXOSX64-NEXT: kmovw {{[-0-9]+}}(%r{{[sb]}}p), %k1 # 2-byte Reload
|
|
; LINUXOSX64-NEXT: vmovdqu {{[-0-9]+}}(%r{{[sb]}}p), %ymm1 # 32-byte Reload
|
|
; LINUXOSX64-NEXT: vmovdqa32 %ymm1, %ymm0 {%k1}
|
|
; LINUXOSX64-NEXT: addq $80, %rsp
|
|
; LINUXOSX64-NEXT: .cfi_def_cfa_offset 16
|
|
; LINUXOSX64-NEXT: popq %rsp
|
|
; LINUXOSX64-NEXT: .cfi_def_cfa_offset 8
|
|
; LINUXOSX64-NEXT: retq
|
|
%b = call x86_regcallcc <8 x i32> @test_argRet256Vector(<8 x i1> %x, <8 x i32> %a, <8 x i32> %a)
|
|
%c = select <8 x i1> %x, <8 x i32> %a, <8 x i32> %b
|
|
ret <8 x i32> %c
|
|
}
|
|
|
|
; Test regcall when receiving/returning 512 bit vector
|
|
define x86_regcallcc <16 x i32> @test_argRet512Vector(<16 x i1> %x, <16 x i32> %a, <16 x i32> %b) {
|
|
; X32-LABEL: test_argRet512Vector:
|
|
; X32: # %bb.0:
|
|
; X32-NEXT: kmovd %eax, %k1
|
|
; X32-NEXT: vpblendmd %zmm0, %zmm1, %zmm0 {%k1}
|
|
; X32-NEXT: retl
|
|
;
|
|
; WIN64-LABEL: test_argRet512Vector:
|
|
; WIN64: # %bb.0:
|
|
; WIN64-NEXT: kmovd %eax, %k1
|
|
; WIN64-NEXT: vpblendmd %zmm0, %zmm1, %zmm0 {%k1}
|
|
; WIN64-NEXT: retq
|
|
;
|
|
; LINUXOSX64-LABEL: test_argRet512Vector:
|
|
; LINUXOSX64: # %bb.0:
|
|
; LINUXOSX64-NEXT: kmovd %eax, %k1
|
|
; LINUXOSX64-NEXT: vpblendmd %zmm0, %zmm1, %zmm0 {%k1}
|
|
; LINUXOSX64-NEXT: retq
|
|
%d = select <16 x i1> %x, <16 x i32> %a, <16 x i32> %b
|
|
ret <16 x i32> %d
|
|
}
|
|
|
|
; Test regcall when passing/retrieving 512 bit vector
|
|
define x86_regcallcc <16 x i32> @test_CallargRet512Vector(<16 x i1> %x, <16 x i32> %a) {
|
|
; X32-LABEL: test_CallargRet512Vector:
|
|
; X32: # %bb.0:
|
|
; X32-NEXT: pushl %esp
|
|
; X32-NEXT: subl $184, %esp
|
|
; X32-NEXT: vmovdqu64 %zmm0, {{[-0-9]+}}(%e{{[sb]}}p) # 64-byte Spill
|
|
; X32-NEXT: kmovd %eax, %k1
|
|
; X32-NEXT: kmovw %k1, {{[-0-9]+}}(%e{{[sb]}}p) # 2-byte Spill
|
|
; X32-NEXT: vmovdqa64 %zmm0, %zmm1
|
|
; X32-NEXT: calll _test_argRet512Vector
|
|
; X32-NEXT: kmovw {{[-0-9]+}}(%e{{[sb]}}p), %k1 # 2-byte Reload
|
|
; X32-NEXT: vmovdqu64 {{[-0-9]+}}(%e{{[sb]}}p), %zmm1 # 64-byte Reload
|
|
; X32-NEXT: vmovdqa32 %zmm1, %zmm0 {%k1}
|
|
; X32-NEXT: addl $184, %esp
|
|
; X32-NEXT: popl %esp
|
|
; X32-NEXT: retl
|
|
;
|
|
; WIN64-LABEL: test_CallargRet512Vector:
|
|
; WIN64: # %bb.0:
|
|
; WIN64-NEXT: pushq %rsp
|
|
; WIN64-NEXT: .seh_pushreg %rsp
|
|
; WIN64-NEXT: subq $176, %rsp
|
|
; WIN64-NEXT: .seh_stackalloc 176
|
|
; WIN64-NEXT: .seh_endprologue
|
|
; WIN64-NEXT: vmovdqu64 %zmm0, {{[-0-9]+}}(%r{{[sb]}}p) # 64-byte Spill
|
|
; WIN64-NEXT: kmovd %eax, %k1
|
|
; WIN64-NEXT: kmovw %k1, {{[-0-9]+}}(%r{{[sb]}}p) # 2-byte Spill
|
|
; WIN64-NEXT: vmovdqa64 %zmm0, %zmm1
|
|
; WIN64-NEXT: callq test_argRet512Vector
|
|
; WIN64-NEXT: kmovw {{[-0-9]+}}(%r{{[sb]}}p), %k1 # 2-byte Reload
|
|
; WIN64-NEXT: vmovdqu64 {{[-0-9]+}}(%r{{[sb]}}p), %zmm1 # 64-byte Reload
|
|
; WIN64-NEXT: vmovdqa32 %zmm1, %zmm0 {%k1}
|
|
; WIN64-NEXT: addq $176, %rsp
|
|
; WIN64-NEXT: popq %rsp
|
|
; WIN64-NEXT: retq
|
|
; WIN64-NEXT: .seh_handlerdata
|
|
; WIN64-NEXT: .text
|
|
; WIN64-NEXT: .seh_endproc
|
|
;
|
|
; LINUXOSX64-LABEL: test_CallargRet512Vector:
|
|
; LINUXOSX64: # %bb.0:
|
|
; LINUXOSX64-NEXT: pushq %rsp
|
|
; LINUXOSX64-NEXT: .cfi_def_cfa_offset 16
|
|
; LINUXOSX64-NEXT: subq $176, %rsp
|
|
; LINUXOSX64-NEXT: .cfi_def_cfa_offset 192
|
|
; LINUXOSX64-NEXT: .cfi_offset %rsp, -16
|
|
; LINUXOSX64-NEXT: vmovdqu64 %zmm0, {{[-0-9]+}}(%r{{[sb]}}p) # 64-byte Spill
|
|
; LINUXOSX64-NEXT: kmovd %eax, %k1
|
|
; LINUXOSX64-NEXT: kmovw %k1, {{[-0-9]+}}(%r{{[sb]}}p) # 2-byte Spill
|
|
; LINUXOSX64-NEXT: vmovdqa64 %zmm0, %zmm1
|
|
; LINUXOSX64-NEXT: callq test_argRet512Vector
|
|
; LINUXOSX64-NEXT: kmovw {{[-0-9]+}}(%r{{[sb]}}p), %k1 # 2-byte Reload
|
|
; LINUXOSX64-NEXT: vmovdqu64 {{[-0-9]+}}(%r{{[sb]}}p), %zmm1 # 64-byte Reload
|
|
; LINUXOSX64-NEXT: vmovdqa32 %zmm1, %zmm0 {%k1}
|
|
; LINUXOSX64-NEXT: addq $176, %rsp
|
|
; LINUXOSX64-NEXT: .cfi_def_cfa_offset 16
|
|
; LINUXOSX64-NEXT: popq %rsp
|
|
; LINUXOSX64-NEXT: .cfi_def_cfa_offset 8
|
|
; LINUXOSX64-NEXT: retq
|
|
%b = call x86_regcallcc <16 x i32> @test_argRet512Vector(<16 x i1> %x, <16 x i32> %a, <16 x i32> %a)
|
|
%c = select <16 x i1> %x, <16 x i32> %a, <16 x i32> %b
|
|
ret <16 x i32> %c
|
|
}
|
|
|
|
; Test regcall when running multiple input parameters - callee saved xmms
|
|
define x86_regcallcc <32 x float> @testf32_inp(<32 x float> %a, <32 x float> %b, <32 x float> %c) nounwind {
|
|
; X32-LABEL: testf32_inp:
|
|
; X32: # %bb.0:
|
|
; X32-NEXT: subl $44, %esp
|
|
; X32-NEXT: vmovups %xmm7, {{[-0-9]+}}(%e{{[sb]}}p) # 16-byte Spill
|
|
; X32-NEXT: vmovups %xmm6, (%esp) # 16-byte Spill
|
|
; X32-NEXT: vaddps %zmm2, %zmm0, %zmm6
|
|
; X32-NEXT: vaddps %zmm3, %zmm1, %zmm7
|
|
; X32-NEXT: vmulps %zmm2, %zmm0, %zmm0
|
|
; X32-NEXT: vsubps %zmm0, %zmm6, %zmm0
|
|
; X32-NEXT: vmulps %zmm3, %zmm1, %zmm1
|
|
; X32-NEXT: vsubps %zmm1, %zmm7, %zmm1
|
|
; X32-NEXT: vaddps %zmm4, %zmm0, %zmm0
|
|
; X32-NEXT: vaddps %zmm5, %zmm1, %zmm1
|
|
; X32-NEXT: vmovups (%esp), %xmm6 # 16-byte Reload
|
|
; X32-NEXT: vmovups {{[-0-9]+}}(%e{{[sb]}}p), %xmm7 # 16-byte Reload
|
|
; X32-NEXT: addl $44, %esp
|
|
; X32-NEXT: retl
|
|
;
|
|
; WIN64-LABEL: testf32_inp:
|
|
; WIN64: # %bb.0:
|
|
; WIN64-NEXT: vaddps %zmm2, %zmm0, %zmm6
|
|
; WIN64-NEXT: vaddps %zmm3, %zmm1, %zmm7
|
|
; WIN64-NEXT: vmulps %zmm2, %zmm0, %zmm0
|
|
; WIN64-NEXT: vsubps %zmm0, %zmm6, %zmm0
|
|
; WIN64-NEXT: vmulps %zmm3, %zmm1, %zmm1
|
|
; WIN64-NEXT: vsubps %zmm1, %zmm7, %zmm1
|
|
; WIN64-NEXT: vaddps %zmm4, %zmm0, %zmm0
|
|
; WIN64-NEXT: vaddps %zmm5, %zmm1, %zmm1
|
|
; WIN64-NEXT: retq
|
|
;
|
|
; LINUXOSX64-LABEL: testf32_inp:
|
|
; LINUXOSX64: # %bb.0:
|
|
; LINUXOSX64-NEXT: vaddps %zmm2, %zmm0, %zmm6
|
|
; LINUXOSX64-NEXT: vaddps %zmm3, %zmm1, %zmm7
|
|
; LINUXOSX64-NEXT: vmulps %zmm2, %zmm0, %zmm0
|
|
; LINUXOSX64-NEXT: vsubps %zmm0, %zmm6, %zmm0
|
|
; LINUXOSX64-NEXT: vmulps %zmm3, %zmm1, %zmm1
|
|
; LINUXOSX64-NEXT: vsubps %zmm1, %zmm7, %zmm1
|
|
; LINUXOSX64-NEXT: vaddps %zmm4, %zmm0, %zmm0
|
|
; LINUXOSX64-NEXT: vaddps %zmm5, %zmm1, %zmm1
|
|
; LINUXOSX64-NEXT: retq
|
|
%x1 = fadd <32 x float> %a, %b
|
|
%x2 = fmul <32 x float> %a, %b
|
|
%x3 = fsub <32 x float> %x1, %x2
|
|
%x4 = fadd <32 x float> %x3, %c
|
|
ret <32 x float> %x4
|
|
}
|
|
|
|
; Test regcall when running multiple input parameters - callee saved GPRs
|
|
define x86_regcallcc i32 @testi32_inp(i32 %a1, i32 %a2, i32 %a3, i32 %a4, i32 %a5, i32 %a6, i32 %b1, i32 %b2, i32 %b3, i32 %b4, i32 %b5, i32 %b6) nounwind {
|
|
; X32-LABEL: testi32_inp:
|
|
; X32: # %bb.0:
|
|
; X32-NEXT: pushl %ebp
|
|
; X32-NEXT: pushl %ebx
|
|
; X32-NEXT: subl $20, %esp
|
|
; X32-NEXT: movl %esi, {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Spill
|
|
; X32-NEXT: movl %edi, {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Spill
|
|
; X32-NEXT: movl %edx, (%esp) # 4-byte Spill
|
|
; X32-NEXT: movl %ecx, {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Spill
|
|
; X32-NEXT: movl %eax, %ebx
|
|
; X32-NEXT: movl %eax, {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Spill
|
|
; X32-NEXT: subl %ecx, %ebx
|
|
; X32-NEXT: movl {{[0-9]+}}(%esp), %esi
|
|
; X32-NEXT: movl %esi, %ebp
|
|
; X32-NEXT: subl {{[0-9]+}}(%esp), %ebp
|
|
; X32-NEXT: imull %ebp, %ebx
|
|
; X32-NEXT: movl %edx, %ebp
|
|
; X32-NEXT: subl %edi, %ebp
|
|
; X32-NEXT: movl {{[0-9]+}}(%esp), %edx
|
|
; X32-NEXT: movl %edx, %ecx
|
|
; X32-NEXT: subl {{[0-9]+}}(%esp), %ecx
|
|
; X32-NEXT: imull %ebp, %ecx
|
|
; X32-NEXT: addl %ecx, %ebx
|
|
; X32-NEXT: movl {{[-0-9]+}}(%e{{[sb]}}p), %edi # 4-byte Reload
|
|
; X32-NEXT: movl %edi, %ebp
|
|
; X32-NEXT: subl {{[0-9]+}}(%esp), %ebp
|
|
; X32-NEXT: movl {{[0-9]+}}(%esp), %ecx
|
|
; X32-NEXT: movl %ecx, %eax
|
|
; X32-NEXT: subl {{[0-9]+}}(%esp), %eax
|
|
; X32-NEXT: imull %ebp, %eax
|
|
; X32-NEXT: addl %eax, %ebx
|
|
; X32-NEXT: movl {{[-0-9]+}}(%e{{[sb]}}p), %eax # 4-byte Reload
|
|
; X32-NEXT: addl {{[-0-9]+}}(%e{{[sb]}}p), %eax # 4-byte Folded Reload
|
|
; X32-NEXT: movl (%esp), %ebp # 4-byte Reload
|
|
; X32-NEXT: addl {{[-0-9]+}}(%e{{[sb]}}p), %ebp # 4-byte Folded Reload
|
|
; X32-NEXT: addl {{[0-9]+}}(%esp), %edi
|
|
; X32-NEXT: addl {{[0-9]+}}(%esp), %esi
|
|
; X32-NEXT: imull %eax, %esi
|
|
; X32-NEXT: addl {{[0-9]+}}(%esp), %edx
|
|
; X32-NEXT: imull %ebp, %edx
|
|
; X32-NEXT: addl %esi, %edx
|
|
; X32-NEXT: addl {{[0-9]+}}(%esp), %ecx
|
|
; X32-NEXT: imull %edi, %ecx
|
|
; X32-NEXT: addl %edx, %ecx
|
|
; X32-NEXT: addl %ecx, %ebx
|
|
; X32-NEXT: movl %ebx, %eax
|
|
; X32-NEXT: addl $20, %esp
|
|
; X32-NEXT: popl %ebx
|
|
; X32-NEXT: popl %ebp
|
|
; X32-NEXT: retl
|
|
;
|
|
; WIN64-LABEL: testi32_inp:
|
|
; WIN64: # %bb.0:
|
|
; WIN64-NEXT: pushq %r13
|
|
; WIN64-NEXT: pushq %rbp
|
|
; WIN64-NEXT: pushq %rbx
|
|
; WIN64-NEXT: movl %eax, %r13d
|
|
; WIN64-NEXT: subl %ecx, %eax
|
|
; WIN64-NEXT: movl %edx, %ebp
|
|
; WIN64-NEXT: subl %edi, %ebp
|
|
; WIN64-NEXT: movl %r9d, %ebx
|
|
; WIN64-NEXT: subl %r10d, %ebx
|
|
; WIN64-NEXT: imull %ebx, %eax
|
|
; WIN64-NEXT: movl %r11d, %ebx
|
|
; WIN64-NEXT: subl %r12d, %ebx
|
|
; WIN64-NEXT: imull %ebp, %ebx
|
|
; WIN64-NEXT: movl %esi, %ebp
|
|
; WIN64-NEXT: subl %r8d, %ebp
|
|
; WIN64-NEXT: addl %ebx, %eax
|
|
; WIN64-NEXT: movl %r14d, %ebx
|
|
; WIN64-NEXT: subl %r15d, %ebx
|
|
; WIN64-NEXT: imull %ebp, %ebx
|
|
; WIN64-NEXT: addl %ebx, %eax
|
|
; WIN64-NEXT: addl %ecx, %r13d
|
|
; WIN64-NEXT: addl %edi, %edx
|
|
; WIN64-NEXT: addl %r8d, %esi
|
|
; WIN64-NEXT: addl %r10d, %r9d
|
|
; WIN64-NEXT: imull %r13d, %r9d
|
|
; WIN64-NEXT: addl %r12d, %r11d
|
|
; WIN64-NEXT: imull %edx, %r11d
|
|
; WIN64-NEXT: addl %r9d, %r11d
|
|
; WIN64-NEXT: addl %r15d, %r14d
|
|
; WIN64-NEXT: imull %esi, %r14d
|
|
; WIN64-NEXT: addl %r11d, %r14d
|
|
; WIN64-NEXT: addl %r14d, %eax
|
|
; WIN64-NEXT: popq %rbx
|
|
; WIN64-NEXT: popq %rbp
|
|
; WIN64-NEXT: popq %r13
|
|
; WIN64-NEXT: retq
|
|
;
|
|
; LINUXOSX64-LABEL: testi32_inp:
|
|
; LINUXOSX64: # %bb.0:
|
|
; LINUXOSX64-NEXT: pushq %rbp
|
|
; LINUXOSX64-NEXT: pushq %rbx
|
|
; LINUXOSX64-NEXT: movl %eax, %r10d
|
|
; LINUXOSX64-NEXT: movl {{[0-9]+}}(%rsp), %r11d
|
|
; LINUXOSX64-NEXT: subl %ecx, %eax
|
|
; LINUXOSX64-NEXT: movl %edx, %ebx
|
|
; LINUXOSX64-NEXT: subl %edi, %ebx
|
|
; LINUXOSX64-NEXT: movl %r9d, %ebp
|
|
; LINUXOSX64-NEXT: subl %r12d, %ebp
|
|
; LINUXOSX64-NEXT: imull %ebp, %eax
|
|
; LINUXOSX64-NEXT: movl %r13d, %ebp
|
|
; LINUXOSX64-NEXT: subl %r14d, %ebp
|
|
; LINUXOSX64-NEXT: imull %ebx, %ebp
|
|
; LINUXOSX64-NEXT: movl %esi, %ebx
|
|
; LINUXOSX64-NEXT: subl %r8d, %ebx
|
|
; LINUXOSX64-NEXT: addl %ebp, %eax
|
|
; LINUXOSX64-NEXT: movl %r15d, %ebp
|
|
; LINUXOSX64-NEXT: subl %r11d, %ebp
|
|
; LINUXOSX64-NEXT: imull %ebx, %ebp
|
|
; LINUXOSX64-NEXT: addl %ebp, %eax
|
|
; LINUXOSX64-NEXT: addl %ecx, %r10d
|
|
; LINUXOSX64-NEXT: addl %edi, %edx
|
|
; LINUXOSX64-NEXT: addl %r8d, %esi
|
|
; LINUXOSX64-NEXT: addl %r12d, %r9d
|
|
; LINUXOSX64-NEXT: imull %r10d, %r9d
|
|
; LINUXOSX64-NEXT: addl %r14d, %r13d
|
|
; LINUXOSX64-NEXT: imull %edx, %r13d
|
|
; LINUXOSX64-NEXT: addl %r9d, %r13d
|
|
; LINUXOSX64-NEXT: addl %r11d, %r15d
|
|
; LINUXOSX64-NEXT: imull %esi, %r15d
|
|
; LINUXOSX64-NEXT: addl %r13d, %r15d
|
|
; LINUXOSX64-NEXT: addl %r15d, %eax
|
|
; LINUXOSX64-NEXT: popq %rbx
|
|
; LINUXOSX64-NEXT: popq %rbp
|
|
; LINUXOSX64-NEXT: retq
|
|
%x1 = sub i32 %a1, %a2
|
|
%x2 = sub i32 %a3, %a4
|
|
%x3 = sub i32 %a5, %a6
|
|
%y1 = sub i32 %b1, %b2
|
|
%y2 = sub i32 %b3, %b4
|
|
%y3 = sub i32 %b5, %b6
|
|
%v1 = add i32 %a1, %a2
|
|
%v2 = add i32 %a3, %a4
|
|
%v3 = add i32 %a5, %a6
|
|
%w1 = add i32 %b1, %b2
|
|
%w2 = add i32 %b3, %b4
|
|
%w3 = add i32 %b5, %b6
|
|
%s1 = mul i32 %x1, %y1
|
|
%s2 = mul i32 %x2, %y2
|
|
%s3 = mul i32 %x3, %y3
|
|
%t1 = mul i32 %v1, %w1
|
|
%t2 = mul i32 %v2, %w2
|
|
%t3 = mul i32 %v3, %w3
|
|
%m1 = add i32 %s1, %s2
|
|
%m2 = add i32 %m1, %s3
|
|
%n1 = add i32 %t1, %t2
|
|
%n2 = add i32 %n1, %t3
|
|
%r1 = add i32 %m2, %n2
|
|
ret i32 %r1
|
|
}
|
|
|
|
; Test that parameters, overflowing register capacity, are passed through the stack
|
|
define x86_regcallcc <32 x float> @testf32_stack(<32 x float> %a0, <32 x float> %b0, <32 x float> %c0, <32 x float> %a1, <32 x float> %b1, <32 x float> %c1, <32 x float> %a2, <32 x float> %b2, <32 x float> %c2) nounwind {
|
|
; X32-LABEL: testf32_stack:
|
|
; X32: # %bb.0:
|
|
; X32-NEXT: pushl %ebp
|
|
; X32-NEXT: movl %esp, %ebp
|
|
; X32-NEXT: andl $-64, %esp
|
|
; X32-NEXT: subl $64, %esp
|
|
; X32-NEXT: vaddps %zmm3, %zmm1, %zmm1
|
|
; X32-NEXT: vaddps %zmm2, %zmm0, %zmm0
|
|
; X32-NEXT: vaddps %zmm0, %zmm4, %zmm0
|
|
; X32-NEXT: vaddps %zmm1, %zmm5, %zmm1
|
|
; X32-NEXT: vaddps %zmm1, %zmm7, %zmm1
|
|
; X32-NEXT: vaddps %zmm0, %zmm6, %zmm0
|
|
; X32-NEXT: vaddps 8(%ebp), %zmm0, %zmm0
|
|
; X32-NEXT: vaddps 72(%ebp), %zmm1, %zmm1
|
|
; X32-NEXT: vaddps 200(%ebp), %zmm1, %zmm1
|
|
; X32-NEXT: vaddps 136(%ebp), %zmm0, %zmm0
|
|
; X32-NEXT: vaddps 264(%ebp), %zmm0, %zmm0
|
|
; X32-NEXT: vaddps 328(%ebp), %zmm1, %zmm1
|
|
; X32-NEXT: vaddps 456(%ebp), %zmm1, %zmm1
|
|
; X32-NEXT: vaddps 392(%ebp), %zmm0, %zmm0
|
|
; X32-NEXT: vaddps 520(%ebp), %zmm0, %zmm0
|
|
; X32-NEXT: vaddps 584(%ebp), %zmm1, %zmm1
|
|
; X32-NEXT: movl %ebp, %esp
|
|
; X32-NEXT: popl %ebp
|
|
; X32-NEXT: retl
|
|
;
|
|
; WIN64-LABEL: testf32_stack:
|
|
; WIN64: # %bb.0:
|
|
; WIN64-NEXT: pushq %rbp
|
|
; WIN64-NEXT: subq $48, %rsp
|
|
; WIN64-NEXT: leaq {{[0-9]+}}(%rsp), %rbp
|
|
; WIN64-NEXT: andq $-64, %rsp
|
|
; WIN64-NEXT: vaddps %zmm3, %zmm1, %zmm1
|
|
; WIN64-NEXT: vaddps %zmm2, %zmm0, %zmm0
|
|
; WIN64-NEXT: vaddps %zmm0, %zmm4, %zmm0
|
|
; WIN64-NEXT: vaddps %zmm1, %zmm5, %zmm1
|
|
; WIN64-NEXT: vaddps %zmm1, %zmm7, %zmm1
|
|
; WIN64-NEXT: vaddps %zmm0, %zmm6, %zmm0
|
|
; WIN64-NEXT: vaddps %zmm0, %zmm8, %zmm0
|
|
; WIN64-NEXT: vaddps %zmm1, %zmm9, %zmm1
|
|
; WIN64-NEXT: vaddps %zmm1, %zmm11, %zmm1
|
|
; WIN64-NEXT: vaddps %zmm0, %zmm10, %zmm0
|
|
; WIN64-NEXT: vaddps %zmm0, %zmm12, %zmm0
|
|
; WIN64-NEXT: vaddps %zmm1, %zmm13, %zmm1
|
|
; WIN64-NEXT: vaddps %zmm1, %zmm15, %zmm1
|
|
; WIN64-NEXT: vaddps %zmm0, %zmm14, %zmm0
|
|
; WIN64-NEXT: vaddps 16(%rbp), %zmm0, %zmm0
|
|
; WIN64-NEXT: vaddps 80(%rbp), %zmm1, %zmm1
|
|
; WIN64-NEXT: movq %rbp, %rsp
|
|
; WIN64-NEXT: popq %rbp
|
|
; WIN64-NEXT: retq
|
|
;
|
|
; LINUXOSX64-LABEL: testf32_stack:
|
|
; LINUXOSX64: # %bb.0:
|
|
; LINUXOSX64-NEXT: pushq %rbp
|
|
; LINUXOSX64-NEXT: movq %rsp, %rbp
|
|
; LINUXOSX64-NEXT: andq $-64, %rsp
|
|
; LINUXOSX64-NEXT: subq $64, %rsp
|
|
; LINUXOSX64-NEXT: vaddps %zmm3, %zmm1, %zmm1
|
|
; LINUXOSX64-NEXT: vaddps %zmm2, %zmm0, %zmm0
|
|
; LINUXOSX64-NEXT: vaddps %zmm0, %zmm4, %zmm0
|
|
; LINUXOSX64-NEXT: vaddps %zmm1, %zmm5, %zmm1
|
|
; LINUXOSX64-NEXT: vaddps %zmm1, %zmm7, %zmm1
|
|
; LINUXOSX64-NEXT: vaddps %zmm0, %zmm6, %zmm0
|
|
; LINUXOSX64-NEXT: vaddps %zmm0, %zmm8, %zmm0
|
|
; LINUXOSX64-NEXT: vaddps %zmm1, %zmm9, %zmm1
|
|
; LINUXOSX64-NEXT: vaddps %zmm1, %zmm11, %zmm1
|
|
; LINUXOSX64-NEXT: vaddps %zmm0, %zmm10, %zmm0
|
|
; LINUXOSX64-NEXT: vaddps %zmm0, %zmm12, %zmm0
|
|
; LINUXOSX64-NEXT: vaddps %zmm1, %zmm13, %zmm1
|
|
; LINUXOSX64-NEXT: vaddps %zmm1, %zmm15, %zmm1
|
|
; LINUXOSX64-NEXT: vaddps %zmm0, %zmm14, %zmm0
|
|
; LINUXOSX64-NEXT: vaddps 16(%rbp), %zmm0, %zmm0
|
|
; LINUXOSX64-NEXT: vaddps 80(%rbp), %zmm1, %zmm1
|
|
; LINUXOSX64-NEXT: movq %rbp, %rsp
|
|
; LINUXOSX64-NEXT: popq %rbp
|
|
; LINUXOSX64-NEXT: retq
|
|
%x1 = fadd <32 x float> %a0, %b0
|
|
%x2 = fadd <32 x float> %c0, %x1
|
|
%x3 = fadd <32 x float> %a1, %x2
|
|
%x4 = fadd <32 x float> %b1, %x3
|
|
%x5 = fadd <32 x float> %c1, %x4
|
|
%x6 = fadd <32 x float> %a2, %x5
|
|
%x7 = fadd <32 x float> %b2, %x6
|
|
%x8 = fadd <32 x float> %c2, %x7
|
|
ret <32 x float> %x8
|
|
}
|
|
|
|
; Test regcall when passing/retrieving mixed types
|
|
define x86_regcallcc i32 @test_argRetMixTypes(double, float, i8 signext, i32, i64, i16 signext, i32*) #0 {
|
|
; X32-LABEL: test_argRetMixTypes:
|
|
; X32: # %bb.0:
|
|
; X32-NEXT: pushl %ebx
|
|
; X32-NEXT: movl {{[0-9]+}}(%esp), %ebx
|
|
; X32-NEXT: vcvtss2sd %xmm1, %xmm1, %xmm1
|
|
; X32-NEXT: vaddsd %xmm0, %xmm1, %xmm0
|
|
; X32-NEXT: vcvtsi2sd %eax, %xmm2, %xmm1
|
|
; X32-NEXT: vaddsd %xmm1, %xmm0, %xmm0
|
|
; X32-NEXT: vcvtsi2sd %ecx, %xmm2, %xmm1
|
|
; X32-NEXT: vaddsd %xmm1, %xmm0, %xmm0
|
|
; X32-NEXT: vmovd %edx, %xmm1
|
|
; X32-NEXT: vpinsrd $1, %edi, %xmm1, %xmm1
|
|
; X32-NEXT: vcvtqq2pd %ymm1, %ymm1
|
|
; X32-NEXT: vaddsd %xmm1, %xmm0, %xmm0
|
|
; X32-NEXT: vcvtsi2sd %esi, %xmm2, %xmm1
|
|
; X32-NEXT: vaddsd %xmm1, %xmm0, %xmm0
|
|
; X32-NEXT: vcvtsi2sdl (%ebx), %xmm2, %xmm1
|
|
; X32-NEXT: vaddsd %xmm1, %xmm0, %xmm0
|
|
; X32-NEXT: vcvttsd2si %xmm0, %eax
|
|
; X32-NEXT: popl %ebx
|
|
; X32-NEXT: vzeroupper
|
|
; X32-NEXT: retl
|
|
;
|
|
; WIN64-LABEL: test_argRetMixTypes:
|
|
; WIN64: # %bb.0:
|
|
; WIN64-NEXT: vcvtss2sd %xmm1, %xmm1, %xmm1
|
|
; WIN64-NEXT: vaddsd %xmm0, %xmm1, %xmm0
|
|
; WIN64-NEXT: vcvtsi2sd %eax, %xmm2, %xmm1
|
|
; WIN64-NEXT: vaddsd %xmm1, %xmm0, %xmm0
|
|
; WIN64-NEXT: vcvtsi2sd %ecx, %xmm2, %xmm1
|
|
; WIN64-NEXT: vaddsd %xmm1, %xmm0, %xmm0
|
|
; WIN64-NEXT: vcvtsi2sd %rdx, %xmm2, %xmm1
|
|
; WIN64-NEXT: vaddsd %xmm1, %xmm0, %xmm0
|
|
; WIN64-NEXT: vcvtsi2sd %edi, %xmm2, %xmm1
|
|
; WIN64-NEXT: vaddsd %xmm1, %xmm0, %xmm0
|
|
; WIN64-NEXT: vcvtsi2sdl (%rsi), %xmm2, %xmm1
|
|
; WIN64-NEXT: vaddsd %xmm1, %xmm0, %xmm0
|
|
; WIN64-NEXT: vcvttsd2si %xmm0, %eax
|
|
; WIN64-NEXT: retq
|
|
;
|
|
; LINUXOSX64-LABEL: test_argRetMixTypes:
|
|
; LINUXOSX64: # %bb.0:
|
|
; LINUXOSX64-NEXT: vcvtss2sd %xmm1, %xmm1, %xmm1
|
|
; LINUXOSX64-NEXT: vaddsd %xmm0, %xmm1, %xmm0
|
|
; LINUXOSX64-NEXT: vcvtsi2sd %eax, %xmm2, %xmm1
|
|
; LINUXOSX64-NEXT: vaddsd %xmm1, %xmm0, %xmm0
|
|
; LINUXOSX64-NEXT: vcvtsi2sd %ecx, %xmm2, %xmm1
|
|
; LINUXOSX64-NEXT: vaddsd %xmm1, %xmm0, %xmm0
|
|
; LINUXOSX64-NEXT: vcvtsi2sd %rdx, %xmm2, %xmm1
|
|
; LINUXOSX64-NEXT: vaddsd %xmm1, %xmm0, %xmm0
|
|
; LINUXOSX64-NEXT: vcvtsi2sd %edi, %xmm2, %xmm1
|
|
; LINUXOSX64-NEXT: vaddsd %xmm1, %xmm0, %xmm0
|
|
; LINUXOSX64-NEXT: vcvtsi2sdl (%rsi), %xmm2, %xmm1
|
|
; LINUXOSX64-NEXT: vaddsd %xmm1, %xmm0, %xmm0
|
|
; LINUXOSX64-NEXT: vcvttsd2si %xmm0, %eax
|
|
; LINUXOSX64-NEXT: retq
|
|
%8 = fpext float %1 to double
|
|
%9 = fadd double %8, %0
|
|
%10 = sitofp i8 %2 to double
|
|
%11 = fadd double %9, %10
|
|
%12 = sitofp i32 %3 to double
|
|
%13 = fadd double %11, %12
|
|
%14 = sitofp i64 %4 to double
|
|
%15 = fadd double %13, %14
|
|
%16 = sitofp i16 %5 to double
|
|
%17 = fadd double %15, %16
|
|
%18 = load i32, i32* %6, align 4
|
|
%19 = sitofp i32 %18 to double
|
|
%20 = fadd double %17, %19
|
|
%21 = fptosi double %20 to i32
|
|
ret i32 %21
|
|
}
|
|
|
|
%struct.complex = type { float, double, i32, i8, i64}
|
|
|
|
define x86_regcallcc %struct.complex @test_argMultiRet(float, double, i32, i8, i64) local_unnamed_addr #0 {
|
|
; X32-LABEL: test_argMultiRet:
|
|
; X32: # %bb.0:
|
|
; X32-NEXT: vaddsd __real@4014000000000000, %xmm1, %xmm1
|
|
; X32-NEXT: movl $4, %eax
|
|
; X32-NEXT: movb $7, %cl
|
|
; X32-NEXT: movl $999, %edx # imm = 0x3E7
|
|
; X32-NEXT: xorl %edi, %edi
|
|
; X32-NEXT: retl
|
|
;
|
|
; WIN64-LABEL: test_argMultiRet:
|
|
; WIN64: # %bb.0:
|
|
; WIN64-NEXT: vaddsd __real@{{.*}}(%rip), %xmm1, %xmm1
|
|
; WIN64-NEXT: movl $999, %edx # imm = 0x3E7
|
|
; WIN64-NEXT: movl $4, %eax
|
|
; WIN64-NEXT: movb $7, %cl
|
|
; WIN64-NEXT: retq
|
|
;
|
|
; LINUXOSX64-LABEL: test_argMultiRet:
|
|
; LINUXOSX64: # %bb.0:
|
|
; LINUXOSX64-NEXT: vaddsd {{.*}}(%rip), %xmm1, %xmm1
|
|
; LINUXOSX64-NEXT: movl $999, %edx # imm = 0x3E7
|
|
; LINUXOSX64-NEXT: movl $4, %eax
|
|
; LINUXOSX64-NEXT: movb $7, %cl
|
|
; LINUXOSX64-NEXT: retq
|
|
%6 = fadd double %1, 5.000000e+00
|
|
%7 = insertvalue %struct.complex undef, float %0, 0
|
|
%8 = insertvalue %struct.complex %7, double %6, 1
|
|
%9 = insertvalue %struct.complex %8, i32 4, 2
|
|
%10 = insertvalue %struct.complex %9, i8 7, 3
|
|
%11 = insertvalue %struct.complex %10, i64 999, 4
|
|
ret %struct.complex %11
|
|
}
|