maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity
llvm-project/llvm/test/Transforms/FunctionAttrs/nocapture.ll

181 lines
4.6 KiB
LLVM
Raw Normal View History

Move this test from date-name to feature-name, and port it to FileCheck. llvm-svn: 147223
2011-12-24 02:41:31 +08:00
; RUN: opt < %s -functionattrs -S | FileCheck %s
Rename AddReadAttrs to FunctionAttrs, and teach it how to work out (in a very simplistic way) which function arguments (pointer arguments only) are only dereferenced and so do not escape. Mark such arguments 'nocapture'. llvm-svn: 61525
2009-01-01 00:14:43 +08:00
@g = global i32* null ; <i32**> [#uses=1]
Extend 'readonly' and 'readnone' to work on function arguments as well as functions. Make the function attributes pass add it to known library functions and when it can deduce it. llvm-svn: 185735
2013-07-06 08:29:58 +08:00
; CHECK: define i32* @c1(i32* readnone %q)
Look through phi nodes and select instructions when calculating nocapture attributes. llvm-svn: 61535
2009-01-01 04:21:34 +08:00
define i32* @c1(i32* %q) {
ret i32* %q
Rename AddReadAttrs to FunctionAttrs, and teach it how to work out (in a very simplistic way) which function arguments (pointer arguments only) are only dereferenced and so do not escape. Mark such arguments 'nocapture'. llvm-svn: 61525
2009-01-01 00:14:43 +08:00
}
Move this test from date-name to feature-name, and port it to FileCheck. llvm-svn: 147223
2011-12-24 02:41:31 +08:00
; CHECK: define void @c2(i32* %q)
Extend 'readonly' and 'readnone' to work on function arguments as well as functions. Make the function attributes pass add it to known library functions and when it can deduce it. llvm-svn: 185735
2013-07-06 08:29:58 +08:00
; It would also be acceptable to mark %q as readnone. Update @c3 too.
Look through phi nodes and select instructions when calculating nocapture attributes. llvm-svn: 61535
2009-01-01 04:21:34 +08:00
define void @c2(i32* %q) {
store i32* %q, i32** @g
Rename AddReadAttrs to FunctionAttrs, and teach it how to work out (in a very simplistic way) which function arguments (pointer arguments only) are only dereferenced and so do not escape. Mark such arguments 'nocapture'. llvm-svn: 61525
2009-01-01 00:14:43 +08:00
ret void
}
Move this test from date-name to feature-name, and port it to FileCheck. llvm-svn: 147223
2011-12-24 02:41:31 +08:00
; CHECK: define void @c3(i32* %q)
Look through phi nodes and select instructions when calculating nocapture attributes. llvm-svn: 61535
2009-01-01 04:21:34 +08:00
define void @c3(i32* %q) {
call void @c2(i32* %q)
Rename AddReadAttrs to FunctionAttrs, and teach it how to work out (in a very simplistic way) which function arguments (pointer arguments only) are only dereferenced and so do not escape. Mark such arguments 'nocapture'. llvm-svn: 61525
2009-01-01 00:14:43 +08:00
ret void
}
Move this test from date-name to feature-name, and port it to FileCheck. llvm-svn: 147223
2011-12-24 02:41:31 +08:00
; CHECK: define i1 @c4(i32* %q, i32 %bitno)
Add tests for two types of traps that escape analysis might one day fall into. llvm-svn: 61549
2009-01-02 08:55:51 +08:00
define i1 @c4(i32* %q, i32 %bitno) {
%tmp = ptrtoint i32* %q to i32
%tmp2 = lshr i32 %tmp, %bitno
%bit = trunc i32 %tmp2 to i1
br i1 %bit, label %l1, label %l0
l0:
ret i1 0 ; escaping value not caught by def-use chaining.
l1:
ret i1 1 ; escaping value not caught by def-use chaining.
}
@lookup_table = global [2 x i1] [ i1 0, i1 1 ]
Move this test from date-name to feature-name, and port it to FileCheck. llvm-svn: 147223
2011-12-24 02:41:31 +08:00
; CHECK: define i1 @c5(i32* %q, i32 %bitno)
Add tests for two types of traps that escape analysis might one day fall into. llvm-svn: 61549
2009-01-02 08:55:51 +08:00
define i1 @c5(i32* %q, i32 %bitno) {
%tmp = ptrtoint i32* %q to i32
%tmp2 = lshr i32 %tmp, %bitno
%bit = and i32 %tmp2, 1
; subtle escape mechanism follows
%lookup = getelementptr [2 x i1]* @lookup_table, i32 0, i32 %bit
%val = load i1* %lookup
ret i1 %val
}
Teach capture tracking that readonly functions can only capture their arguments by returning them or throwing an exception or not based on the argument value. Patch essentially by Frits van Bommel. llvm-svn: 70876
2009-05-05 00:50:29 +08:00
declare void @throw_if_bit_set(i8*, i8) readonly
Move this test from date-name to feature-name, and port it to FileCheck. llvm-svn: 147223
2011-12-24 02:41:31 +08:00
Extend 'readonly' and 'readnone' to work on function arguments as well as functions. Make the function attributes pass add it to known library functions and when it can deduce it. llvm-svn: 185735
2013-07-06 08:29:58 +08:00
; CHECK: define i1 @c6(i8* readonly %q, i8 %bit)
Teach capture tracking that readonly functions can only capture their arguments by returning them or throwing an exception or not based on the argument value. Patch essentially by Frits van Bommel. llvm-svn: 70876
2009-05-05 00:50:29 +08:00
define i1 @c6(i8* %q, i8 %bit) {
invoke void @throw_if_bit_set(i8* %q, i8 %bit)
to label %ret0 unwind label %ret1
ret0:
ret i1 0
ret1:
Update some tests to the new EH scheme. llvm-svn: 138925
2011-09-01 08:58:03 +08:00
%exn = landingpad {i8*, i32} personality i32 (...)* @__gxx_personality_v0
cleanup
Teach capture tracking that readonly functions can only capture their arguments by returning them or throwing an exception or not based on the argument value. Patch essentially by Frits van Bommel. llvm-svn: 70876
2009-05-05 00:50:29 +08:00
ret i1 1
}
Update some tests to the new EH scheme. llvm-svn: 138925
2011-09-01 08:58:03 +08:00
declare i32 @__gxx_personality_v0(...)
Revert r70876 and add a testcase (@c7) showing the problem: bits captured, but the pointer marked nocapture. In fact I now recall that this problem is why only readnone functions returning void were considered before! However keep a small fix that was also in r70876: a readnone function returning void can result in bits being captured if it unwinds, so test for this. llvm-svn: 71168
2009-05-08 02:08:34 +08:00
define i1* @lookup_bit(i32* %q, i32 %bitno) readnone nounwind {
%tmp = ptrtoint i32* %q to i32
%tmp2 = lshr i32 %tmp, %bitno
%bit = and i32 %tmp2, 1
%lookup = getelementptr [2 x i1]* @lookup_table, i32 0, i32 %bit
ret i1* %lookup
}
Extend 'readonly' and 'readnone' to work on function arguments as well as functions. Make the function attributes pass add it to known library functions and when it can deduce it. llvm-svn: 185735
2013-07-06 08:29:58 +08:00
; CHECK: define i1 @c7(i32* readnone %q, i32 %bitno)
Revert r70876 and add a testcase (@c7) showing the problem: bits captured, but the pointer marked nocapture. In fact I now recall that this problem is why only readnone functions returning void were considered before! However keep a small fix that was also in r70876: a readnone function returning void can result in bits being captured if it unwinds, so test for this. llvm-svn: 71168
2009-05-08 02:08:34 +08:00
define i1 @c7(i32* %q, i32 %bitno) {
%ptr = call i1* @lookup_bit(i32* %q, i32 %bitno)
%val = load i1* %ptr
ret i1 %val
}
Move this test from date-name to feature-name, and port it to FileCheck. llvm-svn: 147223
2011-12-24 02:41:31 +08:00
; CHECK: define i32 @nc1(i32* %q, i32* nocapture %p, i1 %b)
Look through phi nodes and select instructions when calculating nocapture attributes. llvm-svn: 61535
2009-01-01 04:21:34 +08:00
define i32 @nc1(i32* %q, i32* %p, i1 %b) {
e:
br label %l
l:
%x = phi i32* [ %p, %e ]
%y = phi i32* [ %q, %e ]
%tmp = bitcast i32* %x to i32* ; <i32*> [#uses=2]
%tmp2 = select i1 %b, i32* %tmp, i32* %y
%val = load i32* %tmp2 ; <i32> [#uses=1]
Rename AddReadAttrs to FunctionAttrs, and teach it how to work out (in a very simplistic way) which function arguments (pointer arguments only) are only dereferenced and so do not escape. Mark such arguments 'nocapture'. llvm-svn: 61525
2009-01-01 00:14:43 +08:00
store i32 0, i32* %tmp
Look through phi nodes and select instructions when calculating nocapture attributes. llvm-svn: 61535
2009-01-01 04:21:34 +08:00
store i32* %y, i32** @g
Rename AddReadAttrs to FunctionAttrs, and teach it how to work out (in a very simplistic way) which function arguments (pointer arguments only) are only dereferenced and so do not escape. Mark such arguments 'nocapture'. llvm-svn: 61525
2009-01-01 00:14:43 +08:00
ret i32 %val
}
Move this test from date-name to feature-name, and port it to FileCheck. llvm-svn: 147223
2011-12-24 02:41:31 +08:00
; CHECK: define void @nc2(i32* nocapture %p, i32* %q)
Look through phi nodes and select instructions when calculating nocapture attributes. llvm-svn: 61535
2009-01-01 04:21:34 +08:00
define void @nc2(i32* %p, i32* %q) {
%1 = call i32 @nc1(i32* %q, i32* %p, i1 0) ; <i32> [#uses=0]
Rename AddReadAttrs to FunctionAttrs, and teach it how to work out (in a very simplistic way) which function arguments (pointer arguments only) are only dereferenced and so do not escape. Mark such arguments 'nocapture'. llvm-svn: 61525
2009-01-01 00:14:43 +08:00
ret void
}
Move this test from date-name to feature-name, and port it to FileCheck. llvm-svn: 147223
2011-12-24 02:41:31 +08:00
; CHECK: define void @nc3(void ()* nocapture %p)
Look through phi nodes and select instructions when calculating nocapture attributes. llvm-svn: 61535
2009-01-01 04:21:34 +08:00
define void @nc3(void ()* %p) {
call void %p()
Rename AddReadAttrs to FunctionAttrs, and teach it how to work out (in a very simplistic way) which function arguments (pointer arguments only) are only dereferenced and so do not escape. Mark such arguments 'nocapture'. llvm-svn: 61525
2009-01-01 00:14:43 +08:00
ret void
}
Make adding nocapture a bit stronger. FreeInst is nocapture. Also, functions that don't write can't leak a pointer except through the return value, so a void readonly function is implicitly nocapture. Test these, and add a test that verifies that f1 calling f2 with an otherwise dead pointer gets both of them marked nocapture. llvm-svn: 61552
2009-01-02 11:46:56 +08:00
Teach capture tracking that readonly functions can only capture their arguments by returning them or throwing an exception or not based on the argument value. Patch essentially by Frits van Bommel. llvm-svn: 70876
2009-05-05 00:50:29 +08:00
declare void @external(i8*) readonly nounwind
Extend 'readonly' and 'readnone' to work on function arguments as well as functions. Make the function attributes pass add it to known library functions and when it can deduce it. llvm-svn: 185735
2013-07-06 08:29:58 +08:00
; CHECK: define void @nc4(i8* nocapture readonly %p)
Make adding nocapture a bit stronger. FreeInst is nocapture. Also, functions that don't write can't leak a pointer except through the return value, so a void readonly function is implicitly nocapture. Test these, and add a test that verifies that f1 calling f2 with an otherwise dead pointer gets both of them marked nocapture. llvm-svn: 61552
2009-01-02 11:46:56 +08:00
define void @nc4(i8* %p) {
call void @external(i8* %p)
ret void
}
Move this test from date-name to feature-name, and port it to FileCheck. llvm-svn: 147223
2011-12-24 02:41:31 +08:00
; CHECK: define void @nc5(void (i8*)* nocapture %f, i8* nocapture %p)
Revert r70876 and add a testcase (@c7) showing the problem: bits captured, but the pointer marked nocapture. In fact I now recall that this problem is why only readnone functions returning void were considered before! However keep a small fix that was also in r70876: a readnone function returning void can result in bits being captured if it unwinds, so test for this. llvm-svn: 71168
2009-05-08 02:08:34 +08:00
define void @nc5(void (i8*)* %f, i8* %p) {
call void %f(i8* %p) readonly nounwind
call void %f(i8* nocapture %p)
Make adding nocapture a bit stronger. FreeInst is nocapture. Also, functions that don't write can't leak a pointer except through the return value, so a void readonly function is implicitly nocapture. Test these, and add a test that verifies that f1 calling f2 with an otherwise dead pointer gets both of them marked nocapture. llvm-svn: 61552
2009-01-02 11:46:56 +08:00
ret void
}
Change CaptureTracking to pass a Use* instead of a Value* when a value is captured. This allows the tracker to look at the specific use, which may be especially interesting for function calls. Use this to fix 'nocapture' deduction in FunctionAttrs. The existing one does not iterate until a fixpoint and does not guarantee that it produces the same result regardless of iteration order. The new implementation builds up a graph of how arguments are passed from function to function, and uses a bottom-up walk on the argument-SCCs to assign nocapture. This gets us nocapture more often, and does so rather efficiently and independent of iteration order. llvm-svn: 147327
2011-12-29 07:24:21 +08:00
Extend 'readonly' and 'readnone' to work on function arguments as well as functions. Make the function attributes pass add it to known library functions and when it can deduce it. llvm-svn: 185735
2013-07-06 08:29:58 +08:00
; CHECK: define void @test1_1(i8* nocapture readnone %x1_1, i8* %y1_1)
; It would be acceptable to add readnone to %y1_1 and %y1_2.
Change CaptureTracking to pass a Use* instead of a Value* when a value is captured. This allows the tracker to look at the specific use, which may be especially interesting for function calls. Use this to fix 'nocapture' deduction in FunctionAttrs. The existing one does not iterate until a fixpoint and does not guarantee that it produces the same result regardless of iteration order. The new implementation builds up a graph of how arguments are passed from function to function, and uses a bottom-up walk on the argument-SCCs to assign nocapture. This gets us nocapture more often, and does so rather efficiently and independent of iteration order. llvm-svn: 147327
2011-12-29 07:24:21 +08:00
define void @test1_1(i8* %x1_1, i8* %y1_1) {
call i8* @test1_2(i8* %x1_1, i8* %y1_1)
store i32* null, i32** @g
ret void
}
Extend 'readonly' and 'readnone' to work on function arguments as well as functions. Make the function attributes pass add it to known library functions and when it can deduce it. llvm-svn: 185735
2013-07-06 08:29:58 +08:00
; CHECK: define i8* @test1_2(i8* nocapture readnone %x1_2, i8* %y1_2)
Change CaptureTracking to pass a Use* instead of a Value* when a value is captured. This allows the tracker to look at the specific use, which may be especially interesting for function calls. Use this to fix 'nocapture' deduction in FunctionAttrs. The existing one does not iterate until a fixpoint and does not guarantee that it produces the same result regardless of iteration order. The new implementation builds up a graph of how arguments are passed from function to function, and uses a bottom-up walk on the argument-SCCs to assign nocapture. This gets us nocapture more often, and does so rather efficiently and independent of iteration order. llvm-svn: 147327
2011-12-29 07:24:21 +08:00
define i8* @test1_2(i8* %x1_2, i8* %y1_2) {
call void @test1_1(i8* %x1_2, i8* %y1_2)
store i32* null, i32** @g
ret i8* %y1_2
}
Extend 'readonly' and 'readnone' to work on function arguments as well as functions. Make the function attributes pass add it to known library functions and when it can deduce it. llvm-svn: 185735
2013-07-06 08:29:58 +08:00
; CHECK: define void @test2(i8* nocapture readnone %x2)
Change CaptureTracking to pass a Use* instead of a Value* when a value is captured. This allows the tracker to look at the specific use, which may be especially interesting for function calls. Use this to fix 'nocapture' deduction in FunctionAttrs. The existing one does not iterate until a fixpoint and does not guarantee that it produces the same result regardless of iteration order. The new implementation builds up a graph of how arguments are passed from function to function, and uses a bottom-up walk on the argument-SCCs to assign nocapture. This gets us nocapture more often, and does so rather efficiently and independent of iteration order. llvm-svn: 147327
2011-12-29 07:24:21 +08:00
define void @test2(i8* %x2) {
call void @test2(i8* %x2)
store i32* null, i32** @g
ret void
}
Extend 'readonly' and 'readnone' to work on function arguments as well as functions. Make the function attributes pass add it to known library functions and when it can deduce it. llvm-svn: 185735
2013-07-06 08:29:58 +08:00
; CHECK: define void @test3(i8* nocapture readnone %x3, i8* nocapture readnone %y3, i8* nocapture readnone %z3)
Change CaptureTracking to pass a Use* instead of a Value* when a value is captured. This allows the tracker to look at the specific use, which may be especially interesting for function calls. Use this to fix 'nocapture' deduction in FunctionAttrs. The existing one does not iterate until a fixpoint and does not guarantee that it produces the same result regardless of iteration order. The new implementation builds up a graph of how arguments are passed from function to function, and uses a bottom-up walk on the argument-SCCs to assign nocapture. This gets us nocapture more often, and does so rather efficiently and independent of iteration order. llvm-svn: 147327
2011-12-29 07:24:21 +08:00
define void @test3(i8* %x3, i8* %y3, i8* %z3) {
call void @test3(i8* %z3, i8* %y3, i8* %x3)
store i32* null, i32** @g
ret void
}
; CHECK: define void @test4_1(i8* %x4_1)
define void @test4_1(i8* %x4_1) {
call i8* @test4_2(i8* %x4_1, i8* %x4_1, i8* %x4_1)
store i32* null, i32** @g
ret void
}
Extend 'readonly' and 'readnone' to work on function arguments as well as functions. Make the function attributes pass add it to known library functions and when it can deduce it. llvm-svn: 185735
2013-07-06 08:29:58 +08:00
; CHECK: define i8* @test4_2(i8* nocapture readnone %x4_2, i8* readnone %y4_2, i8* nocapture readnone %z4_2)
Change CaptureTracking to pass a Use* instead of a Value* when a value is captured. This allows the tracker to look at the specific use, which may be especially interesting for function calls. Use this to fix 'nocapture' deduction in FunctionAttrs. The existing one does not iterate until a fixpoint and does not guarantee that it produces the same result regardless of iteration order. The new implementation builds up a graph of how arguments are passed from function to function, and uses a bottom-up walk on the argument-SCCs to assign nocapture. This gets us nocapture more often, and does so rather efficiently and independent of iteration order. llvm-svn: 147327
2011-12-29 07:24:21 +08:00
define i8* @test4_2(i8* %x4_2, i8* %y4_2, i8* %z4_2) {
call void @test4_1(i8* null)
store i32* null, i32** @g
ret i8* %y4_2
}
declare i8* @test5_1(i8* %x5_1)
; CHECK: define void @test5_2(i8* %x5_2)
define void @test5_2(i8* %x5_2) {
call i8* @test5_1(i8* %x5_2)
store i32* null, i32** @g
ret void
}
declare void @test6_1(i8* %x6_1, i8* nocapture %y6_1, ...)
; CHECK: define void @test6_2(i8* %x6_2, i8* nocapture %y6_2, i8* %z6_2)
define void @test6_2(i8* %x6_2, i8* %y6_2, i8* %z6_2) {
call void (i8*, i8*, ...)* @test6_1(i8* %x6_2, i8* %y6_2, i8* %z6_2)
store i32* null, i32** @g
ret void
}