← Back to branch summary

~pali/+junk/llvm-toolchain-3.7

« back to all changes in this revision

Viewing changes to test/Transforms/InstCombine/assume.ll

  • Committer: Package Import Robot
  • Author(s): Sylvestre Ledru
  • Date: 2015-07-15 17:51:08 UTC
  • Revision ID: package-import@ubuntu.com-20150715175108-l8mynwovkx4zx697
Tags: upstream-3.7~+rc2
Import upstream version 3.7~+rc2

Show diffs side-by-side

added added

removed removed

Lines of Context:
test/Transforms/InstCombine/assume.ll
 
1
; RUN: opt < %s -instcombine -S | FileCheck %s
 
2
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 
3
target triple = "x86_64-unknown-linux-gnu"
 
4
 
 
5
; Function Attrs: nounwind uwtable
 
6
define i32 @foo1(i32* %a) #0 {
 
7
entry:
 
8
  %0 = load i32, i32* %a, align 4
 
9
 
 
10
; Check that the alignment has been upgraded and that the assume has not
 
11
; been removed:
 
12
; CHECK-LABEL: @foo1
 
13
; CHECK-DAG: load i32, i32* %a, align 32
 
14
; CHECK-DAG: call void @llvm.assume
 
15
; CHECK: ret i32
 
16
 
 
17
  %ptrint = ptrtoint i32* %a to i64
 
18
  %maskedptr = and i64 %ptrint, 31
 
19
  %maskcond = icmp eq i64 %maskedptr, 0
 
20
  tail call void @llvm.assume(i1 %maskcond)
 
21
 
 
22
  ret i32 %0
 
23
}
 
24
 
 
25
; Function Attrs: nounwind uwtable
 
26
define i32 @foo2(i32* %a) #0 {
 
27
entry:
 
28
; Same check as in @foo1, but make sure it works if the assume is first too.
 
29
; CHECK-LABEL: @foo2
 
30
; CHECK-DAG: load i32, i32* %a, align 32
 
31
; CHECK-DAG: call void @llvm.assume
 
32
; CHECK: ret i32
 
33
 
 
34
  %ptrint = ptrtoint i32* %a to i64
 
35
  %maskedptr = and i64 %ptrint, 31
 
36
  %maskcond = icmp eq i64 %maskedptr, 0
 
37
  tail call void @llvm.assume(i1 %maskcond)
 
38
 
 
39
  %0 = load i32, i32* %a, align 4
 
40
  ret i32 %0
 
41
}
 
42
 
 
43
; Function Attrs: nounwind
 
44
declare void @llvm.assume(i1) #1
 
45
 
 
46
define i32 @simple(i32 %a) #1 {
 
47
entry:
 
48
 
 
49
; CHECK-LABEL: @simple
 
50
; CHECK: call void @llvm.assume
 
51
; CHECK: ret i32 4
 
52
 
 
53
  %cmp = icmp eq i32 %a, 4
 
54
  tail call void @llvm.assume(i1 %cmp)
 
55
  ret i32 %a
 
56
}
 
57
 
 
58
; Function Attrs: nounwind uwtable
 
59
define i32 @can1(i1 %a, i1 %b, i1 %c) {
 
60
entry:
 
61
  %and1 = and i1 %a, %b
 
62
  %and  = and i1 %and1, %c
 
63
  tail call void @llvm.assume(i1 %and)
 
64
 
 
65
; CHECK-LABEL: @can1
 
66
; CHECK: call void @llvm.assume(i1 %a)
 
67
; CHECK: call void @llvm.assume(i1 %b)
 
68
; CHECK: call void @llvm.assume(i1 %c)
 
69
; CHECK: ret i32
 
70
 
 
71
  ret i32 5
 
72
}
 
73
 
 
74
; Function Attrs: nounwind uwtable
 
