Fold compares irrespective of whether allocation can be elided
[lldb.git] / llvm / test / Transforms / InstCombine / compare-unescaped.ll
1 ; RUN: opt -instcombine -S < %s | FileCheck %s
2
3 @gp = global i32* null, align 8
4
5 declare i8* @malloc(i64) #1
6
7 define i1 @compare_global_trivialeq() {
8   %m = call i8* @malloc(i64 4)
9   %bc = bitcast i8* %m to i32*
10   %lgp = load i32*, i32** @gp, align 8
11   %cmp = icmp eq i32* %bc, %lgp
12   ret i1 %cmp
13 ; CHECK-LABEL: compare_global_trivialeq
14 ; CHECK: ret i1 false
15 }
16
17 define i1 @compare_global_trivialne() {
18   %m = call i8* @malloc(i64 4)
19   %bc = bitcast i8* %m to i32*
20   %lgp = load i32*, i32** @gp, align 8
21   %cmp = icmp ne i32* %bc, %lgp
22   ret i1 %cmp
23 ; CHECK-LABEL: compare_global_trivialne
24 ; CHECK: ret i1 true
25 }
26
27
28 ; Although the %m is marked nocapture in the deopt operand in call to function f,
29 ; we cannot remove the alloc site: call to malloc
30 ; The comparison should fold to false irrespective of whether the call to malloc can be elided or not
31 declare void @f()
32 define i1 @compare_and_call_with_deopt() {
33 ; CHECK-LABEL: compare_and_call_with_deopt
34   %m = call i8* @malloc(i64 24)
35   %bc = bitcast i8* %m to i32*
36   %lgp = load i32*, i32** @gp, align 8, !nonnull !0
37   %cmp = icmp eq i32* %lgp, %bc
38   tail call void @f() [ "deopt"(i8* %m) ]
39   ret i1 %cmp
40 ; CHECK: ret i1 false
41 }
42
43 ; Same functon as above with deopt operand in function f, but comparison is NE
44 define i1 @compare_ne_and_call_with_deopt() {
45 ; CHECK-LABEL: compare_ne_and_call_with_deopt
46   %m = call i8* @malloc(i64 24)
47   %bc = bitcast i8* %m to i32*
48   %lgp = load i32*, i32** @gp, align 8, !nonnull !0
49   %cmp = icmp ne i32* %lgp, %bc
50   tail call void @f() [ "deopt"(i8* %m) ]
51   ret i1 %cmp
52 ; CHECK: ret i1 true
53 }
54
55 ; Same function as above, but global not marked nonnull, and we cannot fold the comparison
56 define i1 @compare_ne_global_maybe_null() {
57 ; CHECK-LABEL: compare_ne_global_maybe_null
58   %m = call i8* @malloc(i64 24)
59   %bc = bitcast i8* %m to i32*
60   %lgp = load i32*, i32** @gp
61   %cmp = icmp ne i32* %lgp, %bc
62   tail call void @f() [ "deopt"(i8* %m) ]
63   ret i1 %cmp
64 ; CHECK: ret i1 %cmp
65 }
66
67 ; FIXME: The comparison should fold to false since %m escapes (call to function escape)
68 ; after the comparison.
69 declare void @escape(i8*)
70 define i1 @compare_and_call_after() {
71 ; CHECK-LABEL: compare_and_call_after
72   %m = call i8* @malloc(i64 24)
73   %bc = bitcast i8* %m to i32*
74   %lgp = load i32*, i32** @gp, align 8, !nonnull !0
75   %cmp = icmp eq i32* %bc, %lgp
76   br i1 %cmp, label %escape_call, label %just_return
77
78 escape_call:
79  call void @escape(i8* %m)
80  ret i1 true
81
82 just_return:
83  ret i1 %cmp
84 }
85
86 define i1 @compare_distinct_mallocs() {
87   %m = call i8* @malloc(i64 4)
88   %n = call i8* @malloc(i64 4)
89   %cmp = icmp eq i8* %m, %n
90   ret i1 %cmp
91   ; CHECK-LABEL: compare_distinct_mallocs
92   ; CHECK: ret i1 false
93 }
94
95 ; the compare is folded to true since the folding compare looks through bitcasts. 
96 ; call to malloc and the bitcast instructions are elided after that since there are no uses of the malloc 
97 define i1 @compare_samepointer_under_bitcast() {
98   %m = call i8* @malloc(i64 4)
99   %bc = bitcast i8* %m to i32*
100   %bcback = bitcast i32* %bc to i8*
101   %cmp = icmp eq i8* %m, %bcback
102   ret i1 %cmp
103 ; CHECK-LABEL: compare_samepointer_under_bitcast
104 ; CHECK: ret i1 true 
105 }
106
107 ; the compare is folded to true since the folding compare looks through bitcasts. 
108 ; The malloc call for %m cannot be elided since it is used in the call to function f.
109 define i1 @compare_samepointer_escaped() {
110   %m = call i8* @malloc(i64 4)
111   %bc = bitcast i8* %m to i32*
112   %bcback = bitcast i32* %bc to i8*
113   %cmp = icmp eq i8* %m, %bcback
114   call void @f() [ "deopt"(i8* %m) ]
115   ret i1 %cmp
116 ; CHECK-LABEL: compare_samepointer_escaped
117 ; CHECK-NEXT: %m = call i8* @malloc(i64 4)
118 ; CHECK-NEXT: call void @f() [ "deopt"(i8* %m) ]
119 ; CHECK: ret i1 true 
120 }
121
122 ; Technically, we can fold the %cmp2 comparison, even though %m escapes through
123 ; the ret statement since `ret` terminates the function and we cannot reach from
124 ; the ret to cmp. 
125 ; FIXME: Folding this %cmp2 when %m escapes through ret could be an issue with
126 ; cross-threading data dependencies since we do not make the distinction between
127 ; atomic and non-atomic loads in capture tracking.
128 define i8* @compare_ret_escape(i8* %c) {
129   %m = call i8* @malloc(i64 4)
130   %n = call i8* @malloc(i64 4)
131   %cmp = icmp eq i8* %n, %c
132   br i1 %cmp, label %retst, label %chk
133
134 retst:
135   ret i8* %m
136
137 chk:
138   %bc = bitcast i8* %m to i32*
139   %lgp = load i32*, i32** @gp, align 8, !nonnull !0
140   %cmp2 = icmp eq i32* %bc, %lgp
141   br i1 %cmp2, label %retst,  label %chk2
142
143 chk2:
144   ret i8* %n
145 ; CHECK-LABEL: compare_ret_escape
146 ; CHECK: %cmp = icmp eq i8* %n, %c
147 ; CHECK: %cmp2 = icmp eq i32* %bc, %lgp
148 }
149
150 ; The malloc call for %m cannot be elided since it is used in the call to function f.
151 ; However, the cmp can be folded to true as %n doesnt escape and %m, %n are distinct allocations
152 define i1 @compare_distinct_pointer_escape() {
153   %m = call i8* @malloc(i64 4)
154   %n = call i8* @malloc(i64 4)
155   tail call void @f() [ "deopt"(i8* %m) ]
156   %cmp = icmp ne i8* %m, %n
157   ret i1 %cmp
158 ; CHECK-LABEL: compare_distinct_pointer_escape
159 ; CHECK-NEXT: %m = call i8* @malloc(i64 4)
160 ; CHECK-NEXT: tail call void @f() [ "deopt"(i8* %m) ]
161 ; CHECK-NEXT: ret i1 true
162 }
163
164 !0 = !{}