mirror of
https://github.com/RPCSX/llvm.git
synced 2024-11-24 20:29:53 +00:00
d89c0abc07
There's no need to do this if the user doesn't call va_start. In the future, we're going to have thunks that forward these register parameters with musttail calls, and they won't need these spills for handling va_start. Most of the test suite changes are adding va_start calls to existing tests to keep things working. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@216294 91177308-0d34-0410-b5e6-96231b3b80d8
222 lines
6.2 KiB
LLVM
222 lines
6.2 KiB
LLVM
; RUN: llc -mtriple=thumbv7-apple-none-macho < %s | FileCheck %s
|
|
; RUN: llc -mtriple=thumbv6m-apple-none-macho -disable-fp-elim < %s | FileCheck %s --check-prefix=CHECK-T1
|
|
; RUN: llc -mtriple=thumbv7-apple-darwin-ios -disable-fp-elim < %s | FileCheck %s --check-prefix=CHECK-IOS
|
|
; RUN: llc -mtriple=thumbv7--linux-gnueabi -disable-fp-elim < %s | FileCheck %s --check-prefix=CHECK-LINUX
|
|
|
|
|
|
declare void @bar(i8*)
|
|
|
|
%bigVec = type [2 x double]
|
|
|
|
@var = global %bigVec zeroinitializer
|
|
|
|
define void @check_simple() minsize {
|
|
; CHECK-LABEL: check_simple:
|
|
; CHECK: push.w {r7, r8, r9, r10, r11, lr}
|
|
; CHECK-NOT: sub sp, sp,
|
|
; ...
|
|
; CHECK-NOT: add sp, sp,
|
|
; CHECK: pop.w {r0, r1, r2, r3, r11, pc}
|
|
|
|
; CHECK-T1-LABEL: check_simple:
|
|
; CHECK-T1: push {r3, r4, r5, r6, r7, lr}
|
|
; CHECK-T1: add r7, sp, #16
|
|
; CHECK-T1-NOT: sub sp, sp,
|
|
; ...
|
|
; CHECK-T1-NOT: add sp, sp,
|
|
; CHECK-T1: pop {r0, r1, r2, r3, r7, pc}
|
|
|
|
; iOS always has a frame pointer and messing with the push affects
|
|
; how it's set in the prologue. Make sure we get that right.
|
|
; CHECK-IOS-LABEL: check_simple:
|
|
; CHECK-IOS: push {r3, r4, r5, r6, r7, lr}
|
|
; CHECK-NOT: sub sp,
|
|
; CHECK-IOS: add r7, sp, #16
|
|
; CHECK-NOT: sub sp,
|
|
; ...
|
|
; CHECK-NOT: add sp,
|
|
; CHEC: pop {r3, r4, r5, r6, r7, pc}
|
|
|
|
%var = alloca i8, i32 16
|
|
call void @bar(i8* %var)
|
|
ret void
|
|
}
|
|
|
|
define void @check_simple_too_big() minsize {
|
|
; CHECK-LABEL: check_simple_too_big:
|
|
; CHECK: push.w {r11, lr}
|
|
; CHECK: sub sp,
|
|
; ...
|
|
; CHECK: add sp,
|
|
; CHECK: pop.w {r11, pc}
|
|
%var = alloca i8, i32 64
|
|
call void @bar(i8* %var)
|
|
ret void
|
|
}
|
|
|
|
define void @check_vfp_fold() minsize {
|
|
; CHECK-LABEL: check_vfp_fold:
|
|
; CHECK: push {r[[GLOBREG:[0-9]+]], lr}
|
|
; CHECK: vpush {d6, d7, d8, d9}
|
|
; CHECK-NOT: sub sp,
|
|
; ...
|
|
; CHECK: vldmia r[[GLOBREG]], {d8, d9}
|
|
; ...
|
|
; CHECK-NOT: add sp,
|
|
; CHECK: vpop {d6, d7, d8, d9}
|
|
; CHECKL pop {r[[GLOBREG]], pc}
|
|
|
|
; iOS uses aligned NEON stores here, which is convenient since we
|
|
; want to make sure that works too.
|
|
; CHECK-IOS-LABEL: check_vfp_fold:
|
|
; CHECK-IOS: push {r0, r1, r2, r3, r4, r7, lr}
|
|
; CHECK-IOS: sub.w r4, sp, #16
|
|
; CHECK-IOS: bic r4, r4, #15
|
|
; CHECK-IOS: mov sp, r4
|
|
; CHECK-IOS: vst1.64 {d8, d9}, [r4:128]
|
|
; ...
|
|
; CHECK-IOS: add r4, sp, #16
|
|
; CHECK-IOS: vld1.64 {d8, d9}, [r4:128]
|
|
; CHECK-IOS: mov sp, r4
|
|
; CHECK-IOS: pop {r4, r7, pc}
|
|
|
|
%var = alloca i8, i32 16
|
|
|
|
%tmp = load %bigVec* @var
|
|
call void @bar(i8* %var)
|
|
store %bigVec %tmp, %bigVec* @var
|
|
|
|
ret void
|
|
}
|
|
|
|
; This function should use just enough space that the "add sp, sp, ..." could be
|
|
; folded in except that doing so would clobber the value being returned.
|
|
define i64 @check_no_return_clobber() minsize {
|
|
; CHECK-LABEL: check_no_return_clobber:
|
|
; CHECK: push.w {r5, r6, r7, r8, r9, r10, r11, lr}
|
|
; CHECK-NOT: sub sp,
|
|
; ...
|
|
; CHECK: add sp, #24
|
|
; CHECK: pop.w {r11, pc}
|
|
|
|
; Just to keep iOS FileCheck within previous function:
|
|
; CHECK-IOS-LABEL: check_no_return_clobber:
|
|
|
|
%var = alloca i8, i32 20
|
|
call void @bar(i8* %var)
|
|
ret i64 0
|
|
}
|
|
|
|
define arm_aapcs_vfpcc double @check_vfp_no_return_clobber() minsize {
|
|
; CHECK-LABEL: check_vfp_no_return_clobber:
|
|
; CHECK: push {r[[GLOBREG:[0-9]+]], lr}
|
|
; CHECK: vpush {d0, d1, d2, d3, d4, d5, d6, d7, d8, d9}
|
|
; CHECK-NOT: sub sp,
|
|
; ...
|
|
; CHECK: add sp, #64
|
|
; CHECK: vpop {d8, d9}
|
|
; CHECK: pop {r[[GLOBREG]], pc}
|
|
|
|
%var = alloca i8, i32 64
|
|
|
|
%tmp = load %bigVec* @var
|
|
call void @bar(i8* %var)
|
|
store %bigVec %tmp, %bigVec* @var
|
|
|
|
ret double 1.0
|
|
}
|
|
|
|
@dbl = global double 0.0
|
|
|
|
; PR18136: there was a bug determining where the first eligible pop in a
|
|
; basic-block was when the entire block was epilogue code.
|
|
define void @test_fold_point(i1 %tst) minsize {
|
|
; CHECK-LABEL: test_fold_point:
|
|
|
|
; Important to check for beginning of basic block, because if it gets
|
|
; if-converted the test is probably no longer checking what it should.
|
|
; CHECK: {{LBB[0-9]+_2}}:
|
|
; CHECK-NEXT: vpop {d7, d8}
|
|
; CHECK-NEXT: pop {r4, pc}
|
|
|
|
; With a guaranteed frame-pointer, we want to make sure that its offset in the
|
|
; push block is correct, even if a few registers have been tacked onto a later
|
|
; vpush (PR18160).
|
|
; CHECK-IOS-LABEL: test_fold_point:
|
|
; CHECK-IOS: push {r4, r7, lr}
|
|
; CHECK-IOS-NEXT: add r7, sp, #4
|
|
; CHECK-IOS-NEXT: vpush {d7, d8}
|
|
|
|
; We want some memory so there's a stack adjustment to fold...
|
|
%var = alloca i8, i32 8
|
|
|
|
; We want a long-lived floating register so that a callee-saved dN is used and
|
|
; there's both a vpop and a pop.
|
|
%live_val = load double* @dbl
|
|
br i1 %tst, label %true, label %end
|
|
true:
|
|
call void @bar(i8* %var)
|
|
store double %live_val, double* @dbl
|
|
br label %end
|
|
end:
|
|
; We want the epilogue to be the only thing in a basic block so that we hit
|
|
; the correct edge-case (first inst in block is correct one to adjust).
|
|
ret void
|
|
}
|
|
|
|
define void @test_varsize(...) minsize {
|
|
; CHECK-T1-LABEL: test_varsize:
|
|
; CHECK-T1: sub sp, #16
|
|
; CHECK-T1: push {r5, r6, r7, lr}
|
|
; ...
|
|
; CHECK-T1: pop {r2, r3, r7}
|
|
; CHECK-T1: pop {r3}
|
|
; CHECK-T1: add sp, #16
|
|
; CHECK-T1: bx r3
|
|
|
|
; CHECK-LABEL: test_varsize:
|
|
; CHECK: sub sp, #16
|
|
; CHECK: push.w {r9, r10, r11, lr}
|
|
; ...
|
|
; CHECK: pop.w {r2, r3, r11, lr}
|
|
; CHECK: add sp, #16
|
|
; CHECK: bx lr
|
|
|
|
%var = alloca i8, i32 8
|
|
call void @llvm.va_start(i8* %var)
|
|
call void @bar(i8* %var)
|
|
ret void
|
|
}
|
|
|
|
%"MyClass" = type { i8*, i32, i32, float, float, float, [2 x i8], i32, i32* }
|
|
|
|
declare float @foo()
|
|
|
|
declare void @bar3()
|
|
|
|
declare %"MyClass"* @bar2(%"MyClass"* returned, i16*, i32, float, float, i32, i32, i1 zeroext, i1 zeroext, i32)
|
|
|
|
define fastcc float @check_vfp_no_return_clobber2(i16* %r, i16* %chars, i32 %length, i1 zeroext %flag) minsize {
|
|
entry:
|
|
; CHECK-LINUX-LABEL: check_vfp_no_return_clobber2
|
|
; CHECK-LINUX: vpush {d0, d1, d2, d3, d4, d5, d6, d7, d8}
|
|
; CHECK-NOT: sub sp,
|
|
; ...
|
|
; CHECK-LINUX: add sp
|
|
; CHECK-LINUX: vpop {d8}
|
|
%run = alloca %"MyClass", align 4
|
|
%call = call %"MyClass"* @bar2(%"MyClass"* %run, i16* %chars, i32 %length, float 0.000000e+00, float 0.000000e+00, i32 1, i32 1, i1 zeroext false, i1 zeroext true, i32 3)
|
|
%call1 = call float @foo()
|
|
%cmp = icmp eq %"MyClass"* %run, null
|
|
br i1 %cmp, label %exit, label %if.then
|
|
|
|
if.then: ; preds = %entry
|
|
call void @bar3()
|
|
br label %exit
|
|
|
|
exit: ; preds = %if.then, %entry
|
|
ret float %call1
|
|
}
|
|
|
|
declare void @llvm.va_start(i8*) nounwind
|