75
define i32 @can2(i1 %a, i1 %b, i1 %c) {
 
76
entry:
 
77
  %v = or i1 %a, %b
 
78
  %w = xor i1 %v, 1
 
79
  tail call void @llvm.assume(i1 %w)
 
80
 
 
81
; CHECK-LABEL: @can2
 
82
; CHECK: %[[V1:[^ ]+]] = xor i1 %a, true
 
83
; CHECK: call void @llvm.assume(i1 %[[V1]])
 
84
; CHECK: %[[V2:[^ ]+]] = xor i1 %b, true
 
85
; CHECK: call void @llvm.assume(i1 %[[V2]])
 
86
; CHECK: ret i32
 
87
 
 
88
  ret i32 5
 
89
}
 
90
 
 
91
define i32 @bar1(i32 %a) #0 {
 
92
entry:
 
93
  %and1 = and i32 %a, 3
 
94
 
 
95
; CHECK-LABEL: @bar1
 
96
; CHECK: call void @llvm.assume
 
97
; CHECK: ret i32 1
 
98
 
 
99
  %and = and i32 %a, 7
 
100
  %cmp = icmp eq i32 %and, 1
 
101
  tail call void @llvm.assume(i1 %cmp)
 
102
 
 
103
  ret i32 %and1
 
104
}
 
105
 
 
106
; Function Attrs: nounwind uwtable
 
107
define i32 @bar2(i32 %a) #0 {
 
108
entry:
 
109
; CHECK-LABEL: @bar2
 
110
; CHECK: call void @llvm.assume
 
111
; CHECK: ret i32 1
 
112
 
 
113
  %and = and i32 %a, 7
 
114
  %cmp = icmp eq i32 %and, 1
 
115
  tail call void @llvm.assume(i1 %cmp)
 
116
 
 
117
  %and1 = and i32 %a, 3
 
118
  ret i32 %and1
 
119
}
 
120
 
 
121
; Function Attrs: nounwind uwtable
 
122
define i32 @bar3(i32 %a, i1 %x, i1 %y) #0 {
 
123
entry:
 
124
  %and1 = and i32 %a, 3
 
125
 
 
126
; Don't be fooled by other assumes around.
 
127
; CHECK-LABEL: @bar3
 
128
; CHECK: call void @llvm.assume
 
129
; CHECK: ret i32 1
 
130
 
 
131
  tail call void @llvm.assume(i1 %x)
 
132
 
 
133
  %and = and i32 %a, 7
 
134
  %cmp = icmp eq i32 %and, 1
 
135
  tail call void @llvm.assume(i1 %cmp)
 
136
 
 
137
  tail call void @llvm.assume(i1 %y)
 
138
 
 
139
  ret i32 %and1
 
140
}
 
141
 
 
142
; Function Attrs: nounwind uwtable
 
143
define i32 @bar4(i32 %a, i32 %b) {
 
144
entry:
 
145
  %and1 = and i32 %b, 3
 
146
 
 
147
; CHECK-LABEL: @bar4
 
148
; CHECK: call void @llvm.assume
 
149
; CHECK: call void @llvm.assume
 
150
; CHECK: ret i32 1
 
151
 
 
152
  %and = and i32 %a, 7
 
153
  %cmp = icmp eq i32 %and, 1
 
154
  tail call void @llvm.assume(i1 %cmp)
 
155
 
 
156
  %cmp2 = icmp eq i32 %a, %b
 
157
  tail call void @llvm.assume(i1 %cmp2)
 
158
 
 
159
  ret i32 %and1
 
160
}
 
161
 
 
162
define i32 @icmp1(i32 %a) #0 {
 
163
entry:
 
164
  %cmp = icmp sgt i32 %a, 5
 
165
  tail call void @llvm.assume(i1 %cmp)
 
166
  %conv = zext i1 %cmp to i32
 
167
  ret i32 %conv
 
168
 
 
169
; CHECK-LABEL: @icmp1
 
170
; CHECK: call void @llvm.assume
 
