1 ; RUN: opt -basicaa -objc-arc -S < %s | FileCheck %s
3 target datalayout = "e-p:64:64:64"
5 declare i8* @objc_retain(i8*)
6 declare i8* @objc_retainAutoreleasedReturnValue(i8*)
7 declare void @objc_release(i8*)
8 declare i8* @objc_autorelease(i8*)
9 declare i8* @objc_autoreleaseReturnValue(i8*)
10 declare void @objc_autoreleasePoolPop(i8*)
11 declare i8* @objc_autoreleasePoolPush()
12 declare i8* @objc_retainBlock(i8*)
14 declare i8* @objc_retainedObject(i8*)
15 declare i8* @objc_unretainedObject(i8*)
16 declare i8* @objc_unretainedPointer(i8*)
18 declare void @use_pointer(i8*)
19 declare void @callee()
20 declare void @callee_fnptr(void ()*)
21 declare void @invokee()
22 declare i8* @returner()
23 declare void @bar(i32 ()*)
25 declare void @llvm.dbg.value(metadata, i64, metadata, metadata)
27 declare i8* @objc_msgSend(i8*, i8*, ...)
29 ; Simple retain+release pair deletion, with some intervening control
30 ; flow and harmless instructions.
32 ; CHECK: define void @test0_precise(i32* %x, i1 %p) [[NUW:#[0-9]+]] {
33 ; CHECK: @objc_retain
34 ; CHECK: @objc_release
35 ; CHECK: }
36 define void @test0_precise(i32* %x, i1 %p) nounwind {
37 entry:
38 %a = bitcast i32* %x to i8*
39 %0 = call i8* @objc_retain(i8* %a) nounwind
40 br i1 %p, label %t, label %f
42 t:
43 store i8 3, i8* %a
44 %b = bitcast i32* %x to float*
45 store float 2.0, float* %b
46 br label %return
48 f:
49 store i32 7, i32* %x
50 br label %return
52 return:
53 %c = bitcast i32* %x to i8*
54 call void @objc_release(i8* %c) nounwind
55 ret void
56 }
58 ; CHECK: define void @test0_imprecise(i32* %x, i1 %p) [[NUW]] {
59 ; CHECK-NOT: @objc_
60 ; CHECK: }
61 define void @test0_imprecise(i32* %x, i1 %p) nounwind {
62 entry:
63 %a = bitcast i32* %x to i8*
64 %0 = call i8* @objc_retain(i8* %a) nounwind
65 br i1 %p, label %t, label %f
67 t:
68 store i8 3, i8* %a
69 %b = bitcast i32* %x to float*
70 store float 2.0, float* %b
71 br label %return
73 f:
74 store i32 7, i32* %x
75 br label %return
77 return:
78 %c = bitcast i32* %x to i8*
79 call void @objc_release(i8* %c) nounwind, !clang.imprecise_release !0
80 ret void
81 }
83 ; Like test0 but the release isn't always executed when the retain is,
84 ; so the optimization is not safe.
86 ; TODO: Make the objc_release's argument be %0.
88 ; CHECK: define void @test1_precise(i32* %x, i1 %p, i1 %q) [[NUW]] {
89 ; CHECK: @objc_retain(i8* %a)
90 ; CHECK: @objc_release
91 ; CHECK: }
92 define void @test1_precise(i32* %x, i1 %p, i1 %q) nounwind {
93 entry:
94 %a = bitcast i32* %x to i8*
95 %0 = call i8* @objc_retain(i8* %a) nounwind
96 br i1 %p, label %t, label %f
98 t:
99 store i8 3, i8* %a
100 %b = bitcast i32* %x to float*
101 store float 2.0, float* %b
102 br label %return
104 f:
105 store i32 7, i32* %x
106 call void @callee()
107 br i1 %q, label %return, label %alt_return
109 return:
110 %c = bitcast i32* %x to i8*
111 call void @objc_release(i8* %c) nounwind
112 ret void
114 alt_return:
115 ret void
116 }
118 ; CHECK: define void @test1_imprecise(i32* %x, i1 %p, i1 %q) [[NUW]] {
119 ; CHECK: @objc_retain(i8* %a)
120 ; CHECK: @objc_release
121 ; CHECK: }
122 define void @test1_imprecise(i32* %x, i1 %p, i1 %q) nounwind {
123 entry:
124 %a = bitcast i32* %x to i8*
125 %0 = call i8* @objc_retain(i8* %a) nounwind
126 br i1 %p, label %t, label %f
128 t:
129 store i8 3, i8* %a
130 %b = bitcast i32* %x to float*
131 store float 2.0, float* %b
132 br label %return
134 f:
135 store i32 7, i32* %x
136 call void @callee()
137 br i1 %q, label %return, label %alt_return
139 return:
140 %c = bitcast i32* %x to i8*
141 call void @objc_release(i8* %c) nounwind, !clang.imprecise_release !0
142 ret void
144 alt_return:
145 ret void
146 }
149 ; Don't do partial elimination into two different CFG diamonds.
151 ; CHECK: define void @test1b_precise(i8* %x, i1 %p, i1 %q) {
152 ; CHECK: entry:
153 ; CHECK: tail call i8* @objc_retain(i8* %x) [[NUW]]
154 ; CHECK-NOT: @objc_
155 ; CHECK: if.end5:
156 ; CHECK: tail call void @objc_release(i8* %x) [[NUW]]
157 ; CHECK-NOT: @objc_
158 ; CHECK: }
159 define void @test1b_precise(i8* %x, i1 %p, i1 %q) {
160 entry:
161 tail call i8* @objc_retain(i8* %x) nounwind
162 br i1 %p, label %if.then, label %if.end
164 if.then: ; preds = %entry
165 tail call void @callee()
166 br label %if.end
168 if.end: ; preds = %if.then, %entry
169 br i1 %q, label %if.then3, label %if.end5
171 if.then3: ; preds = %if.end
172 tail call void @use_pointer(i8* %x)
173 br label %if.end5
175 if.end5: ; preds = %if.then3, %if.end
176 tail call void @objc_release(i8* %x) nounwind
177 ret void
178 }
180 ; CHECK-LABEL: define void @test1b_imprecise(
181 ; CHECK: entry:
182 ; CHECK: tail call i8* @objc_retain(i8* %x) [[NUW:#[0-9]+]]
183 ; CHECK-NOT: @objc_
184 ; CHECK: if.end5:
185 ; CHECK: tail call void @objc_release(i8* %x) [[NUW]], !clang.imprecise_release ![[RELEASE:[0-9]+]]
186 ; CHECK-NOT: @objc_
187 ; CHECK: }
188 define void @test1b_imprecise(i8* %x, i1 %p, i1 %q) {
189 entry:
190 tail call i8* @objc_retain(i8* %x) nounwind
191 br i1 %p, label %if.then, label %if.end
193 if.then: ; preds = %entry
194 tail call void @callee()
195 br label %if.end
197 if.end: ; preds = %if.then, %entry
198 br i1 %q, label %if.then3, label %if.end5
200 if.then3: ; preds = %if.end
201 tail call void @use_pointer(i8* %x)
202 br label %if.end5
204 if.end5: ; preds = %if.then3, %if.end
205 tail call void @objc_release(i8* %x) nounwind, !clang.imprecise_release !0
206 ret void
207 }
210 ; Like test0 but the pointer is passed to an intervening call,
211 ; so the optimization is not safe.
213 ; CHECK-LABEL: define void @test2_precise(
214 ; CHECK: @objc_retain(i8* %a)
215 ; CHECK: @objc_release
216 ; CHECK: }
217 define void @test2_precise(i32* %x, i1 %p) nounwind {
218 entry:
219 %a = bitcast i32* %x to i8*
220 %0 = call i8* @objc_retain(i8* %a) nounwind
221 br i1 %p, label %t, label %f
223 t:
224 store i8 3, i8* %a
225 %b = bitcast i32* %x to float*
226 store float 2.0, float* %b
227 br label %return
229 f:
230 store i32 7, i32* %x
231 call void @use_pointer(i8* %0)
232 %d = bitcast i32* %x to float*
233 store float 3.0, float* %d
234 br label %return
236 return:
237 %c = bitcast i32* %x to i8*
238 call void @objc_release(i8* %c) nounwind
239 ret void
240 }
242 ; CHECK-LABEL: define void @test2_imprecise(
243 ; CHECK: @objc_retain(i8* %a)
244 ; CHECK: @objc_release
245 ; CHECK: }
246 define void @test2_imprecise(i32* %x, i1 %p) nounwind {
247 entry:
248 %a = bitcast i32* %x to i8*
249 %0 = call i8* @objc_retain(i8* %a) nounwind
250 br i1 %p, label %t, label %f
252 t:
253 store i8 3, i8* %a
254 %b = bitcast i32* %x to float*
255 store float 2.0, float* %b
256 br label %return
258 f:
259 store i32 7, i32* %x
260 call void @use_pointer(i8* %0)
261 %d = bitcast i32* %x to float*
262 store float 3.0, float* %d
263 br label %return
265 return:
266 %c = bitcast i32* %x to i8*
267 call void @objc_release(i8* %c) nounwind, !clang.imprecise_release !0
268 ret void
269 }
271 ; Like test0 but the release is in a loop,
272 ; so the optimization is not safe.
274 ; TODO: For now, assume this can't happen.
276 ; CHECK-LABEL: define void @test3_precise(
277 ; TODO: @objc_retain(i8* %a)
278 ; TODO: @objc_release
279 ; CHECK: }
280 define void @test3_precise(i32* %x, i1* %q) nounwind {
281 entry:
282 %a = bitcast i32* %x to i8*
283 %0 = call i8* @objc_retain(i8* %a) nounwind
284 br label %loop
286 loop:
287 %c = bitcast i32* %x to i8*
288 call void @objc_release(i8* %c) nounwind
289 %j = load volatile i1* %q
290 br i1 %j, label %loop, label %return
292 return:
293 ret void
294 }
296 ; CHECK-LABEL: define void @test3_imprecise(
297 ; TODO: @objc_retain(i8* %a)
298 ; TODO: @objc_release
299 ; CHECK: }
300 define void @test3_imprecise(i32* %x, i1* %q) nounwind {
301 entry:
302 %a = bitcast i32* %x to i8*
303 %0 = call i8* @objc_retain(i8* %a) nounwind
304 br label %loop
306 loop:
307 %c = bitcast i32* %x to i8*
308 call void @objc_release(i8* %c) nounwind, !clang.imprecise_release !0
309 %j = load volatile i1* %q
310 br i1 %j, label %loop, label %return
312 return:
313 ret void
314 }
317 ; TODO: For now, assume this can't happen.
319 ; Like test0 but the retain is in a loop,
320 ; so the optimization is not safe.
322 ; CHECK-LABEL: define void @test4_precise(
323 ; TODO: @objc_retain(i8* %a)
324 ; TODO: @objc_release
325 ; CHECK: }
326 define void @test4_precise(i32* %x, i1* %q) nounwind {
327 entry:
328 br label %loop
330 loop:
331 %a = bitcast i32* %x to i8*
332 %0 = call i8* @objc_retain(i8* %a) nounwind
333 %j = load volatile i1* %q
334 br i1 %j, label %loop, label %return
336 return:
337 %c = bitcast i32* %x to i8*
338 call void @objc_release(i8* %c) nounwind
339 ret void
340 }
342 ; CHECK-LABEL: define void @test4_imprecise(
343 ; TODO: @objc_retain(i8* %a)
344 ; TODO: @objc_release
345 ; CHECK: }
346 define void @test4_imprecise(i32* %x, i1* %q) nounwind {
347 entry:
348 br label %loop
350 loop:
351 %a = bitcast i32* %x to i8*
352 %0 = call i8* @objc_retain(i8* %a) nounwind
353 %j = load volatile i1* %q
354 br i1 %j, label %loop, label %return
356 return:
357 %c = bitcast i32* %x to i8*
358 call void @objc_release(i8* %c) nounwind, !clang.imprecise_release !0
359 ret void
360 }
363 ; Like test0 but the pointer is conditionally passed to an intervening call,
364 ; so the optimization is not safe.
366 ; CHECK-LABEL: define void @test5a(
367 ; CHECK: @objc_retain(i8*
368 ; CHECK: @objc_release
369 ; CHECK: }
370 define void @test5a(i32* %x, i1 %q, i8* %y) nounwind {
371 entry:
372 %a = bitcast i32* %x to i8*
373 %0 = call i8* @objc_retain(i8* %a) nounwind
374 %s = select i1 %q, i8* %y, i8* %0
375 call void @use_pointer(i8* %s)
376 store i32 7, i32* %x
377 %c = bitcast i32* %x to i8*
378 call void @objc_release(i8* %c) nounwind
379 ret void
380 }
382 ; CHECK-LABEL: define void @test5b(
383 ; CHECK: @objc_retain(i8*
384 ; CHECK: @objc_release
385 ; CHECK: }
386 define void @test5b(i32* %x, i1 %q, i8* %y) nounwind {
387 entry:
388 %a = bitcast i32* %x to i8*
389 %0 = call i8* @objc_retain(i8* %a) nounwind
390 %s = select i1 %q, i8* %y, i8* %0
391 call void @use_pointer(i8* %s)
392 store i32 7, i32* %x
393 %c = bitcast i32* %x to i8*
394 call void @objc_release(i8* %c) nounwind, !clang.imprecise_release !0
395 ret void
396 }
399 ; retain+release pair deletion, where the release happens on two different
400 ; flow paths.
402 ; CHECK-LABEL: define void @test6a(
403 ; CHECK: entry:
404 ; CHECK: tail call i8* @objc_retain(
405 ; CHECK: t:
406 ; CHECK: call void @objc_release(
407 ; CHECK: f:
408 ; CHECK: call void @objc_release(
409 ; CHECK: return:
410 ; CHECK: }
411 define void @test6a(i32* %x, i1 %p) nounwind {
412 entry:
413 %a = bitcast i32* %x to i8*
414 %0 = call i8* @objc_retain(i8* %a) nounwind
415 br i1 %p, label %t, label %f
417 t:
418 store i8 3, i8* %a
419 %b = bitcast i32* %x to float*
420 store float 2.0, float* %b
421 %ct = bitcast i32* %x to i8*
422 call void @objc_release(i8* %ct) nounwind
423 br label %return
425 f:
426 store i32 7, i32* %x
427 call void @callee()
428 %cf = bitcast i32* %x to i8*
429 call void @objc_release(i8* %cf) nounwind
430 br label %return
432 return:
433 ret void
434 }
436 ; CHECK-LABEL: define void @test6b(
437 ; CHECK-NOT: @objc_
438 ; CHECK: }
439 define void @test6b(i32* %x, i1 %p) nounwind {
440 entry:
441 %a = bitcast i32* %x to i8*
442 %0 = call i8* @objc_retain(i8* %a) nounwind
443 br i1 %p, label %t, label %f
445 t:
446 store i8 3, i8* %a
447 %b = bitcast i32* %x to float*
448 store float 2.0, float* %b
449 %ct = bitcast i32* %x to i8*
450 call void @objc_release(i8* %ct) nounwind, !clang.imprecise_release !0
451 br label %return
453 f:
454 store i32 7, i32* %x
455 call void @callee()
456 %cf = bitcast i32* %x to i8*
457 call void @objc_release(i8* %cf) nounwind, !clang.imprecise_release !0
458 br label %return
460 return:
461 ret void
462 }
464 ; CHECK-LABEL: define void @test6c(
465 ; CHECK: entry:
466 ; CHECK: tail call i8* @objc_retain(
467 ; CHECK: t:
468 ; CHECK: call void @objc_release(
469 ; CHECK: f:
470 ; CHECK: call void @objc_release(
471 ; CHECK: return:
472 ; CHECK: }
473 define void @test6c(i32* %x, i1 %p) nounwind {
474 entry:
475 %a = bitcast i32* %x to i8*
476 %0 = call i8* @objc_retain(i8* %a) nounwind
477 br i1 %p, label %t, label %f
479 t:
480 store i8 3, i8* %a
481 %b = bitcast i32* %x to float*
482 store float 2.0, float* %b
483 %ct = bitcast i32* %x to i8*
484 call void @objc_release(i8* %ct) nounwind
485 br label %return
487 f:
488 store i32 7, i32* %x
489 call void @callee()
490 %cf = bitcast i32* %x to i8*
491 call void @objc_release(i8* %cf) nounwind, !clang.imprecise_release !0
492 br label %return
494 return:
495 ret void
496 }
498 ; CHECK-LABEL: define void @test6d(
499 ; CHECK: entry:
500 ; CHECK: tail call i8* @objc_retain(
501 ; CHECK: t:
502 ; CHECK: call void @objc_release(
503 ; CHECK: f:
504 ; CHECK: call void @objc_release(
505 ; CHECK: return:
506 ; CHECK: }
507 define void @test6d(i32* %x, i1 %p) nounwind {
508 entry:
509 %a = bitcast i32* %x to i8*
510 %0 = call i8* @objc_retain(i8* %a) nounwind
511 br i1 %p, label %t, label %f
513 t:
514 store i8 3, i8* %a
515 %b = bitcast i32* %x to float*
516 store float 2.0, float* %b
517 %ct = bitcast i32* %x to i8*
518 call void @objc_release(i8* %ct) nounwind, !clang.imprecise_release !0
519 br label %return
521 f:
522 store i32 7, i32* %x
523 call void @callee()
524 %cf = bitcast i32* %x to i8*
525 call void @objc_release(i8* %cf) nounwind
526 br label %return
528 return:
529 ret void
530 }
533 ; retain+release pair deletion, where the retain happens on two different
534 ; flow paths.
536 ; CHECK-LABEL: define void @test7(
537 ; CHECK: entry:
538 ; CHECK-NOT: objc_
539 ; CHECK: t:
540 ; CHECK: call i8* @objc_retain
541 ; CHECK: f:
542 ; CHECK: call i8* @objc_retain
543 ; CHECK: return:
544 ; CHECK: call void @objc_release
545 ; CHECK: }
546 define void @test7(i32* %x, i1 %p) nounwind {
547 entry:
548 %a = bitcast i32* %x to i8*
549 br i1 %p, label %t, label %f
551 t:
552 %0 = call i8* @objc_retain(i8* %a) nounwind
553 store i8 3, i8* %a
554 %b = bitcast i32* %x to float*
555 store float 2.0, float* %b
556 br label %return
558 f:
559 %1 = call i8* @objc_retain(i8* %a) nounwind
560 store i32 7, i32* %x
561 call void @callee()
562 br label %return
564 return:
565 %c = bitcast i32* %x to i8*
566 call void @objc_release(i8* %c) nounwind
567 ret void
568 }
570 ; CHECK-LABEL: define void @test7b(
571 ; CHECK-NOT: @objc_
572 ; CHECK: }
573 define void @test7b(i32* %x, i1 %p) nounwind {
574 entry:
575 %a = bitcast i32* %x to i8*
576 br i1 %p, label %t, label %f
578 t:
579 %0 = call i8* @objc_retain(i8* %a) nounwind
580 store i8 3, i8* %a
581 %b = bitcast i32* %x to float*
582 store float 2.0, float* %b
583 br label %return
585 f:
586 %1 = call i8* @objc_retain(i8* %a) nounwind
587 store i32 7, i32* %x
588 call void @callee()
589 br label %return
591 return:
592 %c = bitcast i32* %x to i8*
593 call void @objc_release(i8* %c) nounwind, !clang.imprecise_release !0
594 ret void
595 }
597 ; Like test7, but there's a retain/retainBlock mismatch. Don't delete!
599 ; CHECK-LABEL: define void @test7c(
600 ; CHECK: t:
601 ; CHECK: call i8* @objc_retainBlock
602 ; CHECK: f:
603 ; CHECK: call i8* @objc_retain
604 ; CHECK: return:
605 ; CHECK: call void @objc_release
606 ; CHECK: }
607 define void @test7c(i32* %x, i1 %p) nounwind {
608 entry:
609 %a = bitcast i32* %x to i8*
610 br i1 %p, label %t, label %f
612 t:
613 %0 = call i8* @objc_retainBlock(i8* %a) nounwind
614 store i8 3, i8* %a
615 %b = bitcast i32* %x to float*
616 store float 2.0, float* %b
617 br label %return
619 f:
620 %1 = call i8* @objc_retain(i8* %a) nounwind
621 store i32 7, i32* %x
622 call void @callee()
623 br label %return
625 return:
626 %c = bitcast i32* %x to i8*
627 call void @objc_release(i8* %c) nounwind
628 ret void
629 }
631 ; retain+release pair deletion, where the retain and release both happen on
632 ; different flow paths. Wild!
634 ; CHECK-LABEL: define void @test8a(
635 ; CHECK: entry:
636 ; CHECK: t:
637 ; CHECK: @objc_retain
638 ; CHECK: f:
639 ; CHECK: @objc_retain
640 ; CHECK: mid:
641 ; CHECK: u:
642 ; CHECK: @objc_release
643 ; CHECK: g:
644 ; CHECK: @objc_release
645 ; CHECK: return:
646 ; CHECK: }
647 define void @test8a(i32* %x, i1 %p, i1 %q) nounwind {
648 entry:
649 %a = bitcast i32* %x to i8*
650 br i1 %p, label %t, label %f
652 t:
653 %0 = call i8* @objc_retain(i8* %a) nounwind
654 store i8 3, i8* %a
655 %b = bitcast i32* %x to float*
656 store float 2.0, float* %b
657 br label %mid
659 f:
660 %1 = call i8* @objc_retain(i8* %a) nounwind
661 store i32 7, i32* %x
662 br label %mid
664 mid:
665 br i1 %q, label %u, label %g
667 u:
668 call void @callee()
669 %cu = bitcast i32* %x to i8*
670 call void @objc_release(i8* %cu) nounwind
671 br label %return
673 g:
674 %cg = bitcast i32* %x to i8*
675 call void @objc_release(i8* %cg) nounwind
676 br label %return
678 return:
679 ret void
680 }
682 ; CHECK-LABEL: define void @test8b(
683 ; CHECK-NOT: @objc_
684 ; CHECK: }
685 define void @test8b(i32* %x, i1 %p, i1 %q) nounwind {
686 entry:
687 %a = bitcast i32* %x to i8*
688 br i1 %p, label %t, label %f
690 t:
691 %0 = call i8* @objc_retain(i8* %a) nounwind
692 store i8 3, i8* %a
693 %b = bitcast i32* %x to float*
694 store float 2.0, float* %b
695 br label %mid
697 f:
698 %1 = call i8* @objc_retain(i8* %a) nounwind
699 store i32 7, i32* %x
700 br label %mid
702 mid:
703 br i1 %q, label %u, label %g
705 u:
706 call void @callee()
707 %cu = bitcast i32* %x to i8*
708 call void @objc_release(i8* %cu) nounwind, !clang.imprecise_release !0
709 br label %return
711 g:
712 %cg = bitcast i32* %x to i8*
713 call void @objc_release(i8* %cg) nounwind, !clang.imprecise_release !0
714 br label %return
716 return:
717 ret void
718 }
720 ; CHECK-LABEL: define void @test8c(
721 ; CHECK: entry:
722 ; CHECK: t:
723 ; CHECK: @objc_retain
724 ; CHECK: f:
725 ; CHECK: @objc_retain
726 ; CHECK: mid:
727 ; CHECK: u:
728 ; CHECK: @objc_release
729 ; CHECK: g:
730 ; CHECK: @objc_release
731 ; CHECK: return:
732 ; CHECK: }
733 define void @test8c(i32* %x, i1 %p, i1 %q) nounwind {
734 entry:
735 %a = bitcast i32* %x to i8*
736 br i1 %p, label %t, label %f
738 t:
739 %0 = call i8* @objc_retain(i8* %a) nounwind
740 store i8 3, i8* %a
741 %b = bitcast i32* %x to float*
742 store float 2.0, float* %b
743 br label %mid
745 f:
746 %1 = call i8* @objc_retain(i8* %a) nounwind
747 store i32 7, i32* %x
748 br label %mid
750 mid:
751 br i1 %q, label %u, label %g
753 u:
754 call void @callee()
755 %cu = bitcast i32* %x to i8*
756 call void @objc_release(i8* %cu) nounwind
757 br label %return
759 g:
760 %cg = bitcast i32* %x to i8*
761 call void @objc_release(i8* %cg) nounwind, !clang.imprecise_release !0
762 br label %return
764 return:
765 ret void
766 }
768 ; CHECK-LABEL: define void @test8d(
769 ; CHECK: entry:
770 ; CHECK: t:
771 ; CHECK: @objc_retain
772 ; CHECK: f:
773 ; CHECK: @objc_retain
774 ; CHECK: mid:
775 ; CHECK: u:
776 ; CHECK: @objc_release
777 ; CHECK: g:
778 ; CHECK: @objc_release
779 ; CHECK: return:
780 ; CHECK: }
781 define void @test8d(i32* %x, i1 %p, i1 %q) nounwind {
782 entry:
783 %a = bitcast i32* %x to i8*
784 br i1 %p, label %t, label %f
786 t:
787 %0 = call i8* @objc_retain(i8* %a) nounwind
788 store i8 3, i8* %a
789 %b = bitcast i32* %x to float*
790 store float 2.0, float* %b
791 br label %mid
793 f:
794 %1 = call i8* @objc_retain(i8* %a) nounwind
795 store i32 7, i32* %x
796 br label %mid
798 mid:
799 br i1 %q, label %u, label %g
801 u:
802 call void @callee()
803 %cu = bitcast i32* %x to i8*
804 call void @objc_release(i8* %cu) nounwind, !clang.imprecise_release !0
805 br label %return
807 g:
808 %cg = bitcast i32* %x to i8*
809 call void @objc_release(i8* %cg) nounwind
810 br label %return
812 return:
813 ret void
814 }
816 ; Trivial retain+release pair deletion.
818 ; CHECK-LABEL: define void @test9(
819 ; CHECK-NOT: @objc_
820 ; CHECK: }
821 define void @test9(i8* %x) nounwind {
822 entry:
823 %0 = call i8* @objc_retain(i8* %x) nounwind
824 call void @objc_release(i8* %0) nounwind
825 ret void
826 }
828 ; Retain+release pair, but on an unknown pointer relationship. Don't delete!
830 ; CHECK-LABEL: define void @test9b(
831 ; CHECK: @objc_retain(i8* %x)
832 ; CHECK: @objc_release(i8* %s)
833 ; CHECK: }
834 define void @test9b(i8* %x, i1 %j, i8* %p) nounwind {
835 entry:
836 %0 = call i8* @objc_retain(i8* %x) nounwind
837 %s = select i1 %j, i8* %x, i8* %p
838 call void @objc_release(i8* %s) nounwind
839 ret void
840 }
842 ; Trivial retain+release pair with intervening calls - don't delete!
844 ; CHECK-LABEL: define void @test10(
845 ; CHECK: @objc_retain(i8* %x)
846 ; CHECK: @callee
847 ; CHECK: @use_pointer
848 ; CHECK: @objc_release
849 ; CHECK: }
850 define void @test10(i8* %x) nounwind {
851 entry:
852 %0 = call i8* @objc_retain(i8* %x) nounwind
853 call void @callee()
854 call void @use_pointer(i8* %x)
855 call void @objc_release(i8* %0) nounwind
856 ret void
857 }
859 ; Trivial retain+autoreleaserelease pair. Don't delete!
860 ; Also, add a tail keyword, since objc_retain can never be passed
861 ; a stack argument.
863 ; CHECK-LABEL: define void @test11(
864 ; CHECK: tail call i8* @objc_retain(i8* %x) [[NUW]]
865 ; CHECK: call i8* @objc_autorelease(i8* %0) [[NUW]]
866 ; CHECK: }
867 define void @test11(i8* %x) nounwind {
868 entry:
869 %0 = call i8* @objc_retain(i8* %x) nounwind
870 call i8* @objc_autorelease(i8* %0) nounwind
871 call void @use_pointer(i8* %x)
872 ret void
873 }
875 ; Same as test11 but with no use_pointer call. Delete the pair!
877 ; CHECK-LABEL: define void @test11a(
878 ; CHECK: entry:
879 ; CHECK-NEXT: ret void
880 ; CHECK: }
881 define void @test11a(i8* %x) nounwind {
882 entry:
883 %0 = call i8* @objc_retain(i8* %x) nounwind
884 call i8* @objc_autorelease(i8* %0) nounwind
885 ret void
886 }
888 ; Same as test11 but the value is returned. Do not perform an RV optimization
889 ; since if the frontend emitted code for an __autoreleasing variable, we may
890 ; want it to be in the autorelease pool.
892 ; CHECK-LABEL: define i8* @test11b(
893 ; CHECK: tail call i8* @objc_retain(i8* %x) [[NUW]]
894 ; CHECK: call i8* @objc_autorelease(i8* %0) [[NUW]]
895 ; CHECK: }
896 define i8* @test11b(i8* %x) nounwind {
897 entry:
898 %0 = call i8* @objc_retain(i8* %x) nounwind
899 call i8* @objc_autorelease(i8* %0) nounwind
900 ret i8* %x
901 }
903 ; Trivial retain,release pair with intervening call, but it's dominated
904 ; by another retain - delete!
906 ; CHECK-LABEL: define void @test12(
907 ; CHECK-NEXT: entry:
908 ; CHECK-NEXT: @objc_retain(i8* %x)
909 ; CHECK-NOT: @objc_
910 ; CHECK: }
911 define void @test12(i8* %x, i64 %n) {
912 entry:
913 call i8* @objc_retain(i8* %x) nounwind
914 call i8* @objc_retain(i8* %x) nounwind
915 call void @use_pointer(i8* %x)
916 call void @use_pointer(i8* %x)
917 call void @objc_release(i8* %x) nounwind
918 ret void
919 }
921 ; Trivial retain,autorelease pair. Don't delete!
923 ; CHECK-LABEL: define void @test13(
924 ; CHECK: tail call i8* @objc_retain(i8* %x) [[NUW]]
925 ; CHECK: tail call i8* @objc_retain(i8* %x) [[NUW]]
926 ; CHECK: @use_pointer(i8* %x)
927 ; CHECK: call i8* @objc_autorelease(i8* %x) [[NUW]]
928 ; CHECK: }
929 define void @test13(i8* %x, i64 %n) {
930 entry:
931 call i8* @objc_retain(i8* %x) nounwind
932 call i8* @objc_retain(i8* %x) nounwind
933 call void @use_pointer(i8* %x)
934 call i8* @objc_autorelease(i8* %x) nounwind
935 ret void
936 }
938 ; Delete the retain+release pair.
940 ; CHECK-LABEL: define void @test13b(
941 ; CHECK-NEXT: entry:
942 ; CHECK-NEXT: @objc_retain(i8* %x)
943 ; CHECK-NEXT: @use_pointer
944 ; CHECK-NEXT: @use_pointer
945 ; CHECK-NEXT: ret void
946 ; CHECK-NEXT: }
947 define void @test13b(i8* %x, i64 %n) {
948 entry:
949 call i8* @objc_retain(i8* %x) nounwind
950 call i8* @objc_retain(i8* %x) nounwind
951 call void @use_pointer(i8* %x)
952 call void @use_pointer(i8* %x)
953 call void @objc_release(i8* %x) nounwind
954 ret void
955 }
957 ; Don't delete the retain+release pair because there's an
958 ; autoreleasePoolPop in the way.
960 ; CHECK-LABEL: define void @test13c(
961 ; CHECK: @objc_retain(i8* %x)
962 ; CHECK: @objc_autoreleasePoolPop
963 ; CHECK: @objc_retain(i8* %x)
964 ; CHECK: @use_pointer
965 ; CHECK: @objc_release
966 ; CHECK: }
967 define void @test13c(i8* %x, i64 %n) {
968 entry:
969 call i8* @objc_retain(i8* %x) nounwind
970 call void @objc_autoreleasePoolPop(i8* undef)
971 call i8* @objc_retain(i8* %x) nounwind
972 call void @use_pointer(i8* %x)
973 call void @use_pointer(i8* %x)
974 call void @objc_release(i8* %x) nounwind
975 ret void
976 }
978 ; Like test13c, but there's an autoreleasePoolPush in the way, but that
979 ; doesn't matter.
981 ; CHECK-LABEL: define void @test13d(
982 ; CHECK-NEXT: entry:
983 ; CHECK-NEXT: @objc_retain(i8* %x)
984 ; CHECK-NEXT: @objc_autoreleasePoolPush
985 ; CHECK-NEXT: @use_pointer
986 ; CHECK-NEXT: @use_pointer
987 ; CHECK-NEXT: ret void
988 ; CHECK-NEXT: }
989 define void @test13d(i8* %x, i64 %n) {
990 entry:
991 call i8* @objc_retain(i8* %x) nounwind
992 call i8* @objc_autoreleasePoolPush()
993 call i8* @objc_retain(i8* %x) nounwind
994 call void @use_pointer(i8* %x)
995 call void @use_pointer(i8* %x)
996 call void @objc_release(i8* %x) nounwind
997 ret void
998 }
1000 ; Trivial retain,release pair with intervening call, but it's post-dominated
1001 ; by another release - delete!
1003 ; CHECK-LABEL: define void @test14(
1004 ; CHECK-NEXT: entry:
1005 ; CHECK-NEXT: @use_pointer
1006 ; CHECK-NEXT: @use_pointer
1007 ; CHECK-NEXT: @objc_release
1008 ; CHECK-NEXT: ret void
1009 ; CHECK-NEXT: }
1010 define void @test14(i8* %x, i64 %n) {
1011 entry:
1012 call i8* @objc_retain(i8* %x) nounwind
1013 call void @use_pointer(i8* %x)
1014 call void @use_pointer(i8* %x)
1015 call void @objc_release(i8* %x) nounwind
1016 call void @objc_release(i8* %x) nounwind
1017 ret void
1018 }
1020 ; Trivial retain,autorelease pair with intervening call, but it's post-dominated
1021 ; by another release. Don't delete anything.
1023 ; CHECK-LABEL: define void @test15(
1024 ; CHECK-NEXT: entry:
1025 ; CHECK-NEXT: @objc_retain(i8* %x)
1026 ; CHECK-NEXT: @use_pointer
1027 ; CHECK-NEXT: @objc_autorelease(i8* %x)
1028 ; CHECK-NEXT: @objc_release
1029 ; CHECK-NEXT: ret void
1030 ; CHECK-NEXT: }
1031 define void @test15(i8* %x, i64 %n) {
1032 entry:
1033 call i8* @objc_retain(i8* %x) nounwind
1034 call void @use_pointer(i8* %x)
1035 call i8* @objc_autorelease(i8* %x) nounwind
1036 call void @objc_release(i8* %x) nounwind
1037 ret void
1038 }
1040 ; Trivial retain,autorelease pair, post-dominated
1041 ; by another release. Delete the retain and release.
1043 ; CHECK-LABEL: define void @test15b(
1044 ; CHECK-NEXT: entry:
1045 ; CHECK-NEXT: @objc_retain
1046 ; CHECK-NEXT: @objc_autorelease
1047 ; CHECK-NEXT: @objc_release
1048 ; CHECK-NEXT: ret void
1049 ; CHECK-NEXT: }
1050 define void @test15b(i8* %x, i64 %n) {
1051 entry:
1052 call i8* @objc_retain(i8* %x) nounwind
1053 call i8* @objc_autorelease(i8* %x) nounwind
1054 call void @objc_release(i8* %x) nounwind
1055 ret void
1056 }
1058 ; CHECK-LABEL: define void @test15c(
1059 ; CHECK-NEXT: entry:
1060 ; CHECK-NEXT: @objc_autorelease
1061 ; CHECK-NEXT: ret void
1062 ; CHECK-NEXT: }
1063 define void @test15c(i8* %x, i64 %n) {
1064 entry:
1065 call i8* @objc_retain(i8* %x) nounwind
1066 call i8* @objc_autorelease(i8* %x) nounwind
1067 call void @objc_release(i8* %x) nounwind, !clang.imprecise_release !0
1068 ret void
1069 }
1071 ; Retain+release pairs in diamonds, all dominated by a retain.
1073 ; CHECK-LABEL: define void @test16a(
1074 ; CHECK: @objc_retain(i8* %x)
1075 ; CHECK-NOT: @objc
1076 ; CHECK: }
1077 define void @test16a(i1 %a, i1 %b, i8* %x) {
1078 entry:
1079 call i8* @objc_retain(i8* %x) nounwind
1080 br i1 %a, label %red, label %orange
1082 red:
1083 call i8* @objc_retain(i8* %x) nounwind
1084 br label %yellow
1086 orange:
1087 call i8* @objc_retain(i8* %x) nounwind
1088 br label %yellow
1090 yellow:
1091 call void @use_pointer(i8* %x)
1092 call void @use_pointer(i8* %x)
1093 br i1 %b, label %green, label %blue
1095 green:
1096 call void @objc_release(i8* %x) nounwind
1097 br label %purple
1099 blue:
1100 call void @objc_release(i8* %x) nounwind
1101 br label %purple
1103 purple:
1104 ret void
1105 }
1107 ; CHECK-LABEL: define void @test16b(
1108 ; CHECK: @objc_retain(i8* %x)
1109 ; CHECK-NOT: @objc
1110 ; CHECK: }
1111 define void @test16b(i1 %a, i1 %b, i8* %x) {
1112 entry:
1113 call i8* @objc_retain(i8* %x) nounwind
1114 br i1 %a, label %red, label %orange
1116 red:
1117 call i8* @objc_retain(i8* %x) nounwind
1118 br label %yellow
1120 orange:
1121 call i8* @objc_retain(i8* %x) nounwind
1122 br label %yellow
1124 yellow:
1125 call void @use_pointer(i8* %x)
1126 call void @use_pointer(i8* %x)
1127 br i1 %b, label %green, label %blue
1129 green:
1130 call void @objc_release(i8* %x) nounwind, !clang.imprecise_release !0
1131 br label %purple
1133 blue:
1134 call void @objc_release(i8* %x) nounwind
1135 br label %purple
1137 purple:
1138 ret void
1139 }
1141 ; CHECK-LABEL: define void @test16c(
1142 ; CHECK: @objc_retain(i8* %x)
1143 ; CHECK-NOT: @objc
1144 ; CHECK: }
1145 define void @test16c(i1 %a, i1 %b, i8* %x) {
1146 entry:
1147 call i8* @objc_retain(i8* %x) nounwind
1148 br i1 %a, label %red, label %orange
1150 red:
1151 call i8* @objc_retain(i8* %x) nounwind
1152 br label %yellow
1154 orange:
1155 call i8* @objc_retain(i8* %x) nounwind
1156 br label %yellow
1158 yellow:
1159 call void @use_pointer(i8* %x)
1160 call void @use_pointer(i8* %x)
1161 br i1 %b, label %green, label %blue
1163 green:
1164 call void @objc_release(i8* %x) nounwind, !clang.imprecise_release !0
1165 br label %purple
1167 blue:
1168 call void @objc_release(i8* %x) nounwind, !clang.imprecise_release !0
1169 br label %purple
1171 purple:
1172 ret void
1173 }
1175 ; CHECK-LABEL: define void @test16d(
1176 ; CHECK: @objc_retain(i8* %x)
1177 ; CHECK-NOT: @objc
1178 ; CHECK: }
1179 define void @test16d(i1 %a, i1 %b, i8* %x) {
1180 entry:
1181 call i8* @objc_retain(i8* %x) nounwind
1182 br i1 %a, label %red, label %orange
1184 red:
1185 call i8* @objc_retain(i8* %x) nounwind
1186 br label %yellow
1188 orange:
1189 call i8* @objc_retain(i8* %x) nounwind
1190 br label %yellow
1192 yellow:
1193 call void @use_pointer(i8* %x)
1194 call void @use_pointer(i8* %x)
1195 br i1 %b, label %green, label %blue
1197 green:
1198 call void @objc_release(i8* %x) nounwind
1199 br label %purple
1201 blue:
1202 call void @objc_release(i8* %x) nounwind, !clang.imprecise_release !0
1203 br label %purple
1205 purple:
1206 ret void
1207 }
1210 ; Retain+release pairs in diamonds, all post-dominated by a release.
1212 ; CHECK-LABEL: define void @test17(
1213 ; CHECK-NOT: @objc_
1214 ; CHECK: purple:
1215 ; CHECK: @objc_release
1216 ; CHECK: }
1217 define void @test17(i1 %a, i1 %b, i8* %x) {
1218 entry:
1219 br i1 %a, label %red, label %orange
1221 red:
1222 call i8* @objc_retain(i8* %x) nounwind
1223 br label %yellow
1225 orange:
1226 call i8* @objc_retain(i8* %x) nounwind
1227 br label %yellow
1229 yellow:
1230 call void @use_pointer(i8* %x)
1231 call void @use_pointer(i8* %x)
1232 br i1 %b, label %green, label %blue
1234 green:
1235 call void @objc_release(i8* %x) nounwind
1236 br label %purple
1238 blue:
1239 call void @objc_release(i8* %x) nounwind
1240 br label %purple
1242 purple:
1243 call void @objc_release(i8* %x) nounwind
1244 ret void
1245 }
1247 ; Delete no-ops.
1249 ; CHECK-LABEL: define void @test18(
1250 ; CHECK-NOT: @objc_
1251 ; CHECK: }
1252 define void @test18() {
1253 call i8* @objc_retain(i8* null)
1254 call void @objc_release(i8* null)
1255 call i8* @objc_autorelease(i8* null)
1256 ret void
1257 }
1259 ; Delete no-ops where undef can be assumed to be null.
1261 ; CHECK-LABEL: define void @test18b(
1262 ; CHECK-NOT: @objc_
1263 ; CHECK: }
1264 define void @test18b() {
1265 call i8* @objc_retain(i8* undef)
1266 call void @objc_release(i8* undef)
1267 call i8* @objc_autorelease(i8* undef)
1268 ret void
1269 }
1271 ; Replace uses of arguments with uses of return values, to reduce
1272 ; register pressure.
1274 ; CHECK: define void @test19(i32* %y) {
1275 ; CHECK: %z = bitcast i32* %y to i8*
1276 ; CHECK: %0 = bitcast i32* %y to i8*
1277 ; CHECK: %1 = tail call i8* @objc_retain(i8* %0)
1278 ; CHECK: call void @use_pointer(i8* %z)
1279 ; CHECK: call void @use_pointer(i8* %z)
1280 ; CHECK: %2 = bitcast i32* %y to i8*
1281 ; CHECK: call void @objc_release(i8* %2)
1282 ; CHECK: ret void
1283 ; CHECK: }
1284 define void @test19(i32* %y) {
1285 entry:
1286 %x = bitcast i32* %y to i8*
1287 %0 = call i8* @objc_retain(i8* %x) nounwind
1288 %z = bitcast i32* %y to i8*
1289 call void @use_pointer(i8* %z)
1290 call void @use_pointer(i8* %z)
1291 call void @objc_release(i8* %x)
1292 ret void
1293 }
1295 ; Bitcast insertion
1297 ; CHECK-LABEL: define void @test20(
1298 ; CHECK: %tmp1 = tail call i8* @objc_retain(i8* %tmp) [[NUW]]
1299 ; CHECK-NEXT: invoke
1300 ; CHECK: }
1301 define void @test20(double* %self) {
1302 if.then12:
1303 %tmp = bitcast double* %self to i8*
1304 %tmp1 = call i8* @objc_retain(i8* %tmp) nounwind
1305 invoke void @invokee()
1306 to label %invoke.cont23 unwind label %lpad20
1308 invoke.cont23: ; preds = %if.then12
1309 invoke void @invokee()
1310 to label %if.end unwind label %lpad20
1312 lpad20: ; preds = %invoke.cont23, %if.then12
1313 %tmp502 = phi double* [ undef, %invoke.cont23 ], [ %self, %if.then12 ]
1314 %exn = landingpad {i8*, i32} personality i32 (...)* @__gxx_personality_v0
1315 cleanup
1316 unreachable
1318 if.end: ; preds = %invoke.cont23
1319 ret void
1320 }
1322 ; Delete a redundant retain,autorelease when forwaring a call result
1323 ; directly to a return value.
1325 ; CHECK-LABEL: define i8* @test21(
1326 ; CHECK: call i8* @returner()
1327 ; CHECK-NEXT: ret i8* %call
1328 ; CHECK-NEXT: }
1329 define i8* @test21() {
1330 entry:
1331 %call = call i8* @returner()
1332 %0 = call i8* @objc_retain(i8* %call) nounwind
1333 %1 = call i8* @objc_autorelease(i8* %0) nounwind
1334 ret i8* %1
1335 }
1337 ; Move an objc call up through a phi that has null operands.
1339 ; CHECK-LABEL: define void @test22(
1340 ; CHECK: B:
1341 ; CHECK: %1 = bitcast double* %p to i8*
1342 ; CHECK: call void @objc_release(i8* %1)
1343 ; CHECK: br label %C
1344 ; CHECK: C: ; preds = %B, %A
1345 ; CHECK-NOT: @objc_release
1346 ; CHECK: }
1347 define void @test22(double* %p, i1 %a) {
1348 br i1 %a, label %A, label %B
1349 A:
1350 br label %C
1351 B:
1352 br label %C
1353 C:
1354 %h = phi double* [ null, %A ], [ %p, %B ]
1355 %c = bitcast double* %h to i8*
1356 call void @objc_release(i8* %c)
1357 ret void
1358 }
1360 ; Any call can decrement a retain count.
1362 ; CHECK-LABEL: define void @test24(
1363 ; CHECK: @objc_retain(i8* %a)
1364 ; CHECK: @objc_release
1365 ; CHECK: }
1366 define void @test24(i8* %r, i8* %a) {
1367 call i8* @objc_retain(i8* %a)
1368 call void @use_pointer(i8* %r)
1369 %q = load i8* %a
1370 call void @objc_release(i8* %a)
1371 ret void
1372 }
1374 ; Don't move a retain/release pair if the release can be moved
1375 ; but the retain can't be moved to balance it.
1377 ; CHECK-LABEL: define void @test25(
1378 ; CHECK: entry:
1379 ; CHECK: call i8* @objc_retain(i8* %p)
1380 ; CHECK: true:
1381 ; CHECK: done:
1382 ; CHECK: call void @objc_release(i8* %p)
1383 ; CHECK: }
1384 define void @test25(i8* %p, i1 %x) {
1385 entry:
1386 %f0 = call i8* @objc_retain(i8* %p)
1387 call void @callee()
1388 br i1 %x, label %true, label %done
1390 true:
1391 store i8 0, i8* %p
1392 br label %done
1394 done:
1395 call void @objc_release(i8* %p)
1396 ret void
1397 }
1399 ; Don't move a retain/release pair if the retain can be moved
1400 ; but the release can't be moved to balance it.
1402 ; CHECK-LABEL: define void @test26(
1403 ; CHECK: entry:
1404 ; CHECK: call i8* @objc_retain(i8* %p)
1405 ; CHECK: true:
1406 ; CHECK: done:
1407 ; CHECK: call void @objc_release(i8* %p)
1408 ; CHECK: }
1409 define void @test26(i8* %p, i1 %x) {
1410 entry:
1411 %f0 = call i8* @objc_retain(i8* %p)
1412 br i1 %x, label %true, label %done
1414 true:
1415 call void @callee()
1416 br label %done
1418 done:
1419 store i8 0, i8* %p
1420 call void @objc_release(i8* %p)
1421 ret void
1422 }
1424 ; Don't sink the retain,release into the loop.
1426 ; CHECK-LABEL: define void @test27(
1427 ; CHECK: entry:
1428 ; CHECK: call i8* @objc_retain(i8* %p)
1429 ; CHECK: loop:
1430 ; CHECK-NOT: @objc_
1431 ; CHECK: done:
1432 ; CHECK: call void @objc_release
1433 ; CHECK: }
1434 define void @test27(i8* %p, i1 %x, i1 %y) {
1435 entry:
1436 %f0 = call i8* @objc_retain(i8* %p)
1437 br i1 %x, label %loop, label %done
1439 loop:
1440 call void @callee()
1441 store i8 0, i8* %p
1442 br i1 %y, label %done, label %loop
1444 done:
1445 call void @objc_release(i8* %p)
1446 ret void
1447 }
1449 ; Trivial code motion case: Triangle.
1451 ; CHECK-LABEL: define void @test28(
1452 ; CHECK-NOT: @objc_
1453 ; CHECK: true:
1454 ; CHECK: call i8* @objc_retain(
1455 ; CHECK: call void @callee()
1456 ; CHECK: store
1457 ; CHECK: call void @objc_release
1458 ; CHECK: done:
1459 ; CHECK-NOT: @objc_
1460 ; CHECK: }
1461 define void @test28(i8* %p, i1 %x) {
1462 entry:
1463 %f0 = call i8* @objc_retain(i8* %p)
1464 br i1 %x, label %true, label %done
1466 true:
1467 call void @callee()
1468 store i8 0, i8* %p
1469 br label %done
1471 done:
1472 call void @objc_release(i8* %p), !clang.imprecise_release !0
1473 ret void
1474 }
1476 ; Trivial code motion case: Triangle, but no metadata. Don't move past
1477 ; unrelated memory references!
1479 ; CHECK-LABEL: define void @test28b(
1480 ; CHECK: call i8* @objc_retain(
1481 ; CHECK: true:
1482 ; CHECK-NOT: @objc_
1483 ; CHECK: call void @callee()
1484 ; CHECK-NOT: @objc_
1485 ; CHECK: store
1486 ; CHECK-NOT: @objc_
1487 ; CHECK: done:
1488 ; CHECK: @objc_release
1489 ; CHECK: }
1490 define void @test28b(i8* %p, i1 %x, i8* noalias %t) {
1491 entry:
1492 %f0 = call i8* @objc_retain(i8* %p)
1493 br i1 %x, label %true, label %done
1495 true:
1496 call void @callee()
1497 store i8 0, i8* %p
1498 br label %done
1500 done:
1501 store i8 0, i8* %t
1502 call void @objc_release(i8* %p)
1503 ret void
1504 }
1506 ; Trivial code motion case: Triangle, with metadata. Do move past
1507 ; unrelated memory references! And preserve the metadata.
1509 ; CHECK-LABEL: define void @test28c(
1510 ; CHECK-NOT: @objc_
1511 ; CHECK: true:
1512 ; CHECK: call i8* @objc_retain(
1513 ; CHECK: call void @callee()
1514 ; CHECK: store
1515 ; CHECK: call void @objc_release(i8* %p) [[NUW]], !clang.imprecise_release
1516 ; CHECK: done:
1517 ; CHECK-NOT: @objc_
1518 ; CHECK: }
1519 define void @test28c(i8* %p, i1 %x, i8* noalias %t) {
1520 entry:
1521 %f0 = call i8* @objc_retain(i8* %p)
1522 br i1 %x, label %true, label %done
1524 true:
1525 call void @callee()
1526 store i8 0, i8* %p
1527 br label %done
1529 done:
1530 store i8 0, i8* %t
1531 call void @objc_release(i8* %p), !clang.imprecise_release !0
1532 ret void
1533 }
1535 ; Like test28. but with two releases.
1537 ; CHECK-LABEL: define void @test29(
1538 ; CHECK-NOT: @objc_
1539 ; CHECK: true:
1540 ; CHECK: call i8* @objc_retain(
1541 ; CHECK: call void @callee()
1542 ; CHECK: store
1543 ; CHECK: call void @objc_release
1544 ; CHECK-NOT: @objc_release
1545 ; CHECK: done:
1546 ; CHECK-NOT: @objc_
1547 ; CHECK: ohno:
1548 ; CHECK-NOT: @objc_
1549 ; CHECK: }
1550 define void @test29(i8* %p, i1 %x, i1 %y) {
1551 entry:
1552 %f0 = call i8* @objc_retain(i8* %p)
1553 br i1 %x, label %true, label %done
1555 true:
1556 call void @callee()
1557 store i8 0, i8* %p
1558 br i1 %y, label %done, label %ohno
1560 done:
1561 call void @objc_release(i8* %p)
1562 ret void
1564 ohno:
1565 call void @objc_release(i8* %p)
1566 ret void
1567 }
1569 ; Basic case with the use and call in a diamond
1570 ; with an extra release.
1572 ; CHECK-LABEL: define void @test30(
1573 ; CHECK-NOT: @objc_
1574 ; CHECK: true:
1575 ; CHECK: call i8* @objc_retain(
1576 ; CHECK: call void @callee()
1577 ; CHECK: store
1578 ; CHECK: call void @objc_release
1579 ; CHECK-NOT: @objc_release
1580 ; CHECK: false:
1581 ; CHECK-NOT: @objc_
1582 ; CHECK: done:
1583 ; CHECK-NOT: @objc_
1584 ; CHECK: ohno:
1585 ; CHECK-NOT: @objc_
1586 ; CHECK: }
1587 define void @test30(i8* %p, i1 %x, i1 %y, i1 %z) {
1588 entry:
1589 %f0 = call i8* @objc_retain(i8* %p)
1590 br i1 %x, label %true, label %false
1592 true:
1593 call void @callee()
1594 store i8 0, i8* %p
1595 br i1 %y, label %done, label %ohno
1597 false:
1598 br i1 %z, label %done, label %ohno
1600 done:
1601 call void @objc_release(i8* %p)
1602 ret void
1604 ohno:
1605 call void @objc_release(i8* %p)
1606 ret void
1607 }
1609 ; Basic case with a mergeable release.
1611 ; CHECK-LABEL: define void @test31(
1612 ; CHECK: call i8* @objc_retain(i8* %p)
1613 ; CHECK: call void @callee()
1614 ; CHECK: store
1615 ; CHECK: call void @objc_release
1616 ; CHECK-NOT: @objc_release
1617 ; CHECK: true:
1618 ; CHECK-NOT: @objc_release
1619 ; CHECK: false:
1620 ; CHECK-NOT: @objc_release
1621 ; CHECK: ret void
1622 ; CHECK-NOT: @objc_release
1623 ; CHECK: }
1624 define void @test31(i8* %p, i1 %x) {
1625 entry:
1626 %f0 = call i8* @objc_retain(i8* %p)
1627 call void @callee()
1628 store i8 0, i8* %p
1629 br i1 %x, label %true, label %false
1630 true:
1631 call void @objc_release(i8* %p)
1632 ret void
1633 false:
1634 call void @objc_release(i8* %p)
1635 ret void
1636 }
1638 ; Don't consider bitcasts or getelementptrs direct uses.
1640 ; CHECK-LABEL: define void @test32(
1641 ; CHECK-NOT: @objc_
1642 ; CHECK: true:
1643 ; CHECK: call i8* @objc_retain(
1644 ; CHECK: call void @callee()
1645 ; CHECK: store
1646 ; CHECK: call void @objc_release
1647 ; CHECK: done:
1648 ; CHECK-NOT: @objc_
1649 ; CHECK: }
1650 define void @test32(i8* %p, i1 %x) {
1651 entry:
1652 %f0 = call i8* @objc_retain(i8* %p)
1653 br i1 %x, label %true, label %done
1655 true:
1656 call void @callee()
1657 store i8 0, i8* %p
1658 br label %done
1660 done:
1661 %g = bitcast i8* %p to i8*
1662 %h = getelementptr i8* %g, i64 0
1663 call void @objc_release(i8* %g)
1664 ret void
1665 }
1667 ; Do consider icmps to be direct uses.
1669 ; CHECK-LABEL: define void @test33(
1670 ; CHECK-NOT: @objc_
1671 ; CHECK: true:
1672 ; CHECK: call i8* @objc_retain(
1673 ; CHECK: call void @callee()
1674 ; CHECK: icmp
1675 ; CHECK: call void @objc_release
1676 ; CHECK: done:
1677 ; CHECK-NOT: @objc_
1678 ; CHECK: }
1679 define void @test33(i8* %p, i1 %x, i8* %y) {
1680 entry:
1681 %f0 = call i8* @objc_retain(i8* %p)
1682 br i1 %x, label %true, label %done
1684 true:
1685 call void @callee()
1686 %v = icmp eq i8* %p, %y
1687 br label %done
1689 done:
1690 %g = bitcast i8* %p to i8*
1691 %h = getelementptr i8* %g, i64 0
1692 call void @objc_release(i8* %g)
1693 ret void
1694 }
1696 ; Delete retain,release if there's just a possible dec and we have imprecise
1697 ; releases.
1699 ; CHECK-LABEL: define void @test34a(
1700 ; CHECK: call i8* @objc_retain
1701 ; CHECK: true:
1702 ; CHECK: done:
1703 ; CHECK: call void @objc_release
1704 ; CHECK: }
1705 define void @test34a(i8* %p, i1 %x, i8* %y) {
1706 entry:
1707 %f0 = call i8* @objc_retain(i8* %p)
1708 br i1 %x, label %true, label %done
1710 true:
1711 call void @callee()
1712 br label %done
1714 done:
1715 %g = bitcast i8* %p to i8*
1716 %h = getelementptr i8* %g, i64 0
1717 call void @objc_release(i8* %g)
1718 ret void
1719 }
1721 ; CHECK-LABEL: define void @test34b(
1722 ; CHECK-NOT: @objc_
1723 ; CHECK: }
1724 define void @test34b(i8* %p, i1 %x, i8* %y) {
1725 entry:
1726 %f0 = call i8* @objc_retain(i8* %p)
1727 br i1 %x, label %true, label %done
1729 true:
1730 call void @callee()
1731 br label %done
1733 done:
1734 %g = bitcast i8* %p to i8*
1735 %h = getelementptr i8* %g, i64 0
1736 call void @objc_release(i8* %g), !clang.imprecise_release !0
1737 ret void
1738 }
1741 ; Delete retain,release if there's just a use and we do not have a precise
1742 ; release.
1744 ; Precise.
1745 ; CHECK-LABEL: define void @test35a(
1746 ; CHECK: entry:
1747 ; CHECK: call i8* @objc_retain
1748 ; CHECK: true:
1749 ; CHECK: done:
1750 ; CHECK: call void @objc_release
1751 ; CHECK: }
1752 define void @test35a(i8* %p, i1 %x, i8* %y) {
1753 entry:
1754 %f0 = call i8* @objc_retain(i8* %p)
1755 br i1 %x, label %true, label %done
1757 true:
1758 %v = icmp eq i8* %p, %y
1759 br label %done
1761 done:
1762 %g = bitcast i8* %p to i8*
1763 %h = getelementptr i8* %g, i64 0
1764 call void @objc_release(i8* %g)
1765 ret void
1766 }
1768 ; Imprecise.
1769 ; CHECK-LABEL: define void @test35b(
1770 ; CHECK-NOT: @objc_
1771 ; CHECK: }
1772 define void @test35b(i8* %p, i1 %x, i8* %y) {
1773 entry:
1774 %f0 = call i8* @objc_retain(i8* %p)
1775 br i1 %x, label %true, label %done
1777 true:
1778 %v = icmp eq i8* %p, %y
1779 br label %done
1781 done:
1782 %g = bitcast i8* %p to i8*
1783 %h = getelementptr i8* %g, i64 0
1784 call void @objc_release(i8* %g), !clang.imprecise_release !0
1785 ret void
1786 }
1788 ; Delete a retain,release if there's no actual use and we have precise release.
1790 ; CHECK-LABEL: define void @test36a(
1791 ; CHECK: @objc_retain
1792 ; CHECK: call void @callee()
1793 ; CHECK-NOT: @objc_
1794 ; CHECK: call void @callee()
1795 ; CHECK: @objc_release
1796 ; CHECK: }
1797 define void @test36a(i8* %p) {
1798 entry:
1799 call i8* @objc_retain(i8* %p)
1800 call void @callee()
1801 call void @callee()
1802 call void @objc_release(i8* %p)
1803 ret void
1804 }
1806 ; Like test36, but with metadata.
1808 ; CHECK-LABEL: define void @test36b(
1809 ; CHECK-NOT: @objc_
1810 ; CHECK: }
1811 define void @test36b(i8* %p) {
1812 entry:
1813 call i8* @objc_retain(i8* %p)
1814 call void @callee()
1815 call void @callee()
1816 call void @objc_release(i8* %p), !clang.imprecise_release !0
1817 ret void
1818 }
1820 ; Be aggressive about analyzing phis to eliminate possible uses.
1822 ; CHECK-LABEL: define void @test38(
1823 ; CHECK-NOT: @objc_
1824 ; CHECK: }
1825 define void @test38(i8* %p, i1 %u, i1 %m, i8* %z, i8* %y, i8* %x, i8* %w) {
1826 entry:
1827 call i8* @objc_retain(i8* %p)
1828 br i1 %u, label %true, label %false
1829 true:
1830 br i1 %m, label %a, label %b
1831 false:
1832 br i1 %m, label %c, label %d
1833 a:
1834 br label %e
1835 b:
1836 br label %e
1837 c:
1838 br label %f
1839 d:
1840 br label %f
1841 e:
1842 %j = phi i8* [ %z, %a ], [ %y, %b ]
1843 br label %g
1844 f:
1845 %k = phi i8* [ %w, %c ], [ %x, %d ]
1846 br label %g
1847 g:
1848 %h = phi i8* [ %j, %e ], [ %k, %f ]
1849 call void @use_pointer(i8* %h)
1850 call void @objc_release(i8* %p), !clang.imprecise_release !0
1851 ret void
1852 }
1854 ; Delete retain,release pairs around loops.
1856 ; CHECK-LABEL: define void @test39(
1857 ; CHECK-NOT: @objc_
1858 ; CHECK: }
1859 define void @test39(i8* %p) {
1860 entry:
1861 %0 = call i8* @objc_retain(i8* %p)
1862 br label %loop
1864 loop: ; preds = %loop, %entry
1865 br i1 undef, label %loop, label %exit
1867 exit: ; preds = %loop
1868 call void @objc_release(i8* %0), !clang.imprecise_release !0
1869 ret void
1870 }
1872 ; Delete retain,release pairs around loops containing uses.
1874 ; CHECK-LABEL: define void @test39b(
1875 ; CHECK-NOT: @objc_
1876 ; CHECK: }
1877 define void @test39b(i8* %p) {
1878 entry:
1879 %0 = call i8* @objc_retain(i8* %p)
1880 br label %loop
1882 loop: ; preds = %loop, %entry
1883 store i8 0, i8* %0
1884 br i1 undef, label %loop, label %exit
1886 exit: ; preds = %loop
1887 call void @objc_release(i8* %0), !clang.imprecise_release !0
1888 ret void
1889 }
1891 ; Delete retain,release pairs around loops containing potential decrements.
1893 ; CHECK-LABEL: define void @test39c(
1894 ; CHECK-NOT: @objc_
1895 ; CHECK: }
1896 define void @test39c(i8* %p) {
1897 entry:
1898 %0 = call i8* @objc_retain(i8* %p)
1899 br label %loop
1901 loop: ; preds = %loop, %entry
1902 call void @use_pointer(i8* %0)
1903 br i1 undef, label %loop, label %exit
1905 exit: ; preds = %loop
1906 call void @objc_release(i8* %0), !clang.imprecise_release !0
1907 ret void
1908 }
1910 ; Delete retain,release pairs around loops even if
1911 ; the successors are in a different order.
1913 ; CHECK-LABEL: define void @test40(
1914 ; CHECK-NOT: @objc_
1915 ; CHECK: }
1916 define void @test40(i8* %p) {
1917 entry:
1918 %0 = call i8* @objc_retain(i8* %p)
1919 br label %loop
1921 loop: ; preds = %loop, %entry
1922 call void @use_pointer(i8* %0)
1923 br i1 undef, label %exit, label %loop
1925 exit: ; preds = %loop
1926 call void @objc_release(i8* %0), !clang.imprecise_release !0
1927 ret void
1928 }
1930 ; Do the known-incremented retain+release elimination even if the pointer
1931 ; is also autoreleased.
1933 ; CHECK-LABEL: define void @test42(
1934 ; CHECK-NEXT: entry:
1935 ; CHECK-NEXT: call i8* @objc_retain(i8* %p)
1936 ; CHECK-NEXT: call i8* @objc_autorelease(i8* %p)
1937 ; CHECK-NEXT: call void @use_pointer(i8* %p)
1938 ; CHECK-NEXT: call void @use_pointer(i8* %p)
1939 ; CHECK-NEXT: ret void
1940 ; CHECK-NEXT: }
1941 define void @test42(i8* %p) {
1942 entry:
1943 call i8* @objc_retain(i8* %p)
1944 call i8* @objc_autorelease(i8* %p)
1945 call i8* @objc_retain(i8* %p)
1946 call void @use_pointer(i8* %p)
1947 call void @use_pointer(i8* %p)
1948 call void @objc_release(i8* %p)
1949 ret void
1950 }
1952 ; Don't the known-incremented retain+release elimination if the pointer is
1953 ; autoreleased and there's an autoreleasePoolPop.
1955 ; CHECK-LABEL: define void @test43(
1956 ; CHECK-NEXT: entry:
1957 ; CHECK-NEXT: call i8* @objc_retain(i8* %p)
1958 ; CHECK-NEXT: call i8* @objc_autorelease(i8* %p)
1959 ; CHECK-NEXT: call i8* @objc_retain
1960 ; CHECK-NEXT: call void @use_pointer(i8* %p)
1961 ; CHECK-NEXT: call void @use_pointer(i8* %p)
1962 ; CHECK-NEXT: call void @objc_autoreleasePoolPop(i8* undef)
1963 ; CHECK-NEXT: call void @objc_release
1964 ; CHECK-NEXT: ret void
1965 ; CHECK-NEXT: }
1966 define void @test43(i8* %p) {
1967 entry:
1968 call i8* @objc_retain(i8* %p)
1969 call i8* @objc_autorelease(i8* %p)
1970 call i8* @objc_retain(i8* %p)
1971 call void @use_pointer(i8* %p)
1972 call void @use_pointer(i8* %p)
1973 call void @objc_autoreleasePoolPop(i8* undef)
1974 call void @objc_release(i8* %p)
1975 ret void
1976 }
1978 ; Do the known-incremented retain+release elimination if the pointer is
1979 ; autoreleased and there's an autoreleasePoolPush.
1981 ; CHECK-LABEL: define void @test43b(
1982 ; CHECK-NEXT: entry:
1983 ; CHECK-NEXT: call i8* @objc_retain(i8* %p)
1984 ; CHECK-NEXT: call i8* @objc_autorelease(i8* %p)
1985 ; CHECK-NEXT: call void @use_pointer(i8* %p)
1986 ; CHECK-NEXT: call void @use_pointer(i8* %p)
1987 ; CHECK-NEXT: call i8* @objc_autoreleasePoolPush()
1988 ; CHECK-NEXT: ret void
1989 ; CHECK-NEXT: }
1990 define void @test43b(i8* %p) {
1991 entry:
1992 call i8* @objc_retain(i8* %p)
1993 call i8* @objc_autorelease(i8* %p)
1994 call i8* @objc_retain(i8* %p)
1995 call void @use_pointer(i8* %p)
1996 call void @use_pointer(i8* %p)
1997 call i8* @objc_autoreleasePoolPush()
1998 call void @objc_release(i8* %p)
1999 ret void
2000 }
2002 ; Do retain+release elimination for non-provenance pointers.
2004 ; CHECK-LABEL: define void @test44(
2005 ; CHECK-NOT: objc_
2006 ; CHECK: }
2007 define void @test44(i8** %pp) {
2008 %p = load i8** %pp
2009 %q = call i8* @objc_retain(i8* %p)
2010 call void @objc_release(i8* %q)
2011 ret void
2012 }
2014 ; Don't delete retain+release with an unknown-provenance
2015 ; may-alias objc_release between them.
2017 ; CHECK-LABEL: define void @test45(
2018 ; CHECK: call i8* @objc_retain(i8* %p)
2019 ; CHECK: call void @objc_release(i8* %q)
2020 ; CHECK: call void @use_pointer(i8* %p)
2021 ; CHECK: call void @objc_release(i8* %p)
2022 ; CHECK: }
2023 define void @test45(i8** %pp, i8** %qq) {
2024 %p = load i8** %pp
2025 %q = load i8** %qq
2026 call i8* @objc_retain(i8* %p)
2027 call void @objc_release(i8* %q)
2028 call void @use_pointer(i8* %p)
2029 call void @objc_release(i8* %p)
2030 ret void
2031 }
2033 ; Don't delete retain and autorelease here.
2035 ; CHECK-LABEL: define void @test46(
2036 ; CHECK: tail call i8* @objc_retain(i8* %p) [[NUW]]
2037 ; CHECK: true:
2038 ; CHECK: call i8* @objc_autorelease(i8* %p) [[NUW]]
2039 ; CHECK: }
2040 define void @test46(i8* %p, i1 %a) {
2041 entry:
2042 call i8* @objc_retain(i8* %p)
2043 br i1 %a, label %true, label %false
2045 true:
2046 call i8* @objc_autorelease(i8* %p)
2047 call void @use_pointer(i8* %p)
2048 ret void
2050 false:
2051 ret void
2052 }
2054 ; Delete no-op cast calls.
2056 ; CHECK-LABEL: define i8* @test47(
2057 ; CHECK-NOT: call
2058 ; CHECK: ret i8* %p
2059 ; CHECK: }
2060 define i8* @test47(i8* %p) nounwind {
2061 %x = call i8* @objc_retainedObject(i8* %p)
2062 ret i8* %x
2063 }
2065 ; Delete no-op cast calls.
2067 ; CHECK-LABEL: define i8* @test48(
2068 ; CHECK-NOT: call
2069 ; CHECK: ret i8* %p
2070 ; CHECK: }
2071 define i8* @test48(i8* %p) nounwind {
2072 %x = call i8* @objc_unretainedObject(i8* %p)
2073 ret i8* %x
2074 }
2076 ; Delete no-op cast calls.
2078 ; CHECK-LABEL: define i8* @test49(
2079 ; CHECK-NOT: call
2080 ; CHECK: ret i8* %p
2081 ; CHECK: }
2082 define i8* @test49(i8* %p) nounwind {
2083 %x = call i8* @objc_unretainedPointer(i8* %p)
2084 ret i8* %x
2085 }
2087 ; Do delete retain+release with intervening stores of the address value if we
2088 ; have imprecise release attached to objc_release.
2090 ; CHECK-LABEL: define void @test50a(
2091 ; CHECK-NEXT: call i8* @objc_retain
2092 ; CHECK-NEXT: call void @callee
2093 ; CHECK-NEXT: store
2094 ; CHECK-NEXT: call void @objc_release
2095 ; CHECK-NEXT: ret void
2096 ; CHECK-NEXT: }
2097 define void @test50a(i8* %p, i8** %pp) {
2098 call i8* @objc_retain(i8* %p)
2099 call void @callee()
2100 store i8* %p, i8** %pp
2101 call void @objc_release(i8* %p)
2102 ret void
2103 }
2105 ; CHECK-LABEL: define void @test50b(
2106 ; CHECK-NOT: @objc_
2107 ; CHECK: }
2108 define void @test50b(i8* %p, i8** %pp) {
2109 call i8* @objc_retain(i8* %p)
2110 call void @callee()
2111 store i8* %p, i8** %pp
2112 call void @objc_release(i8* %p), !clang.imprecise_release !0
2113 ret void
2114 }
2117 ; Don't delete retain+release with intervening stores through the
2118 ; address value.
2120 ; CHECK-LABEL: define void @test51a(
2121 ; CHECK: call i8* @objc_retain(i8* %p)
2122 ; CHECK: call void @objc_release(i8* %p)
2123 ; CHECK: ret void
2124 ; CHECK: }
2125 define void @test51a(i8* %p) {
2126 call i8* @objc_retain(i8* %p)
2127 call void @callee()
2128 store i8 0, i8* %p
2129 call void @objc_release(i8* %p)
2130 ret void
2131 }
2133 ; CHECK-LABEL: define void @test51b(
2134 ; CHECK: call i8* @objc_retain(i8* %p)
2135 ; CHECK: call void @objc_release(i8* %p)
2136 ; CHECK: ret void
2137 ; CHECK: }
2138 define void @test51b(i8* %p) {
2139 call i8* @objc_retain(i8* %p)
2140 call void @callee()
2141 store i8 0, i8* %p
2142 call void @objc_release(i8* %p), !clang.imprecise_release !0
2143 ret void
2144 }
2146 ; Don't delete retain+release with intervening use of a pointer of
2147 ; unknown provenance.
2149 ; CHECK-LABEL: define void @test52a(
2150 ; CHECK: call i8* @objc_retain
2151 ; CHECK: call void @callee()
2152 ; CHECK: call void @use_pointer(i8* %z)
2153 ; CHECK: call void @objc_release
2154 ; CHECK: ret void
2155 ; CHECK: }
2156 define void @test52a(i8** %zz, i8** %pp) {
2157 %p = load i8** %pp
2158 %1 = call i8* @objc_retain(i8* %p)
2159 call void @callee()
2160 %z = load i8** %zz
2161 call void @use_pointer(i8* %z)
2162 call void @objc_release(i8* %p)
2163 ret void
2164 }
2166 ; CHECK-LABEL: define void @test52b(
2167 ; CHECK: call i8* @objc_retain
2168 ; CHECK: call void @callee()
2169 ; CHECK: call void @use_pointer(i8* %z)
2170 ; CHECK: call void @objc_release
2171 ; CHECK: ret void
2172 ; CHECK: }
2173 define void @test52b(i8** %zz, i8** %pp) {
2174 %p = load i8** %pp
2175 %1 = call i8* @objc_retain(i8* %p)
2176 call void @callee()
2177 %z = load i8** %zz
2178 call void @use_pointer(i8* %z)
2179 call void @objc_release(i8* %p), !clang.imprecise_release !0
2180 ret void
2181 }
2183 ; Like test52, but the pointer has function type, so it's assumed to
2184 ; be not reference counted.
2185 ; Oops. That's wrong. Clang sometimes uses function types gratuitously.
2186 ; See rdar://10551239.
2188 ; CHECK-LABEL: define void @test53(
2189 ; CHECK: @objc_
2190 ; CHECK: }
2191 define void @test53(void ()** %zz, i8** %pp) {
2192 %p = load i8** %pp
2193 %1 = call i8* @objc_retain(i8* %p)
2194 call void @callee()
2195 %z = load void ()** %zz
2196 call void @callee_fnptr(void ()* %z)
2197 call void @objc_release(i8* %p)
2198 ret void
2199 }
2201 ; Convert autorelease to release if the value is unused.
2203 ; CHECK-LABEL: define void @test54(
2204 ; CHECK: call i8* @returner()
2205 ; CHECK-NEXT: call void @objc_release(i8* %t) [[NUW]], !clang.imprecise_release ![[RELEASE]]
2206 ; CHECK-NEXT: ret void
2207 ; CHECK: }
2208 define void @test54() {
2209 %t = call i8* @returner()
2210 call i8* @objc_autorelease(i8* %t)
2211 ret void
2212 }
2214 ; Nested retain+release pairs. Delete them both.
2216 ; CHECK-LABEL: define void @test55(
2217 ; CHECK-NOT: @objc
2218 ; CHECK: }
2219 define void @test55(i8* %x) {
2220 entry:
2221 %0 = call i8* @objc_retain(i8* %x) nounwind
2222 %1 = call i8* @objc_retain(i8* %x) nounwind
2223 call void @objc_release(i8* %x) nounwind
2224 call void @objc_release(i8* %x) nounwind
2225 ret void
2226 }
2228 ; Nested retain+release pairs where the inner pair depends
2229 ; on the outer pair to be removed, and then the outer pair
2230 ; can be partially eliminated. Plus an extra outer pair to
2231 ; eliminate, for fun.
2233 ; CHECK-LABEL: define void @test56(
2234 ; CHECK-NOT: @objc
2235 ; CHECK: if.then:
2236 ; CHECK-NEXT: %0 = tail call i8* @objc_retain(i8* %x) [[NUW]]
2237 ; CHECK-NEXT: tail call void @use_pointer(i8* %x)
2238 ; CHECK-NEXT: tail call void @use_pointer(i8* %x)
2239 ; CHECK-NEXT: tail call void @objc_release(i8* %x) [[NUW]], !clang.imprecise_release ![[RELEASE]]
2240 ; CHECK-NEXT: br label %if.end
2241 ; CHECK-NOT: @objc
2242 ; CHECK: }
2243 define void @test56(i8* %x, i32 %n) {
2244 entry:
2245 %0 = tail call i8* @objc_retain(i8* %x) nounwind
2246 %1 = tail call i8* @objc_retain(i8* %0) nounwind
2247 %tobool = icmp eq i32 %n, 0
2248 br i1 %tobool, label %if.end, label %if.then
2250 if.then: ; preds = %entry
2251 %2 = tail call i8* @objc_retain(i8* %1) nounwind
2252 tail call void @use_pointer(i8* %2)
2253 tail call void @use_pointer(i8* %2)
2254 tail call void @objc_release(i8* %2) nounwind, !clang.imprecise_release !0
2255 br label %if.end
2257 if.end: ; preds = %entry, %if.then
2258 tail call void @objc_release(i8* %1) nounwind, !clang.imprecise_release !0
2259 tail call void @objc_release(i8* %0) nounwind, !clang.imprecise_release !0
2260 ret void
2261 }
2263 ; When there are adjacent retain+release pairs, the first one is
2264 ; known unnecessary because the presence of the second one means that
2265 ; the first one won't be deleting the object.
2267 ; CHECK-LABEL: define void @test57(
2268 ; CHECK-NEXT: entry:
2269 ; CHECK-NEXT: call void @use_pointer(i8* %x)
2270 ; CHECK-NEXT: call void @use_pointer(i8* %x)
2271 ; CHECK-NEXT: %0 = tail call i8* @objc_retain(i8* %x) [[NUW]]
2272 ; CHECK-NEXT: call void @use_pointer(i8* %x)
2273 ; CHECK-NEXT: call void @use_pointer(i8* %x)
2274 ; CHECK-NEXT: call void @objc_release(i8* %x) [[NUW]]
2275 ; CHECK-NEXT: ret void
2276 ; CHECK-NEXT: }
2277 define void @test57(i8* %x) nounwind {
2278 entry:
2279 call i8* @objc_retain(i8* %x) nounwind
2280 call void @use_pointer(i8* %x)
2281 call void @use_pointer(i8* %x)
2282 call void @objc_release(i8* %x) nounwind
2283 call i8* @objc_retain(i8* %x) nounwind
2284 call void @use_pointer(i8* %x)
2285 call void @use_pointer(i8* %x)
2286 call void @objc_release(i8* %x) nounwind
2287 ret void
2288 }
2290 ; An adjacent retain+release pair is sufficient even if it will be
2291 ; removed itself.
2293 ; CHECK-LABEL: define void @test58(
2294 ; CHECK-NEXT: entry:
2295 ; CHECK-NEXT: call void @use_pointer(i8* %x)
2296 ; CHECK-NEXT: call void @use_pointer(i8* %x)
2297 ; CHECK-NEXT: ret void
2298 ; CHECK-NEXT: }
2299 define void @test58(i8* %x) nounwind {
2300 entry:
2301 call i8* @objc_retain(i8* %x) nounwind
2302 call void @use_pointer(i8* %x)
2303 call void @use_pointer(i8* %x)
2304 call void @objc_release(i8* %x) nounwind
2305 call i8* @objc_retain(i8* %x) nounwind
2306 call void @objc_release(i8* %x) nounwind
2307 ret void
2308 }
2310 ; Don't delete the second retain+release pair in an adjacent set.
2312 ; CHECK-LABEL: define void @test59(
2313 ; CHECK-NEXT: entry:
2314 ; CHECK-NEXT: %0 = tail call i8* @objc_retain(i8* %x) [[NUW]]
2315 ; CHECK-NEXT: call void @use_pointer(i8* %x)
2316 ; CHECK-NEXT: call void @use_pointer(i8* %x)
2317 ; CHECK-NEXT: call void @objc_release(i8* %x) [[NUW]]
2318 ; CHECK-NEXT: ret void
2319 ; CHECK-NEXT: }
2320 define void @test59(i8* %x) nounwind {
2321 entry:
2322 %a = call i8* @objc_retain(i8* %x) nounwind
2323 call void @objc_release(i8* %x) nounwind
2324 %b = call i8* @objc_retain(i8* %x) nounwind
2325 call void @use_pointer(i8* %x)
2326 call void @use_pointer(i8* %x)
2327 call void @objc_release(i8* %x) nounwind
2328 ret void
2329 }
2331 ; Constant pointers to objects don't need reference counting.
2333 @constptr = external constant i8*
2334 @something = external global i8*
2336 ; We have a precise lifetime retain/release here. We can not remove them since
2337 ; @something is not constant.
2339 ; CHECK-LABEL: define void @test60a(
2340 ; CHECK: call i8* @objc_retain
2341 ; CHECK: call void @objc_release
2342 ; CHECK: }
2343 define void @test60a() {
2344 %t = load i8** @constptr
2345 %s = load i8** @something
2346 call i8* @objc_retain(i8* %s)
2347 call void @callee()
2348 call void @use_pointer(i8* %t)
2349 call void @objc_release(i8* %s)
2350 ret void
2351 }
2353 ; CHECK-LABEL: define void @test60b(
2354 ; CHECK: call i8* @objc_retain
2355 ; CHECK-NOT: call i8* @objc_retain
2356 ; CHECK-NOT: call i8* @objc_rrelease
2357 ; CHECK: }
2358 define void @test60b() {
2359 %t = load i8** @constptr
2360 %s = load i8** @something
2361 call i8* @objc_retain(i8* %s)
2362 call i8* @objc_retain(i8* %s)
2363 call void @callee()
2364 call void @use_pointer(i8* %t)
2365 call void @objc_release(i8* %s)
2366 ret void
2367 }
2369 ; CHECK-LABEL: define void @test60c(
2370 ; CHECK-NOT: @objc_
2371 ; CHECK: }
2372 define void @test60c() {
2373 %t = load i8** @constptr
2374 %s = load i8** @something
2375 call i8* @objc_retain(i8* %s)
2376 call void @callee()
2377 call void @use_pointer(i8* %t)
2378 call void @objc_release(i8* %s), !clang.imprecise_release !0
2379 ret void
2380 }
2382 ; CHECK-LABEL: define void @test60d(
2383 ; CHECK-NOT: @objc_
2384 ; CHECK: }
2385 define void @test60d() {
2386 %t = load i8** @constptr
2387 %s = load i8** @something
2388 call i8* @objc_retain(i8* %t)
2389 call void @callee()
2390 call void @use_pointer(i8* %s)
2391 call void @objc_release(i8* %t)
2392 ret void
2393 }
2395 ; CHECK-LABEL: define void @test60e(
2396 ; CHECK-NOT: @objc_
2397 ; CHECK: }
2398 define void @test60e() {
2399 %t = load i8** @constptr
2400 %s = load i8** @something
2401 call i8* @objc_retain(i8* %t)
2402 call void @callee()
2403 call void @use_pointer(i8* %s)
2404 call void @objc_release(i8* %t), !clang.imprecise_release !0
2405 ret void
2406 }
2408 ; Constant pointers to objects don't need to be considered related to other
2409 ; pointers.
2411 ; CHECK-LABEL: define void @test61(
2412 ; CHECK-NOT: @objc_
2413 ; CHECK: }
2414 define void @test61() {
2415 %t = load i8** @constptr
2416 call i8* @objc_retain(i8* %t)
2417 call void @callee()
2418 call void @use_pointer(i8* %t)
2419 call void @objc_release(i8* %t)
2420 ret void
2421 }
2423 ; Delete a retain matched by releases when one is inside the loop and the
2424 ; other is outside the loop.
2426 ; CHECK-LABEL: define void @test62(
2427 ; CHECK-NOT: @objc_
2428 ; CHECK: }
2429 define void @test62(i8* %x, i1* %p) nounwind {
2430 entry:
2431 br label %loop
2433 loop:
2434 call i8* @objc_retain(i8* %x)
2435 %q = load i1* %p
2436 br i1 %q, label %loop.more, label %exit
2438 loop.more:
2439 call void @objc_release(i8* %x)
2440 br label %loop
2442 exit:
2443 call void @objc_release(i8* %x)
2444 ret void
2445 }
2447 ; Like test62 but with no release in exit.
2448 ; Don't delete anything!
2450 ; CHECK-LABEL: define void @test63(
2451 ; CHECK: loop:
2452 ; CHECK: tail call i8* @objc_retain(i8* %x)
2453 ; CHECK: loop.more:
2454 ; CHECK: call void @objc_release(i8* %x)
2455 ; CHECK: }
2456 define void @test63(i8* %x, i1* %p) nounwind {
2457 entry:
2458 br label %loop
2460 loop:
2461 call i8* @objc_retain(i8* %x)
2462 %q = load i1* %p
2463 br i1 %q, label %loop.more, label %exit
2465 loop.more:
2466 call void @objc_release(i8* %x)
2467 br label %loop
2469 exit:
2470 ret void
2471 }
2473 ; Like test62 but with no release in loop.more.
2474 ; Don't delete anything!
2476 ; CHECK-LABEL: define void @test64(
2477 ; CHECK: loop:
2478 ; CHECK: tail call i8* @objc_retain(i8* %x)
2479 ; CHECK: exit:
2480 ; CHECK: call void @objc_release(i8* %x)
2481 ; CHECK: }
2482 define void @test64(i8* %x, i1* %p) nounwind {
2483 entry:
2484 br label %loop
2486 loop:
2487 call i8* @objc_retain(i8* %x)
2488 %q = load i1* %p
2489 br i1 %q, label %loop.more, label %exit
2491 loop.more:
2492 br label %loop
2494 exit:
2495 call void @objc_release(i8* %x)
2496 ret void
2497 }
2499 ; Move an autorelease past a phi with a null.
2501 ; CHECK-LABEL: define i8* @test65(
2502 ; CHECK: if.then:
2503 ; CHECK: call i8* @objc_autorelease(
2504 ; CHECK: return:
2505 ; CHECK-NOT: @objc_autorelease
2506 ; CHECK: }
2507 define i8* @test65(i1 %x) {
2508 entry:
2509 br i1 %x, label %return, label %if.then
2511 if.then: ; preds = %entry
2512 %c = call i8* @returner()
2513 %s = call i8* @objc_retainAutoreleasedReturnValue(i8* %c) nounwind
2514 br label %return
2516 return: ; preds = %if.then, %entry
2517 %retval = phi i8* [ %s, %if.then ], [ null, %entry ]
2518 %q = call i8* @objc_autorelease(i8* %retval) nounwind
2519 ret i8* %retval
2520 }
2522 ; Don't move an autorelease past an autorelease pool boundary.
2524 ; CHECK-LABEL: define i8* @test65b(
2525 ; CHECK: if.then:
2526 ; CHECK-NOT: @objc_autorelease
2527 ; CHECK: return:
2528 ; CHECK: call i8* @objc_autorelease(
2529 ; CHECK: }
2530 define i8* @test65b(i1 %x) {
2531 entry:
2532 %t = call i8* @objc_autoreleasePoolPush()
2533 br i1 %x, label %return, label %if.then
2535 if.then: ; preds = %entry
2536 %c = call i8* @returner()
2537 %s = call i8* @objc_retainAutoreleasedReturnValue(i8* %c) nounwind
2538 br label %return
2540 return: ; preds = %if.then, %entry
2541 %retval = phi i8* [ %s, %if.then ], [ null, %entry ]
2542 call void @objc_autoreleasePoolPop(i8* %t)
2543 %q = call i8* @objc_autorelease(i8* %retval) nounwind
2544 ret i8* %retval
2545 }
2547 ; Don't move an autoreleaseReuturnValue, which would break
2548 ; the RV optimization.
2550 ; CHECK-LABEL: define i8* @test65c(
2551 ; CHECK: if.then:
2552 ; CHECK-NOT: @objc_autorelease
2553 ; CHECK: return:
2554 ; CHECK: call i8* @objc_autoreleaseReturnValue(
2555 ; CHECK: }
2556 define i8* @test65c(i1 %x) {
2557 entry:
2558 br i1 %x, label %return, label %if.then
2560 if.then: ; preds = %entry
2561 %c = call i8* @returner()
2562 %s = call i8* @objc_retainAutoreleasedReturnValue(i8* %c) nounwind
2563 br label %return
2565 return: ; preds = %if.then, %entry
2566 %retval = phi i8* [ %s, %if.then ], [ null, %entry ]
2567 %q = call i8* @objc_autoreleaseReturnValue(i8* %retval) nounwind
2568 ret i8* %retval
2569 }
2571 ; An objc_retain can serve as a may-use for a different pointer.
2572 ; rdar://11931823
2574 ; CHECK-LABEL: define void @test66a(
2575 ; CHECK: tail call i8* @objc_retain(i8* %cond) [[NUW]]
2576 ; CHECK: tail call void @objc_release(i8* %call) [[NUW]]
2577 ; CHECK: tail call i8* @objc_retain(i8* %tmp8) [[NUW]]
2578 ; CHECK: tail call void @objc_release(i8* %cond) [[NUW]]
2579 ; CHECK: }
2580 define void @test66a(i8* %tmp5, i8* %bar, i1 %tobool, i1 %tobool1, i8* %call) {
2581 entry:
2582 br i1 %tobool, label %cond.true, label %cond.end
2584 cond.true:
2585 br label %cond.end
2587 cond.end: ; preds = %cond.true, %entry
2588 %cond = phi i8* [ %tmp5, %cond.true ], [ %call, %entry ]
2589 %tmp7 = tail call i8* @objc_retain(i8* %cond) nounwind
2590 tail call void @objc_release(i8* %call) nounwind
2591 %tmp8 = select i1 %tobool1, i8* %cond, i8* %bar
2592 %tmp9 = tail call i8* @objc_retain(i8* %tmp8) nounwind
2593 tail call void @objc_release(i8* %cond) nounwind
2594 ret void
2595 }
2597 ; CHECK-LABEL: define void @test66b(
2598 ; CHECK: tail call i8* @objc_retain(i8* %cond) [[NUW]]
2599 ; CHECK: tail call void @objc_release(i8* %call) [[NUW]]
2600 ; CHECK: tail call i8* @objc_retain(i8* %tmp8) [[NUW]]
2601 ; CHECK: tail call void @objc_release(i8* %cond) [[NUW]]
2602 ; CHECK: }
2603 define void @test66b(i8* %tmp5, i8* %bar, i1 %tobool, i1 %tobool1, i8* %call) {
2604 entry:
2605 br i1 %tobool, label %cond.true, label %cond.end
2607 cond.true:
2608 br label %cond.end
2610 cond.end: ; preds = %cond.true, %entry
2611 %cond = phi i8* [ %tmp5, %cond.true ], [ %call, %entry ]
2612 %tmp7 = tail call i8* @objc_retain(i8* %cond) nounwind
2613 tail call void @objc_release(i8* %call) nounwind, !clang.imprecise_release !0
2614 %tmp8 = select i1 %tobool1, i8* %cond, i8* %bar
2615 %tmp9 = tail call i8* @objc_retain(i8* %tmp8) nounwind
2616 tail call void @objc_release(i8* %cond) nounwind
2617 ret void
2618 }
2620 ; CHECK-LABEL: define void @test66c(
2621 ; CHECK: tail call i8* @objc_retain(i8* %cond) [[NUW]]
2622 ; CHECK: tail call void @objc_release(i8* %call) [[NUW]]
2623 ; CHECK: tail call i8* @objc_retain(i8* %tmp8) [[NUW]]
2624 ; CHECK: tail call void @objc_release(i8* %cond) [[NUW]]
2625 ; CHECK: }
2626 define void @test66c(i8* %tmp5, i8* %bar, i1 %tobool, i1 %tobool1, i8* %call) {
2627 entry:
2628 br i1 %tobool, label %cond.true, label %cond.end
2630 cond.true:
2631 br label %cond.end
2633 cond.end: ; preds = %cond.true, %entry
2634 %cond = phi i8* [ %tmp5, %cond.true ], [ %call, %entry ]
2635 %tmp7 = tail call i8* @objc_retain(i8* %cond) nounwind
2636 tail call void @objc_release(i8* %call) nounwind
2637 %tmp8 = select i1 %tobool1, i8* %cond, i8* %bar
2638 %tmp9 = tail call i8* @objc_retain(i8* %tmp8) nounwind, !clang.imprecise_release !0
2639 tail call void @objc_release(i8* %cond) nounwind
2640 ret void
2641 }
2643 ; CHECK-LABEL: define void @test66d(
2644 ; CHECK: tail call i8* @objc_retain(i8* %cond) [[NUW]]
2645 ; CHECK: tail call void @objc_release(i8* %call) [[NUW]]
2646 ; CHECK: tail call i8* @objc_retain(i8* %tmp8) [[NUW]]
2647 ; CHECK: tail call void @objc_release(i8* %cond) [[NUW]]
2648 ; CHECK: }
2649 define void @test66d(i8* %tmp5, i8* %bar, i1 %tobool, i1 %tobool1, i8* %call) {
2650 entry:
2651 br i1 %tobool, label %cond.true, label %cond.end
2653 cond.true:
2654 br label %cond.end
2656 cond.end: ; preds = %cond.true, %entry
2657 %cond = phi i8* [ %tmp5, %cond.true ], [ %call, %entry ]
2658 %tmp7 = tail call i8* @objc_retain(i8* %cond) nounwind
2659 tail call void @objc_release(i8* %call) nounwind, !clang.imprecise_release !0
2660 %tmp8 = select i1 %tobool1, i8* %cond, i8* %bar
2661 %tmp9 = tail call i8* @objc_retain(i8* %tmp8) nounwind
2662 tail call void @objc_release(i8* %cond) nounwind, !clang.imprecise_release !0
2663 ret void
2664 }
2666 ; A few real-world testcases.
2668 @.str4 = private unnamed_addr constant [33 x i8] c"-[A z] = { %f, %f, { %f, %f } }\0A\00"
2669 @"OBJC_IVAR_$_A.myZ" = global i64 20, section "__DATA, __objc_const", align 8
2670 declare i32 @printf(i8* nocapture, ...) nounwind
2671 declare i32 @puts(i8* nocapture) nounwind
2672 @str = internal constant [16 x i8] c"-[ Top0 _getX ]\00"
2674 ; CHECK: define { <2 x float>, <2 x float> } @"\01-[A z]"({}* %self, i8* nocapture %_cmd) [[NUW]] {
2675 ; CHECK-NOT: @objc_
2676 ; CHECK: }
2678 define {<2 x float>, <2 x float>} @"\01-[A z]"({}* %self, i8* nocapture %_cmd) nounwind {
2679 invoke.cont:
2680 %0 = bitcast {}* %self to i8*
2681 %1 = tail call i8* @objc_retain(i8* %0) nounwind
2682 tail call void @llvm.dbg.value(metadata !{{}* %self}, i64 0, metadata !0, metadata !{})
2683 tail call void @llvm.dbg.value(metadata !{{}* %self}, i64 0, metadata !0, metadata !{})
2684 %ivar = load i64* @"OBJC_IVAR_$_A.myZ", align 8
2685 %add.ptr = getelementptr i8* %0, i64 %ivar
2686 %tmp1 = bitcast i8* %add.ptr to float*
2687 %tmp2 = load float* %tmp1, align 4
2688 %conv = fpext float %tmp2 to double
2689 %add.ptr.sum = add i64 %ivar, 4
2690 %tmp6 = getelementptr inbounds i8* %0, i64 %add.ptr.sum
2691 %2 = bitcast i8* %tmp6 to float*
2692 %tmp7 = load float* %2, align 4
2693 %conv8 = fpext float %tmp7 to double
2694 %add.ptr.sum36 = add i64 %ivar, 8
2695 %tmp12 = getelementptr inbounds i8* %0, i64 %add.ptr.sum36
2696 %arrayidx = bitcast i8* %tmp12 to float*
2697 %tmp13 = load float* %arrayidx, align 4
2698 %conv14 = fpext float %tmp13 to double
2699 %tmp12.sum = add i64 %ivar, 12
2700 %arrayidx19 = getelementptr inbounds i8* %0, i64 %tmp12.sum
2701 %3 = bitcast i8* %arrayidx19 to float*
2702 %tmp20 = load float* %3, align 4
2703 %conv21 = fpext float %tmp20 to double
2704 %call = tail call i32 (i8*, ...)* @printf(i8* getelementptr inbounds ([33 x i8]* @.str4, i64 0, i64 0), double %conv, double %conv8, double %conv14, double %conv21)
2705 %ivar23 = load i64* @"OBJC_IVAR_$_A.myZ", align 8
2706 %add.ptr24 = getelementptr i8* %0, i64 %ivar23
2707 %4 = bitcast i8* %add.ptr24 to i128*
2708 %srcval = load i128* %4, align 4
2709 tail call void @objc_release(i8* %0) nounwind
2710 %tmp29 = trunc i128 %srcval to i64
2711 %tmp30 = bitcast i64 %tmp29 to <2 x float>
2712 %tmp31 = insertvalue {<2 x float>, <2 x float>} undef, <2 x float> %tmp30, 0
2713 %tmp32 = lshr i128 %srcval, 64
2714 %tmp33 = trunc i128 %tmp32 to i64
2715 %tmp34 = bitcast i64 %tmp33 to <2 x float>
2716 %tmp35 = insertvalue {<2 x float>, <2 x float>} %tmp31, <2 x float> %tmp34, 1
2717 ret {<2 x float>, <2 x float>} %tmp35
2718 }
2720 ; CHECK: @"\01-[Top0 _getX]"({}* %self, i8* nocapture %_cmd) [[NUW]] {
2721 ; CHECK-NOT: @objc_
2722 ; CHECK: }
2724 define i32 @"\01-[Top0 _getX]"({}* %self, i8* nocapture %_cmd) nounwind {
2725 invoke.cont:
2726 %0 = bitcast {}* %self to i8*
2727 %1 = tail call i8* @objc_retain(i8* %0) nounwind
2728 %puts = tail call i32 @puts(i8* getelementptr inbounds ([16 x i8]* @str, i64 0, i64 0))
2729 tail call void @objc_release(i8* %0) nounwind
2730 ret i32 0
2731 }
2733 @"\01L_OBJC_METH_VAR_NAME_" = internal global [5 x i8] c"frob\00", section "__TEXT,__cstring,cstring_literals", align 1@"\01L_OBJC_SELECTOR_REFERENCES_" = internal global i8* getelementptr inbounds ([5 x i8]* @"\01L_OBJC_METH_VAR_NAME_", i64 0, i64 0), section "__DATA, __objc_selrefs, literal_pointers, no_dead_strip"
2734 @"\01L_OBJC_IMAGE_INFO" = internal constant [2 x i32] [i32 0, i32 16], section "__DATA, __objc_imageinfo, regular, no_dead_strip"
2735 @llvm.used = appending global [3 x i8*] [i8* getelementptr inbounds ([5 x i8]* @"\01L_OBJC_METH_VAR_NAME_", i32 0, i32 0), i8* bitcast (i8** @"\01L_OBJC_SELECTOR_REFERENCES_" to i8*), i8* bitcast ([2 x i32]* @"\01L_OBJC_IMAGE_INFO" to i8*)], section "llvm.metadata"
2737 ; A simple loop. Eliminate the retain and release inside of it!
2739 ; CHECK: define void @loop(i8* %x, i64 %n) {
2740 ; CHECK: for.body:
2741 ; CHECK-NOT: @objc_
2742 ; CHECK: @objc_msgSend
2743 ; CHECK-NOT: @objc_
2744 ; CHECK: for.end:
2745 ; CHECK: }
2746 define void @loop(i8* %x, i64 %n) {
2747 entry:
2748 %0 = tail call i8* @objc_retain(i8* %x) nounwind
2749 %cmp9 = icmp sgt i64 %n, 0
2750 br i1 %cmp9, label %for.body, label %for.end
2752 for.body: ; preds = %entry, %for.body
2753 %i.010 = phi i64 [ %inc, %for.body ], [ 0, %entry ]
2754 %1 = tail call i8* @objc_retain(i8* %x) nounwind
2755 %tmp5 = load i8** @"\01L_OBJC_SELECTOR_REFERENCES_", align 8
2756 %call = tail call i8* (i8*, i8*, ...)* @objc_msgSend(i8* %1, i8* %tmp5)
2757 tail call void @objc_release(i8* %1) nounwind, !clang.imprecise_release !0
2758 %inc = add nsw i64 %i.010, 1
2759 %exitcond = icmp eq i64 %inc, %n
2760 br i1 %exitcond, label %for.end, label %for.body
2762 for.end: ; preds = %for.body, %entry
2763 tail call void @objc_release(i8* %x) nounwind, !clang.imprecise_release !0
2764 ret void
2765 }
2767 ; ObjCARCOpt can delete the retain,release on self.
2769 ; CHECK: define void @TextEditTest(%2* %self, %3* %pboard) {
2770 ; CHECK-NOT: call i8* @objc_retain(i8* %tmp7)
2771 ; CHECK: }
2773 %0 = type { i8* (i8*, %struct._message_ref_t*, ...)*, i8* }
2774 %1 = type opaque
2775 %2 = type opaque
2776 %3 = type opaque
2777 %4 = type opaque
2778 %5 = type opaque
2779 %struct.NSConstantString = type { i32*, i32, i8*, i64 }
2780 %struct._NSRange = type { i64, i64 }
2781 %struct.__CFString = type opaque
2782 %struct.__method_list_t = type { i32, i32, [0 x %struct._objc_method] }
2783 %struct._class_ro_t = type { i32, i32, i32, i8*, i8*, %struct.__method_list_t*, %struct._objc_protocol_list*, %struct._ivar_list_t*, i8*, %struct._prop_list_t* }
2784 %struct._class_t = type { %struct._class_t*, %struct._class_t*, %struct._objc_cache*, i8* (i8*, i8*)**, %struct._class_ro_t* }
2785 %struct._ivar_list_t = type { i32, i32, [0 x %struct._ivar_t] }
2786 %struct._ivar_t = type { i64*, i8*, i8*, i32, i32 }
2787 %struct._message_ref_t = type { i8*, i8* }
2788 %struct._objc_cache = type opaque
2789 %struct._objc_method = type { i8*, i8*, i8* }
2790 %struct._objc_protocol_list = type { i64, [0 x %struct._protocol_t*] }
2791 %struct._prop_list_t = type { i32, i32, [0 x %struct._message_ref_t] }
2792 %struct._protocol_t = type { i8*, i8*, %struct._objc_protocol_list*, %struct.__method_list_t*, %struct.__method_list_t*, %struct.__method_list_t*, %struct.__method_list_t*, %struct._prop_list_t*, i32, i32 }
2794 @"\01L_OBJC_CLASSLIST_REFERENCES_$_17" = external hidden global %struct._class_t*, section "__DATA, __objc_classrefs, regular, no_dead_strip", align 8
2795 @kUTTypePlainText = external constant %struct.__CFString*
2796 @"\01L_OBJC_SELECTOR_REFERENCES_19" = external hidden global i8*, section "__DATA, __objc_selrefs, literal_pointers, no_dead_strip"
2797 @"\01L_OBJC_SELECTOR_REFERENCES_21" = external hidden global i8*, section "__DATA, __objc_selrefs, literal_pointers, no_dead_strip"
2798 @"\01L_OBJC_SELECTOR_REFERENCES_23" = external hidden global i8*, section "__DATA, __objc_selrefs, literal_pointers, no_dead_strip"
2799 @"\01L_OBJC_SELECTOR_REFERENCES_25" = external hidden global i8*, section "__DATA, __objc_selrefs, literal_pointers, no_dead_strip"
2800 @"\01L_OBJC_CLASSLIST_REFERENCES_$_26" = external hidden global %struct._class_t*, section "__DATA, __objc_classrefs, regular, no_dead_strip", align 8
2801 @"\01L_OBJC_SELECTOR_REFERENCES_28" = external hidden global i8*, section "__DATA, __objc_selrefs, literal_pointers, no_dead_strip"
2802 @"\01L_OBJC_CLASSLIST_REFERENCES_$_29" = external hidden global %struct._class_t*, section "__DATA, __objc_classrefs, regular, no_dead_strip", align 8
2803 @"\01L_OBJC_SELECTOR_REFERENCES_31" = external hidden global i8*, section "__DATA, __objc_selrefs, literal_pointers, no_dead_strip"
2804 @"\01L_OBJC_SELECTOR_REFERENCES_33" = external hidden global i8*, section "__DATA, __objc_selrefs, literal_pointers, no_dead_strip"
2805 @"\01L_OBJC_SELECTOR_REFERENCES_35" = external hidden global i8*, section "__DATA, __objc_selrefs, literal_pointers, no_dead_strip"
2806 @"\01L_OBJC_SELECTOR_REFERENCES_37" = external hidden global i8*, section "__DATA, __objc_selrefs, literal_pointers, no_dead_strip"
2807 @"\01L_OBJC_CLASSLIST_REFERENCES_$_38" = external hidden global %struct._class_t*, section "__DATA, __objc_classrefs, regular, no_dead_strip", align 8
2808 @"\01L_OBJC_SELECTOR_REFERENCES_40" = external hidden global i8*, section "__DATA, __objc_selrefs, literal_pointers, no_dead_strip"
2809 @"\01L_OBJC_SELECTOR_REFERENCES_42" = external hidden global i8*, section "__DATA, __objc_selrefs, literal_pointers, no_dead_strip"
2810 @_unnamed_cfstring_44 = external hidden constant %struct.NSConstantString, section "__DATA,__cfstring"
2811 @"\01L_OBJC_SELECTOR_REFERENCES_46" = external hidden global i8*, section "__DATA, __objc_selrefs, literal_pointers, no_dead_strip"
2812 @"\01L_OBJC_SELECTOR_REFERENCES_48" = external hidden global i8*, section "__DATA, __objc_selrefs, literal_pointers, no_dead_strip"
2813 @"\01l_objc_msgSend_fixup_isEqual_" = external hidden global %0, section "__DATA, __objc_msgrefs, coalesced", align 16
2814 @"\01L_OBJC_CLASSLIST_REFERENCES_$_50" = external hidden global %struct._class_t*, section "__DATA, __objc_classrefs, regular, no_dead_strip", align 8
2815 @NSCocoaErrorDomain = external constant %1*
2816 @"\01L_OBJC_CLASSLIST_REFERENCES_$_51" = external hidden global %struct._class_t*, section "__DATA, __objc_classrefs, regular, no_dead_strip", align 8
2817 @NSFilePathErrorKey = external constant %1*
2818 @"\01L_OBJC_SELECTOR_REFERENCES_53" = external hidden global i8*, section "__DATA, __objc_selrefs, literal_pointers, no_dead_strip"
2819 @"\01L_OBJC_SELECTOR_REFERENCES_55" = external hidden global i8*, section "__DATA, __objc_selrefs, literal_pointers, no_dead_strip"
2820 @"\01L_OBJC_CLASSLIST_REFERENCES_$_56" = external hidden global %struct._class_t*, section "__DATA, __objc_classrefs, regular, no_dead_strip", align 8
2821 @"\01L_OBJC_SELECTOR_REFERENCES_58" = external hidden global i8*, section "__DATA, __objc_selrefs, literal_pointers, no_dead_strip"
2822 @"\01L_OBJC_SELECTOR_REFERENCES_60" = external hidden global i8*, section "__DATA, __objc_selrefs, literal_pointers, no_dead_strip"
2824 declare %1* @truncatedString(%1*, i64)
2825 define void @TextEditTest(%2* %self, %3* %pboard) {
2826 entry:
2827 %err = alloca %4*, align 8
2828 %tmp7 = bitcast %2* %self to i8*
2829 %tmp8 = call i8* @objc_retain(i8* %tmp7) nounwind
2830 store %4* null, %4** %err, align 8
2831 %tmp1 = load %struct._class_t** @"\01L_OBJC_CLASSLIST_REFERENCES_$_17", align 8
2832 %tmp2 = load %struct.__CFString** @kUTTypePlainText, align 8
2833 %tmp3 = load i8** @"\01L_OBJC_SELECTOR_REFERENCES_19", align 8
2834 %tmp4 = bitcast %struct._class_t* %tmp1 to i8*
2835 %call5 = call i8* (i8*, i8*, ...)* @objc_msgSend(i8* %tmp4, i8* %tmp3, %struct.__CFString* %tmp2)
2836 %tmp5 = load i8** @"\01L_OBJC_SELECTOR_REFERENCES_21", align 8
2837 %tmp6 = bitcast %3* %pboard to i8*
2838 %call76 = call i8* (i8*, i8*, ...)* @objc_msgSend(i8* %tmp6, i8* %tmp5, i8* %call5)
2839 %tmp9 = call i8* @objc_retain(i8* %call76) nounwind
2840 %tobool = icmp eq i8* %tmp9, null
2841 br i1 %tobool, label %end, label %land.lhs.true
2843 land.lhs.true: ; preds = %entry
2844 %tmp11 = load i8** @"\01L_OBJC_SELECTOR_REFERENCES_23", align 8
2845 %call137 = call i8* (i8*, i8*, ...)* @objc_msgSend(i8* %tmp6, i8* %tmp11, i8* %tmp9)
2846 %tmp = bitcast i8* %call137 to %1*
2847 %tmp10 = call i8* @objc_retain(i8* %call137) nounwind
2848 call void @objc_release(i8* null) nounwind
2849 %tmp12 = call i8* @objc_retain(i8* %call137) nounwind
2850 call void @objc_release(i8* null) nounwind
2851 %tobool16 = icmp eq i8* %call137, null
2852 br i1 %tobool16, label %end, label %if.then
2854 if.then: ; preds = %land.lhs.true
2855 %tmp19 = load i8** @"\01L_OBJC_SELECTOR_REFERENCES_25", align 8
2856 %call21 = call signext i8 bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to i8 (i8*, i8*)*)(i8* %call137, i8* %tmp19)
2857 %tobool22 = icmp eq i8 %call21, 0
2858 br i1 %tobool22, label %if.then44, label %land.lhs.true23
2860 land.lhs.true23: ; preds = %if.then
2861 %tmp24 = load %struct._class_t** @"\01L_OBJC_CLASSLIST_REFERENCES_$_26", align 8
2862 %tmp26 = load i8** @"\01L_OBJC_SELECTOR_REFERENCES_28", align 8
2863 %tmp27 = bitcast %struct._class_t* %tmp24 to i8*
2864 %call2822 = call i8* (i8*, i8*, ...)* @objc_msgSend(i8* %tmp27, i8* %tmp26, i8* %call137)
2865 %tmp13 = bitcast i8* %call2822 to %5*
2866 %tmp14 = call i8* @objc_retain(i8* %call2822) nounwind
2867 call void @objc_release(i8* null) nounwind
2868 %tobool30 = icmp eq i8* %call2822, null
2869 br i1 %tobool30, label %if.then44, label %if.end
2871 if.end: ; preds = %land.lhs.true23
2872 %tmp32 = load %struct._class_t** @"\01L_OBJC_CLASSLIST_REFERENCES_$_29", align 8
2873 %tmp33 = load i8** @"\01L_OBJC_SELECTOR_REFERENCES_31", align 8
2874 %tmp34 = bitcast %struct._class_t* %tmp32 to i8*
2875 %call35 = call i8* (i8*, i8*, ...)* @objc_msgSend(i8* %tmp34, i8* %tmp33)
2876 %tmp37 = load i8** @"\01L_OBJC_SELECTOR_REFERENCES_33", align 8
2877 %call3923 = call i8* (i8*, i8*, ...)* @objc_msgSend(i8* %call35, i8* %tmp37, i8* %call2822, i32 signext 1, %4** %err)
2878 %cmp = icmp eq i8* %call3923, null
2879 br i1 %cmp, label %if.then44, label %end
2881 if.then44: ; preds = %if.end, %land.lhs.true23, %if.then
2882 %url.025 = phi %5* [ %tmp13, %if.end ], [ %tmp13, %land.lhs.true23 ], [ null, %if.then ]
2883 %tmp49 = load i8** @"\01L_OBJC_SELECTOR_REFERENCES_35", align 8
2884 %call51 = call %struct._NSRange bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to %struct._NSRange (i8*, i8*, i64, i64)*)(i8* %call137, i8* %tmp49, i64 0, i64 0)
2885 %call513 = extractvalue %struct._NSRange %call51, 0
2886 %call514 = extractvalue %struct._NSRange %call51, 1
2887 %tmp52 = load i8** @"\01L_OBJC_SELECTOR_REFERENCES_37", align 8
2888 %call548 = call i8* (i8*, i8*, ...)* @objc_msgSend(i8* %call137, i8* %tmp52, i64 %call513, i64 %call514)
2889 %tmp55 = load %struct._class_t** @"\01L_OBJC_CLASSLIST_REFERENCES_$_38", align 8
2890 %tmp56 = load i8** @"\01L_OBJC_SELECTOR_REFERENCES_40", align 8
2891 %tmp57 = bitcast %struct._class_t* %tmp55 to i8*
2892 %call58 = call i8* (i8*, i8*, ...)* @objc_msgSend(i8* %tmp57, i8* %tmp56)
2893 %tmp59 = load i8** @"\01L_OBJC_SELECTOR_REFERENCES_42", align 8
2894 %call6110 = call i8* (i8*, i8*, ...)* @objc_msgSend(i8* %call548, i8* %tmp59, i8* %call58)
2895 %tmp15 = call i8* @objc_retain(i8* %call6110) nounwind
2896 call void @objc_release(i8* %call137) nounwind
2897 %tmp64 = load i8** @"\01L_OBJC_SELECTOR_REFERENCES_46", align 8
2898 %call66 = call signext i8 bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to i8 (i8*, i8*, %1*)*)(i8* %call6110, i8* %tmp64, %1* bitcast (%struct.NSConstantString* @_unnamed_cfstring_44 to %1*))
2899 %tobool67 = icmp eq i8 %call66, 0
2900 br i1 %tobool67, label %if.end74, label %if.then68
2902 if.then68: ; preds = %if.then44
2903 %tmp70 = load i8** @"\01L_OBJC_SELECTOR_REFERENCES_48", align 8
2904 %call7220 = call i8* (i8*, i8*, ...)* @objc_msgSend(i8* %call6110, i8* %tmp70)
2905 %tmp16 = call i8* @objc_retain(i8* %call7220) nounwind
2906 call void @objc_release(i8* %call6110) nounwind
2907 br label %if.end74
2909 if.end74: ; preds = %if.then68, %if.then44
2910 %filename.0.in = phi i8* [ %call7220, %if.then68 ], [ %call6110, %if.then44 ]
2911 %filename.0 = bitcast i8* %filename.0.in to %1*
2912 %tmp17 = load i8** bitcast (%0* @"\01l_objc_msgSend_fixup_isEqual_" to i8**), align 16
2913 %tmp18 = bitcast i8* %tmp17 to i8 (i8*, %struct._message_ref_t*, i8*, ...)*
2914 %call78 = call signext i8 (i8*, %struct._message_ref_t*, i8*, ...)* %tmp18(i8* %call137, %struct._message_ref_t* bitcast (%0* @"\01l_objc_msgSend_fixup_isEqual_" to %struct._message_ref_t*), i8* %filename.0.in)
2915 %tobool79 = icmp eq i8 %call78, 0
2916 br i1 %tobool79, label %land.lhs.true80, label %if.then109
2918 land.lhs.true80: ; preds = %if.end74
2919 %tmp82 = load i8** @"\01L_OBJC_SELECTOR_REFERENCES_25", align 8
2920 %call84 = call signext i8 bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to i8 (i8*, i8*)*)(i8* %filename.0.in, i8* %tmp82)
2921 %tobool86 = icmp eq i8 %call84, 0
2922 br i1 %tobool86, label %if.then109, label %if.end106
2924 if.end106: ; preds = %land.lhs.true80
2925 %tmp88 = load %struct._class_t** @"\01L_OBJC_CLASSLIST_REFERENCES_$_26", align 8
2926 %tmp90 = load i8** @"\01L_OBJC_SELECTOR_REFERENCES_28", align 8
2927 %tmp91 = bitcast %struct._class_t* %tmp88 to i8*
2928 %call9218 = call i8* (i8*, i8*, ...)* @objc_msgSend(i8* %tmp91, i8* %tmp90, i8* %filename.0.in)
2929 %tmp20 = bitcast i8* %call9218 to %5*
2930 %tmp21 = call i8* @objc_retain(i8* %call9218) nounwind
2931 %tmp22 = bitcast %5* %url.025 to i8*
2932 call void @objc_release(i8* %tmp22) nounwind
2933 %tmp94 = load %struct._class_t** @"\01L_OBJC_CLASSLIST_REFERENCES_$_29", align 8
2934 %tmp95 = load i8** @"\01L_OBJC_SELECTOR_REFERENCES_31", align 8
2935 %tmp96 = bitcast %struct._class_t* %tmp94 to i8*
2936 %call97 = call i8* (i8*, i8*, ...)* @objc_msgSend(i8* %tmp96, i8* %tmp95)
2937 %tmp99 = load i8** @"\01L_OBJC_SELECTOR_REFERENCES_33", align 8
2938 %call10119 = call i8* (i8*, i8*, ...)* @objc_msgSend(i8* %call97, i8* %tmp99, i8* %call9218, i32 signext 1, %4** %err)
2939 %phitmp = icmp eq i8* %call10119, null
2940 br i1 %phitmp, label %if.then109, label %end
2942 if.then109: ; preds = %if.end106, %land.lhs.true80, %if.end74
2943 %url.129 = phi %5* [ %tmp20, %if.end106 ], [ %url.025, %if.end74 ], [ %url.025, %land.lhs.true80 ]
2944 %tmp110 = load %4** %err, align 8
2945 %tobool111 = icmp eq %4* %tmp110, null
2946 br i1 %tobool111, label %if.then112, label %if.end125
2948 if.then112: ; preds = %if.then109
2949 %tmp113 = load %struct._class_t** @"\01L_OBJC_CLASSLIST_REFERENCES_$_50", align 8
2950 %tmp114 = load %1** @NSCocoaErrorDomain, align 8
2951 %tmp115 = load %struct._class_t** @"\01L_OBJC_CLASSLIST_REFERENCES_$_51", align 8
2952 %call117 = call %1* @truncatedString(%1* %filename.0, i64 1034)
2953 %tmp118 = load %1** @NSFilePathErrorKey, align 8
2954 %tmp119 = load i8** @"\01L_OBJC_SELECTOR_REFERENCES_53", align 8
2955 %tmp120 = bitcast %struct._class_t* %tmp115 to i8*
2956 %call12113 = call i8* (i8*, i8*, ...)* @objc_msgSend(i8* %tmp120, i8* %tmp119, %1* %call117, %1* %tmp118, i8* null)
2957 %tmp122 = load i8** @"\01L_OBJC_SELECTOR_REFERENCES_55", align 8
2958 %tmp123 = bitcast %struct._class_t* %tmp113 to i8*
2959 %call12414 = call i8* (i8*, i8*, ...)* @objc_msgSend(i8* %tmp123, i8* %tmp122, %1* %tmp114, i64 258, i8* %call12113)
2960 %tmp23 = call i8* @objc_retain(i8* %call12414) nounwind
2961 %tmp25 = call i8* @objc_autorelease(i8* %tmp23) nounwind
2962 %tmp28 = bitcast i8* %tmp25 to %4*
2963 store %4* %tmp28, %4** %err, align 8
2964 br label %if.end125
2966 if.end125: ; preds = %if.then112, %if.then109
2967 %tmp127 = phi %4* [ %tmp110, %if.then109 ], [ %tmp28, %if.then112 ]
2968 %tmp126 = load %struct._class_t** @"\01L_OBJC_CLASSLIST_REFERENCES_$_56", align 8
2969 %tmp128 = load i8** @"\01L_OBJC_SELECTOR_REFERENCES_58", align 8
2970 %tmp129 = bitcast %struct._class_t* %tmp126 to i8*
2971 %call13015 = call i8* (i8*, i8*, ...)* @objc_msgSend(i8* %tmp129, i8* %tmp128, %4* %tmp127)
2972 %tmp131 = load i8** @"\01L_OBJC_SELECTOR_REFERENCES_60", align 8
2973 %call13317 = call i8* (i8*, i8*, ...)* @objc_msgSend(i8* %call13015, i8* %tmp131)
2974 br label %end
2976 end: ; preds = %if.end125, %if.end106, %if.end, %land.lhs.true, %entry
2977 %filename.2 = phi %1* [ %filename.0, %if.end106 ], [ %filename.0, %if.end125 ], [ %tmp, %land.lhs.true ], [ null, %entry ], [ %tmp, %if.end ]
2978 %origFilename.0 = phi %1* [ %tmp, %if.end106 ], [ %tmp, %if.end125 ], [ %tmp, %land.lhs.true ], [ null, %entry ], [ %tmp, %if.end ]
2979 %url.2 = phi %5* [ %tmp20, %if.end106 ], [ %url.129, %if.end125 ], [ null, %land.lhs.true ], [ null, %entry ], [ %tmp13, %if.end ]
2980 call void @objc_release(i8* %tmp9) nounwind, !clang.imprecise_release !0
2981 %tmp29 = bitcast %5* %url.2 to i8*
2982 call void @objc_release(i8* %tmp29) nounwind, !clang.imprecise_release !0
2983 %tmp30 = bitcast %1* %origFilename.0 to i8*
2984 call void @objc_release(i8* %tmp30) nounwind, !clang.imprecise_release !0
2985 %tmp31 = bitcast %1* %filename.2 to i8*
2986 call void @objc_release(i8* %tmp31) nounwind, !clang.imprecise_release !0
2987 call void @objc_release(i8* %tmp7) nounwind, !clang.imprecise_release !0
2988 ret void
2989 }
2991 declare i32 @__gxx_personality_v0(...)
2993 declare i32 @objc_sync_enter(i8*)
2994 declare i32 @objc_sync_exit(i8*)
2996 ; Make sure that we understand that objc_sync_{enter,exit} are IC_User not
2997 ; IC_Call/IC_CallOrUser.
2999 ; CHECK-LABEL: define void @test67(
3000 ; CHECK-NEXT: call i32 @objc_sync_enter(i8* %x)
3001 ; CHECK-NEXT: call i32 @objc_sync_exit(i8* %x)
3002 ; CHECK-NEXT: ret void
3003 ; CHECK-NEXT: }
3004 define void @test67(i8* %x) {
3005 call i8* @objc_retain(i8* %x)
3006 call i32 @objc_sync_enter(i8* %x)
3007 call i32 @objc_sync_exit(i8* %x)
3008 call void @objc_release(i8* %x), !clang.imprecise_release !0
3009 ret void
3010 }
3012 !llvm.module.flags = !{!1}
3014 !0 = metadata !{}
3015 !1 = metadata !{i32 1, metadata !"Debug Info Version", i32 1}
3017 ; CHECK: attributes #0 = { nounwind readnone }
3018 ; CHECK: attributes [[NUW]] = { nounwind }
3019 ; CHECK: ![[RELEASE]] = metadata !{}