[WinEH] Verify consistent funclet unwind exits
[oota-llvm.git] / test / CodeGen / WinEH / wineh-cloning.ll
1 ; RUN: opt -mtriple=x86_64-pc-windows-msvc -S -winehprepare  < %s | FileCheck %s
2
3 declare i32 @__CxxFrameHandler3(...)
4 declare i32 @__C_specific_handler(...)
5 declare void @ProcessCLRException(...)
6
7 declare void @f()
8
9 declare void @llvm.foo(i32) nounwind
10 declare void @llvm.bar() nounwind
11 declare i32 @llvm.qux() nounwind
12 declare i1 @llvm.baz() nounwind
13
14 define void @test1() personality i32 (...)* @__CxxFrameHandler3 {
15 entry:
16   ; %x def colors: {entry} subset of use colors; must spill
17   %x = call i32 @llvm.qux()
18   invoke void @f()
19     to label %noreturn unwind label %catch.switch
20 catch.switch:
21   %cs = catchswitch within none [label %catch] unwind to caller
22 catch:
23   %cp = catchpad within %cs []
24   br label %noreturn
25 noreturn:
26   ; %x use colors: {entry, cleanup}
27   call void @llvm.foo(i32 %x)
28   unreachable
29 }
30 ; Need two copies of the call to @h, one under entry and one under catch.
31 ; Currently we generate a load for each, though we shouldn't need one
32 ; for the use in entry's copy.
33 ; CHECK-LABEL: define void @test1(
34 ; CHECK: entry:
35 ; CHECK:   %x = call i32 @llvm.qux()
36 ; CHECK:   invoke void @f()
37 ; CHECK:     to label %[[EntryCopy:[^ ]+]] unwind label %catch
38 ; CHECK: catch.switch:
39 ; CHECK:   %cs = catchswitch within none [label %catch] unwind to caller
40 ; CHECK: catch:
41 ; CHECK:   catchpad within %cs []
42 ; CHECK-NEXT: call void @llvm.foo(i32 %x)
43 ; CHECK: [[EntryCopy]]:
44 ; CHECK:   call void @llvm.foo(i32 %x)
45
46
47 define void @test2() personality i32 (...)* @__CxxFrameHandler3 {
48 entry:
49   invoke void @f()
50     to label %exit unwind label %cleanup
51 cleanup:
52   cleanuppad within none []
53   br label %exit
54 exit:
55   call void @llvm.bar()
56   ret void
57 }
58 ; Need two copies of %exit's call to @f -- the subsequent ret is only
59 ; valid when coming from %entry, but on the path from %cleanup, this
60 ; might be a valid call to @f which might dynamically not return.
61 ; CHECK-LABEL: define void @test2(
62 ; CHECK: entry:
63 ; CHECK:   invoke void @f()
64 ; CHECK:     to label %[[exit:[^ ]+]] unwind label %cleanup
65 ; CHECK: cleanup:
66 ; CHECK:   cleanuppad within none []
67 ; CHECK:   call void @llvm.bar()
68 ; CHECK-NEXT: unreachable
69 ; CHECK: [[exit]]:
70 ; CHECK:   call void @llvm.bar()
71 ; CHECK-NEXT: ret void
72
73
74 define void @test3() personality i32 (...)* @__CxxFrameHandler3 {
75 entry:
76   invoke void @f()
77     to label %invoke.cont unwind label %catch.switch
78 invoke.cont:
79   invoke void @f()
80     to label %exit unwind label %cleanup
81 catch.switch:
82   %cs = catchswitch within none [label %catch] unwind to caller
83 catch:
84   catchpad within %cs []
85   br label %shared
86 cleanup:
87   cleanuppad within none []
88   br label %shared
89 shared:
90   call void @llvm.bar()
91   br label %exit
92 exit:
93   ret void
94 }
95 ; Need two copies of %shared's call to @f (similar to @test2 but
96 ; the two regions here are siblings, not parent-child).
97 ; CHECK-LABEL: define void @test3(
98 ; CHECK:   invoke void @f()
99 ; CHECK:   invoke void @f()
100 ; CHECK:     to label %[[exit:[^ ]+]] unwind
101 ; CHECK: catch:
102 ; CHECK:   catchpad within %cs []
103 ; CHECK-NEXT: call void @llvm.bar()
104 ; CHECK-NEXT: unreachable
105 ; CHECK: cleanup:
106 ; CHECK:   cleanuppad within none []
107 ; CHECK:   call void @llvm.bar()
108 ; CHECK-NEXT: unreachable
109 ; CHECK: [[exit]]:
110 ; CHECK:   ret void
111
112
113 define void @test4() personality i32 (...)* @__CxxFrameHandler3 {
114 entry:
115   invoke void @f()
116     to label %shared unwind label %catch.switch
117 catch.switch:
118   %cs = catchswitch within none [label %catch] unwind to caller
119 catch:
120   catchpad within %cs []
121   br label %shared
122 shared:
123   %x = call i32 @llvm.qux()
124   %i = call i32 @llvm.qux()
125   %zero.trip = icmp eq i32 %i, 0
126   br i1 %zero.trip, label %exit, label %loop
127 loop:
128   %i.loop = phi i32 [ %i, %shared ], [ %i.dec, %loop.tail ]
129   %b = call i1 @llvm.baz()
130   br i1 %b, label %left, label %right
131 left:
132   %y = call i32 @llvm.qux()
133   br label %loop.tail
134 right:
135   call void @llvm.foo(i32 %x)
136   br label %loop.tail
137 loop.tail:
138   %i.dec = sub i32 %i.loop, 1
139   %done = icmp eq i32 %i.dec, 0
140   br i1 %done, label %exit, label %loop
141 exit:
142   call void @llvm.foo(i32 %x)
143   unreachable
144 }
145 ; Make sure we can clone regions that have internal control
146 ; flow and SSA values.  Here we need two copies of everything
147 ; from %shared to %exit.
148 ; CHECK-LABEL: define void @test4(
149 ; CHECK:  entry:
150 ; CHECK:    to label %[[shared_E:[^ ]+]] unwind label %catch.switch
151 ; CHECK:  catch:
152 ; CHECK:    catchpad within %cs []
153 ; CHECK:    [[x_C:%[^ ]+]] = call i32 @llvm.qux()
154 ; CHECK:    [[i_C:%[^ ]+]] = call i32 @llvm.qux()
155 ; CHECK:    [[zt_C:%[^ ]+]] = icmp eq i32 [[i_C]], 0
156 ; CHECK:    br i1 [[zt_C]], label %[[exit_C:[^ ]+]], label %[[loop_C:[^ ]+]]
157 ; CHECK:  [[shared_E]]:
158 ; CHECK:    [[x_E:%[^ ]+]] = call i32 @llvm.qux()
159 ; CHECK:    [[i_E:%[^ ]+]] = call i32 @llvm.qux()
160 ; CHECK:    [[zt_E:%[^ ]+]] = icmp eq i32 [[i_E]], 0
161 ; CHECK:    br i1 [[zt_E]], label %[[exit_E:[^ ]+]], label %[[loop_E:[^ ]+]]
162 ; CHECK:  [[loop_C]]:
163 ; CHECK:    [[iloop_C:%[^ ]+]] = phi i32 [ [[i_C]], %catch ], [ [[idec_C:%[^ ]+]], %[[looptail_C:[^ ]+]] ]
164 ; CHECK:    [[b_C:%[^ ]+]] = call i1 @llvm.baz()
165 ; CHECK:    br i1 [[b_C]], label %[[left_C:[^ ]+]], label %[[right_C:[^ ]+]]
166 ; CHECK:  [[loop_E]]:
167 ; CHECK:    [[iloop_E:%[^ ]+]] = phi i32 [ [[i_E]], %[[shared_E]] ], [ [[idec_E:%[^ ]+]], %[[looptail_E:[^ ]+]] ]
168 ; CHECK:    [[b_E:%[^ ]+]] = call i1 @llvm.baz()
169 ; CHECK:    br i1 [[b_E]], label %[[left_E:[^ ]+]], label %[[right_E:[^ ]+]]
170 ; CHECK:  [[left_C]]:
171 ; CHECK:    [[y_C:%[^ ]+]] = call i32 @llvm.qux()
172 ; CHECK:    br label %[[looptail_C]]
173 ; CHECK:  [[left_E]]:
174 ; CHECK:    [[y_E:%[^ ]+]] = call i32 @llvm.qux()
175 ; CHECK:    br label %[[looptail_E]]
176 ; CHECK:  [[right_C]]:
177 ; CHECK:    call void @llvm.foo(i32 [[x_C]])
178 ; CHECK:    br label %[[looptail_C]]
179 ; CHECK:  [[right_E]]:
180 ; CHECK:    call void @llvm.foo(i32 [[x_E]])
181 ; CHECK:    br label %[[looptail_E]]
182 ; CHECK:  [[looptail_C]]:
183 ; CHECK:    [[idec_C]] = sub i32 [[iloop_C]], 1
184 ; CHECK:    [[done_C:%[^ ]+]] = icmp eq i32 [[idec_C]], 0
185 ; CHECK:    br i1 [[done_C]], label %[[exit_C]], label %[[loop_C]]
186 ; CHECK:  [[looptail_E]]:
187 ; CHECK:    [[idec_E]] = sub i32 [[iloop_E]], 1
188 ; CHECK:    [[done_E:%[^ ]+]] = icmp eq i32 [[idec_E]], 0
189 ; CHECK:    br i1 [[done_E]], label %[[exit_E]], label %[[loop_E]]
190 ; CHECK:  [[exit_C]]:
191 ; CHECK:    call void @llvm.foo(i32 [[x_C]])
192 ; CHECK:    unreachable
193 ; CHECK:  [[exit_E]]:
194 ; CHECK:    call void @llvm.foo(i32 [[x_E]])
195 ; CHECK:    unreachable
196
197
198 define void @test5() personality i32 (...)* @__C_specific_handler {
199 entry:
200   invoke void @f()
201     to label %exit unwind label %outer
202 outer:
203   %o = cleanuppad within none []
204   %x = call i32 @llvm.qux()
205   invoke void @f() [ "funclet"(token %o) ]
206     to label %outer.ret unwind label %catch.switch
207 catch.switch:
208   %cs = catchswitch within %o [label %inner] unwind to caller
209 inner:
210   %i = catchpad within %cs []
211   catchret from %i to label %outer.post-inner
212 outer.post-inner:
213   call void @llvm.foo(i32 %x)
214   br label %outer.ret
215 outer.ret:
216   cleanupret from %o unwind to caller
217 exit:
218   ret void
219 }
220 ; Simple nested case (catch-inside-cleanup).  Nothing needs
221 ; to be cloned.  The def and use of %x are both in %outer
222 ; and so don't need to be spilled.
223 ; CHECK-LABEL: define void @test5(
224 ; CHECK:      outer:
225 ; CHECK:        %x = call i32 @llvm.qux()
226 ; CHECK-NEXT:   invoke void @f()
227 ; CHECK-NEXT:     to label %outer.ret unwind label %catch.switch
228 ; CHECK:      inner:
229 ; CHECK-NEXT:   %i = catchpad within %cs []
230 ; CHECK-NEXT:   catchret from %i to label %outer.post-inner
231 ; CHECK:      outer.post-inner:
232 ; CHECK-NEXT:   call void @llvm.foo(i32 %x)
233 ; CHECK-NEXT:   br label %outer.ret
234
235
236 define void @test9() personality i32 (...)* @__C_specific_handler {
237 entry:
238   invoke void @f()
239     to label %invoke.cont unwind label %left
240 invoke.cont:
241   invoke void @f()
242     to label %unreachable unwind label %right
243 left:
244   %cp.left = cleanuppad within none []
245   call void @llvm.foo(i32 1)
246   invoke void @f() [ "funclet"(token %cp.left) ]
247     to label %unreachable unwind label %right
248 right:
249   %cp.right = cleanuppad within none []
250   call void @llvm.foo(i32 2)
251   invoke void @f() [ "funclet"(token %cp.right) ]
252     to label %unreachable unwind label %left
253 unreachable:
254   unreachable
255 }
256 ; This is an irreducible loop with two funclets that enter each other.
257 ; CHECK-LABEL: define void @test9(
258 ; CHECK:     entry:
259 ; CHECK:               to label %invoke.cont unwind label %[[LEFT:.+]]
260 ; CHECK:     invoke.cont:
261 ; CHECK:               to label %[[UNREACHABLE_ENTRY:.+]] unwind label %[[RIGHT:.+]]
262 ; CHECK:     [[LEFT]]:
263 ; CHECK:       call void @llvm.foo(i32 1)
264 ; CHECK:       invoke void @f()
265 ; CHECK:               to label %[[UNREACHABLE_LEFT:.+]] unwind label %[[RIGHT]]
266 ; CHECK:     [[RIGHT]]:
267 ; CHECK:       call void @llvm.foo(i32 2)
268 ; CHECK:       invoke void @f()
269 ; CHECK:               to label %[[UNREACHABLE_RIGHT:.+]] unwind label %[[LEFT]]
270 ; CHECK:     [[UNREACHABLE_RIGHT]]:
271 ; CHECK:       unreachable
272 ; CHECK:     [[UNREACHABLE_LEFT]]:
273 ; CHECK:       unreachable
274 ; CHECK:     [[UNREACHABLE_ENTRY]]:
275 ; CHECK:       unreachable
276
277
278 define void @test10() personality i32 (...)* @__CxxFrameHandler3 {
279 entry:
280   invoke void @f()
281     to label %unreachable unwind label %inner
282 inner:
283   %cleanup = cleanuppad within none []
284   ; make sure we don't overlook this cleanupret and try to process
285   ; successor %outer as a child of inner.
286   cleanupret from %cleanup unwind label %outer
287 outer:
288   %cs = catchswitch within none [label %catch.body] unwind to caller
289
290 catch.body:
291   %catch = catchpad within %cs []
292   catchret from %catch to label %exit
293 exit:
294   ret void
295 unreachable:
296   unreachable
297 }
298 ; CHECK-LABEL: define void @test10(
299 ; CHECK-NEXT: entry:
300 ; CHECK-NEXT:   invoke
301 ; CHECK-NEXT:     to label %unreachable unwind label %inner
302 ; CHECK:      inner:
303 ; CHECK-NEXT:   %cleanup = cleanuppad within none []
304 ; CHECK-NEXT:   cleanupret from %cleanup unwind label %outer
305 ; CHECK:      outer:
306 ; CHECK-NEXT:   %cs = catchswitch within none [label %catch.body] unwind to caller
307 ; CHECK:      catch.body:
308 ; CHECK-NEXT:   %catch = catchpad within %cs []
309 ; CHECK-NEXT:   catchret from %catch to label %exit
310 ; CHECK:      exit:
311 ; CHECK-NEXT:   ret void
312
313 define void @test11() personality i32 (...)* @__C_specific_handler {
314 entry:
315   invoke void @f()
316     to label %exit unwind label %cleanup.outer
317 cleanup.outer:
318   %outer = cleanuppad within none []
319   invoke void @f() [ "funclet"(token %outer) ]
320     to label %outer.cont unwind label %cleanup.inner
321 outer.cont:
322   br label %merge
323 cleanup.inner:
324   %inner = cleanuppad within %outer []
325   br label %merge
326 merge:
327   call void @llvm.bar()
328   unreachable
329 exit:
330   ret void
331 }
332 ; merge.end will get cloned for outer and inner, but is implausible
333 ; from inner, so the call @f() in inner's copy of merge should be
334 ; rewritten to call @f()
335 ; CHECK-LABEL: define void @test11()
336 ; CHECK:      %inner = cleanuppad within %outer []
337 ; CHECK-NEXT: call void @llvm.bar()
338 ; CHECK-NEXT: unreachable
339
340 define void @test12() personality i32 (...)* @__CxxFrameHandler3 !dbg !5 {
341 entry:
342   invoke void @f()
343     to label %cont unwind label %left, !dbg !8
344 cont:
345   invoke void @f()
346     to label %exit unwind label %right
347 left:
348   cleanuppad within none []
349   br label %join
350 right:
351   cleanuppad within none []
352   br label %join
353 join:
354   ; This call will get cloned; make sure we can handle cloning
355   ; instructions with debug metadata attached.
356   call void @llvm.bar(), !dbg !9
357   unreachable
358 exit:
359   ret void
360 }
361
362 ; CHECK-LABEL: define void @test13()
363 ; CHECK: ret void
364 define void @test13() personality i32 (...)* @__CxxFrameHandler3 {
365 entry:
366   ret void
367
368 unreachable:
369   cleanuppad within none []
370   unreachable
371 }
372
373 define void @test14() personality void (...)* @ProcessCLRException {
374 entry:
375   invoke void @f()
376     to label %cont unwind label %cleanup
377 cont:
378   invoke void @f()
379     to label %exit unwind label %switch.outer
380 cleanup:
381   %cleanpad = cleanuppad within none []
382   invoke void @f() [ "funclet" (token %cleanpad) ]
383     to label %cleanret unwind label %switch.inner
384 switch.inner:
385   %cs.inner = catchswitch within %cleanpad [label %pad.inner] unwind to caller
386 pad.inner:
387   %cp.inner = catchpad within %cs.inner [i32 1]
388   catchret from %cp.inner to label %join
389 cleanret:
390   cleanupret from %cleanpad unwind to caller
391 switch.outer:
392   %cs.outer = catchswitch within none [label %pad.outer] unwind to caller
393 pad.outer:
394   %cp.outer = catchpad within %cs.outer [i32 2]
395   catchret from %cp.outer to label %join
396 join:
397   %phi = phi i32 [ 1, %pad.inner ], [ 2, %pad.outer ]
398   call void @llvm.foo(i32 %phi)
399   unreachable
400 exit:
401   ret void
402 }
403 ; Both catchrets target %join, but the catchret from %cp.inner
404 ; returns to %cleanpad and the catchret from %cp.outer returns to the
405 ; main function, so %join needs to get cloned and one of the cleanuprets
406 ; needs to be updated to target the clone
407 ; CHECK-LABEL: define void @test14()
408 ; CHECK: catchret from %cp.inner to label %[[Clone1:.+]]
409 ; CHECK: catchret from %cp.outer to label %[[Clone2:.+]]
410 ; CHECK: [[Clone1]]:
411 ; CHECK-NEXT: call void @llvm.foo(i32 1)
412 ; CHECK-NEXT: unreachable
413 ; CHECK: [[Clone2]]:
414 ; CHECK-NEXT: call void @llvm.foo(i32 2)
415 ; CHECK-NEXT: unreachable
416
417 ;; Debug info (from test12)
418
419 ; Make sure the DISubprogram doesn't get cloned
420 ; CHECK-LABEL: !llvm.module.flags
421 ; CHECK-NOT: !DISubprogram
422 ; CHECK: !{{[0-9]+}} = distinct !DISubprogram(name: "test12"
423 ; CHECK-NOT: !DISubprogram
424 !llvm.module.flags = !{!0}
425 !llvm.dbg.cu = !{!1}
426
427 !0 = !{i32 2, !"Debug Info Version", i32 3}
428 !1 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus, file: !2, producer: "compiler", isOptimized: false, runtimeVersion: 0, emissionKind: 1, enums: !3, subprograms: !4)
429 !2 = !DIFile(filename: "test.cpp", directory: ".")
430 !3 = !{}
431 !4 = !{!5}
432 !5 = distinct !DISubprogram(name: "test12", scope: !2, file: !2, type: !6, isLocal: false, isDefinition: true, scopeLine: 3, flags: DIFlagPrototyped, isOptimized: true, variables: !3)
433 !6 = !DISubroutineType(types: !7)
434 !7 = !{null}
435 !8 = !DILocation(line: 1, scope: !5)
436 !9 = !DILocation(line: 2, scope: !5)