mirror of
https://github.com/RPCS3/llvm-mirror.git
synced 2024-11-25 04:02:41 +01:00
7022e7d38f
Summary: After teaching InlineCost more about address spaces () another fault was detected in the inliner. If an argument has the byval attribute the parameter might be copied to an alloca. That part seems to work fine even if the argument has a different address space than the alloca address space. However, if the address spaces differ, then the inlined function still might refer to the parameter using the original address space (the inliner does not handle that situation very well). This patch avoids the problem by simply disallowing inlining when there are byval arguments with address space that differs from the alloca address space. I'm not really sure how to transform the code if we want to get inlining for this situation. I assume that it never has been working, and that the fixes in r321809 just exposed an old problem. Fault found by skatkov (Serguei Katkov). It is mentioned in follow up comments to https://reviews.llvm.org/D40455. Reviewers: skatkov Reviewed By: skatkov Subscribers: uabelho, eraman, llvm-commits, haicheng Differential Revision: https://reviews.llvm.org/D41898 llvm-svn: 322181
166 lines
5.3 KiB
LLVM
166 lines
5.3 KiB
LLVM
; RUN: opt < %s -inline -S | FileCheck %s
|
|
; RUN: opt < %s -passes='cgscc(inline)' -S | FileCheck %s
|
|
|
|
; The verifier does catch problems with inlining of byval arguments that has a
|
|
; different address space compared to the alloca. But running instcombine
|
|
; after inline used to trigger asserts unless we disallow such inlining.
|
|
; RUN: opt < %s -inline -instcombine -disable-output 2>/dev/null
|
|
|
|
target datalayout = "p:32:32-p1:64:64-p2:16:16-n16:32:64"
|
|
|
|
; Inlining a byval struct should cause an explicit copy into an alloca.
|
|
|
|
%struct.ss = type { i32, i64 }
|
|
@.str = internal constant [10 x i8] c"%d, %lld\0A\00" ; <[10 x i8]*> [#uses=1]
|
|
|
|
define internal void @f(%struct.ss* byval %b) nounwind {
|
|
entry:
|
|
%tmp = getelementptr %struct.ss, %struct.ss* %b, i32 0, i32 0 ; <i32*> [#uses=2]
|
|
%tmp1 = load i32, i32* %tmp, align 4 ; <i32> [#uses=1]
|
|
%tmp2 = add i32 %tmp1, 1 ; <i32> [#uses=1]
|
|
store i32 %tmp2, i32* %tmp, align 4
|
|
ret void
|
|
}
|
|
|
|
declare i32 @printf(i8*, ...) nounwind
|
|
|
|
define i32 @test1() nounwind {
|
|
entry:
|
|
%S = alloca %struct.ss ; <%struct.ss*> [#uses=4]
|
|
%tmp1 = getelementptr %struct.ss, %struct.ss* %S, i32 0, i32 0 ; <i32*> [#uses=1]
|
|
store i32 1, i32* %tmp1, align 8
|
|
%tmp4 = getelementptr %struct.ss, %struct.ss* %S, i32 0, i32 1 ; <i64*> [#uses=1]
|
|
store i64 2, i64* %tmp4, align 4
|
|
call void @f( %struct.ss* byval %S ) nounwind
|
|
ret i32 0
|
|
; CHECK: @test1()
|
|
; CHECK: %S1 = alloca %struct.ss
|
|
; CHECK: %S = alloca %struct.ss
|
|
; CHECK: call void @llvm.memcpy
|
|
; CHECK: ret i32 0
|
|
}
|
|
|
|
; Inlining a byval struct should NOT cause an explicit copy
|
|
; into an alloca if the function is readonly
|
|
|
|
define internal i32 @f2(%struct.ss* byval %b) nounwind readonly {
|
|
entry:
|
|
%tmp = getelementptr %struct.ss, %struct.ss* %b, i32 0, i32 0 ; <i32*> [#uses=2]
|
|
%tmp1 = load i32, i32* %tmp, align 4 ; <i32> [#uses=1]
|
|
%tmp2 = add i32 %tmp1, 1 ; <i32> [#uses=1]
|
|
ret i32 %tmp2
|
|
}
|
|
|
|
define i32 @test2() nounwind {
|
|
entry:
|
|
%S = alloca %struct.ss ; <%struct.ss*> [#uses=4]
|
|
%tmp1 = getelementptr %struct.ss, %struct.ss* %S, i32 0, i32 0 ; <i32*> [#uses=1]
|
|
store i32 1, i32* %tmp1, align 8
|
|
%tmp4 = getelementptr %struct.ss, %struct.ss* %S, i32 0, i32 1 ; <i64*> [#uses=1]
|
|
store i64 2, i64* %tmp4, align 4
|
|
%X = call i32 @f2( %struct.ss* byval %S ) nounwind
|
|
ret i32 %X
|
|
; CHECK: @test2()
|
|
; CHECK: %S = alloca %struct.ss
|
|
; CHECK-NOT: call void @llvm.memcpy
|
|
; CHECK: ret i32
|
|
}
|
|
|
|
|
|
; Inlining a byval with an explicit alignment needs to use *at least* that
|
|
; alignment on the generated alloca.
|
|
; PR8769
|
|
declare void @g3(%struct.ss* %p)
|
|
|
|
define internal void @f3(%struct.ss* byval align 64 %b) nounwind {
|
|
call void @g3(%struct.ss* %b) ;; Could make alignment assumptions!
|
|
ret void
|
|
}
|
|
|
|
define void @test3() nounwind {
|
|
entry:
|
|
%S = alloca %struct.ss, align 1 ;; May not be aligned.
|
|
call void @f3( %struct.ss* byval align 64 %S) nounwind
|
|
ret void
|
|
; CHECK: @test3()
|
|
; CHECK: %S1 = alloca %struct.ss, align 64
|
|
; CHECK: %S = alloca %struct.ss
|
|
; CHECK: call void @llvm.memcpy
|
|
; CHECK: call void @g3(%struct.ss* %S1)
|
|
; CHECK: ret void
|
|
}
|
|
|
|
|
|
; Inlining a byval struct should NOT cause an explicit copy
|
|
; into an alloca if the function is readonly, but should increase an alloca's
|
|
; alignment to satisfy an explicit alignment request.
|
|
|
|
define internal i32 @f4(%struct.ss* byval align 64 %b) nounwind readonly {
|
|
call void @g3(%struct.ss* %b)
|
|
ret i32 4
|
|
}
|
|
|
|
define i32 @test4() nounwind {
|
|
entry:
|
|
%S = alloca %struct.ss, align 2 ; <%struct.ss*> [#uses=4]
|
|
%X = call i32 @f4( %struct.ss* byval align 64 %S ) nounwind
|
|
ret i32 %X
|
|
; CHECK: @test4()
|
|
; CHECK: %S = alloca %struct.ss, align 64
|
|
; CHECK-NOT: call void @llvm.memcpy
|
|
; CHECK: call void @g3
|
|
; CHECK: ret i32 4
|
|
}
|
|
|
|
%struct.S0 = type { i32 }
|
|
|
|
@b = global %struct.S0 { i32 1 }, align 4
|
|
@a = common global i32 0, align 4
|
|
|
|
define internal void @f5(%struct.S0* byval nocapture readonly align 4 %p) {
|
|
entry:
|
|
store i32 0, i32* getelementptr inbounds (%struct.S0, %struct.S0* @b, i64 0, i32 0), align 4
|
|
%f2 = getelementptr inbounds %struct.S0, %struct.S0* %p, i64 0, i32 0
|
|
%0 = load i32, i32* %f2, align 4
|
|
store i32 %0, i32* @a, align 4
|
|
ret void
|
|
}
|
|
|
|
define i32 @test5() {
|
|
entry:
|
|
tail call void @f5(%struct.S0* byval align 4 @b)
|
|
%0 = load i32, i32* @a, align 4
|
|
ret i32 %0
|
|
; CHECK: @test5()
|
|
; CHECK: store i32 0, i32* getelementptr inbounds (%struct.S0, %struct.S0* @b, i64 0, i32 0), align 4
|
|
; CHECK-NOT: load i32, i32* getelementptr inbounds (%struct.S0, %struct.S0* @b, i64 0, i32 0), align 4
|
|
}
|
|
|
|
; Inlining a byval struct that is in a different address space compared to the
|
|
; alloca address space is at the moment not expected. That would need
|
|
; adjustments inside the inlined function since the address space attribute of
|
|
; the inlined argument changes.
|
|
|
|
%struct.S1 = type { i32 }
|
|
|
|
@d = addrspace(1) global %struct.S1 { i32 1 }, align 4
|
|
@c = common addrspace(1) global i32 0, align 4
|
|
|
|
define internal void @f5_as1(%struct.S1 addrspace(1)* byval nocapture readonly align 4 %p) {
|
|
entry:
|
|
store i32 0, i32 addrspace(1)* getelementptr inbounds (%struct.S1, %struct.S1 addrspace(1)* @d, i64 0, i32 0), align 4
|
|
%f2 = getelementptr inbounds %struct.S1, %struct.S1 addrspace(1)* %p, i64 0, i32 0
|
|
%0 = load i32, i32 addrspace(1)* %f2, align 4
|
|
store i32 %0, i32 addrspace(1)* @c, align 4
|
|
ret void
|
|
}
|
|
|
|
define i32 @test5_as1() {
|
|
entry:
|
|
tail call void @f5_as1(%struct.S1 addrspace(1)* byval align 4 @d)
|
|
%0 = load i32, i32 addrspace(1)* @c, align 4
|
|
ret i32 %0
|
|
; CHECK: @test5_as1()
|
|
; CHECK: call void @f5_as1
|
|
}
|