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]+]] {
34 ; CHECK: @objc_release
36 define void @test0_precise(i32* %x, i1 %p) nounwind {
38 %a = bitcast i32* %x to i8*
39 %0 = call i8* @objc_retain(i8* %a) nounwind
40 br i1 %p, label %t, label %f
44 %b = bitcast i32* %x to float*
45 store float 2.0, float* %b
53 %c = bitcast i32* %x to i8*
54 call void @objc_release(i8* %c) nounwind
58 ; CHECK: define void @test0_imprecise(i32* %x, i1 %p) [[NUW]] {
61 define void @test0_imprecise(i32* %x, i1 %p) nounwind {
63 %a = bitcast i32* %x to i8*
64 %0 = call i8* @objc_retain(i8* %a) nounwind
65 br i1 %p, label %t, label %f
69 %b = bitcast i32* %x to float*
70 store float 2.0, float* %b
78 %c = bitcast i32* %x to i8*
79 call void @objc_release(i8* %c) nounwind, !clang.imprecise_release !0
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
92 define void @test1_precise(i32* %x, i1 %p, i1 %q) nounwind {
94 %a = bitcast i32* %x to i8*
95 %0 = call i8* @objc_retain(i8* %a) nounwind
96 br i1 %p, label %t, label %f
100 %b = bitcast i32* %x to float*
101 store float 2.0, float* %b
107 br i1 %q, label %return, label %alt_return
110 %c = bitcast i32* %x to i8*
111 call void @objc_release(i8* %c) nounwind
118 ; CHECK: define void @test1_imprecise(i32* %x, i1 %p, i1 %q) [[NUW]] {
119 ; CHECK: @objc_retain(i8* %a)
120 ; CHECK: @objc_release
122 define void @test1_imprecise(i32* %x, i1 %p, i1 %q) nounwind {
124 %a = bitcast i32* %x to i8*
125 %0 = call i8* @objc_retain(i8* %a) nounwind
126 br i1 %p, label %t, label %f
130 %b = bitcast i32* %x to float*
131 store float 2.0, float* %b
137 br i1 %q, label %return, label %alt_return
140 %c = bitcast i32* %x to i8*
141 call void @objc_release(i8* %c) nounwind, !clang.imprecise_release !0
149 ; Don't do partial elimination into two different CFG diamonds.
151 ; CHECK: define void @test1b_precise(i8* %x, i1 %p, i1 %q) {
153 ; CHECK: tail call i8* @objc_retain(i8* %x) [[NUW]]
156 ; CHECK: tail call void @objc_release(i8* %x) [[NUW]]
159 define void @test1b_precise(i8* %x, i1 %p, i1 %q) {
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()
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)
175 if.end5: ; preds = %if.then3, %if.end
176 tail call void @objc_release(i8* %x) nounwind
180 ; CHECK-LABEL: define void @test1b_imprecise(
182 ; CHECK: tail call i8* @objc_retain(i8* %x) [[NUW:#[0-9]+]]
185 ; CHECK: tail call void @objc_release(i8* %x) [[NUW]], !clang.imprecise_release ![[RELEASE:[0-9]+]]
188 define void @test1b_imprecise(i8* %x, i1 %p, i1 %q) {
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()
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)
204 if.end5: ; preds = %if.then3, %if.end
205 tail call void @objc_release(i8* %x) nounwind, !clang.imprecise_release !0
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
217 define void @test2_precise(i32* %x, i1 %p) nounwind {
219 %a = bitcast i32* %x to i8*
220 %0 = call i8* @objc_retain(i8* %a) nounwind
221 br i1 %p, label %t, label %f
225 %b = bitcast i32* %x to float*
226 store float 2.0, float* %b
231 call void @use_pointer(i8* %0)
232 %d = bitcast i32* %x to float*
233 store float 3.0, float* %d
237 %c = bitcast i32* %x to i8*
238 call void @objc_release(i8* %c) nounwind
242 ; CHECK-LABEL: define void @test2_imprecise(
243 ; CHECK: @objc_retain(i8* %a)
244 ; CHECK: @objc_release
246 define void @test2_imprecise(i32* %x, i1 %p) nounwind {
248 %a = bitcast i32* %x to i8*
249 %0 = call i8* @objc_retain(i8* %a) nounwind
250 br i1 %p, label %t, label %f
254 %b = bitcast i32* %x to float*
255 store float 2.0, float* %b
260 call void @use_pointer(i8* %0)
261 %d = bitcast i32* %x to float*
262 store float 3.0, float* %d
266 %c = bitcast i32* %x to i8*
267 call void @objc_release(i8* %c) nounwind, !clang.imprecise_release !0
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
280 define void @test3_precise(i32* %x, i1* %q) nounwind {
282 %a = bitcast i32* %x to i8*
283 %0 = call i8* @objc_retain(i8* %a) nounwind
287 %c = bitcast i32* %x to i8*
288 call void @objc_release(i8* %c) nounwind
289 %j = load volatile i1, i1* %q
290 br i1 %j, label %loop, label %return
296 ; CHECK-LABEL: define void @test3_imprecise(
297 ; TODO: @objc_retain(i8* %a)
298 ; TODO: @objc_release
300 define void @test3_imprecise(i32* %x, i1* %q) nounwind {
302 %a = bitcast i32* %x to i8*
303 %0 = call i8* @objc_retain(i8* %a) nounwind
307 %c = bitcast i32* %x to i8*
308 call void @objc_release(i8* %c) nounwind, !clang.imprecise_release !0
309 %j = load volatile i1, i1* %q
310 br i1 %j, label %loop, label %return
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
326 define void @test4_precise(i32* %x, i1* %q) nounwind {
331 %a = bitcast i32* %x to i8*
332 %0 = call i8* @objc_retain(i8* %a) nounwind
333 %j = load volatile i1, i1* %q
334 br i1 %j, label %loop, label %return
337 %c = bitcast i32* %x to i8*
338 call void @objc_release(i8* %c) nounwind
342 ; CHECK-LABEL: define void @test4_imprecise(
343 ; TODO: @objc_retain(i8* %a)
344 ; TODO: @objc_release
346 define void @test4_imprecise(i32* %x, i1* %q) nounwind {
351 %a = bitcast i32* %x to i8*
352 %0 = call i8* @objc_retain(i8* %a) nounwind
353 %j = load volatile i1, i1* %q
354 br i1 %j, label %loop, label %return
357 %c = bitcast i32* %x to i8*
358 call void @objc_release(i8* %c) nounwind, !clang.imprecise_release !0
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
370 define void @test5a(i32* %x, i1 %q, i8* %y) nounwind {
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)
377 %c = bitcast i32* %x to i8*
378 call void @objc_release(i8* %c) nounwind
382 ; CHECK-LABEL: define void @test5b(
383 ; CHECK: @objc_retain(i8*
384 ; CHECK: @objc_release
386 define void @test5b(i32* %x, i1 %q, i8* %y) nounwind {
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)
393 %c = bitcast i32* %x to i8*
394 call void @objc_release(i8* %c) nounwind, !clang.imprecise_release !0
399 ; retain+release pair deletion, where the release happens on two different
402 ; CHECK-LABEL: define void @test6a(
404 ; CHECK: tail call i8* @objc_retain(
406 ; CHECK: call void @objc_release(
408 ; CHECK: call void @objc_release(
411 define void @test6a(i32* %x, i1 %p) nounwind {
413 %a = bitcast i32* %x to i8*
414 %0 = call i8* @objc_retain(i8* %a) nounwind
415 br i1 %p, label %t, label %f
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
428 %cf = bitcast i32* %x to i8*
429 call void @objc_release(i8* %cf) nounwind
436 ; CHECK-LABEL: define void @test6b(
439 define void @test6b(i32* %x, i1 %p) nounwind {
441 %a = bitcast i32* %x to i8*
442 %0 = call i8* @objc_retain(i8* %a) nounwind
443 br i1 %p, label %t, label %f
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
456 %cf = bitcast i32* %x to i8*
457 call void @objc_release(i8* %cf) nounwind, !clang.imprecise_release !0
464 ; CHECK-LABEL: define void @test6c(
466 ; CHECK: tail call i8* @objc_retain(
468 ; CHECK: call void @objc_release(
470 ; CHECK: call void @objc_release(
473 define void @test6c(i32* %x, i1 %p) nounwind {
475 %a = bitcast i32* %x to i8*
476 %0 = call i8* @objc_retain(i8* %a) nounwind
477 br i1 %p, label %t, label %f
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
490 %cf = bitcast i32* %x to i8*
491 call void @objc_release(i8* %cf) nounwind, !clang.imprecise_release !0
498 ; CHECK-LABEL: define void @test6d(
500 ; CHECK: tail call i8* @objc_retain(
502 ; CHECK: call void @objc_release(
504 ; CHECK: call void @objc_release(
507 define void @test6d(i32* %x, i1 %p) nounwind {
509 %a = bitcast i32* %x to i8*
510 %0 = call i8* @objc_retain(i8* %a) nounwind
511 br i1 %p, label %t, label %f
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
524 %cf = bitcast i32* %x to i8*
525 call void @objc_release(i8* %cf) nounwind
533 ; retain+release pair deletion, where the retain happens on two different
536 ; CHECK-LABEL: define void @test7(
540 ; CHECK: call i8* @objc_retain
542 ; CHECK: call i8* @objc_retain
544 ; CHECK: call void @objc_release
546 define void @test7(i32* %x, i1 %p) nounwind {
548 %a = bitcast i32* %x to i8*
549 br i1 %p, label %t, label %f
552 %0 = call i8* @objc_retain(i8* %a) nounwind
554 %b = bitcast i32* %x to float*
555 store float 2.0, float* %b
559 %1 = call i8* @objc_retain(i8* %a) nounwind
565 %c = bitcast i32* %x to i8*
566 call void @objc_release(i8* %c) nounwind
570 ; CHECK-LABEL: define void @test7b(
573 define void @test7b(i32* %x, i1 %p) nounwind {
575 %a = bitcast i32* %x to i8*
576 br i1 %p, label %t, label %f
579 %0 = call i8* @objc_retain(i8* %a) nounwind
581 %b = bitcast i32* %x to float*
582 store float 2.0, float* %b
586 %1 = call i8* @objc_retain(i8* %a) nounwind
592 %c = bitcast i32* %x to i8*
593 call void @objc_release(i8* %c) nounwind, !clang.imprecise_release !0
597 ; Like test7, but there's a retain/retainBlock mismatch. Don't delete!
599 ; CHECK-LABEL: define void @test7c(
601 ; CHECK: call i8* @objc_retainBlock
603 ; CHECK: call i8* @objc_retain
605 ; CHECK: call void @objc_release
607 define void @test7c(i32* %x, i1 %p) nounwind {
609 %a = bitcast i32* %x to i8*
610 br i1 %p, label %t, label %f
613 %0 = call i8* @objc_retainBlock(i8* %a) nounwind
615 %b = bitcast i32* %x to float*
616 store float 2.0, float* %b
620 %1 = call i8* @objc_retain(i8* %a) nounwind
626 %c = bitcast i32* %x to i8*
627 call void @objc_release(i8* %c) nounwind
631 ; retain+release pair deletion, where the retain and release both happen on
632 ; different flow paths. Wild!
634 ; CHECK-LABEL: define void @test8a(
637 ; CHECK: @objc_retain
639 ; CHECK: @objc_retain
642 ; CHECK: @objc_release
644 ; CHECK: @objc_release
647 define void @test8a(i32* %x, i1 %p, i1 %q) nounwind {
649 %a = bitcast i32* %x to i8*
650 br i1 %p, label %t, label %f
653 %0 = call i8* @objc_retain(i8* %a) nounwind
655 %b = bitcast i32* %x to float*
656 store float 2.0, float* %b
660 %1 = call i8* @objc_retain(i8* %a) nounwind
665 br i1 %q, label %u, label %g
669 %cu = bitcast i32* %x to i8*
670 call void @objc_release(i8* %cu) nounwind
674 %cg = bitcast i32* %x to i8*
675 call void @objc_release(i8* %cg) nounwind
682 ; CHECK-LABEL: define void @test8b(
685 define void @test8b(i32* %x, i1 %p, i1 %q) nounwind {
687 %a = bitcast i32* %x to i8*
688 br i1 %p, label %t, label %f
691 %0 = call i8* @objc_retain(i8* %a) nounwind
693 %b = bitcast i32* %x to float*
694 store float 2.0, float* %b
698 %1 = call i8* @objc_retain(i8* %a) nounwind
703 br i1 %q, label %u, label %g
707 %cu = bitcast i32* %x to i8*
708 call void @objc_release(i8* %cu) nounwind, !clang.imprecise_release !0
712 %cg = bitcast i32* %x to i8*
713 call void @objc_release(i8* %cg) nounwind, !clang.imprecise_release !0
720 ; CHECK-LABEL: define void @test8c(
723 ; CHECK: @objc_retain
725 ; CHECK: @objc_retain
728 ; CHECK: @objc_release
730 ; CHECK: @objc_release
733 define void @test8c(i32* %x, i1 %p, i1 %q) nounwind {
735 %a = bitcast i32* %x to i8*
736 br i1 %p, label %t, label %f
739 %0 = call i8* @objc_retain(i8* %a) nounwind
741 %b = bitcast i32* %x to float*
742 store float 2.0, float* %b
746 %1 = call i8* @objc_retain(i8* %a) nounwind
751 br i1 %q, label %u, label %g
755 %cu = bitcast i32* %x to i8*
756 call void @objc_release(i8* %cu) nounwind
760 %cg = bitcast i32* %x to i8*
761 call void @objc_release(i8* %cg) nounwind, !clang.imprecise_release !0
768 ; CHECK-LABEL: define void @test8d(
771 ; CHECK: @objc_retain
773 ; CHECK: @objc_retain
776 ; CHECK: @objc_release
778 ; CHECK: @objc_release
781 define void @test8d(i32* %x, i1 %p, i1 %q) nounwind {
783 %a = bitcast i32* %x to i8*
784 br i1 %p, label %t, label %f
787 %0 = call i8* @objc_retain(i8* %a) nounwind
789 %b = bitcast i32* %x to float*
790 store float 2.0, float* %b
794 %1 = call i8* @objc_retain(i8* %a) nounwind
799 br i1 %q, label %u, label %g
803 %cu = bitcast i32* %x to i8*
804 call void @objc_release(i8* %cu) nounwind, !clang.imprecise_release !0
808 %cg = bitcast i32* %x to i8*
809 call void @objc_release(i8* %cg) nounwind
816 ; Trivial retain+release pair deletion.
818 ; CHECK-LABEL: define void @test9(
821 define void @test9(i8* %x) nounwind {
823 %0 = call i8* @objc_retain(i8* %x) nounwind
824 call void @objc_release(i8* %0) nounwind
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)
834 define void @test9b(i8* %x, i1 %j, i8* %p) nounwind {
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
842 ; Trivial retain+release pair with intervening calls - don't delete!
844 ; CHECK-LABEL: define void @test10(
845 ; CHECK: @objc_retain(i8* %x)
847 ; CHECK: @use_pointer
848 ; CHECK: @objc_release
850 define void @test10(i8* %x) nounwind {
852 %0 = call i8* @objc_retain(i8* %x) nounwind
854 call void @use_pointer(i8* %x)
855 call void @objc_release(i8* %0) nounwind
859 ; Trivial retain+autoreleaserelease pair. Don't delete!
860 ; Also, add a tail keyword, since objc_retain can never be passed
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]]
867 define void @test11(i8* %x) nounwind {
869 %0 = call i8* @objc_retain(i8* %x) nounwind
870 call i8* @objc_autorelease(i8* %0) nounwind
871 call void @use_pointer(i8* %x)
875 ; Same as test11 but with no use_pointer call. Delete the pair!
877 ; CHECK-LABEL: define void @test11a(
879 ; CHECK-NEXT: ret void
881 define void @test11a(i8* %x) nounwind {
883 %0 = call i8* @objc_retain(i8* %x) nounwind
884 call i8* @objc_autorelease(i8* %0) nounwind
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]]
896 define i8* @test11b(i8* %x) nounwind {
898 %0 = call i8* @objc_retain(i8* %x) nounwind
899 call i8* @objc_autorelease(i8* %0) nounwind
903 ; We can not delete this retain, release since we do not have a post-dominating
904 ; use of the release.
906 ; CHECK-LABEL: define void @test12(
908 ; CHECK-NEXT: @objc_retain(i8* %x)
909 ; CHECK-NEXT: @objc_retain
910 ; CHECK: @objc_release
912 define void @test12(i8* %x, i64 %n) {
914 call i8* @objc_retain(i8* %x) nounwind
915 call i8* @objc_retain(i8* %x) nounwind
916 call void @use_pointer(i8* %x)
917 call void @use_pointer(i8* %x)
918 call void @objc_release(i8* %x) nounwind
922 ; Trivial retain,autorelease pair. Don't delete!
924 ; CHECK-LABEL: define void @test13(
925 ; CHECK: tail call i8* @objc_retain(i8* %x) [[NUW]]
926 ; CHECK: tail call i8* @objc_retain(i8* %x) [[NUW]]
927 ; CHECK: @use_pointer(i8* %x)
928 ; CHECK: call i8* @objc_autorelease(i8* %x) [[NUW]]
930 define void @test13(i8* %x, i64 %n) {
932 call i8* @objc_retain(i8* %x) nounwind
933 call i8* @objc_retain(i8* %x) nounwind
934 call void @use_pointer(i8* %x)
935 call i8* @objc_autorelease(i8* %x) nounwind
939 ; Delete the retain+release pair.
941 ; CHECK-LABEL: define void @test13b(
943 ; CHECK-NEXT: @objc_retain(i8* %x)
944 ; CHECK-NEXT: @use_pointer
945 ; CHECK-NEXT: @use_pointer
946 ; CHECK-NEXT: @use_pointer
947 ; CHECK-NEXT: @objc_release
948 ; CHECK-NEXT: ret void
950 define void @test13b(i8* %x, i64 %n) {
952 call i8* @objc_retain(i8* %x) nounwind
953 call i8* @objc_retain(i8* %x) nounwind
954 call void @use_pointer(i8* %x)
955 call void @use_pointer(i8* %x)
956 call void @objc_release(i8* %x) nounwind
957 call void @use_pointer(i8* %x)
958 call void @objc_release(i8* %x) nounwind
962 ; Don't delete the retain+release pair because there's an
963 ; autoreleasePoolPop in the way.
965 ; CHECK-LABEL: define void @test13c(
966 ; CHECK: @objc_retain(i8* %x)
967 ; CHECK: @objc_autoreleasePoolPop
968 ; CHECK: @objc_retain(i8* %x)
969 ; CHECK: @use_pointer
970 ; CHECK: @objc_release
972 define void @test13c(i8* %x, i64 %n) {
974 call i8* @objc_retain(i8* %x) nounwind
975 call void @objc_autoreleasePoolPop(i8* undef)
976 call i8* @objc_retain(i8* %x) nounwind
977 call void @use_pointer(i8* %x)
978 call void @use_pointer(i8* %x)
979 call void @objc_release(i8* %x) nounwind
983 ; Like test13c, but there's an autoreleasePoolPush in the way, but that
986 ; CHECK-LABEL: define void @test13d(
988 ; CHECK-NEXT: @objc_retain(i8* %x)
989 ; CHECK-NEXT: @objc_autoreleasePoolPush
990 ; CHECK-NEXT: @use_pointer
991 ; CHECK-NEXT: @use_pointer
992 ; CHECK-NEXT: @use_pointer
993 ; CHECK-NEXT: @objc_release
994 ; CHECK-NEXT: ret void
996 define void @test13d(i8* %x, i64 %n) {
998 call i8* @objc_retain(i8* %x) nounwind
999 call i8* @objc_autoreleasePoolPush()
1000 call i8* @objc_retain(i8* %x) nounwind
1001 call void @use_pointer(i8* %x)
1002 call void @use_pointer(i8* %x)
1003 call void @objc_release(i8* %x) nounwind
1004 call void @use_pointer(i8* %x)
1005 call void @objc_release(i8* %x) nounwind
1009 ; Trivial retain,release pair with intervening call, and it's post-dominated by
1010 ; another release. But it is not known safe in the top down direction. We can
1013 ; CHECK-LABEL: define void @test14(
1014 ; CHECK-NEXT: entry:
1015 ; CHECK-NEXT: @objc_retain
1016 ; CHECK-NEXT: @use_pointer
1017 ; CHECK-NEXT: @use_pointer
1018 ; CHECK-NEXT: @objc_release
1019 ; CHECK-NEXT: @objc_release
1020 ; CHECK-NEXT: ret void
1022 define void @test14(i8* %x, i64 %n) {
1024 call i8* @objc_retain(i8* %x) nounwind
1025 call void @use_pointer(i8* %x)
1026 call void @use_pointer(i8* %x)
1027 call void @objc_release(i8* %x) nounwind
1028 call void @objc_release(i8* %x) nounwind
1032 ; Trivial retain,autorelease pair with intervening call, but it's post-dominated
1033 ; by another release. Don't delete anything.
1035 ; CHECK-LABEL: define void @test15(
1036 ; CHECK-NEXT: entry:
1037 ; CHECK-NEXT: @objc_retain(i8* %x)
1038 ; CHECK-NEXT: @use_pointer
1039 ; CHECK-NEXT: @objc_autorelease(i8* %x)
1040 ; CHECK-NEXT: @objc_release
1041 ; CHECK-NEXT: ret void
1043 define void @test15(i8* %x, i64 %n) {
1045 call i8* @objc_retain(i8* %x) nounwind
1046 call void @use_pointer(i8* %x)
1047 call i8* @objc_autorelease(i8* %x) nounwind
1048 call void @objc_release(i8* %x) nounwind
1052 ; Trivial retain,autorelease pair, post-dominated
1053 ; by another release. Delete the retain and release.
1055 ; CHECK-LABEL: define void @test15b(
1056 ; CHECK-NEXT: entry:
1057 ; CHECK-NEXT: @objc_retain
1058 ; CHECK-NEXT: @objc_autorelease
1059 ; CHECK-NEXT: @objc_release
1060 ; CHECK-NEXT: ret void
1062 define void @test15b(i8* %x, i64 %n) {
1064 call i8* @objc_retain(i8* %x) nounwind
1065 call i8* @objc_autorelease(i8* %x) nounwind
1066 call void @objc_release(i8* %x) nounwind
1070 ; CHECK-LABEL: define void @test15c(
1071 ; CHECK-NEXT: entry:
1072 ; CHECK-NEXT: @objc_autorelease
1073 ; CHECK-NEXT: ret void
1075 define void @test15c(i8* %x, i64 %n) {
1077 call i8* @objc_retain(i8* %x) nounwind
1078 call i8* @objc_autorelease(i8* %x) nounwind
1079 call void @objc_release(i8* %x) nounwind, !clang.imprecise_release !0
1083 ; Retain+release pairs in diamonds, all dominated by a retain.
1085 ; CHECK-LABEL: define void @test16a(
1086 ; CHECK: @objc_retain(i8* %x)
1089 ; CHECK: @use_pointer
1090 ; CHECK: @objc_release
1092 define void @test16a(i1 %a, i1 %b, i8* %x) {
1094 call i8* @objc_retain(i8* %x) nounwind
1095 br i1 %a, label %red, label %orange
1098 call i8* @objc_retain(i8* %x) nounwind
1102 call i8* @objc_retain(i8* %x) nounwind
1106 call void @use_pointer(i8* %x)
1107 call void @use_pointer(i8* %x)
1108 br i1 %b, label %green, label %blue
1111 call void @objc_release(i8* %x) nounwind
1115 call void @objc_release(i8* %x) nounwind
1119 call void @use_pointer(i8* %x)
1120 call void @objc_release(i8* %x) nounwind
1124 ; CHECK-LABEL: define void @test16b(
1125 ; CHECK: @objc_retain(i8* %x)
1128 ; CHECK-NEXT: @use_pointer
1129 ; CHECK-NEXT: @use_pointer
1130 ; CHECK-NEXT: @objc_release
1132 define void @test16b(i1 %a, i1 %b, i8* %x) {
1134 call i8* @objc_retain(i8* %x) nounwind
1135 br i1 %a, label %red, label %orange
1138 call i8* @objc_retain(i8* %x) nounwind
1142 call i8* @objc_retain(i8* %x) nounwind
1146 call void @use_pointer(i8* %x)
1147 call void @use_pointer(i8* %x)
1148 br i1 %b, label %green, label %blue
1151 call void @objc_release(i8* %x) nounwind, !clang.imprecise_release !0
1155 call void @objc_release(i8* %x) nounwind
1159 call void @use_pointer(i8* %x)
1160 call void @use_pointer(i8* %x)
1161 call void @objc_release(i8* %x) nounwind
1165 ; CHECK-LABEL: define void @test16c(
1166 ; CHECK: @objc_retain(i8* %x)
1169 ; CHECK: @use_pointer
1170 ; CHECK: @objc_release
1172 define void @test16c(i1 %a, i1 %b, i8* %x) {
1174 call i8* @objc_retain(i8* %x) nounwind
1175 br i1 %a, label %red, label %orange
1178 call i8* @objc_retain(i8* %x) nounwind
1182 call i8* @objc_retain(i8* %x) nounwind
1186 call void @use_pointer(i8* %x)
1187 call void @use_pointer(i8* %x)
1188 br i1 %b, label %green, label %blue
1191 call void @objc_release(i8* %x) nounwind, !clang.imprecise_release !0
1195 call void @objc_release(i8* %x) nounwind, !clang.imprecise_release !0
1199 call void @use_pointer(i8* %x)
1200 call void @objc_release(i8* %x) nounwind, !clang.imprecise_release !0
1204 ; CHECK-LABEL: define void @test16d(
1205 ; CHECK: @objc_retain(i8* %x)
1208 define void @test16d(i1 %a, i1 %b, i8* %x) {
1210 call i8* @objc_retain(i8* %x) nounwind
1211 br i1 %a, label %red, label %orange
1214 call i8* @objc_retain(i8* %x) nounwind
1218 call i8* @objc_retain(i8* %x) nounwind
1222 call void @use_pointer(i8* %x)
1223 call void @use_pointer(i8* %x)
1224 br i1 %b, label %green, label %blue
1227 call void @objc_release(i8* %x) nounwind
1231 call void @objc_release(i8* %x) nounwind, !clang.imprecise_release !0
1240 ; CHECK-LABEL: define void @test18(
1243 define void @test18() {
1244 call i8* @objc_retain(i8* null)
1245 call void @objc_release(i8* null)
1246 call i8* @objc_autorelease(i8* null)
1250 ; Delete no-ops where undef can be assumed to be null.
1252 ; CHECK-LABEL: define void @test18b(
1255 define void @test18b() {
1256 call i8* @objc_retain(i8* undef)
1257 call void @objc_release(i8* undef)
1258 call i8* @objc_autorelease(i8* undef)
1262 ; Replace uses of arguments with uses of return values, to reduce
1263 ; register pressure.
1265 ; CHECK: define void @test19(i32* %y) {
1266 ; CHECK: %z = bitcast i32* %y to i8*
1267 ; CHECK: %0 = bitcast i32* %y to i8*
1268 ; CHECK: %1 = tail call i8* @objc_retain(i8* %0)
1269 ; CHECK: call void @use_pointer(i8* %z)
1270 ; CHECK: call void @use_pointer(i8* %z)
1271 ; CHECK: %2 = bitcast i32* %y to i8*
1272 ; CHECK: call void @objc_release(i8* %2)
1275 define void @test19(i32* %y) {
1277 %x = bitcast i32* %y to i8*
1278 %0 = call i8* @objc_retain(i8* %x) nounwind
1279 %z = bitcast i32* %y to i8*
1280 call void @use_pointer(i8* %z)
1281 call void @use_pointer(i8* %z)
1282 call void @objc_release(i8* %x)
1288 ; CHECK-LABEL: define void @test20(
1289 ; CHECK: %tmp1 = tail call i8* @objc_retain(i8* %tmp) [[NUW]]
1290 ; CHECK-NEXT: invoke
1292 define void @test20(double* %self) personality i32 (...)* @__gxx_personality_v0 {
1294 %tmp = bitcast double* %self to i8*
1295 %tmp1 = call i8* @objc_retain(i8* %tmp) nounwind
1296 invoke void @invokee()
1297 to label %invoke.cont23 unwind label %lpad20
1299 invoke.cont23: ; preds = %if.then12
1300 invoke void @invokee()
1301 to label %if.end unwind label %lpad20
1303 lpad20: ; preds = %invoke.cont23, %if.then12
1304 %tmp502 = phi double* [ undef, %invoke.cont23 ], [ %self, %if.then12 ]
1305 %exn = landingpad {i8*, i32}
1309 if.end: ; preds = %invoke.cont23
1313 ; Delete a redundant retain,autorelease when forwaring a call result
1314 ; directly to a return value.
1316 ; CHECK-LABEL: define i8* @test21(
1317 ; CHECK: call i8* @returner()
1318 ; CHECK-NEXT: ret i8* %call
1320 define i8* @test21() {
1322 %call = call i8* @returner()
1323 %0 = call i8* @objc_retain(i8* %call) nounwind
1324 %1 = call i8* @objc_autorelease(i8* %0) nounwind
1328 ; Move an objc call up through a phi that has null operands.
1330 ; CHECK-LABEL: define void @test22(
1332 ; CHECK: %1 = bitcast double* %p to i8*
1333 ; CHECK: call void @objc_release(i8* %1)
1334 ; CHECK: br label %C
1335 ; CHECK: C: ; preds = %B, %A
1336 ; CHECK-NOT: @objc_release
1338 define void @test22(double* %p, i1 %a) {
1339 br i1 %a, label %A, label %B
1345 %h = phi double* [ null, %A ], [ %p, %B ]
1346 %c = bitcast double* %h to i8*
1347 call void @objc_release(i8* %c)
1351 ; Any call can decrement a retain count.
1353 ; CHECK-LABEL: define void @test24(
1354 ; CHECK: @objc_retain(i8* %a)
1355 ; CHECK: @objc_release
1357 define void @test24(i8* %r, i8* %a) {
1358 call i8* @objc_retain(i8* %a)
1359 call void @use_pointer(i8* %r)
1360 %q = load i8, i8* %a
1361 call void @objc_release(i8* %a)
1365 ; Don't move a retain/release pair if the release can be moved
1366 ; but the retain can't be moved to balance it.
1368 ; CHECK-LABEL: define void @test25(
1370 ; CHECK: call i8* @objc_retain(i8* %p)
1373 ; CHECK: call void @objc_release(i8* %p)
1375 define void @test25(i8* %p, i1 %x) {
1377 %f0 = call i8* @objc_retain(i8* %p)
1379 br i1 %x, label %true, label %done
1386 call void @objc_release(i8* %p)
1390 ; Don't move a retain/release pair if the retain can be moved
1391 ; but the release can't be moved to balance it.
1393 ; CHECK-LABEL: define void @test26(
1395 ; CHECK: call i8* @objc_retain(i8* %p)
1398 ; CHECK: call void @objc_release(i8* %p)
1400 define void @test26(i8* %p, i1 %x) {
1402 %f0 = call i8* @objc_retain(i8* %p)
1403 br i1 %x, label %true, label %done
1411 call void @objc_release(i8* %p)
1415 ; Don't sink the retain,release into the loop.
1417 ; CHECK-LABEL: define void @test27(
1419 ; CHECK: call i8* @objc_retain(i8* %p)
1423 ; CHECK: call void @objc_release
1425 define void @test27(i8* %p, i1 %x, i1 %y) {
1427 %f0 = call i8* @objc_retain(i8* %p)
1428 br i1 %x, label %loop, label %done
1433 br i1 %y, label %done, label %loop
1436 call void @objc_release(i8* %p)
1440 ; Trivial code motion case: Triangle.
1442 ; CHECK-LABEL: define void @test28(
1445 ; CHECK: call i8* @objc_retain(
1446 ; CHECK: call void @callee()
1448 ; CHECK: call void @objc_release
1452 define void @test28(i8* %p, i1 %x) {
1454 %f0 = call i8* @objc_retain(i8* %p)
1455 br i1 %x, label %true, label %done
1463 call void @objc_release(i8* %p), !clang.imprecise_release !0
1467 ; Trivial code motion case: Triangle, but no metadata. Don't move past
1468 ; unrelated memory references!
1470 ; CHECK-LABEL: define void @test28b(
1471 ; CHECK: call i8* @objc_retain(
1474 ; CHECK: call void @callee()
1479 ; CHECK: @objc_release
1481 define void @test28b(i8* %p, i1 %x, i8* noalias %t) {
1483 %f0 = call i8* @objc_retain(i8* %p)
1484 br i1 %x, label %true, label %done
1493 call void @objc_release(i8* %p)
1497 ; Trivial code motion case: Triangle, with metadata. Do move past
1498 ; unrelated memory references! And preserve the metadata.
1500 ; CHECK-LABEL: define void @test28c(
1503 ; CHECK: call i8* @objc_retain(
1504 ; CHECK: call void @callee()
1506 ; CHECK: call void @objc_release(i8* %p) [[NUW]], !clang.imprecise_release
1510 define void @test28c(i8* %p, i1 %x, i8* noalias %t) {
1512 %f0 = call i8* @objc_retain(i8* %p)
1513 br i1 %x, label %true, label %done
1522 call void @objc_release(i8* %p), !clang.imprecise_release !0
1526 ; Like test28. but with two releases.
1528 ; CHECK-LABEL: define void @test29(
1531 ; CHECK: call i8* @objc_retain(
1532 ; CHECK: call void @callee()
1534 ; CHECK: call void @objc_release
1535 ; CHECK-NOT: @objc_release
1541 define void @test29(i8* %p, i1 %x, i1 %y) {
1543 %f0 = call i8* @objc_retain(i8* %p)
1544 br i1 %x, label %true, label %done
1549 br i1 %y, label %done, label %ohno
1552 call void @objc_release(i8* %p)
1556 call void @objc_release(i8* %p)
1560 ; Basic case with the use and call in a diamond
1561 ; with an extra release.
1563 ; CHECK-LABEL: define void @test30(
1566 ; CHECK: call i8* @objc_retain(
1567 ; CHECK: call void @callee()
1569 ; CHECK: call void @objc_release
1570 ; CHECK-NOT: @objc_release
1578 define void @test30(i8* %p, i1 %x, i1 %y, i1 %z) {
1580 %f0 = call i8* @objc_retain(i8* %p)
1581 br i1 %x, label %true, label %false
1586 br i1 %y, label %done, label %ohno
1589 br i1 %z, label %done, label %ohno
1592 call void @objc_release(i8* %p)
1596 call void @objc_release(i8* %p)
1600 ; Basic case with a mergeable release.
1602 ; CHECK-LABEL: define void @test31(
1603 ; CHECK: call i8* @objc_retain(i8* %p)
1604 ; CHECK: call void @callee()
1606 ; CHECK: call void @objc_release
1607 ; CHECK-NOT: @objc_release
1609 ; CHECK-NOT: @objc_release
1611 ; CHECK-NOT: @objc_release
1613 ; CHECK-NOT: @objc_release
1615 define void @test31(i8* %p, i1 %x) {
1617 %f0 = call i8* @objc_retain(i8* %p)
1620 br i1 %x, label %true, label %false
1622 call void @objc_release(i8* %p)
1625 call void @objc_release(i8* %p)
1629 ; Don't consider bitcasts or getelementptrs direct uses.
1631 ; CHECK-LABEL: define void @test32(
1634 ; CHECK: call i8* @objc_retain(
1635 ; CHECK: call void @callee()
1637 ; CHECK: call void @objc_release
1641 define void @test32(i8* %p, i1 %x) {
1643 %f0 = call i8* @objc_retain(i8* %p)
1644 br i1 %x, label %true, label %done
1652 %g = bitcast i8* %p to i8*
1653 %h = getelementptr i8, i8* %g, i64 0
1654 call void @objc_release(i8* %g)
1658 ; Do consider icmps to be direct uses.
1660 ; CHECK-LABEL: define void @test33(
1663 ; CHECK: call i8* @objc_retain(
1664 ; CHECK: call void @callee()
1666 ; CHECK: call void @objc_release
1670 define void @test33(i8* %p, i1 %x, i8* %y) {
1672 %f0 = call i8* @objc_retain(i8* %p)
1673 br i1 %x, label %true, label %done
1677 %v = icmp eq i8* %p, %y
1681 %g = bitcast i8* %p to i8*
1682 %h = getelementptr i8, i8* %g, i64 0
1683 call void @objc_release(i8* %g)
1687 ; Delete retain,release if there's just a possible dec and we have imprecise
1690 ; CHECK-LABEL: define void @test34a(
1691 ; CHECK: call i8* @objc_retain
1694 ; CHECK: call void @objc_release
1696 define void @test34a(i8* %p, i1 %x, i8* %y) {
1698 %f0 = call i8* @objc_retain(i8* %p)
1699 br i1 %x, label %true, label %done
1706 %g = bitcast i8* %p to i8*
1707 %h = getelementptr i8, i8* %g, i64 0
1708 call void @objc_release(i8* %g)
1712 ; CHECK-LABEL: define void @test34b(
1715 define void @test34b(i8* %p, i1 %x, i8* %y) {
1717 %f0 = call i8* @objc_retain(i8* %p)
1718 br i1 %x, label %true, label %done
1725 %g = bitcast i8* %p to i8*
1726 %h = getelementptr i8, i8* %g, i64 0
1727 call void @objc_release(i8* %g), !clang.imprecise_release !0
1732 ; Delete retain,release if there's just a use and we do not have a precise
1736 ; CHECK-LABEL: define void @test35a(
1738 ; CHECK: call i8* @objc_retain
1741 ; CHECK: call void @objc_release
1743 define void @test35a(i8* %p, i1 %x, i8* %y) {
1745 %f0 = call i8* @objc_retain(i8* %p)
1746 br i1 %x, label %true, label %done
1749 %v = icmp eq i8* %p, %y
1753 %g = bitcast i8* %p to i8*
1754 %h = getelementptr i8, i8* %g, i64 0
1755 call void @objc_release(i8* %g)
1760 ; CHECK-LABEL: define void @test35b(
1763 define void @test35b(i8* %p, i1 %x, i8* %y) {
1765 %f0 = call i8* @objc_retain(i8* %p)
1766 br i1 %x, label %true, label %done
1769 %v = icmp eq i8* %p, %y
1773 %g = bitcast i8* %p to i8*
1774 %h = getelementptr i8, i8* %g, i64 0
1775 call void @objc_release(i8* %g), !clang.imprecise_release !0
1779 ; Delete a retain,release if there's no actual use and we have precise release.
1781 ; CHECK-LABEL: define void @test36a(
1782 ; CHECK: @objc_retain
1783 ; CHECK: call void @callee()
1785 ; CHECK: call void @callee()
1786 ; CHECK: @objc_release
1788 define void @test36a(i8* %p) {
1790 call i8* @objc_retain(i8* %p)
1793 call void @objc_release(i8* %p)
1797 ; Like test36, but with metadata.
1799 ; CHECK-LABEL: define void @test36b(
1802 define void @test36b(i8* %p) {
1804 call i8* @objc_retain(i8* %p)
1807 call void @objc_release(i8* %p), !clang.imprecise_release !0
1811 ; Be aggressive about analyzing phis to eliminate possible uses.
1813 ; CHECK-LABEL: define void @test38(
1816 define void @test38(i8* %p, i1 %u, i1 %m, i8* %z, i8* %y, i8* %x, i8* %w) {
1818 call i8* @objc_retain(i8* %p)
1819 br i1 %u, label %true, label %false
1821 br i1 %m, label %a, label %b
1823 br i1 %m, label %c, label %d
1833 %j = phi i8* [ %z, %a ], [ %y, %b ]
1836 %k = phi i8* [ %w, %c ], [ %x, %d ]
1839 %h = phi i8* [ %j, %e ], [ %k, %f ]
1840 call void @use_pointer(i8* %h)
1841 call void @objc_release(i8* %p), !clang.imprecise_release !0
1845 ; Delete retain,release pairs around loops.
1847 ; CHECK-LABEL: define void @test39(
1850 define void @test39(i8* %p) {
1852 %0 = call i8* @objc_retain(i8* %p)
1855 loop: ; preds = %loop, %entry
1856 br i1 undef, label %loop, label %exit
1858 exit: ; preds = %loop
1859 call void @objc_release(i8* %0), !clang.imprecise_release !0
1863 ; Delete retain,release pairs around loops containing uses.
1865 ; CHECK-LABEL: define void @test39b(
1868 define void @test39b(i8* %p) {
1870 %0 = call i8* @objc_retain(i8* %p)
1873 loop: ; preds = %loop, %entry
1875 br i1 undef, label %loop, label %exit
1877 exit: ; preds = %loop
1878 call void @objc_release(i8* %0), !clang.imprecise_release !0
1882 ; Delete retain,release pairs around loops containing potential decrements.
1884 ; CHECK-LABEL: define void @test39c(
1887 define void @test39c(i8* %p) {
1889 %0 = call i8* @objc_retain(i8* %p)
1892 loop: ; preds = %loop, %entry
1893 call void @use_pointer(i8* %0)
1894 br i1 undef, label %loop, label %exit
1896 exit: ; preds = %loop
1897 call void @objc_release(i8* %0), !clang.imprecise_release !0
1901 ; Delete retain,release pairs around loops even if
1902 ; the successors are in a different order.
1904 ; CHECK-LABEL: define void @test40(
1907 define void @test40(i8* %p) {
1909 %0 = call i8* @objc_retain(i8* %p)
1912 loop: ; preds = %loop, %entry
1913 call void @use_pointer(i8* %0)
1914 br i1 undef, label %exit, label %loop
1916 exit: ; preds = %loop
1917 call void @objc_release(i8* %0), !clang.imprecise_release !0
1921 ; Do the known-incremented retain+release elimination even if the pointer
1922 ; is also autoreleased.
1924 ; CHECK-LABEL: define void @test42(
1925 ; CHECK-NEXT: entry:
1926 ; CHECK-NEXT: call i8* @objc_retain(i8* %p)
1927 ; CHECK-NEXT: call i8* @objc_autorelease(i8* %p)
1928 ; CHECK-NEXT: call void @use_pointer(i8* %p)
1929 ; CHECK-NEXT: call void @use_pointer(i8* %p)
1930 ; CHECK-NEXT: call void @use_pointer(i8* %p)
1931 ; CHECK-NEXT: call void @use_pointer(i8* %p)
1932 ; CHECK-NEXT: call void @objc_release(i8* %p)
1933 ; CHECK-NEXT: ret void
1935 define void @test42(i8* %p) {
1937 call i8* @objc_retain(i8* %p)
1938 call i8* @objc_autorelease(i8* %p)
1939 call i8* @objc_retain(i8* %p)
1940 call void @use_pointer(i8* %p)
1941 call void @use_pointer(i8* %p)
1942 call void @objc_release(i8* %p)
1943 call void @use_pointer(i8* %p)
1944 call void @use_pointer(i8* %p)
1945 call void @objc_release(i8* %p)
1949 ; Don't the known-incremented retain+release elimination if the pointer is
1950 ; autoreleased and there's an autoreleasePoolPop.
1952 ; CHECK-LABEL: define void @test43(
1953 ; CHECK-NEXT: entry:
1954 ; CHECK-NEXT: call i8* @objc_retain(i8* %p)
1955 ; CHECK-NEXT: call i8* @objc_autorelease(i8* %p)
1956 ; CHECK-NEXT: call i8* @objc_retain
1957 ; CHECK-NEXT: call void @use_pointer(i8* %p)
1958 ; CHECK-NEXT: call void @use_pointer(i8* %p)
1959 ; CHECK-NEXT: call void @objc_autoreleasePoolPop(i8* undef)
1960 ; CHECK-NEXT: call void @objc_release
1961 ; CHECK-NEXT: ret void
1963 define void @test43(i8* %p) {
1965 call i8* @objc_retain(i8* %p)
1966 call i8* @objc_autorelease(i8* %p)
1967 call i8* @objc_retain(i8* %p)
1968 call void @use_pointer(i8* %p)
1969 call void @use_pointer(i8* %p)
1970 call void @objc_autoreleasePoolPop(i8* undef)
1971 call void @objc_release(i8* %p)
1975 ; Do the known-incremented retain+release elimination if the pointer is
1976 ; autoreleased and there's an autoreleasePoolPush.
1978 ; CHECK-LABEL: define void @test43b(
1979 ; CHECK-NEXT: entry:
1980 ; CHECK-NEXT: call i8* @objc_retain(i8* %p)
1981 ; CHECK-NEXT: call i8* @objc_autorelease(i8* %p)
1982 ; CHECK-NEXT: call void @use_pointer(i8* %p)
1983 ; CHECK-NEXT: call void @use_pointer(i8* %p)
1984 ; CHECK-NEXT: call i8* @objc_autoreleasePoolPush()
1985 ; CHECK-NEXT: call void @use_pointer(i8* %p)
1986 ; CHECK-NEXT: call void @objc_release
1987 ; CHECK-NEXT: ret void
1989 define void @test43b(i8* %p) {
1991 call i8* @objc_retain(i8* %p)
1992 call i8* @objc_autorelease(i8* %p)
1993 call i8* @objc_retain(i8* %p)
1994 call void @use_pointer(i8* %p)
1995 call void @use_pointer(i8* %p)
1996 call i8* @objc_autoreleasePoolPush()
1997 call void @objc_release(i8* %p)
1998 call void @use_pointer(i8* %p)
1999 call void @objc_release(i8* %p)
2003 ; Do retain+release elimination for non-provenance pointers.
2005 ; CHECK-LABEL: define void @test44(
2008 define void @test44(i8** %pp) {
2009 %p = load i8*, i8** %pp
2010 %q = call i8* @objc_retain(i8* %p)
2011 call void @objc_release(i8* %q)
2015 ; Don't delete retain+release with an unknown-provenance
2016 ; may-alias objc_release between them.
2018 ; CHECK-LABEL: define void @test45(
2019 ; CHECK: call i8* @objc_retain(i8* %p)
2020 ; CHECK: call void @objc_release(i8* %q)
2021 ; CHECK: call void @use_pointer(i8* %p)
2022 ; CHECK: call void @objc_release(i8* %p)
2024 define void @test45(i8** %pp, i8** %qq) {
2025 %p = load i8*, i8** %pp
2026 %q = load i8*, i8** %qq
2027 call i8* @objc_retain(i8* %p)
2028 call void @objc_release(i8* %q)
2029 call void @use_pointer(i8* %p)
2030 call void @objc_release(i8* %p)
2034 ; Don't delete retain and autorelease here.
2036 ; CHECK-LABEL: define void @test46(
2037 ; CHECK: tail call i8* @objc_retain(i8* %p) [[NUW]]
2039 ; CHECK: call i8* @objc_autorelease(i8* %p) [[NUW]]
2041 define void @test46(i8* %p, i1 %a) {
2043 call i8* @objc_retain(i8* %p)
2044 br i1 %a, label %true, label %false
2047 call i8* @objc_autorelease(i8* %p)
2048 call void @use_pointer(i8* %p)
2055 ; Delete no-op cast calls.
2057 ; CHECK-LABEL: define i8* @test47(
2061 define i8* @test47(i8* %p) nounwind {
2062 %x = call i8* @objc_retainedObject(i8* %p)
2066 ; Delete no-op cast calls.
2068 ; CHECK-LABEL: define i8* @test48(
2072 define i8* @test48(i8* %p) nounwind {
2073 %x = call i8* @objc_unretainedObject(i8* %p)
2077 ; Delete no-op cast calls.
2079 ; CHECK-LABEL: define i8* @test49(
2083 define i8* @test49(i8* %p) nounwind {
2084 %x = call i8* @objc_unretainedPointer(i8* %p)
2088 ; Do delete retain+release with intervening stores of the address value if we
2089 ; have imprecise release attached to objc_release.
2091 ; CHECK-LABEL: define void @test50a(
2092 ; CHECK-NEXT: call i8* @objc_retain
2093 ; CHECK-NEXT: call void @callee
2095 ; CHECK-NEXT: call void @objc_release
2096 ; CHECK-NEXT: ret void
2098 define void @test50a(i8* %p, i8** %pp) {
2099 call i8* @objc_retain(i8* %p)
2101 store i8* %p, i8** %pp
2102 call void @objc_release(i8* %p)
2106 ; CHECK-LABEL: define void @test50b(
2109 define void @test50b(i8* %p, i8** %pp) {
2110 call i8* @objc_retain(i8* %p)
2112 store i8* %p, i8** %pp
2113 call void @objc_release(i8* %p), !clang.imprecise_release !0
2118 ; Don't delete retain+release with intervening stores through the
2121 ; CHECK-LABEL: define void @test51a(
2122 ; CHECK: call i8* @objc_retain(i8* %p)
2123 ; CHECK: call void @objc_release(i8* %p)
2126 define void @test51a(i8* %p) {
2127 call i8* @objc_retain(i8* %p)
2130 call void @objc_release(i8* %p)
2134 ; CHECK-LABEL: define void @test51b(
2135 ; CHECK: call i8* @objc_retain(i8* %p)
2136 ; CHECK: call void @objc_release(i8* %p)
2139 define void @test51b(i8* %p) {
2140 call i8* @objc_retain(i8* %p)
2143 call void @objc_release(i8* %p), !clang.imprecise_release !0
2147 ; Don't delete retain+release with intervening use of a pointer of
2148 ; unknown provenance.
2150 ; CHECK-LABEL: define void @test52a(
2151 ; CHECK: call i8* @objc_retain
2152 ; CHECK: call void @callee()
2153 ; CHECK: call void @use_pointer(i8* %z)
2154 ; CHECK: call void @objc_release
2157 define void @test52a(i8** %zz, i8** %pp) {
2158 %p = load i8*, i8** %pp
2159 %1 = call i8* @objc_retain(i8* %p)
2161 %z = load i8*, i8** %zz
2162 call void @use_pointer(i8* %z)
2163 call void @objc_release(i8* %p)
2167 ; CHECK-LABEL: define void @test52b(
2168 ; CHECK: call i8* @objc_retain
2169 ; CHECK: call void @callee()
2170 ; CHECK: call void @use_pointer(i8* %z)
2171 ; CHECK: call void @objc_release
2174 define void @test52b(i8** %zz, i8** %pp) {
2175 %p = load i8*, i8** %pp
2176 %1 = call i8* @objc_retain(i8* %p)
2178 %z = load i8*, i8** %zz
2179 call void @use_pointer(i8* %z)
2180 call void @objc_release(i8* %p), !clang.imprecise_release !0
2184 ; Like test52, but the pointer has function type, so it's assumed to
2185 ; be not reference counted.
2186 ; Oops. That's wrong. Clang sometimes uses function types gratuitously.
2187 ; See rdar://10551239.
2189 ; CHECK-LABEL: define void @test53(
2192 define void @test53(void ()** %zz, i8** %pp) {
2193 %p = load i8*, i8** %pp
2194 %1 = call i8* @objc_retain(i8* %p)
2196 %z = load void ()*, void ()** %zz
2197 call void @callee_fnptr(void ()* %z)
2198 call void @objc_release(i8* %p)
2202 ; Convert autorelease to release if the value is unused.
2204 ; CHECK-LABEL: define void @test54(
2205 ; CHECK: call i8* @returner()
2206 ; CHECK-NEXT: call void @objc_release(i8* %t) [[NUW]], !clang.imprecise_release ![[RELEASE]]
2207 ; CHECK-NEXT: ret void
2209 define void @test54() {
2210 %t = call i8* @returner()
2211 call i8* @objc_autorelease(i8* %t)
2215 ; Nested retain+release pairs. Delete them both.
2217 ; CHECK-LABEL: define void @test55(
2220 define void @test55(i8* %x) {
2222 %0 = call i8* @objc_retain(i8* %x) nounwind
2223 %1 = call i8* @objc_retain(i8* %x) nounwind
2224 call void @objc_release(i8* %x) nounwind
2225 call void @objc_release(i8* %x) nounwind
2229 ; Nested retain+release pairs where the inner pair depends
2230 ; on the outer pair to be removed, and then the outer pair
2231 ; can be partially eliminated. Plus an extra outer pair to
2232 ; eliminate, for fun.
2234 ; CHECK-LABEL: define void @test56(
2237 ; CHECK-NEXT: %0 = tail call i8* @objc_retain(i8* %x) [[NUW]]
2238 ; CHECK-NEXT: tail call void @use_pointer(i8* %x)
2239 ; CHECK-NEXT: tail call void @use_pointer(i8* %x)
2240 ; CHECK-NEXT: tail call void @objc_release(i8* %x) [[NUW]], !clang.imprecise_release ![[RELEASE]]
2241 ; CHECK-NEXT: br label %if.end
2244 define void @test56(i8* %x, i32 %n) {
2246 %0 = tail call i8* @objc_retain(i8* %x) nounwind
2247 %1 = tail call i8* @objc_retain(i8* %0) nounwind
2248 %tobool = icmp eq i32 %n, 0
2249 br i1 %tobool, label %if.end, label %if.then
2251 if.then: ; preds = %entry
2252 %2 = tail call i8* @objc_retain(i8* %1) nounwind
2253 tail call void @use_pointer(i8* %2)
2254 tail call void @use_pointer(i8* %2)
2255 tail call void @objc_release(i8* %2) nounwind, !clang.imprecise_release !0
2258 if.end: ; preds = %entry, %if.then
2259 tail call void @objc_release(i8* %1) nounwind, !clang.imprecise_release !0
2260 tail call void @objc_release(i8* %0) nounwind, !clang.imprecise_release !0
2264 ; When there are adjacent retain+release pairs, the first one is known
2265 ; unnecessary because the presence of the second one means that the first one
2266 ; won't be deleting the object.
2268 ; CHECK-LABEL: define void @test57(
2269 ; CHECK-NEXT: entry:
2270 ; CHECK-NEXT: tail call i8* @objc_retain(i8* %x) [[NUW]]
2271 ; CHECK-NEXT: call void @use_pointer(i8* %x)
2272 ; CHECK-NEXT: call void @use_pointer(i8* %x)
2273 ; CHECK-NEXT: tail call i8* @objc_retain(i8* %x) [[NUW]]
2274 ; CHECK-NEXT: call void @use_pointer(i8* %x)
2275 ; CHECK-NEXT: call void @use_pointer(i8* %x)
2276 ; CHECK-NEXT: call void @objc_release(i8* %x) [[NUW]]
2277 ; CHECK-NEXT: ret void
2279 define void @test57(i8* %x) nounwind {
2281 call i8* @objc_retain(i8* %x) nounwind
2282 call i8* @objc_retain(i8* %x) nounwind
2283 call void @use_pointer(i8* %x)
2284 call void @use_pointer(i8* %x)
2285 call void @objc_release(i8* %x) nounwind
2286 call i8* @objc_retain(i8* %x) nounwind
2287 call void @use_pointer(i8* %x)
2288 call void @use_pointer(i8* %x)
2289 call void @objc_release(i8* %x) nounwind
2293 ; An adjacent retain+release pair is sufficient even if it will be
2296 ; CHECK-LABEL: define void @test58(
2297 ; CHECK-NEXT: entry:
2298 ; CHECK-NEXT: @objc_retain
2299 ; CHECK-NEXT: call void @use_pointer(i8* %x)
2300 ; CHECK-NEXT: call void @use_pointer(i8* %x)
2301 ; CHECK-NEXT: ret void
2303 define void @test58(i8* %x) nounwind {
2305 call i8* @objc_retain(i8* %x) nounwind
2306 call i8* @objc_retain(i8* %x) nounwind
2307 call void @use_pointer(i8* %x)
2308 call void @use_pointer(i8* %x)
2309 call void @objc_release(i8* %x) nounwind
2310 call i8* @objc_retain(i8* %x) nounwind
2311 call void @objc_release(i8* %x) nounwind
2315 ; Don't delete the second retain+release pair in an adjacent set.
2317 ; CHECK-LABEL: define void @test59(
2318 ; CHECK-NEXT: entry:
2319 ; CHECK-NEXT: %0 = tail call i8* @objc_retain(i8* %x) [[NUW]]
2320 ; CHECK-NEXT: call void @use_pointer(i8* %x)
2321 ; CHECK-NEXT: call void @use_pointer(i8* %x)
2322 ; CHECK-NEXT: call void @objc_release(i8* %x) [[NUW]]
2323 ; CHECK-NEXT: ret void
2325 define void @test59(i8* %x) nounwind {
2327 %a = call i8* @objc_retain(i8* %x) nounwind
2328 call void @objc_release(i8* %x) nounwind
2329 %b = call i8* @objc_retain(i8* %x) nounwind
2330 call void @use_pointer(i8* %x)
2331 call void @use_pointer(i8* %x)
2332 call void @objc_release(i8* %x) nounwind
2336 ; Constant pointers to objects don't need reference counting.
2338 @constptr = external constant i8*
2339 @something = external global i8*
2341 ; We have a precise lifetime retain/release here. We can not remove them since
2342 ; @something is not constant.
2344 ; CHECK-LABEL: define void @test60a(
2345 ; CHECK: call i8* @objc_retain
2346 ; CHECK: call void @objc_release
2348 define void @test60a() {
2349 %t = load i8*, i8** @constptr
2350 %s = load i8*, i8** @something
2351 call i8* @objc_retain(i8* %s)
2353 call void @use_pointer(i8* %t)
2354 call void @objc_release(i8* %s)
2358 ; CHECK-LABEL: define void @test60b(
2359 ; CHECK: call i8* @objc_retain
2360 ; CHECK-NOT: call i8* @objc_retain
2361 ; CHECK-NOT: call i8* @objc_release
2363 define void @test60b() {
2364 %t = load i8*, i8** @constptr
2365 %s = load i8*, i8** @something
2366 call i8* @objc_retain(i8* %t)
2367 call i8* @objc_retain(i8* %t)
2369 call void @use_pointer(i8* %s)
2370 call void @objc_release(i8* %t)
2374 ; CHECK-LABEL: define void @test60c(
2377 define void @test60c() {
2378 %t = load i8*, i8** @constptr
2379 %s = load i8*, i8** @something
2380 call i8* @objc_retain(i8* %t)
2382 call void @use_pointer(i8* %s)
2383 call void @objc_release(i8* %t), !clang.imprecise_release !0
2387 ; CHECK-LABEL: define void @test60d(
2390 define void @test60d() {
2391 %t = load i8*, i8** @constptr
2392 %s = load i8*, i8** @something
2393 call i8* @objc_retain(i8* %t)
2395 call void @use_pointer(i8* %s)
2396 call void @objc_release(i8* %t)
2400 ; CHECK-LABEL: define void @test60e(
2403 define void @test60e() {
2404 %t = load i8*, i8** @constptr
2405 %s = load i8*, i8** @something
2406 call i8* @objc_retain(i8* %t)
2408 call void @use_pointer(i8* %s)
2409 call void @objc_release(i8* %t), !clang.imprecise_release !0
2413 ; Constant pointers to objects don't need to be considered related to other
2416 ; CHECK-LABEL: define void @test61(
2419 define void @test61() {
2420 %t = load i8*, i8** @constptr
2421 call i8* @objc_retain(i8* %t)
2423 call void @use_pointer(i8* %t)
2424 call void @objc_release(i8* %t)
2428 ; Delete a retain matched by releases when one is inside the loop and the
2429 ; other is outside the loop.
2431 ; CHECK-LABEL: define void @test62(
2434 define void @test62(i8* %x, i1* %p) nounwind {
2439 call i8* @objc_retain(i8* %x)
2440 %q = load i1, i1* %p
2441 br i1 %q, label %loop.more, label %exit
2444 call void @objc_release(i8* %x)
2448 call void @objc_release(i8* %x)
2452 ; Like test62 but with no release in exit.
2453 ; Don't delete anything!
2455 ; CHECK-LABEL: define void @test63(
2457 ; CHECK: tail call i8* @objc_retain(i8* %x)
2459 ; CHECK: call void @objc_release(i8* %x)
2461 define void @test63(i8* %x, i1* %p) nounwind {
2466 call i8* @objc_retain(i8* %x)
2467 %q = load i1, i1* %p
2468 br i1 %q, label %loop.more, label %exit
2471 call void @objc_release(i8* %x)
2478 ; Like test62 but with no release in loop.more.
2479 ; Don't delete anything!
2481 ; CHECK-LABEL: define void @test64(
2483 ; CHECK: tail call i8* @objc_retain(i8* %x)
2485 ; CHECK: call void @objc_release(i8* %x)
2487 define void @test64(i8* %x, i1* %p) nounwind {
2492 call i8* @objc_retain(i8* %x)
2493 %q = load i1, i1* %p
2494 br i1 %q, label %loop.more, label %exit
2500 call void @objc_release(i8* %x)
2504 ; Move an autorelease past a phi with a null.
2506 ; CHECK-LABEL: define i8* @test65(
2508 ; CHECK: call i8* @objc_autorelease(
2510 ; CHECK-NOT: @objc_autorelease
2512 define i8* @test65(i1 %x) {
2514 br i1 %x, label %return, label %if.then
2516 if.then: ; preds = %entry
2517 %c = call i8* @returner()
2518 %s = call i8* @objc_retainAutoreleasedReturnValue(i8* %c) nounwind
2521 return: ; preds = %if.then, %entry
2522 %retval = phi i8* [ %s, %if.then ], [ null, %entry ]
2523 %q = call i8* @objc_autorelease(i8* %retval) nounwind
2527 ; Don't move an autorelease past an autorelease pool boundary.
2529 ; CHECK-LABEL: define i8* @test65b(
2531 ; CHECK-NOT: @objc_autorelease
2533 ; CHECK: call i8* @objc_autorelease(
2535 define i8* @test65b(i1 %x) {
2537 %t = call i8* @objc_autoreleasePoolPush()
2538 br i1 %x, label %return, label %if.then
2540 if.then: ; preds = %entry
2541 %c = call i8* @returner()
2542 %s = call i8* @objc_retainAutoreleasedReturnValue(i8* %c) nounwind
2545 return: ; preds = %if.then, %entry
2546 %retval = phi i8* [ %s, %if.then ], [ null, %entry ]
2547 call void @objc_autoreleasePoolPop(i8* %t)
2548 %q = call i8* @objc_autorelease(i8* %retval) nounwind
2552 ; Don't move an autoreleaseReuturnValue, which would break
2553 ; the RV optimization.
2555 ; CHECK-LABEL: define i8* @test65c(
2557 ; CHECK-NOT: @objc_autorelease
2559 ; CHECK: call i8* @objc_autoreleaseReturnValue(
2561 define i8* @test65c(i1 %x) {
2563 br i1 %x, label %return, label %if.then
2565 if.then: ; preds = %entry
2566 %c = call i8* @returner()
2567 %s = call i8* @objc_retainAutoreleasedReturnValue(i8* %c) nounwind
2570 return: ; preds = %if.then, %entry
2571 %retval = phi i8* [ %s, %if.then ], [ null, %entry ]
2572 %q = call i8* @objc_autoreleaseReturnValue(i8* %retval) nounwind
2576 ; An objc_retain can serve as a may-use for a different pointer.
2579 ; CHECK-LABEL: define void @test66a(
2580 ; CHECK: tail call i8* @objc_retain(i8* %cond) [[NUW]]
2581 ; CHECK: tail call void @objc_release(i8* %call) [[NUW]]
2582 ; CHECK: tail call i8* @objc_retain(i8* %tmp8) [[NUW]]
2583 ; CHECK: tail call void @objc_release(i8* %cond) [[NUW]]
2585 define void @test66a(i8* %tmp5, i8* %bar, i1 %tobool, i1 %tobool1, i8* %call) {
2587 br i1 %tobool, label %cond.true, label %cond.end
2592 cond.end: ; preds = %cond.true, %entry
2593 %cond = phi i8* [ %tmp5, %cond.true ], [ %call, %entry ]
2594 %tmp7 = tail call i8* @objc_retain(i8* %cond) nounwind
2595 tail call void @objc_release(i8* %call) nounwind
2596 %tmp8 = select i1 %tobool1, i8* %cond, i8* %bar
2597 %tmp9 = tail call i8* @objc_retain(i8* %tmp8) nounwind
2598 tail call void @objc_release(i8* %cond) nounwind
2602 ; CHECK-LABEL: define void @test66b(
2603 ; CHECK: tail call i8* @objc_retain(i8* %cond) [[NUW]]
2604 ; CHECK: tail call void @objc_release(i8* %call) [[NUW]]
2605 ; CHECK: tail call i8* @objc_retain(i8* %tmp8) [[NUW]]
2606 ; CHECK: tail call void @objc_release(i8* %cond) [[NUW]]
2608 define void @test66b(i8* %tmp5, i8* %bar, i1 %tobool, i1 %tobool1, i8* %call) {
2610 br i1 %tobool, label %cond.true, label %cond.end
2615 cond.end: ; preds = %cond.true, %entry
2616 %cond = phi i8* [ %tmp5, %cond.true ], [ %call, %entry ]
2617 %tmp7 = tail call i8* @objc_retain(i8* %cond) nounwind
2618 tail call void @objc_release(i8* %call) nounwind, !clang.imprecise_release !0
2619 %tmp8 = select i1 %tobool1, i8* %cond, i8* %bar
2620 %tmp9 = tail call i8* @objc_retain(i8* %tmp8) nounwind
2621 tail call void @objc_release(i8* %cond) nounwind
2625 ; CHECK-LABEL: define void @test66c(
2626 ; CHECK: tail call i8* @objc_retain(i8* %cond) [[NUW]]
2627 ; CHECK: tail call void @objc_release(i8* %call) [[NUW]]
2628 ; CHECK: tail call i8* @objc_retain(i8* %tmp8) [[NUW]]
2629 ; CHECK: tail call void @objc_release(i8* %cond) [[NUW]]
2631 define void @test66c(i8* %tmp5, i8* %bar, i1 %tobool, i1 %tobool1, i8* %call) {
2633 br i1 %tobool, label %cond.true, label %cond.end
2638 cond.end: ; preds = %cond.true, %entry
2639 %cond = phi i8* [ %tmp5, %cond.true ], [ %call, %entry ]
2640 %tmp7 = tail call i8* @objc_retain(i8* %cond) nounwind
2641 tail call void @objc_release(i8* %call) nounwind
2642 %tmp8 = select i1 %tobool1, i8* %cond, i8* %bar
2643 %tmp9 = tail call i8* @objc_retain(i8* %tmp8) nounwind, !clang.imprecise_release !0
2644 tail call void @objc_release(i8* %cond) nounwind
2648 ; CHECK-LABEL: define void @test66d(
2649 ; CHECK: tail call i8* @objc_retain(i8* %cond) [[NUW]]
2650 ; CHECK: tail call void @objc_release(i8* %call) [[NUW]]
2651 ; CHECK: tail call i8* @objc_retain(i8* %tmp8) [[NUW]]
2652 ; CHECK: tail call void @objc_release(i8* %cond) [[NUW]]
2654 define void @test66d(i8* %tmp5, i8* %bar, i1 %tobool, i1 %tobool1, i8* %call) {
2656 br i1 %tobool, label %cond.true, label %cond.end
2661 cond.end: ; preds = %cond.true, %entry
2662 %cond = phi i8* [ %tmp5, %cond.true ], [ %call, %entry ]
2663 %tmp7 = tail call i8* @objc_retain(i8* %cond) nounwind
2664 tail call void @objc_release(i8* %call) nounwind, !clang.imprecise_release !0
2665 %tmp8 = select i1 %tobool1, i8* %cond, i8* %bar
2666 %tmp9 = tail call i8* @objc_retain(i8* %tmp8) nounwind
2667 tail call void @objc_release(i8* %cond) nounwind, !clang.imprecise_release !0
2671 ; A few real-world testcases.
2673 @.str4 = private unnamed_addr constant [33 x i8] c"-[A z] = { %f, %f, { %f, %f } }\0A\00"
2674 @"OBJC_IVAR_$_A.myZ" = global i64 20, section "__DATA, __objc_const", align 8
2675 declare i32 @printf(i8* nocapture, ...) nounwind
2676 declare i32 @puts(i8* nocapture) nounwind
2677 @str = internal constant [16 x i8] c"-[ Top0 _getX ]\00"
2679 ; CHECK: define { <2 x float>, <2 x float> } @"\01-[A z]"({}* %self, i8* nocapture %_cmd) [[NUW]] {
2683 define {<2 x float>, <2 x float>} @"\01-[A z]"({}* %self, i8* nocapture %_cmd) nounwind {
2685 %0 = bitcast {}* %self to i8*
2686 %1 = tail call i8* @objc_retain(i8* %0) nounwind
2687 tail call void @llvm.dbg.value(metadata {}* %self, i64 0, metadata !DILocalVariable(scope: !2), metadata !DIExpression()), !dbg !DILocation(scope: !2)
2688 tail call void @llvm.dbg.value(metadata {}* %self, i64 0, metadata !DILocalVariable(scope: !2), metadata !DIExpression()), !dbg !DILocation(scope: !2)
2689 %ivar = load i64, i64* @"OBJC_IVAR_$_A.myZ", align 8
2690 %add.ptr = getelementptr i8, i8* %0, i64 %ivar
2691 %tmp1 = bitcast i8* %add.ptr to float*
2692 %tmp2 = load float, float* %tmp1, align 4
2693 %conv = fpext float %tmp2 to double
2694 %add.ptr.sum = add i64 %ivar, 4
2695 %tmp6 = getelementptr inbounds i8, i8* %0, i64 %add.ptr.sum
2696 %2 = bitcast i8* %tmp6 to float*
2697 %tmp7 = load float, float* %2, align 4
2698 %conv8 = fpext float %tmp7 to double
2699 %add.ptr.sum36 = add i64 %ivar, 8
2700 %tmp12 = getelementptr inbounds i8, i8* %0, i64 %add.ptr.sum36
2701 %arrayidx = bitcast i8* %tmp12 to float*
2702 %tmp13 = load float, float* %arrayidx, align 4
2703 %conv14 = fpext float %tmp13 to double
2704 %tmp12.sum = add i64 %ivar, 12
2705 %arrayidx19 = getelementptr inbounds i8, i8* %0, i64 %tmp12.sum
2706 %3 = bitcast i8* %arrayidx19 to float*
2707 %tmp20 = load float, float* %3, align 4
2708 %conv21 = fpext float %tmp20 to double
2709 %call = tail call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([33 x i8], [33 x i8]* @.str4, i64 0, i64 0), double %conv, double %conv8, double %conv14, double %conv21)
2710 %ivar23 = load i64, i64* @"OBJC_IVAR_$_A.myZ", align 8
2711 %add.ptr24 = getelementptr i8, i8* %0, i64 %ivar23
2712 %4 = bitcast i8* %add.ptr24 to i128*
2713 %srcval = load i128, i128* %4, align 4
2714 tail call void @objc_release(i8* %0) nounwind
2715 %tmp29 = trunc i128 %srcval to i64
2716 %tmp30 = bitcast i64 %tmp29 to <2 x float>
2717 %tmp31 = insertvalue {<2 x float>, <2 x float>} undef, <2 x float> %tmp30, 0
2718 %tmp32 = lshr i128 %srcval, 64
2719 %tmp33 = trunc i128 %tmp32 to i64
2720 %tmp34 = bitcast i64 %tmp33 to <2 x float>
2721 %tmp35 = insertvalue {<2 x float>, <2 x float>} %tmp31, <2 x float> %tmp34, 1
2722 ret {<2 x float>, <2 x float>} %tmp35
2725 ; CHECK: @"\01-[Top0 _getX]"({}* %self, i8* nocapture %_cmd) [[NUW]] {
2729 define i32 @"\01-[Top0 _getX]"({}* %self, i8* nocapture %_cmd) nounwind {
2731 %0 = bitcast {}* %self to i8*
2732 %1 = tail call i8* @objc_retain(i8* %0) nounwind
2733 %puts = tail call i32 @puts(i8* getelementptr inbounds ([16 x i8], [16 x i8]* @str, i64 0, i64 0))
2734 tail call void @objc_release(i8* %0) nounwind
2738 @"\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], [5 x i8]* @"\01L_OBJC_METH_VAR_NAME_", i64 0, i64 0), section "__DATA, __objc_selrefs, literal_pointers, no_dead_strip"
2739 @"\01L_OBJC_IMAGE_INFO" = internal constant [2 x i32] [i32 0, i32 16], section "__DATA, __objc_imageinfo, regular, no_dead_strip"
2740 @llvm.used = appending global [3 x i8*] [i8* getelementptr inbounds ([5 x i8], [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"
2742 ; A simple loop. Eliminate the retain and release inside of it!
2744 ; CHECK: define void @loop(i8* %x, i64 %n) {
2747 ; CHECK: @objc_msgSend
2751 define void @loop(i8* %x, i64 %n) {
2753 %0 = tail call i8* @objc_retain(i8* %x) nounwind
2754 %cmp9 = icmp sgt i64 %n, 0
2755 br i1 %cmp9, label %for.body, label %for.end
2757 for.body: ; preds = %entry, %for.body
2758 %i.010 = phi i64 [ %inc, %for.body ], [ 0, %entry ]
2759 %1 = tail call i8* @objc_retain(i8* %x) nounwind
2760 %tmp5 = load i8*, i8** @"\01L_OBJC_SELECTOR_REFERENCES_", align 8
2761 %call = tail call i8* (i8*, i8*, ...) @objc_msgSend(i8* %1, i8* %tmp5)
2762 tail call void @objc_release(i8* %1) nounwind, !clang.imprecise_release !0
2763 %inc = add nsw i64 %i.010, 1
2764 %exitcond = icmp eq i64 %inc, %n
2765 br i1 %exitcond, label %for.end, label %for.body
2767 for.end: ; preds = %for.body, %entry
2768 tail call void @objc_release(i8* %x) nounwind, !clang.imprecise_release !0
2772 ; ObjCARCOpt can delete the retain,release on self.
2774 ; CHECK: define void @TextEditTest(%2* %self, %3* %pboard) {
2775 ; CHECK-NOT: call i8* @objc_retain(i8* %tmp7)
2778 %0 = type { i8* (i8*, %struct._message_ref_t*, ...)*, i8* }
2784 %struct.NSConstantString = type { i32*, i32, i8*, i64 }
2785 %struct._NSRange = type { i64, i64 }
2786 %struct.__CFString = type opaque
2787 %struct.__method_list_t = type { i32, i32, [0 x %struct._objc_method] }
2788 %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* }
2789 %struct._class_t = type { %struct._class_t*, %struct._class_t*, %struct._objc_cache*, i8* (i8*, i8*)**, %struct._class_ro_t* }
2790 %struct._ivar_list_t = type { i32, i32, [0 x %struct._ivar_t] }
2791 %struct._ivar_t = type { i64*, i8*, i8*, i32, i32 }
2792 %struct._message_ref_t = type { i8*, i8* }
2793 %struct._objc_cache = type opaque
2794 %struct._objc_method = type { i8*, i8*, i8* }
2795 %struct._objc_protocol_list = type { i64, [0 x %struct._protocol_t*] }
2796 %struct._prop_list_t = type { i32, i32, [0 x %struct._message_ref_t] }
2797 %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 }
2799 @"\01L_OBJC_CLASSLIST_REFERENCES_$_17" = external hidden global %struct._class_t*, section "__DATA, __objc_classrefs, regular, no_dead_strip", align 8
2800 @kUTTypePlainText = external constant %struct.__CFString*
2801 @"\01L_OBJC_SELECTOR_REFERENCES_19" = external hidden global i8*, section "__DATA, __objc_selrefs, literal_pointers, no_dead_strip"
2802 @"\01L_OBJC_SELECTOR_REFERENCES_21" = external hidden global i8*, section "__DATA, __objc_selrefs, literal_pointers, no_dead_strip"
2803 @"\01L_OBJC_SELECTOR_REFERENCES_23" = external hidden global i8*, section "__DATA, __objc_selrefs, literal_pointers, no_dead_strip"
2804 @"\01L_OBJC_SELECTOR_REFERENCES_25" = external hidden global i8*, section "__DATA, __objc_selrefs, literal_pointers, no_dead_strip"
2805 @"\01L_OBJC_CLASSLIST_REFERENCES_$_26" = external hidden global %struct._class_t*, section "__DATA, __objc_classrefs, regular, no_dead_strip", align 8
2806 @"\01L_OBJC_SELECTOR_REFERENCES_28" = external hidden global i8*, section "__DATA, __objc_selrefs, literal_pointers, no_dead_strip"
2807 @"\01L_OBJC_CLASSLIST_REFERENCES_$_29" = external hidden global %struct._class_t*, section "__DATA, __objc_classrefs, regular, no_dead_strip", align 8
2808 @"\01L_OBJC_SELECTOR_REFERENCES_31" = external hidden global i8*, section "__DATA, __objc_selrefs, literal_pointers, no_dead_strip"
2809 @"\01L_OBJC_SELECTOR_REFERENCES_33" = external hidden global i8*, section "__DATA, __objc_selrefs, literal_pointers, no_dead_strip"
2810 @"\01L_OBJC_SELECTOR_REFERENCES_35" = external hidden global i8*, section "__DATA, __objc_selrefs, literal_pointers, no_dead_strip"
2811 @"\01L_OBJC_SELECTOR_REFERENCES_37" = external hidden global i8*, section "__DATA, __objc_selrefs, literal_pointers, no_dead_strip"
2812 @"\01L_OBJC_CLASSLIST_REFERENCES_$_38" = external hidden global %struct._class_t*, section "__DATA, __objc_classrefs, regular, no_dead_strip", align 8
2813 @"\01L_OBJC_SELECTOR_REFERENCES_40" = external hidden global i8*, section "__DATA, __objc_selrefs, literal_pointers, no_dead_strip"
2814 @"\01L_OBJC_SELECTOR_REFERENCES_42" = external hidden global i8*, section "__DATA, __objc_selrefs, literal_pointers, no_dead_strip"
2815 @_unnamed_cfstring_44 = external hidden constant %struct.NSConstantString, section "__DATA,__cfstring"
2816 @"\01L_OBJC_SELECTOR_REFERENCES_46" = external hidden global i8*, section "__DATA, __objc_selrefs, literal_pointers, no_dead_strip"
2817 @"\01L_OBJC_SELECTOR_REFERENCES_48" = external hidden global i8*, section "__DATA, __objc_selrefs, literal_pointers, no_dead_strip"
2818 @"\01l_objc_msgSend_fixup_isEqual_" = external hidden global %0, section "__DATA, __objc_msgrefs, coalesced", align 16
2819 @"\01L_OBJC_CLASSLIST_REFERENCES_$_50" = external hidden global %struct._class_t*, section "__DATA, __objc_classrefs, regular, no_dead_strip", align 8
2820 @NSCocoaErrorDomain = external constant %1*
2821 @"\01L_OBJC_CLASSLIST_REFERENCES_$_51" = external hidden global %struct._class_t*, section "__DATA, __objc_classrefs, regular, no_dead_strip", align 8
2822 @NSFilePathErrorKey = external constant %1*
2823 @"\01L_OBJC_SELECTOR_REFERENCES_53" = external hidden global i8*, section "__DATA, __objc_selrefs, literal_pointers, no_dead_strip"
2824 @"\01L_OBJC_SELECTOR_REFERENCES_55" = external hidden global i8*, section "__DATA, __objc_selrefs, literal_pointers, no_dead_strip"
2825 @"\01L_OBJC_CLASSLIST_REFERENCES_$_56" = external hidden global %struct._class_t*, section "__DATA, __objc_classrefs, regular, no_dead_strip", align 8
2826 @"\01L_OBJC_SELECTOR_REFERENCES_58" = external hidden global i8*, section "__DATA, __objc_selrefs, literal_pointers, no_dead_strip"
2827 @"\01L_OBJC_SELECTOR_REFERENCES_60" = external hidden global i8*, section "__DATA, __objc_selrefs, literal_pointers, no_dead_strip"
2829 declare %1* @truncatedString(%1*, i64)
2830 define void @TextEditTest(%2* %self, %3* %pboard) {
2832 %err = alloca %4*, align 8
2833 %tmp7 = bitcast %2* %self to i8*
2834 %tmp8 = call i8* @objc_retain(i8* %tmp7) nounwind
2835 store %4* null, %4** %err, align 8
2836 %tmp1 = load %struct._class_t*, %struct._class_t** @"\01L_OBJC_CLASSLIST_REFERENCES_$_17", align 8
2837 %tmp2 = load %struct.__CFString*, %struct.__CFString** @kUTTypePlainText, align 8
2838 %tmp3 = load i8*, i8** @"\01L_OBJC_SELECTOR_REFERENCES_19", align 8
2839 %tmp4 = bitcast %struct._class_t* %tmp1 to i8*
2840 %call5 = call i8* (i8*, i8*, ...) @objc_msgSend(i8* %tmp4, i8* %tmp3, %struct.__CFString* %tmp2)
2841 %tmp5 = load i8*, i8** @"\01L_OBJC_SELECTOR_REFERENCES_21", align 8
2842 %tmp6 = bitcast %3* %pboard to i8*
2843 %call76 = call i8* (i8*, i8*, ...) @objc_msgSend(i8* %tmp6, i8* %tmp5, i8* %call5)
2844 %tmp9 = call i8* @objc_retain(i8* %call76) nounwind
2845 %tobool = icmp eq i8* %tmp9, null
2846 br i1 %tobool, label %end, label %land.lhs.true
2848 land.lhs.true: ; preds = %entry
2849 %tmp11 = load i8*, i8** @"\01L_OBJC_SELECTOR_REFERENCES_23", align 8
2850 %call137 = call i8* (i8*, i8*, ...) @objc_msgSend(i8* %tmp6, i8* %tmp11, i8* %tmp9)
2851 %tmp = bitcast i8* %call137 to %1*
2852 %tmp10 = call i8* @objc_retain(i8* %call137) nounwind
2853 call void @objc_release(i8* null) nounwind
2854 %tmp12 = call i8* @objc_retain(i8* %call137) nounwind
2855 call void @objc_release(i8* null) nounwind
2856 %tobool16 = icmp eq i8* %call137, null
2857 br i1 %tobool16, label %end, label %if.then
2859 if.then: ; preds = %land.lhs.true
2860 %tmp19 = load i8*, i8** @"\01L_OBJC_SELECTOR_REFERENCES_25", align 8
2861 %call21 = call signext i8 bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to i8 (i8*, i8*)*)(i8* %call137, i8* %tmp19)
2862 %tobool22 = icmp eq i8 %call21, 0
2863 br i1 %tobool22, label %if.then44, label %land.lhs.true23
2865 land.lhs.true23: ; preds = %if.then
2866 %tmp24 = load %struct._class_t*, %struct._class_t** @"\01L_OBJC_CLASSLIST_REFERENCES_$_26", align 8
2867 %tmp26 = load i8*, i8** @"\01L_OBJC_SELECTOR_REFERENCES_28", align 8
2868 %tmp27 = bitcast %struct._class_t* %tmp24 to i8*
2869 %call2822 = call i8* (i8*, i8*, ...) @objc_msgSend(i8* %tmp27, i8* %tmp26, i8* %call137)
2870 %tmp13 = bitcast i8* %call2822 to %5*
2871 %tmp14 = call i8* @objc_retain(i8* %call2822) nounwind
2872 call void @objc_release(i8* null) nounwind
2873 %tobool30 = icmp eq i8* %call2822, null
2874 br i1 %tobool30, label %if.then44, label %if.end
2876 if.end: ; preds = %land.lhs.true23
2877 %tmp32 = load %struct._class_t*, %struct._class_t** @"\01L_OBJC_CLASSLIST_REFERENCES_$_29", align 8
2878 %tmp33 = load i8*, i8** @"\01L_OBJC_SELECTOR_REFERENCES_31", align 8
2879 %tmp34 = bitcast %struct._class_t* %tmp32 to i8*
2880 %call35 = call i8* (i8*, i8*, ...) @objc_msgSend(i8* %tmp34, i8* %tmp33)
2881 %tmp37 = load i8*, i8** @"\01L_OBJC_SELECTOR_REFERENCES_33", align 8
2882 %call3923 = call i8* (i8*, i8*, ...) @objc_msgSend(i8* %call35, i8* %tmp37, i8* %call2822, i32 signext 1, %4** %err)
2883 %cmp = icmp eq i8* %call3923, null
2884 br i1 %cmp, label %if.then44, label %end
2886 if.then44: ; preds = %if.end, %land.lhs.true23, %if.then
2887 %url.025 = phi %5* [ %tmp13, %if.end ], [ %tmp13, %land.lhs.true23 ], [ null, %if.then ]
2888 %tmp49 = load i8*, i8** @"\01L_OBJC_SELECTOR_REFERENCES_35", align 8
2889 %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)
2890 %call513 = extractvalue %struct._NSRange %call51, 0
2891 %call514 = extractvalue %struct._NSRange %call51, 1
2892 %tmp52 = load i8*, i8** @"\01L_OBJC_SELECTOR_REFERENCES_37", align 8
2893 %call548 = call i8* (i8*, i8*, ...) @objc_msgSend(i8* %call137, i8* %tmp52, i64 %call513, i64 %call514)
2894 %tmp55 = load %struct._class_t*, %struct._class_t** @"\01L_OBJC_CLASSLIST_REFERENCES_$_38", align 8
2895 %tmp56 = load i8*, i8** @"\01L_OBJC_SELECTOR_REFERENCES_40", align 8
2896 %tmp57 = bitcast %struct._class_t* %tmp55 to i8*
2897 %call58 = call i8* (i8*, i8*, ...) @objc_msgSend(i8* %tmp57, i8* %tmp56)
2898 %tmp59 = load i8*, i8** @"\01L_OBJC_SELECTOR_REFERENCES_42", align 8
2899 %call6110 = call i8* (i8*, i8*, ...) @objc_msgSend(i8* %call548, i8* %tmp59, i8* %call58)
2900 %tmp15 = call i8* @objc_retain(i8* %call6110) nounwind
2901 call void @objc_release(i8* %call137) nounwind
2902 %tmp64 = load i8*, i8** @"\01L_OBJC_SELECTOR_REFERENCES_46", align 8
2903 %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*))
2904 %tobool67 = icmp eq i8 %call66, 0
2905 br i1 %tobool67, label %if.end74, label %if.then68
2907 if.then68: ; preds = %if.then44
2908 %tmp70 = load i8*, i8** @"\01L_OBJC_SELECTOR_REFERENCES_48", align 8
2909 %call7220 = call i8* (i8*, i8*, ...) @objc_msgSend(i8* %call6110, i8* %tmp70)
2910 %tmp16 = call i8* @objc_retain(i8* %call7220) nounwind
2911 call void @objc_release(i8* %call6110) nounwind
2914 if.end74: ; preds = %if.then68, %if.then44
2915 %filename.0.in = phi i8* [ %call7220, %if.then68 ], [ %call6110, %if.then44 ]
2916 %filename.0 = bitcast i8* %filename.0.in to %1*
2917 %tmp17 = load i8*, i8** bitcast (%0* @"\01l_objc_msgSend_fixup_isEqual_" to i8**), align 16
2918 %tmp18 = bitcast i8* %tmp17 to i8 (i8*, %struct._message_ref_t*, i8*, ...)*
2919 %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)
2920 %tobool79 = icmp eq i8 %call78, 0
2921 br i1 %tobool79, label %land.lhs.true80, label %if.then109
2923 land.lhs.true80: ; preds = %if.end74
2924 %tmp82 = load i8*, i8** @"\01L_OBJC_SELECTOR_REFERENCES_25", align 8
2925 %call84 = call signext i8 bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to i8 (i8*, i8*)*)(i8* %filename.0.in, i8* %tmp82)
2926 %tobool86 = icmp eq i8 %call84, 0
2927 br i1 %tobool86, label %if.then109, label %if.end106
2929 if.end106: ; preds = %land.lhs.true80
2930 %tmp88 = load %struct._class_t*, %struct._class_t** @"\01L_OBJC_CLASSLIST_REFERENCES_$_26", align 8
2931 %tmp90 = load i8*, i8** @"\01L_OBJC_SELECTOR_REFERENCES_28", align 8
2932 %tmp91 = bitcast %struct._class_t* %tmp88 to i8*
2933 %call9218 = call i8* (i8*, i8*, ...) @objc_msgSend(i8* %tmp91, i8* %tmp90, i8* %filename.0.in)
2934 %tmp20 = bitcast i8* %call9218 to %5*
2935 %tmp21 = call i8* @objc_retain(i8* %call9218) nounwind
2936 %tmp22 = bitcast %5* %url.025 to i8*
2937 call void @objc_release(i8* %tmp22) nounwind
2938 %tmp94 = load %struct._class_t*, %struct._class_t** @"\01L_OBJC_CLASSLIST_REFERENCES_$_29", align 8
2939 %tmp95 = load i8*, i8** @"\01L_OBJC_SELECTOR_REFERENCES_31", align 8
2940 %tmp96 = bitcast %struct._class_t* %tmp94 to i8*
2941 %call97 = call i8* (i8*, i8*, ...) @objc_msgSend(i8* %tmp96, i8* %tmp95)
2942 %tmp99 = load i8*, i8** @"\01L_OBJC_SELECTOR_REFERENCES_33", align 8
2943 %call10119 = call i8* (i8*, i8*, ...) @objc_msgSend(i8* %call97, i8* %tmp99, i8* %call9218, i32 signext 1, %4** %err)
2944 %phitmp = icmp eq i8* %call10119, null
2945 br i1 %phitmp, label %if.then109, label %end
2947 if.then109: ; preds = %if.end106, %land.lhs.true80, %if.end74
2948 %url.129 = phi %5* [ %tmp20, %if.end106 ], [ %url.025, %if.end74 ], [ %url.025, %land.lhs.true80 ]
2949 %tmp110 = load %4*, %4** %err, align 8
2950 %tobool111 = icmp eq %4* %tmp110, null
2951 br i1 %tobool111, label %if.then112, label %if.end125
2953 if.then112: ; preds = %if.then109
2954 %tmp113 = load %struct._class_t*, %struct._class_t** @"\01L_OBJC_CLASSLIST_REFERENCES_$_50", align 8
2955 %tmp114 = load %1*, %1** @NSCocoaErrorDomain, align 8
2956 %tmp115 = load %struct._class_t*, %struct._class_t** @"\01L_OBJC_CLASSLIST_REFERENCES_$_51", align 8
2957 %call117 = call %1* @truncatedString(%1* %filename.0, i64 1034)
2958 %tmp118 = load %1*, %1** @NSFilePathErrorKey, align 8
2959 %tmp119 = load i8*, i8** @"\01L_OBJC_SELECTOR_REFERENCES_53", align 8
2960 %tmp120 = bitcast %struct._class_t* %tmp115 to i8*
2961 %call12113 = call i8* (i8*, i8*, ...) @objc_msgSend(i8* %tmp120, i8* %tmp119, %1* %call117, %1* %tmp118, i8* null)
2962 %tmp122 = load i8*, i8** @"\01L_OBJC_SELECTOR_REFERENCES_55", align 8
2963 %tmp123 = bitcast %struct._class_t* %tmp113 to i8*
2964 %call12414 = call i8* (i8*, i8*, ...) @objc_msgSend(i8* %tmp123, i8* %tmp122, %1* %tmp114, i64 258, i8* %call12113)
2965 %tmp23 = call i8* @objc_retain(i8* %call12414) nounwind
2966 %tmp25 = call i8* @objc_autorelease(i8* %tmp23) nounwind
2967 %tmp28 = bitcast i8* %tmp25 to %4*
2968 store %4* %tmp28, %4** %err, align 8
2971 if.end125: ; preds = %if.then112, %if.then109
2972 %tmp127 = phi %4* [ %tmp110, %if.then109 ], [ %tmp28, %if.then112 ]
2973 %tmp126 = load %struct._class_t*, %struct._class_t** @"\01L_OBJC_CLASSLIST_REFERENCES_$_56", align 8
2974 %tmp128 = load i8*, i8** @"\01L_OBJC_SELECTOR_REFERENCES_58", align 8
2975 %tmp129 = bitcast %struct._class_t* %tmp126 to i8*
2976 %call13015 = call i8* (i8*, i8*, ...) @objc_msgSend(i8* %tmp129, i8* %tmp128, %4* %tmp127)
2977 %tmp131 = load i8*, i8** @"\01L_OBJC_SELECTOR_REFERENCES_60", align 8
2978 %call13317 = call i8* (i8*, i8*, ...) @objc_msgSend(i8* %call13015, i8* %tmp131)
2981 end: ; preds = %if.end125, %if.end106, %if.end, %land.lhs.true, %entry
2982 %filename.2 = phi %1* [ %filename.0, %if.end106 ], [ %filename.0, %if.end125 ], [ %tmp, %land.lhs.true ], [ null, %entry ], [ %tmp, %if.end ]
2983 %origFilename.0 = phi %1* [ %tmp, %if.end106 ], [ %tmp, %if.end125 ], [ %tmp, %land.lhs.true ], [ null, %entry ], [ %tmp, %if.end ]
2984 %url.2 = phi %5* [ %tmp20, %if.end106 ], [ %url.129, %if.end125 ], [ null, %land.lhs.true ], [ null, %entry ], [ %tmp13, %if.end ]
2985 call void @objc_release(i8* %tmp9) nounwind, !clang.imprecise_release !0
2986 %tmp29 = bitcast %5* %url.2 to i8*
2987 call void @objc_release(i8* %tmp29) nounwind, !clang.imprecise_release !0
2988 %tmp30 = bitcast %1* %origFilename.0 to i8*
2989 call void @objc_release(i8* %tmp30) nounwind, !clang.imprecise_release !0
2990 %tmp31 = bitcast %1* %filename.2 to i8*
2991 call void @objc_release(i8* %tmp31) nounwind, !clang.imprecise_release !0
2992 call void @objc_release(i8* %tmp7) nounwind, !clang.imprecise_release !0
2996 declare i32 @__gxx_personality_v0(...)
2998 declare i32 @objc_sync_enter(i8*)
2999 declare i32 @objc_sync_exit(i8*)
3001 ; Make sure that we understand that objc_sync_{enter,exit} are IC_User not
3002 ; IC_Call/IC_CallOrUser.
3004 ; CHECK-LABEL: define void @test67(
3005 ; CHECK-NEXT: call i32 @objc_sync_enter(i8* %x)
3006 ; CHECK-NEXT: call i32 @objc_sync_exit(i8* %x)
3007 ; CHECK-NEXT: ret void
3009 define void @test67(i8* %x) {
3010 call i8* @objc_retain(i8* %x)
3011 call i32 @objc_sync_enter(i8* %x)
3012 call i32 @objc_sync_exit(i8* %x)
3013 call void @objc_release(i8* %x), !clang.imprecise_release !0
3017 !llvm.module.flags = !{!1}
3020 !1 = !{i32 1, !"Debug Info Version", i32 3}
3021 !2 = distinct !DISubprogram()
3023 ; CHECK: attributes #0 = { nounwind readnone }
3024 ; CHECK: attributes [[NUW]] = { nounwind }
3025 ; CHECK: ![[RELEASE]] = !{}