171
; CHECK: ret i32 1
 
172
 
 
173
}
 
174
 
 
175
; Function Attrs: nounwind uwtable
 
176
define i32 @icmp2(i32 %a) #0 {
 
177
entry:
 
178
  %cmp = icmp sgt i32 %a, 5
 
179
  tail call void @llvm.assume(i1 %cmp)
 
180
  %0 = zext i1 %cmp to i32
 
181
  %lnot.ext = xor i32 %0, 1
 
182
  ret i32 %lnot.ext
 
183
 
 
184
; CHECK-LABEL: @icmp2
 
185
; CHECK: call void @llvm.assume
 
186
; CHECK: ret i32 0
 
187
}
 
188
 
 
189
declare void @escape(i32* %a)
 
190
 
 
191
; Do we canonicalize a nonnull assumption on a load into
 
192
; metadata form?
 
193
define i1 @nonnull1(i32** %a) {
 
194
entry:
 
195
  %load = load i32*, i32** %a
 
196
  %cmp = icmp ne i32* %load, null
 
197
  tail call void @llvm.assume(i1 %cmp)
 
198
  tail call void @escape(i32* %load)
 
199
  %rval = icmp eq i32* %load, null
 
200
  ret i1 %rval
 
201
 
 
202
; CHECK-LABEL: @nonnull1
 
203
; CHECK: !nonnull
 
204
; CHECK-NOT: call void @llvm.assume
 
205
; CHECK: ret i1 false
 
206
}
 
207
 
 
208
; Make sure the above canonicalization applies only
 
209
; to pointer types.  Doing otherwise would be illegal.
 
210
define i1 @nonnull2(i32* %a) {
 
211
entry:
 
212
  %load = load i32, i32* %a
 
213
  %cmp = icmp ne i32 %load, 0
 
214
  tail call void @llvm.assume(i1 %cmp)
 
215
  %rval = icmp eq i32 %load, 0
 
216
  ret i1 %rval
 
217
 
 
218
; CHECK-LABEL: @nonnull2
 
219
; CHECK-NOT: !nonnull
 
220
; CHECK: call void @llvm.assume
 
221
}
 
222
 
 
223
; Make sure the above canonicalization does not trigger
 
224
; if the assume is control dependent on something else
 
225
define i1 @nonnull3(i32** %a, i1 %control) {
 
226
entry:
 
227
  %load = load i32*, i32** %a
 
228
  %cmp = icmp ne i32* %load, null
 
229
  br i1 %control, label %taken, label %not_taken
 
230
taken:
 
231
  tail call void @llvm.assume(i1 %cmp)
 
232
  %rval = icmp eq i32* %load, null
 
233
  ret i1 %rval
 
234
not_taken:
 
235
  ret i1 true
 
236
 
 
237
; CHECK-LABEL: @nonnull3
 
238
; CHECK-NOT: !nonnull
 
239
; CHECK: call void @llvm.assume
 
240
}
 
241
 
 
242
; Make sure the above canonicalization does not trigger
 
243
; if the path from the load to the assume is potentially 
 
244
; interrupted by an exception being thrown
 
245
define i1 @nonnull4(i32** %a) {
 
246
entry:
 
247
  %load = load i32*, i32** %a
 
248
  ;; This call may throw!
 
249
  tail call void @escape(i32* %load)
 
250
  %cmp = icmp ne i32* %load, null
 
251
  tail call void @llvm.assume(i1 %cmp)
 
252
  %rval = icmp eq i32* %load, null
 
253
  ret i1 %rval
 
254
 
 
255
; CHECK-LABEL: @nonnull4
 
256
; CHECK-NOT: !nonnull
 
257
; CHECK: call void @llvm.assume
 
258
}
 
259
 
 
260
 
 
261
 
 
262
 
 
263
attributes #0 = { nounwind uwtable }
 
264
attributes #1 = { nounwind }
 
265