ObjCARC: Try to fix faulty tests

[arsenm]

Summary

These were trying to check if there was not an llvm.objc call before a
closing "}", which presumably was intended to match the end of the
function. Really this was matching the closing } in "bitcast {}* %selfto i8*",
which can't be what anyone intended. This broke after converting the test
to opaque pointer deleted this bitcast.

There are in fact @llvm.obj calls remaining in the function, so this
may indicate the transform this was intended to check is actually
broken. In @"\01-[A z]" (great test name), the first retain call seems
to move down to the printf. The second case, @"\01-[Top0 _getX]", has
no change.

[dexonsmith]

@ahatanak or @rjmccall, can you confirm whether a bug has crept in while the test was broken? Is a retain/release around @printf and/or @puts expected? Or maybe there's no bug, but the printf/puts declarations need to be annotated somehow?

Regardless, this patch seems like an improvement. It make sense to me to commit this (maybe with FIXMEs in front of those check lines and/or an LLVM bug filed), although for now it'd be good to wait a bit to give them a chance to respond. I assume they're flooded with a holiday email deluge (IIRC, last week would have been a holiday for those at Apple).

llvm/test/Transforms/ObjCARC/basic.ll

2715

Can/should this be CHECK: [^]} to confirm it's a scoping brace instead of a type brace?

[ahatanak]

ARC optimizer was previously removing the retain/release pair, but it's not clear to me why it was safe to do so. There is a load that loads an ivar of the object before the call to @llvm.objc.release, so the object has to be kept alive at least until that point.

I have to investigate when it stopped removing the pair.

[ahatanak]

I confirmed ARC optimizer hasn't removed the retain/release pairs in both functions at least since October 2017. The retain/release pair in @"\01-[Top0 _getX]" can be removed. I'm not sure about the one in @"\01-[A z]".

[arsenm]

Check brace is at start of line

llvm/test/Transforms/ObjCARC/basic.ll

2715

[^]} doesn't work, but {{^}}} does (which looks like a bug in the check itself)

[dexonsmith]

In D138796#3957499, @ahatanak wrote:

I confirmed ARC optimizer hasn't removed the retain/release pairs in both functions at least since October 2017. The retain/release pair in @"\01-[Top0 _getX]" can be removed. I'm not sure about the one in @"\01-[A z]".

Great progress; seems to me like the regression is old enough it might not be an easy fix. Are you okay with the tests being cleaned up to reflect reality in the meantime?

One option would be this commit as-is (maybe with a comment in the regressed test?). Another alternative would be to move the tests that had bitrotted to a different file, which is XFAIL'ed for now while you investigate how/whether to get them passing again; this has the benefit of making the expected/desired behaviour clear.

WDYT?

llvm/test/Transforms/ObjCARC/basic.ll

2715

Right, right; I misremembered how to get into regex mode. {{^}}} seems correct.

[ahatanak]

In D138796#3967899, @dexonsmith wrote:

In D138796#3957499, @ahatanak wrote:

I confirmed ARC optimizer hasn't removed the retain/release pairs in both functions at least since October 2017. The retain/release pair in @"\01-[Top0 _getX]" can be removed. I'm not sure about the one in @"\01-[A z]".

Great progress; seems to me like the regression is old enough it might not be an easy fix. Are you okay with the tests being cleaned up to reflect reality in the meantime?

Yes, I think that's okay. We are tracking this internally, so this can be committed as-is.

[dexonsmith]

In D138796#3975547, @ahatanak wrote:

In D138796#3967899, @dexonsmith wrote:

In D138796#3957499, @ahatanak wrote:

I confirmed ARC optimizer hasn't removed the retain/release pairs in both functions at least since October 2017. The retain/release pair in @"\01-[Top0 _getX]" can be removed. I'm not sure about the one in @"\01-[A z]".

Great progress; seems to me like the regression is old enough it might not be an easy fix. Are you okay with the tests being cleaned up to reflect reality in the meantime?

Yes, I think that's okay. We are tracking this internally, so this can be committed as-is.

In that case, this LGTM.

@arsenm, I'd prefer that you add comments to the two broken cases saying that the optimizer should somehow cleanup those pairs (or move those cases to an XFAIL test), so that if some future person works on this it'll be more clear. Up to you though.

[arsenm]

021ff534bf2a6fd4ccef8bae1b6feb8439a0cc5c

llvm/test/Transforms/ObjCARC/basic.ll

 declare i8* @objc_msgSend(i8*, i8*, ...)
 
 ; Simple retain+release pair deletion, with some intervening control
 ; flow and harmless instructions.
 
 ; CHECK: define void @test0_precise(i32* %x, i1 %p) [[NUW:#[0-9]+]] {
 ; CHECK: @llvm.objc.retain
 ; CHECK: @llvm.objc.release
-; CHECK: }
+; CHECK: {{^}}}
 define void @test0_precise(i32* %x, i1 %p) nounwind {
 entry:
   %a = bitcast i32* %x to i8*
   %0 = call i8* @llvm.objc.retain(i8* %a) nounwind
   br i1 %p, label %t, label %f
 
 t:
   store i8 3, i8* %a
   %b = bitcast i32* %x to float*
   store float 2.0, float* %b
   br label %return
 
 f:
   store i32 7, i32* %x
   br label %return
 
 return:
   %c = bitcast i32* %x to i8*
   call void @llvm.objc.release(i8* %c) nounwind
   ret void
 }
 
 ; CHECK: define void @test0_imprecise(i32* %x, i1 %p) [[NUW]] {
 ; CHECK-NOT: @llvm.objc.
-; CHECK: }
+; CHECK: {{^}}}
 define void @test0_imprecise(i32* %x, i1 %p) nounwind {
 entry:
   %a = bitcast i32* %x to i8*
   %0 = call i8* @llvm.objc.retain(i8* %a) nounwind
   br i1 %p, label %t, label %f
 
 t:
   store i8 3, i8* %a

 ; Like test0 but the release isn't always executed when the retain is,
 ; so the optimization is not safe.
 
 ; TODO: Make the llvm.objc.release's argument be %0.
 
 ; CHECK: define void @test1_precise(i32* %x, i1 %p, i1 %q) [[NUW]] {
 ; CHECK: @llvm.objc.retain(i8* %a)
 ; CHECK: @llvm.objc.release
-; CHECK: }
+; CHECK: {{^}}}
 define void @test1_precise(i32* %x, i1 %p, i1 %q) nounwind {
 entry:
   %a = bitcast i32* %x to i8*
   %0 = call i8* @llvm.objc.retain(i8* %a) nounwind
   br i1 %p, label %t, label %f
 
 t:
   store i8 3, i8* %a

 
 alt_return:
   ret void
 }
 
 ; CHECK: define void @test1_imprecise(i32* %x, i1 %p, i1 %q) [[NUW]] {
 ; CHECK: @llvm.objc.retain(i8* %a)
 ; CHECK: @llvm.objc.release
-; CHECK: }
+; CHECK: {{^}}}
 define void @test1_imprecise(i32* %x, i1 %p, i1 %q) nounwind {
 entry:
   %a = bitcast i32* %x to i8*
   %0 = call i8* @llvm.objc.retain(i8* %a) nounwind
   br i1 %p, label %t, label %f
 
 t:
   store i8 3, i8* %a

 
 ; CHECK: define void @test1b_precise(i8* %x, i1 %p, i1 %q) {
 ; CHECK: entry:
 ; CHECK:   tail call i8* @llvm.objc.retain(i8* %x) [[NUW]]
 ; CHECK-NOT: @llvm.objc.
 ; CHECK: if.end5:
 ; CHECK:   tail call void @llvm.objc.release(i8* %x) [[NUW]]
 ; CHECK-NOT: @llvm.objc.
-; CHECK: }
+; CHECK: {{^}}}
 define void @test1b_precise(i8* %x, i1 %p, i1 %q) {
 entry:
   tail call i8* @llvm.objc.retain(i8* %x) nounwind
   br i1 %p, label %if.then, label %if.end
 
 if.then:                                          ; preds = %entry
   tail call void @callee()
   br label %if.end

 
 ; CHECK-LABEL: define void @test1b_imprecise(
 ; CHECK: entry:
 ; CHECK:   tail call i8* @llvm.objc.retain(i8* %x) [[NUW:#[0-9]+]]
 ; CHECK-NOT: @llvm.objc.
 ; CHECK: if.end5:
 ; CHECK:   tail call void @llvm.objc.release(i8* %x) [[NUW]], !clang.imprecise_release ![[RELEASE:[0-9]+]]
 ; CHECK-NOT: @llvm.objc.
-; CHECK: }
+; CHECK: {{^}}}
 define void @test1b_imprecise(i8* %x, i1 %p, i1 %q) {
 entry:
   tail call i8* @llvm.objc.retain(i8* %x) nounwind
   br i1 %p, label %if.then, label %if.end
 
 if.then:                                          ; preds = %entry
   tail call void @callee()
   br label %if.end

 
 
 ; Like test0 but the pointer is passed to an intervening call,
 ; so the optimization is not safe.
 
 ; CHECK-LABEL: define void @test2_precise(
 ; CHECK: @llvm.objc.retain(i8* %a)
 ; CHECK: @llvm.objc.release
-; CHECK: }
+; CHECK: {{^}}}
 define void @test2_precise(i32* %x, i1 %p) nounwind {
 entry:
   %a = bitcast i32* %x to i8*
   %0 = call i8* @llvm.objc.retain(i8* %a) nounwind
   br i1 %p, label %t, label %f
 
 t:
   store i8 3, i8* %a
return:
   %c = bitcast i32* %x to i8*
   call void @llvm.objc.release(i8* %c) nounwind
   ret void
 }
 
 ; CHECK-LABEL: define void @test2_imprecise(
 ; CHECK: @llvm.objc.retain(i8* %a)
 ; CHECK: @llvm.objc.release
-; CHECK: }
+; CHECK: {{^}}}
 define void @test2_imprecise(i32* %x, i1 %p) nounwind {
 entry:
   %a = bitcast i32* %x to i8*
   %0 = call i8* @llvm.objc.retain(i8* %a) nounwind
   br i1 %p, label %t, label %f
 
 t:
   store i8 3, i8* %a

 ; Like test0 but the release is in a loop,
 ; so the optimization is not safe.
 
 ; TODO: For now, assume this can't happen.
 
 ; CHECK-LABEL: define void @test3_precise(
 ; TODO: @llvm.objc.retain(i8* %a)
 ; TODO: @llvm.objc.release
-; CHECK: }
+; CHECK: {{^}}}
 define void @test3_precise(i32* %x, i1* %q) nounwind {
 entry:
   %a = bitcast i32* %x to i8*
   %0 = call i8* @llvm.objc.retain(i8* %a) nounwind
   br label %loop
 
 loop:
   %c = bitcast i32* %x to i8*
   call void @llvm.objc.release(i8* %c) nounwind
   %j = load volatile i1, i1* %q
   br i1 %j, label %loop, label %return
 
 return:
   ret void
 }
 
 ; CHECK-LABEL: define void @test3_imprecise(
 ; TODO: @llvm.objc.retain(i8* %a)
 ; TODO: @llvm.objc.release
-; CHECK: }
+; CHECK: {{^}}}
 define void @test3_imprecise(i32* %x, i1* %q) nounwind {
 entry:
   %a = bitcast i32* %x to i8*
   %0 = call i8* @llvm.objc.retain(i8* %a) nounwind
   br label %loop
 
 loop:
   %c = bitcast i32* %x to i8*

 ; TODO: For now, assume this can't happen.
 
 ; Like test0 but the retain is in a loop,
 ; so the optimization is not safe.
 
 ; CHECK-LABEL: define void @test4_precise(
 ; TODO: @llvm.objc.retain(i8* %a)
 ; TODO: @llvm.objc.release
-; CHECK: }
+; CHECK: {{^}}}
 define void @test4_precise(i32* %x, i1* %q) nounwind {
 entry:
   br label %loop
 
 loop:
   %a = bitcast i32* %x to i8*
   %0 = call i8* @llvm.objc.retain(i8* %a) nounwind
   %j = load volatile i1, i1* %q
   br i1 %j, label %loop, label %return
 
 return:
   %c = bitcast i32* %x to i8*
   call void @llvm.objc.release(i8* %c) nounwind
   ret void
 }
 
 ; CHECK-LABEL: define void @test4_imprecise(
 ; TODO: @llvm.objc.retain(i8* %a)
 ; TODO: @llvm.objc.release
-; CHECK: }
+; CHECK: {{^}}}
 define void @test4_imprecise(i32* %x, i1* %q) nounwind {
 entry:
   br label %loop
 
 loop:
   %a = bitcast i32* %x to i8*
   %0 = call i8* @llvm.objc.retain(i8* %a) nounwind
   %j = load volatile i1, i1* %q
   br i1 %j, label %loop, label %return
 
 return:
   %c = bitcast i32* %x to i8*
   call void @llvm.objc.release(i8* %c) nounwind, !clang.imprecise_release !0
   ret void
 }
 
 
 ; Like test0 but the pointer is conditionally passed to an intervening call,
 ; so the optimization is not safe.
 
 ; CHECK-LABEL: define void @test5a(
 ; CHECK: @llvm.objc.retain(i8*
 ; CHECK: @llvm.objc.release
-; CHECK: }
+; CHECK: {{^}}}
 define void @test5a(i32* %x, i1 %q, i8* %y) nounwind {
 entry:
   %a = bitcast i32* %x to i8*
   %0 = call i8* @llvm.objc.retain(i8* %a) nounwind
   %s = select i1 %q, i8* %y, i8* %0
   call void @use_pointer(i8* %s)
   store i32 7, i32* %x
   %c = bitcast i32* %x to i8*
   call void @llvm.objc.release(i8* %c) nounwind
   ret void
 }
 
 ; CHECK-LABEL: define void @test5b(
 ; CHECK: @llvm.objc.retain(i8*
 ; CHECK: @llvm.objc.release
-; CHECK: }
+; CHECK: {{^}}}
 define void @test5b(i32* %x, i1 %q, i8* %y) nounwind {
 entry:
   %a = bitcast i32* %x to i8*
   %0 = call i8* @llvm.objc.retain(i8* %a) nounwind
   %s = select i1 %q, i8* %y, i8* %0
   call void @use_pointer(i8* %s)
   store i32 7, i32* %x
   %c = bitcast i32* %x to i8*
   call void @llvm.objc.release(i8* %c) nounwind, !clang.imprecise_release !0
   ret void
 }
 
 
 ; retain+release pair deletion, where the release happens on two different
 ; flow paths.
 
 ; CHECK-LABEL: define void @test6a(
 ; CHECK: entry:
 ; CHECK:   tail call i8* @llvm.objc.retain
 ; CHECK: t:
 ; CHECK:   call void @llvm.objc.release
 ; CHECK: f:
 ; CHECK:   call void @llvm.objc.release
 ; CHECK: return:
-; CHECK: }
+; CHECK: {{^}}}
 define void @test6a(i32* %x, i1 %p) nounwind {
 entry:
   %a = bitcast i32* %x to i8*
   %0 = call i8* @llvm.objc.retain(i8* %a) nounwind
   br i1 %p, label %t, label %f
 
 t:
   store i8 3, i8* %a
f:
   br label %return
 
 return:
   ret void
 }
 
 ; CHECK-LABEL: define void @test6b(
 ; CHECK-NOT: @llvm.objc.
-; CHECK: }
+; CHECK: {{^}}}
 define void @test6b(i32* %x, i1 %p) nounwind {
 entry:
   %a = bitcast i32* %x to i8*
   %0 = call i8* @llvm.objc.retain(i8* %a) nounwind
   br i1 %p, label %t, label %f
 
 t:
   store i8 3, i8* %a

 ; CHECK-LABEL: define void @test6c(
 ; CHECK: entry:
 ; CHECK:   tail call i8* @llvm.objc.retain
 ; CHECK: t:
 ; CHECK:   call void @llvm.objc.release
 ; CHECK: f:
 ; CHECK:   call void @llvm.objc.release
 ; CHECK: return:
-; CHECK: }
+; CHECK: {{^}}}
 define void @test6c(i32* %x, i1 %p) nounwind {
 entry:
   %a = bitcast i32* %x to i8*
   %0 = call i8* @llvm.objc.retain(i8* %a) nounwind
   br i1 %p, label %t, label %f
 
 t:
   store i8 3, i8* %a

 ; CHECK-LABEL: define void @test6d(
 ; CHECK: entry:
 ; CHECK:   tail call i8* @llvm.objc.retain
 ; CHECK: t:
 ; CHECK:   call void @llvm.objc.release
 ; CHECK: f:
 ; CHECK:   call void @llvm.objc.release
 ; CHECK: return:
-; CHECK: }
+; CHECK: {{^}}}
 define void @test6d(i32* %x, i1 %p) nounwind {
 entry:
   %a = bitcast i32* %x to i8*
   %0 = call i8* @llvm.objc.retain(i8* %a) nounwind
   br i1 %p, label %t, label %f
 
 t:
   store i8 3, i8* %a

 ; CHECK:     entry:
 ; CHECK-NOT:   llvm.objc.
 ; CHECK:     t:
 ; CHECK:       call i8* @llvm.objc.retain
 ; CHECK:     f:
 ; CHECK:       call i8* @llvm.objc.retain
 ; CHECK:     return:
 ; CHECK:       call void @llvm.objc.release
-; CHECK: }
+; CHECK: {{^}}}
 define void @test7(i32* %x, i1 %p) nounwind {
 entry:
   %a = bitcast i32* %x to i8*
   br i1 %p, label %t, label %f
 
 t:
   %0 = call i8* @llvm.objc.retain(i8* %a) nounwind
   store i8 3, i8* %a

 return:
   %c = bitcast i32* %x to i8*
   call void @llvm.objc.release(i8* %c) nounwind
   ret void
 }
 
 ; CHECK-LABEL: define void @test7b(
 ; CHECK-NOT: @llvm.objc.
-; CHECK: }
+; CHECK: {{^}}}
 define void @test7b(i32* %x, i1 %p) nounwind {
 entry:
   %a = bitcast i32* %x to i8*
   br i1 %p, label %t, label %f
 
 t:
   %0 = call i8* @llvm.objc.retain(i8* %a) nounwind
   store i8 3, i8* %a

 
 ; CHECK-LABEL: define void @test7c(
 ; CHECK: t:
 ; CHECK:   call i8* @llvm.objc.retainBlock
 ; CHECK: f:
 ; CHECK:   call i8* @llvm.objc.retain
 ; CHECK: return:
 ; CHECK:   call void @llvm.objc.release
-; CHECK: }
+; CHECK: {{^}}}
 define void @test7c(i32* %x, i1 %p) nounwind {
 entry:
   %a = bitcast i32* %x to i8*
   br i1 %p, label %t, label %f
 
 t:
   %0 = call i8* @llvm.objc.retainBlock(i8* %a) nounwind
   store i8 3, i8* %a

 ; CHECK: f:
 ; CHECK:   @llvm.objc.retain
 ; CHECK: mid:
 ; CHECK: u:
 ; CHECK:   @llvm.objc.release
 ; CHECK: g:
 ; CHECK:   @llvm.objc.release
 ; CHECK: return:
-; CHECK: }
+; CHECK: {{^}}}
 define void @test8a(i32* %x, i1 %p, i1 %q) nounwind {
 entry:
   %a = bitcast i32* %x to i8*
   br i1 %p, label %t, label %f
 
 t:
   %0 = call i8* @llvm.objc.retain(i8* %a) nounwind
   store i8 3, i8* %a
g:
   br label %return
 
 return:
   ret void
 }
 
 ; CHECK-LABEL: define void @test8b(
 ; CHECK-NOT: @llvm.objc.
-; CHECK: }
+; CHECK: {{^}}}
 define void @test8b(i32* %x, i1 %p, i1 %q) nounwind {
 entry:
   %a = bitcast i32* %x to i8*
   br i1 %p, label %t, label %f
 
 t:
   %0 = call i8* @llvm.objc.retain(i8* %a) nounwind
   store i8 3, i8* %a

 ; CHECK-NOT: @llvm.objc.
 ; CHECK: mid:
 ; CHECK: u:
 ; CHECK:   @llvm.objc.retain
 ; CHECK:   @llvm.objc.release
 ; CHECK: g:
 ; CHECK-NOT: @llvm.objc.
 ; CHECK: return:
-; CHECK: }
+; CHECK: {{^}}}
 define void @test8c(i32* %x, i1 %p, i1 %q) nounwind {
 entry:
   %a = bitcast i32* %x to i8*
   br i1 %p, label %t, label %f
 
 t:
   %0 = call i8* @llvm.objc.retain(i8* %a) nounwind
   store i8 3, i8* %a

 ; CHECK: f:
 ; CHECK:   @llvm.objc.retain
 ; CHECK: mid:
 ; CHECK: u:
 ; CHECK:   @llvm.objc.release
 ; CHECK: g:
 ; CHECK:   @llvm.objc.release
 ; CHECK: return:
-; CHECK: }
+; CHECK: {{^}}}
 define void @test8d(i32* %x, i1 %p, i1 %q) nounwind {
 entry:
   %a = bitcast i32* %x to i8*
   br i1 %p, label %t, label %f
 
 t:
   %0 = call i8* @llvm.objc.retain(i8* %a) nounwind
   store i8 3, i8* %a

 return:
   ret void
 }
 
 ; Trivial retain+release pair deletion.
 
 ; CHECK-LABEL: define void @test9(
 ; CHECK-NOT: @llvm.objc.
-; CHECK: }
+; CHECK: {{^}}}
 define void @test9(i8* %x) nounwind {
 entry:
   %0 = call i8* @llvm.objc.retain(i8* %x) nounwind
   call void @llvm.objc.release(i8* %0) nounwind
   ret void
 }
 
 ; Retain+release pair, but on an unknown pointer relationship. Don't delete!
 
 ; CHECK-LABEL: define void @test9b(
 ; CHECK: @llvm.objc.retain(i8* %x)
 ; CHECK: @llvm.objc.release(i8* %s)
-; CHECK: }
+; CHECK: {{^}}}
 define void @test9b(i8* %x, i1 %j, i8* %p) nounwind {
 entry:
   %0 = call i8* @llvm.objc.retain(i8* %x) nounwind
   %s = select i1 %j, i8* %x, i8* %p
   call void @llvm.objc.release(i8* %s) nounwind
   ret void
 }
 
 ; Trivial retain+release pair with intervening calls - don't delete!
 
 ; CHECK-LABEL: define void @test10(
 ; CHECK: @llvm.objc.retain(i8* %x)
 ; CHECK: @callee
 ; CHECK: @use_pointer
 ; CHECK: @llvm.objc.release
-; CHECK: }
+; CHECK: {{^}}}
 define void @test10(i8* %x) nounwind {
 entry:
   %0 = call i8* @llvm.objc.retain(i8* %x) nounwind
   call void @callee()
   call void @use_pointer(i8* %x)
   call void @llvm.objc.release(i8* %0) nounwind
   ret void
 }
 
 ; Trivial retain+autoreleaserelease pair. Don't delete!
 ; Also, add a tail keyword, since llvm.objc.retain can never be passed
 ; a stack argument.
 
 ; CHECK-LABEL: define void @test11(
 ; CHECK: tail call i8* @llvm.objc.retain(i8* %x) [[NUW]]
 ; CHECK: call i8* @llvm.objc.autorelease(i8* %0) [[NUW]]
-; CHECK: }
+; CHECK: {{^}}}
 define void @test11(i8* %x) nounwind {
 entry:
   %0 = call i8* @llvm.objc.retain(i8* %x) nounwind
   call i8* @llvm.objc.autorelease(i8* %0) nounwind
   call void @use_pointer(i8* %x)
   ret void
 }
 
 ; Same as test11 but with no use_pointer call. Delete the pair!
 
 ; CHECK-LABEL: define void @test11a(
 ; CHECK: entry:
 ; CHECK-NEXT: ret void
-; CHECK: }
+; CHECK: {{^}}}
 define void @test11a(i8* %x) nounwind {
 entry:
   %0 = call i8* @llvm.objc.retain(i8* %x) nounwind
   call i8* @llvm.objc.autorelease(i8* %0) nounwind
   ret void
 }
 
 ; Same as test11 but the value is returned. Do not perform an RV optimization
 ; since if the frontend emitted code for an __autoreleasing variable, we may
 ; want it to be in the autorelease pool.
 
 ; CHECK-LABEL: define i8* @test11b(
 ; CHECK: tail call i8* @llvm.objc.retain(i8* %x) [[NUW]]
 ; CHECK: call i8* @llvm.objc.autorelease(i8* %0) [[NUW]]
-; CHECK: }
+; CHECK: {{^}}}
 define i8* @test11b(i8* %x) nounwind {
 entry:
   %0 = call i8* @llvm.objc.retain(i8* %x) nounwind
   call i8* @llvm.objc.autorelease(i8* %0) nounwind
   ret i8* %x
 }
 
 ; We can not delete this retain, release since we do not have a post-dominating
 ; use of the release.
 
 ; CHECK-LABEL: define void @test12(
 ; CHECK-NEXT: entry:
 ; CHECK-NEXT: @llvm.objc.retain(i8* %x)
 ; CHECK-NEXT: @llvm.objc.retain
 ; CHECK: @llvm.objc.release
-; CHECK: }
+; CHECK: {{^}}}
 define void @test12(i8* %x, i64 %n) {
 entry:
   call i8* @llvm.objc.retain(i8* %x) nounwind
   call i8* @llvm.objc.retain(i8* %x) nounwind
   call void @use_pointer(i8* %x)
   call void @use_pointer(i8* %x)
   call void @llvm.objc.release(i8* %x) nounwind
   ret void
 }
 
 ; Trivial retain,autorelease pair. Don't delete!
 
 ; CHECK-LABEL: define void @test13(
 ; CHECK: tail call i8* @llvm.objc.retain(i8* %x) [[NUW]]
 ; CHECK: tail call i8* @llvm.objc.retain(i8* %x) [[NUW]]
 ; CHECK: @use_pointer(i8* %x)
 ; CHECK: call i8* @llvm.objc.autorelease(i8* %x) [[NUW]]
-; CHECK: }
+; CHECK: {{^}}}
 define void @test13(i8* %x, i64 %n) {
 entry:
   call i8* @llvm.objc.retain(i8* %x) nounwind
   call i8* @llvm.objc.retain(i8* %x) nounwind
   call void @use_pointer(i8* %x)
   call i8* @llvm.objc.autorelease(i8* %x) nounwind
   ret void
 }

 ; autoreleasePoolPop in the way.
 
 ; CHECK-LABEL: define void @test13c(
 ; CHECK: @llvm.objc.retain(i8* %x)
 ; CHECK: @llvm.objc.autoreleasePoolPop
 ; CHECK: @llvm.objc.retain(i8* %x)
 ; CHECK: @use_pointer
 ; CHECK: @llvm.objc.release
-; CHECK: }
+; CHECK: {{^}}}
 define void @test13c(i8* %x, i64 %n) {
 entry:
   call i8* @llvm.objc.retain(i8* %x) nounwind
   call void @llvm.objc.autoreleasePoolPop(i8* undef)
   call i8* @llvm.objc.retain(i8* %x) nounwind
   call void @use_pointer(i8* %x)
   call void @use_pointer(i8* %x)
   call void @llvm.objc.release(i8* %x) nounwind

 ; Retain+release pairs in diamonds, all dominated by a retain.
 
 ; CHECK-LABEL: define void @test16a(
 ; CHECK: @llvm.objc.retain(i8* %x)
 ; CHECK-NOT: @objc
 ; CHECK: purple:
 ; CHECK: @use_pointer
 ; CHECK: @llvm.objc.release
-; CHECK: }
+; CHECK: {{^}}}
 define void @test16a(i1 %a, i1 %b, i8* %x) {
 entry:
   call i8* @llvm.objc.retain(i8* %x) nounwind
   br i1 %a, label %red, label %orange
 
 red:
   call i8* @llvm.objc.retain(i8* %x) nounwind
   br label %yellow

 
 ; CHECK-LABEL: define void @test16b(
 ; CHECK: @llvm.objc.retain(i8* %x)
 ; CHECK-NOT: @objc
 ; CHECK: purple:
 ; CHECK-NEXT: @use_pointer
 ; CHECK-NEXT: @use_pointer
 ; CHECK-NEXT: @llvm.objc.release
-; CHECK: }
+; CHECK: {{^}}}
 define void @test16b(i1 %a, i1 %b, i8* %x) {
 entry:
   call i8* @llvm.objc.retain(i8* %x) nounwind
   br i1 %a, label %red, label %orange
 
 red:
   call i8* @llvm.objc.retain(i8* %x) nounwind
   br label %yellow

 }
 
 ; CHECK-LABEL: define void @test16c(
 ; CHECK: @llvm.objc.retain(i8* %x)
 ; CHECK-NOT: @objc
 ; CHECK: purple:
 ; CHECK: @use_pointer
 ; CHECK: @llvm.objc.release
-; CHECK: }
+; CHECK: {{^}}}
 define void @test16c(i1 %a, i1 %b, i8* %x) {
 entry:
   call i8* @llvm.objc.retain(i8* %x) nounwind
   br i1 %a, label %red, label %orange
 
 red:
   call i8* @llvm.objc.retain(i8* %x) nounwind
   br label %yellow
purple:
   call void @use_pointer(i8* %x)
   call void @llvm.objc.release(i8* %x) nounwind, !clang.imprecise_release !0
   ret void
 }
 
 ; CHECK-LABEL: define void @test16d(
 ; CHECK: @llvm.objc.retain(i8* %x)
 ; CHECK: @llvm.objc
-; CHECK: }
+; CHECK: {{^}}}
 define void @test16d(i1 %a, i1 %b, i8* %x) {
 entry:
   call i8* @llvm.objc.retain(i8* %x) nounwind
   br i1 %a, label %red, label %orange
 
 red:
   call i8* @llvm.objc.retain(i8* %x) nounwind
   br label %yellow

 purple:
   ret void
 }
 
 ; Delete no-ops.
 
 ; CHECK-LABEL: define void @test18(
 ; CHECK-NOT: @llvm.objc.
-; CHECK: }
+; CHECK: {{^}}}
 define void @test18() {
   call i8* @llvm.objc.retain(i8* null)
   call void @llvm.objc.release(i8* null)
   call i8* @llvm.objc.autorelease(i8* null)
   ret void
 }
 
 ; Delete no-ops where undef can be assumed to be null.
 
 ; CHECK-LABEL: define void @test18b(
 ; CHECK-NOT: @llvm.objc.
-; CHECK: }
+; CHECK: {{^}}}
 define void @test18b() {
   call i8* @llvm.objc.retain(i8* undef)
   call void @llvm.objc.release(i8* undef)
   call i8* @llvm.objc.autorelease(i8* undef)
   ret void
 }
 
 ; Replace uses of arguments with uses of return values, to reduce
 ; register pressure.
 
 ; CHECK: define void @test19(i32* %y) {
 ; CHECK:   %z = bitcast i32* %y to i8*
 ; CHECK:   %0 = bitcast i32* %y to i8*
 ; CHECK:   %1 = tail call i8* @llvm.objc.retain(i8* %0)
 ; CHECK:   call void @use_pointer(i8* %z)
 ; CHECK:   call void @use_pointer(i8* %z)
 ; CHECK:   %2 = bitcast i32* %y to i8*
 ; CHECK:   call void @llvm.objc.release(i8* %2)
 ; CHECK:   ret void
-; CHECK: }
+; CHECK: {{^}}}
 define void @test19(i32* %y) {
 entry:
   %x = bitcast i32* %y to i8*
   %0 = call i8* @llvm.objc.retain(i8* %x) nounwind
   %z = bitcast i32* %y to i8*
   call void @use_pointer(i8* %z)
   call void @use_pointer(i8* %z)
   call void @llvm.objc.release(i8* %x)
   ret void
 }
 
 ; Bitcast insertion
 
 ; CHECK-LABEL: define void @test20(
 ; CHECK: %tmp1 = tail call i8* @llvm.objc.retain(i8* %tmp) [[NUW]]
 ; CHECK-NEXT: invoke
-; CHECK: }
+; CHECK: {{^}}}
 define void @test20(double* %self) personality i32 (...)* @__gxx_personality_v0 {
 if.then12:
   %tmp = bitcast double* %self to i8*
   %tmp1 = call i8* @llvm.objc.retain(i8* %tmp) nounwind
   invoke void @invokee()
           to label %invoke.cont23 unwind label %lpad20
 
 invoke.cont23:                                    ; preds = %if.then12

 
 ; CHECK-LABEL: define void @test22(
 ; CHECK: B:
 ; CHECK:   %1 = bitcast double* %p to i8*
 ; CHECK:   call void @llvm.objc.release(i8* %1)
 ; CHECK:   br label %C
 ; CHECK: C:                                                ; preds = %B, %A
 ; CHECK-NOT: @llvm.objc.release
-; CHECK: }
+; CHECK: {{^}}}
 define void @test22(double* %p, i1 %a) {
   br i1 %a, label %A, label %B
 A:
   br label %C
 B:
   br label %C
 C:
   %h = phi double* [ null, %A ], [ %p, %B ]
C:
   ret void
 }
 
 ; Any call can decrement a retain count.
 
 ; CHECK-LABEL: define void @test24(
 ; CHECK: @llvm.objc.retain(i8* %a)
 ; CHECK: @llvm.objc.release
-; CHECK: }
+; CHECK: {{^}}}
 define void @test24(i8* %r, i8* %a) {
   call i8* @llvm.objc.retain(i8* %a)
   call void @use_pointer(i8* %r)
   %q = load i8, i8* %a
   call void @llvm.objc.release(i8* %a)
   ret void
 }
 
 ; Don't move a retain/release pair if the release can be moved
 ; but the retain can't be moved to balance it.
 
 ; CHECK-LABEL: define void @test25(
 ; CHECK: entry:
 ; CHECK:   call i8* @llvm.objc.retain(i8* %p)
 ; CHECK: true:
 ; CHECK: done:
 ; CHECK:   call void @llvm.objc.release(i8* %p)
-; CHECK: }
+; CHECK: {{^}}}
 define void @test25(i8* %p, i1 %x) {
 entry:
   %f0 = call i8* @llvm.objc.retain(i8* %p)
   call void @callee()
   br i1 %x, label %true, label %done
 
 true:
   store i8 0, i8* %p
   br label %done
 
 done:
   call void @llvm.objc.release(i8* %p)
   ret void
 }
 
 ; Don't move a retain/release pair if the retain can be moved
 ; but the release can't be moved to balance it.
 
 ; CHECK-LABEL: define void @test26(
 ; CHECK: entry:
 ; CHECK:   call i8* @llvm.objc.retain(i8* %p)
 ; CHECK: true:
 ; CHECK: done:
 ; CHECK:   call void @llvm.objc.release(i8* %p)
-; CHECK: }
+; CHECK: {{^}}}
 define void @test26(i8* %p, i1 %x) {
 entry:
   %f0 = call i8* @llvm.objc.retain(i8* %p)
   br i1 %x, label %true, label %done
 
 true:
   call void @callee()
   br label %done
 
 done:
   store i8 0, i8* %p
   call void @llvm.objc.release(i8* %p)
   ret void
 }
 
 ; Don't sink the retain,release into the loop.
 
 ; CHECK-LABEL: define void @test27(
 ; CHECK: entry:
 ; CHECK: call i8* @llvm.objc.retain(i8* %p)
 ; CHECK: loop:
 ; CHECK-NOT: @llvm.objc.
 ; CHECK: done:
 ; CHECK: call void @llvm.objc.release
-; CHECK: }
+; CHECK: {{^}}}
 define void @test27(i8* %p, i1 %x, i1 %y) {
-entry: 
+entry:
   %f0 = call i8* @llvm.objc.retain(i8* %p)
   br i1 %x, label %loop, label %done
 
 loop:
   call void @callee()
   store i8 0, i8* %p
   br i1 %y, label %done, label %loop
-  
-done: 
+done:
   call void @llvm.objc.release(i8* %p)
   ret void
 }
 
 ; Trivial code motion case: Triangle.
 
 ; CHECK-LABEL: define void @test28(
 ; CHECK-NOT: @llvm.objc.
 ; CHECK: true:
 ; CHECK: call i8* @llvm.objc.retain
 ; CHECK: call void @callee()
 ; CHECK: store
 ; CHECK: call void @llvm.objc.release
 ; CHECK: done:
 ; CHECK-NOT: @llvm.objc.
-; CHECK: }
+; CHECK: {{^}}}
 define void @test28(i8* %p, i1 %x) {
 entry:
   %f0 = call i8* @llvm.objc.retain(i8* %p)
   br i1 %x, label %true, label %done
 
 true:
   call void @callee()
   store i8 0, i8* %p

 ; CHECK: true:
 ; CHECK-NOT: @llvm.objc.
 ; CHECK: call void @callee()
 ; CHECK-NOT: @llvm.objc.
 ; CHECK: store
 ; CHECK-NOT: @llvm.objc.
 ; CHECK: done:
 ; CHECK: @llvm.objc.release
-; CHECK: }
+; CHECK: {{^}}}
 define void @test28b(i8* %p, i1 %x, i8* noalias %t) {
 entry:
   %f0 = call i8* @llvm.objc.retain(i8* %p)
   br i1 %x, label %true, label %done
 
 true:
   call void @callee()
   store i8 0, i8* %p

 ; CHECK-NOT: @llvm.objc.
 ; CHECK: true:
 ; CHECK: call i8* @llvm.objc.retain
 ; CHECK: call void @callee()
 ; CHECK: store
 ; CHECK: call void @llvm.objc.release(i8* %p) [[NUW]], !clang.imprecise_release
 ; CHECK: done:
 ; CHECK-NOT: @llvm.objc.
-; CHECK: }
+; CHECK: {{^}}}
 define void @test28c(i8* %p, i1 %x, i8* noalias %t) {
 entry:
   %f0 = call i8* @llvm.objc.retain(i8* %p)
   br i1 %x, label %true, label %done
 
 true:
   call void @callee()
   store i8 0, i8* %p

 ; CHECK: call i8* @llvm.objc.retain
 ; CHECK: true:
 ; CHECK: call void @callee()
 ; CHECK: store
 ; CHECK: done:
 ; CHECK: call void @llvm.objc.release
 ; CHECK: ohno:
 ; CHECK: call void @llvm.objc.release
-; CHECK: }
+; CHECK: {{^}}}
 define void @test29(i8* %p, i1 %x, i1 %y) {
 entry:
   %f0 = call i8* @llvm.objc.retain(i8* %p)
   br i1 %x, label %true, label %done
 
 true:
   call void @callee()
   store i8 0, i8* %p

 ; CHECK: true:
 ; CHECK: call void @callee()
 ; CHECK: store
 ; CHECK: false:
 ; CHECK: done:
 ; CHECK: call void @llvm.objc.release
 ; CHECK: ohno:
 ; CHECK: call void @llvm.objc.release
-; CHECK: }
+; CHECK: {{^}}}
 define void @test30(i8* %p, i1 %x, i1 %y, i1 %z) {
 entry:
   %f0 = call i8* @llvm.objc.retain(i8* %p)
   br i1 %x, label %true, label %false
 
 true:
   call void @callee()
   store i8 0, i8* %p

 ; CHECK: call i8* @llvm.objc.retain(i8* %p)
 ; CHECK: call void @callee()
 ; CHECK: store
 ; CHECK: true:
 ; CHECK: call void @llvm.objc.release
 ; CHECK: false:
 ; CHECK: call void @llvm.objc.release
 ; CHECK: ret void
-; CHECK: }
+; CHECK: {{^}}}
 define void @test31(i8* %p, i1 %x) {
 entry:
   %f0 = call i8* @llvm.objc.retain(i8* %p)
   call void @callee()
   store i8 0, i8* %p
   br i1 %x, label %true, label %false
 true:
   call void @llvm.objc.release(i8* %p)
   ret void
 false:
   call void @llvm.objc.release(i8* %p)
   ret void
 }
 
 ; Don't consider bitcasts or getelementptrs direct uses.
 
 ; CHECK-LABEL: define void @test32(
 ; CHECK: call i8* @llvm.objc.retain
 ; CHECK: true:
 ; CHECK: call void @callee()
 ; CHECK: store
 ; CHECK: done:
 ; CHECK: call void @llvm.objc.release
-; CHECK: }
+; CHECK: {{^}}}
 define void @test32(i8* %p, i1 %x) {
 entry:
   %f0 = call i8* @llvm.objc.retain(i8* %p)
   br i1 %x, label %true, label %done
 
 true:
   call void @callee()
   store i8 0, i8* %p

 
 ; CHECK-LABEL: define void @test33(
 ; CHECK: call i8* @llvm.objc.retain
 ; CHECK: true:
 ; CHECK: call void @callee()
 ; CHECK: icmp
 ; CHECK: done:
 ; CHECK: call void @llvm.objc.release
-; CHECK: }
+; CHECK: {{^}}}
 define void @test33(i8* %p, i1 %x, i8* %y) {
 entry:
   %f0 = call i8* @llvm.objc.retain(i8* %p)
   br i1 %x, label %true, label %done
 
 true:
   call void @callee()
   %v = icmp eq i8* %p, %y

 ; Delete retain,release if there's just a possible dec and we have imprecise
 ; releases.
 
 ; CHECK-LABEL: define void @test34a(
 ; CHECK:   call i8* @llvm.objc.retain
 ; CHECK: true:
 ; CHECK: done:
 ; CHECK: call void @llvm.objc.release
-; CHECK: }
+; CHECK: {{^}}}
 define void @test34a(i8* %p, i1 %x, i8* %y) {
 entry:
   %f0 = call i8* @llvm.objc.retain(i8* %p)
   br i1 %x, label %true, label %done
 
 true:
   call void @callee()
   br label %done
 
 done:
   %g = bitcast i8* %p to i8*
   %h = getelementptr i8, i8* %g, i64 0
   call void @llvm.objc.release(i8* %g)
   ret void
 }
 
 ; CHECK-LABEL: define void @test34b(
 ; CHECK-NOT: @llvm.objc.
-; CHECK: }
+; CHECK: {{^}}}
 define void @test34b(i8* %p, i1 %x, i8* %y) {
 entry:
   %f0 = call i8* @llvm.objc.retain(i8* %p)
   br i1 %x, label %true, label %done
 
 true:
   call void @callee()
   br label %done

 
 ; Precise.
 ; CHECK-LABEL: define void @test35a(
 ; CHECK: entry:
 ; CHECK:   call i8* @llvm.objc.retain
 ; CHECK: true:
 ; CHECK: done:
 ; CHECK:   call void @llvm.objc.release
-; CHECK: }
+; CHECK: {{^}}}
 define void @test35a(i8* %p, i1 %x, i8* %y) {
 entry:
   %f0 = call i8* @llvm.objc.retain(i8* %p)
   br i1 %x, label %true, label %done
 
 true:
   %v = icmp eq i8* %p, %y
   br label %done
 
 done:
   %g = bitcast i8* %p to i8*
   %h = getelementptr i8, i8* %g, i64 0
   call void @llvm.objc.release(i8* %g)
   ret void
 }
 
 ; Imprecise.
 ; CHECK-LABEL: define void @test35b(
 ; CHECK-NOT: @llvm.objc.
-; CHECK: }
+; CHECK: {{^}}}
 define void @test35b(i8* %p, i1 %x, i8* %y) {
 entry:
   %f0 = call i8* @llvm.objc.retain(i8* %p)
   br i1 %x, label %true, label %done
 
 true:
   %v = icmp eq i8* %p, %y
   br label %done
 
 done:
   %g = bitcast i8* %p to i8*
   %h = getelementptr i8, i8* %g, i64 0
   call void @llvm.objc.release(i8* %g), !clang.imprecise_release !0
   ret void
 }
 
 ; Delete a retain,release if there's no actual use and we have precise release.
 
 ; CHECK-LABEL: define void @test36a(
 ; CHECK: @llvm.objc.retain
 ; CHECK: call void @callee()
 ; CHECK-NOT: @llvm.objc.
 ; CHECK: call void @callee()
 ; CHECK: @llvm.objc.release
-; CHECK: }
+; CHECK: {{^}}}
 define void @test36a(i8* %p) {
 entry:
   call i8* @llvm.objc.retain(i8* %p)
   call void @callee()
   call void @callee()
   call void @llvm.objc.release(i8* %p)
   ret void
 }
 
 ; Like test36, but with metadata.
 
 ; CHECK-LABEL: define void @test36b(
 ; CHECK-NOT: @llvm.objc.
-; CHECK: }
+; CHECK: {{^}}}
 define void @test36b(i8* %p) {
 entry:
   call i8* @llvm.objc.retain(i8* %p)
   call void @callee()
   call void @callee()
   call void @llvm.objc.release(i8* %p), !clang.imprecise_release !0
   ret void
 }
 
 ; Be aggressive about analyzing phis to eliminate possible uses.
 
 ; CHECK-LABEL: define void @test38(
 ; CHECK-NOT: @llvm.objc.
-; CHECK: }
+; CHECK: {{^}}}
 define void @test38(i8* %p, i1 %u, i1 %m, i8* %z, i8* %y, i8* %x, i8* %w) {
 entry:
   call i8* @llvm.objc.retain(i8* %p)
   br i1 %u, label %true, label %false
 true:
   br i1 %m, label %a, label %b
 false:
   br i1 %m, label %c, label %d
g:
   call void @llvm.objc.release(i8* %p), !clang.imprecise_release !0
   ret void
 }
 
 ; Delete retain,release pairs around loops.
 
 ; CHECK-LABEL: define void @test39(
 ; CHECK-NOT: @llvm.objc.
-; CHECK: }
+; CHECK: {{^}}}
 define void @test39(i8* %p) {
 entry:
   %0 = call i8* @llvm.objc.retain(i8* %p)
   br label %loop
 
 loop:                                             ; preds = %loop, %entry
   br i1 undef, label %loop, label %exit
 
 exit:                                             ; preds = %loop
   call void @llvm.objc.release(i8* %0), !clang.imprecise_release !0
   ret void
 }
 
 ; Delete retain,release pairs around loops containing uses.
 
 ; CHECK-LABEL: define void @test39b(
 ; CHECK-NOT: @llvm.objc.
-; CHECK: }
+; CHECK: {{^}}}
 define void @test39b(i8* %p) {
 entry:
   %0 = call i8* @llvm.objc.retain(i8* %p)
   br label %loop
 
 loop:                                             ; preds = %loop, %entry
   store i8 0, i8* %0
   br i1 undef, label %loop, label %exit
 
 exit:                                             ; preds = %loop
   call void @llvm.objc.release(i8* %0), !clang.imprecise_release !0
   ret void
 }
 
 ; Delete retain,release pairs around loops containing potential decrements.
 
 ; CHECK-LABEL: define void @test39c(
 ; CHECK-NOT: @llvm.objc.
-; CHECK: }
+; CHECK: {{^}}}
 define void @test39c(i8* %p) {
 entry:
   %0 = call i8* @llvm.objc.retain(i8* %p)
   br label %loop
 
 loop:                                             ; preds = %loop, %entry
   call void @use_pointer(i8* %0)
   br i1 undef, label %loop, label %exit
 
 exit:                                             ; preds = %loop
   call void @llvm.objc.release(i8* %0), !clang.imprecise_release !0
   ret void
 }
 
 ; Delete retain,release pairs around loops even if
 ; the successors are in a different order.
 
 ; CHECK-LABEL: define void @test40(
 ; CHECK-NOT: @llvm.objc.
-; CHECK: }
+; CHECK: {{^}}}
 define void @test40(i8* %p) {
 entry:
   %0 = call i8* @llvm.objc.retain(i8* %p)
   br label %loop
 
 loop:                                             ; preds = %loop, %entry
   call void @use_pointer(i8* %0)
   br i1 undef, label %exit, label %loop
entry:
   call void @llvm.objc.release(i8* %p)
   ret void
 }
 
 ; Do retain+release elimination for non-provenance pointers.
 
 ; CHECK-LABEL: define void @test44(
 ; CHECK-NOT: llvm.objc.
-; CHECK: }
+; CHECK: {{^}}}
 define void @test44(i8** %pp) {
   %p = load i8*, i8** %pp
   %q = call i8* @llvm.objc.retain(i8* %p)
   call void @llvm.objc.release(i8* %q)
   ret void
 }
 
 ; Don't delete retain+release with an unknown-provenance
 ; may-alias llvm.objc.release between them.
 
 ; CHECK-LABEL: define void @test45(
 ; CHECK: call i8* @llvm.objc.retain(i8* %p)
 ; CHECK: call void @llvm.objc.release(i8* %q)
 ; CHECK: call void @use_pointer(i8* %p)
 ; CHECK: call void @llvm.objc.release(i8* %p)
-; CHECK: }
+; CHECK: {{^}}}
 define void @test45(i8** %pp, i8** %qq) {
   %p = load i8*, i8** %pp
   %q = load i8*, i8** %qq
   call i8* @llvm.objc.retain(i8* %p)
   call void @llvm.objc.release(i8* %q)
   call void @use_pointer(i8* %p)
   call void @llvm.objc.release(i8* %p)
   ret void
 }
 
 ; Don't delete retain and autorelease here.
 
 ; CHECK-LABEL: define void @test46(
 ; CHECK: tail call i8* @llvm.objc.retain(i8* %p) [[NUW]]
 ; CHECK: true:
 ; CHECK: call i8* @llvm.objc.autorelease(i8* %p) [[NUW]]
-; CHECK: }
+; CHECK: {{^}}}
 define void @test46(i8* %p, i1 %a) {
 entry:
   call i8* @llvm.objc.retain(i8* %p)
   br i1 %a, label %true, label %false
 
 true:
   call i8* @llvm.objc.autorelease(i8* %p)
   call void @use_pointer(i8* %p)
   ret void
 
 false:
   ret void
 }
 
 ; Delete no-op cast calls.
 
 ; CHECK-LABEL: define i8* @test47(
 ; CHECK-NOT: call
 ; CHECK: ret i8* %p
-; CHECK: }
+; CHECK: {{^}}}
 define i8* @test47(i8* %p) nounwind {
   %x = call i8* @llvm.objc.retainedObject(i8* %p)
   ret i8* %x
 }
 
 ; Delete no-op cast calls.
 
 ; CHECK-LABEL: define i8* @test48(
 ; CHECK-NOT: call
 ; CHECK: ret i8* %p
-; CHECK: }
+; CHECK: {{^}}}
 define i8* @test48(i8* %p) nounwind {
   %x = call i8* @llvm.objc.unretainedObject(i8* %p)
   ret i8* %x
 }
 
 ; Delete no-op cast calls.
 
 ; CHECK-LABEL: define i8* @test49(
 ; CHECK-NOT: call
 ; CHECK: ret i8* %p
-; CHECK: }
+; CHECK: {{^}}}
 define i8* @test49(i8* %p) nounwind {
   %x = call i8* @llvm.objc.unretainedPointer(i8* %p)
   ret i8* %x
 }
 
 ; Do delete retain+release with intervening stores of the address value if we
 ; have imprecise release attached to llvm.objc.release.
 
define void @test50a(i8* %p, i8** %pp) {
   call void @callee()
   store i8* %p, i8** %pp
   call void @llvm.objc.release(i8* %p)
   ret void
 }
 
 ; CHECK-LABEL: define void @test50b(
 ; CHECK-NOT: @llvm.objc.
-; CHECK: }
+; CHECK: {{^}}}
 define void @test50b(i8* %p, i8** %pp) {
   call i8* @llvm.objc.retain(i8* %p)
   call void @callee()
   store i8* %p, i8** %pp
   call void @llvm.objc.release(i8* %p), !clang.imprecise_release !0
   ret void
 }
 
 
 ; Don't delete retain+release with intervening stores through the
 ; address value.
 
 ; CHECK-LABEL: define void @test51a(
 ; CHECK: call i8* @llvm.objc.retain(i8* %p)
 ; CHECK: call void @llvm.objc.release(i8* %p)
 ; CHECK: ret void
-; CHECK: }
+; CHECK: {{^}}}
 define void @test51a(i8* %p) {
   call i8* @llvm.objc.retain(i8* %p)
   call void @callee()
   store i8 0, i8* %p
   call void @llvm.objc.release(i8* %p)
   ret void
 }
 
 ; CHECK-LABEL: define void @test51b(
 ; CHECK: call i8* @llvm.objc.retain(i8* %p)
 ; CHECK: call void @llvm.objc.release(i8* %p)
 ; CHECK: ret void
-; CHECK: }
+; CHECK: {{^}}}
 define void @test51b(i8* %p) {
   call i8* @llvm.objc.retain(i8* %p)
   call void @callee()
   store i8 0, i8* %p
   call void @llvm.objc.release(i8* %p), !clang.imprecise_release !0
   ret void
 }
 
 ; Don't delete retain+release with intervening use of a pointer of
 ; unknown provenance.
 
 ; CHECK-LABEL: define void @test52a(
 ; CHECK: call i8* @llvm.objc.retain
 ; CHECK: call void @callee()
 ; CHECK: call void @use_pointer(i8* %z)
 ; CHECK: call void @llvm.objc.release
 ; CHECK: ret void
-; CHECK: }
+; CHECK: {{^}}}
 define void @test52a(i8** %zz, i8** %pp) {
   %p = load i8*, i8** %pp
   %1 = call i8* @llvm.objc.retain(i8* %p)
   call void @callee()
   %z = load i8*, i8** %zz
   call void @use_pointer(i8* %z)
   call void @llvm.objc.release(i8* %p)
   ret void
 }
 
 ; CHECK-LABEL: define void @test52b(
 ; CHECK: call i8* @llvm.objc.retain
 ; CHECK: call void @callee()
 ; CHECK: call void @use_pointer(i8* %z)
 ; CHECK: call void @llvm.objc.release
 ; CHECK: ret void
-; CHECK: }
+; CHECK: {{^}}}
 define void @test52b(i8** %zz, i8** %pp) {
   %p = load i8*, i8** %pp
   %1 = call i8* @llvm.objc.retain(i8* %p)
   call void @callee()
   %z = load i8*, i8** %zz
   call void @use_pointer(i8* %z)
   call void @llvm.objc.release(i8* %p), !clang.imprecise_release !0
   ret void
 }
 
 ; Like test52, but the pointer has function type, so it's assumed to
 ; be not reference counted.
 ; Oops. That's wrong. Clang sometimes uses function types gratuitously.
 ; See rdar://10551239.
 
 ; CHECK-LABEL: define void @test53(
 ; CHECK: @llvm.objc.
-; CHECK: }
+; CHECK: {{^}}}
 define void @test53(void ()** %zz, i8** %pp) {
   %p = load i8*, i8** %pp
   %1 = call i8* @llvm.objc.retain(i8* %p)
   call void @callee()
   %z = load void ()*, void ()** %zz
   call void @callee_fnptr(void ()* %z)
   call void @llvm.objc.release(i8* %p)
   ret void
 }
 
 ; Convert autorelease to release if the value is unused.
 
 ; CHECK-LABEL: define void @test54(
 ; CHECK: call i8* @returner()
 ; CHECK-NEXT: call void @llvm.objc.release(i8* %t) [[NUW]], !clang.imprecise_release ![[RELEASE]]
 ; CHECK-NEXT: ret void
-; CHECK: }
+; CHECK: {{^}}}
 define void @test54() {
   %t = call i8* @returner()
   call i8* @llvm.objc.autorelease(i8* %t)
   ret void
 }
 
 ; Nested retain+release pairs. Delete them both.
 
 ; CHECK-LABEL: define void @test55(
 ; CHECK-NOT: @objc
-; CHECK: }
-define void @test55(i8* %x) { 
-entry: 
-  %0 = call i8* @llvm.objc.retain(i8* %x) nounwind 
-  %1 = call i8* @llvm.objc.retain(i8* %x) nounwind 
-  call void @llvm.objc.release(i8* %x) nounwind 
-  call void @llvm.objc.release(i8* %x) nounwind 
-  ret void 
+; CHECK: {{^}}}
+define void @test55(i8* %x) {
+entry:
+  %0 = call i8* @llvm.objc.retain(i8* %x) nounwind
+  %1 = call i8* @llvm.objc.retain(i8* %x) nounwind
+  call void @llvm.objc.release(i8* %x) nounwind
+  call void @llvm.objc.release(i8* %x) nounwind
+  ret void
 }
 
 ; Nested retain+release pairs where the inner pair depends
 ; on the outer pair to be removed, and then the outer pair
 ; can be partially eliminated. Plus an extra outer pair to
 ; eliminate, for fun.
 
 ; CHECK-LABEL: define void @test56(
 ; CHECK-NOT: @objc
 ; CHECK: if.then:
 ; CHECK-NEXT: %0 = tail call i8* @llvm.objc.retain(i8* %x) [[NUW]]
 ; CHECK-NEXT: tail call void @use_pointer(i8* %x)
 ; CHECK-NEXT: tail call void @use_pointer(i8* %x)
 ; CHECK-NEXT: tail call void @llvm.objc.release(i8* %x) [[NUW]], !clang.imprecise_release ![[RELEASE]]
 ; CHECK-NEXT: br label %if.end
 ; CHECK-NOT: @objc
-; CHECK: }
+; CHECK: {{^}}}
 define void @test56(i8* %x, i32 %n) {
 entry:
   %0 = tail call i8* @llvm.objc.retain(i8* %x) nounwind
   %1 = tail call i8* @llvm.objc.retain(i8* %0) nounwind
   %tobool = icmp eq i32 %n, 0
   br i1 %tobool, label %if.end, label %if.then
 
 if.then:                                          ; preds = %entry

 @something = external global i8*
 
 ; We have a precise lifetime retain/release here. We can not remove them since
 ; @something is not constant.
 
 ; CHECK-LABEL: define void @test60a(
 ; CHECK: call i8* @llvm.objc.retain
 ; CHECK: call void @llvm.objc.release
-; CHECK: }
+; CHECK: {{^}}}
 define void @test60a() {
   %t = load i8*, i8** @constptr
   %s = load i8*, i8** @something
   call i8* @llvm.objc.retain(i8* %s)
   call void @callee()
   call void @use_pointer(i8* %t)
   call void @llvm.objc.release(i8* %s)
   ret void
 }
 
 ; CHECK-LABEL: define void @test60b(
 ; CHECK: call i8* @llvm.objc.retain
 ; CHECK-NOT: call i8* @llvm.objc.retain
 ; CHECK-NOT: call i8* @llvm.objc.release
-; CHECK: }
+; CHECK: {{^}}}
 define void @test60b() {
   %t = load i8*, i8** @constptr
   %s = load i8*, i8** @something
   call i8* @llvm.objc.retain(i8* %t)
   call i8* @llvm.objc.retain(i8* %t)
   call void @callee()
   call void @use_pointer(i8* %s)
   call void @llvm.objc.release(i8* %t)
   ret void
 }
 
 ; CHECK-LABEL: define void @test60c(
 ; CHECK-NOT: @llvm.objc.
-; CHECK: }
+; CHECK: {{^}}}
 define void @test60c() {
   %t = load i8*, i8** @constptr
   %s = load i8*, i8** @something
   call i8* @llvm.objc.retain(i8* %t)
   call void @callee()
   call void @use_pointer(i8* %s)
   call void @llvm.objc.release(i8* %t), !clang.imprecise_release !0
   ret void
 }
 
 ; CHECK-LABEL: define void @test60d(
 ; CHECK-NOT: @llvm.objc.
-; CHECK: }
+; CHECK: {{^}}}
 define void @test60d() {
   %t = load i8*, i8** @constptr
   %s = load i8*, i8** @something
   call i8* @llvm.objc.retain(i8* %t)
   call void @callee()
   call void @use_pointer(i8* %s)
   call void @llvm.objc.release(i8* %t)
   ret void
 }
 
 ; CHECK-LABEL: define void @test60e(
 ; CHECK-NOT: @llvm.objc.
-; CHECK: }
+; CHECK: {{^}}}
 define void @test60e() {
   %t = load i8*, i8** @constptr
   %s = load i8*, i8** @something
   call i8* @llvm.objc.retain(i8* %t)
   call void @callee()
   call void @use_pointer(i8* %s)
   call void @llvm.objc.release(i8* %t), !clang.imprecise_release !0
   ret void
 }
 
 ; Constant pointers to objects don't need to be considered related to other
 ; pointers.
 
 ; CHECK-LABEL: define void @test61(
 ; CHECK-NOT: @llvm.objc.
-; CHECK: }
+; CHECK: {{^}}}
 define void @test61() {
   %t = load i8*, i8** @constptr
   call i8* @llvm.objc.retain(i8* %t)
   call void @callee()
   call void @use_pointer(i8* %t)
   call void @llvm.objc.release(i8* %t)
   ret void
 }
 
 ; Delete a retain matched by releases when one is inside the loop and the
 ; other is outside the loop.
 
 ; CHECK-LABEL: define void @test62(
 ; CHECK-NOT: @llvm.objc.
-; CHECK: }
+; CHECK: {{^}}}
 define void @test62(i8* %x, i1* %p) nounwind {
 entry:
   br label %loop
 
 loop:
   call i8* @llvm.objc.retain(i8* %x)
   %q = load i1, i1* %p
   br i1 %q, label %loop.more, label %exit

 ; Like test62 but with no release in exit.
 ; Don't delete anything!
 
 ; CHECK-LABEL: define void @test63(
 ; CHECK: loop:
 ; CHECK:   tail call i8* @llvm.objc.retain(i8* %x)
 ; CHECK: loop.more:
 ; CHECK:   call void @llvm.objc.release(i8* %x)
-; CHECK: }
+; CHECK: {{^}}}
 define void @test63(i8* %x, i1* %p) nounwind {
 entry:
   br label %loop
 
 loop:
   call i8* @llvm.objc.retain(i8* %x)
   %q = load i1, i1* %p
   br i1 %q, label %loop.more, label %exit

 ; Like test62 but with no release in loop.more.
 ; Don't delete anything!
 
 ; CHECK-LABEL: define void @test64(
 ; CHECK: loop:
 ; CHECK:   tail call i8* @llvm.objc.retain(i8* %x)
 ; CHECK: exit:
 ; CHECK:   call void @llvm.objc.release(i8* %x)
-; CHECK: }
+; CHECK: {{^}}}
 define void @test64(i8* %x, i1* %p) nounwind {
 entry:
   br label %loop
 
 loop:
   call i8* @llvm.objc.retain(i8* %x)
   %q = load i1, i1* %p
   br i1 %q, label %loop.more, label %exit
 
 loop.more:
   br label %loop
 
 exit:
   call void @llvm.objc.release(i8* %x)
   ret void
 }
 
 ; Move an autorelease past a phi with a null.
 
 ; CHECK-LABEL: define i8* @test65(
 ; CHECK: if.then:
 ; CHECK:   call i8* @llvm.objc.autorelease(
 ; CHECK: return:
 ; CHECK-NOT: @llvm.objc.autorelease
-; CHECK: }
+; CHECK: {{^}}}
 define i8* @test65(i1 %x) {
 entry:
   br i1 %x, label %return, label %if.then
 
 if.then:                                          ; preds = %entry
   %c = call i8* @returner()
   %s = call i8* @llvm.objc.retainAutoreleasedReturnValue(i8* %c) nounwind
   br label %return
 
 return:                                           ; preds = %if.then, %entry
   %retval = phi i8* [ %s, %if.then ], [ null, %entry ]
   %q = call i8* @llvm.objc.autorelease(i8* %retval) nounwind
   ret i8* %retval
 }
 
 ; Don't move an autorelease past an autorelease pool boundary.
 
 ; CHECK-LABEL: define i8* @test65b(
 ; CHECK: if.then:
 ; CHECK-NOT: @llvm.objc.autorelease
 ; CHECK: return:
 ; CHECK:   call i8* @llvm.objc.autorelease(
-; CHECK: }
+; CHECK: {{^}}}
 define i8* @test65b(i1 %x) {
 entry:
   %t = call i8* @llvm.objc.autoreleasePoolPush()
   br i1 %x, label %return, label %if.then
 
 if.then:                                          ; preds = %entry
   %c = call i8* @returner()
   %s = call i8* @llvm.objc.retainAutoreleasedReturnValue(i8* %c) nounwind

 ; Don't move an autoreleaseReuturnValue, which would break
 ; the RV optimization.
 
 ; CHECK-LABEL: define i8* @test65c(
 ; CHECK: if.then:
 ; CHECK-NOT: @llvm.objc.autorelease
 ; CHECK: return:
 ; CHECK:   call i8* @llvm.objc.autoreleaseReturnValue(
-; CHECK: }
+; CHECK: {{^}}}
 define i8* @test65c(i1 %x) {
 entry:
   br i1 %x, label %return, label %if.then
 
 if.then:                                          ; preds = %entry
   %c = call i8* @returner()
   %s = call i8* @llvm.objc.retainAutoreleasedReturnValue(i8* %c) nounwind
   br label %return
 
 return:                                           ; preds = %if.then, %entry
   %retval = phi i8* [ %s, %if.then ], [ null, %entry ]
   %q = call i8* @llvm.objc.autoreleaseReturnValue(i8* %retval) nounwind
   ret i8* %retval
 }
 
 ; CHECK-LABEL: define i8* @test65d(
 ; CHECK: if.then:
 ; CHECK-NOT: @llvm.objc.autorelease
 ; CHECK: return:
 ; CHECK:   call i8* @llvm.objc.autoreleaseReturnValue(
-; CHECK: }
+; CHECK: {{^}}}
 define i8* @test65d(i1 %x) {
 entry:
   br i1 %x, label %return, label %if.then
 
 if.then:                                          ; preds = %entry
   %c = call i8* @returner()
   %s = call i8* @llvm.objc.unsafeClaimAutoreleasedReturnValue(i8* %c) nounwind
   br label %return
 
 return:                                           ; preds = %if.then, %entry
   %retval = phi i8* [ %s, %if.then ], [ null, %entry ]
   %q = call i8* @llvm.objc.autoreleaseReturnValue(i8* %retval) nounwind
   ret i8* %retval
 }
 
 ; An llvm.objc.retain can serve as a may-use for a different pointer.
 ; rdar://11931823
 
 ; CHECK-LABEL: define void @test66a(
 ; CHECK:   tail call i8* @llvm.objc.retain(i8* %cond) [[NUW]]
 ; CHECK:   tail call void @llvm.objc.release(i8* %call) [[NUW]]
 ; CHECK:   tail call i8* @llvm.objc.retain(i8* %tmp8) [[NUW]]
 ; CHECK:   tail call void @llvm.objc.release(i8* %cond) [[NUW]]
-; CHECK: }
+; CHECK: {{^}}}
 define void @test66a(i8* %tmp5, i8* %bar, i1 %tobool, i1 %tobool1, i8* %call) {
 entry:
   br i1 %tobool, label %cond.true, label %cond.end
 
 cond.true:
   br label %cond.end
 
 cond.end:                                         ; preds = %cond.true, %entry
   %cond = phi i8* [ %tmp5, %cond.true ], [ %call, %entry ]
   %tmp7 = tail call i8* @llvm.objc.retain(i8* %cond) nounwind
   tail call void @llvm.objc.release(i8* %call) nounwind
   %tmp8 = select i1 %tobool1, i8* %cond, i8* %bar
   %tmp9 = tail call i8* @llvm.objc.retain(i8* %tmp8) nounwind
   tail call void @llvm.objc.release(i8* %cond) nounwind
   ret void
 }
 
 ; CHECK-LABEL: define void @test66b(
 ; CHECK:   tail call i8* @llvm.objc.retain(i8* %cond) [[NUW]]
 ; CHECK:   tail call void @llvm.objc.release(i8* %call) [[NUW]]
 ; CHECK:   tail call i8* @llvm.objc.retain(i8* %tmp8) [[NUW]]
 ; CHECK:   tail call void @llvm.objc.release(i8* %cond) [[NUW]]
-; CHECK: }
+; CHECK: {{^}}}
 define void @test66b(i8* %tmp5, i8* %bar, i1 %tobool, i1 %tobool1, i8* %call) {
 entry:
   br i1 %tobool, label %cond.true, label %cond.end
 
 cond.true:
   br label %cond.end
 
 cond.end:                                         ; preds = %cond.true, %entry
   %cond = phi i8* [ %tmp5, %cond.true ], [ %call, %entry ]
   %tmp7 = tail call i8* @llvm.objc.retain(i8* %cond) nounwind
   tail call void @llvm.objc.release(i8* %call) nounwind, !clang.imprecise_release !0
   %tmp8 = select i1 %tobool1, i8* %cond, i8* %bar
   %tmp9 = tail call i8* @llvm.objc.retain(i8* %tmp8) nounwind
   tail call void @llvm.objc.release(i8* %cond) nounwind
   ret void
 }
 
 ; CHECK-LABEL: define void @test66c(
 ; CHECK:   tail call i8* @llvm.objc.retain(i8* %cond) [[NUW]]
 ; CHECK:   tail call void @llvm.objc.release(i8* %call) [[NUW]]
 ; CHECK:   tail call i8* @llvm.objc.retain(i8* %tmp8) [[NUW]]
 ; CHECK:   tail call void @llvm.objc.release(i8* %cond) [[NUW]]
-; CHECK: }
+; CHECK: {{^}}}
 define void @test66c(i8* %tmp5, i8* %bar, i1 %tobool, i1 %tobool1, i8* %call) {
 entry:
   br i1 %tobool, label %cond.true, label %cond.end
 
 cond.true:
   br label %cond.end
 
 cond.end:                                         ; preds = %cond.true, %entry
   %cond = phi i8* [ %tmp5, %cond.true ], [ %call, %entry ]
   %tmp7 = tail call i8* @llvm.objc.retain(i8* %cond) nounwind
   tail call void @llvm.objc.release(i8* %call) nounwind
   %tmp8 = select i1 %tobool1, i8* %cond, i8* %bar
   %tmp9 = tail call i8* @llvm.objc.retain(i8* %tmp8) nounwind, !clang.imprecise_release !0
   tail call void @llvm.objc.release(i8* %cond) nounwind
   ret void
 }
 
 ; CHECK-LABEL: define void @test66d(
 ; CHECK:   tail call i8* @llvm.objc.retain(i8* %cond) [[NUW]]
 ; CHECK:   tail call void @llvm.objc.release(i8* %call) [[NUW]]
 ; CHECK:   tail call i8* @llvm.objc.retain(i8* %tmp8) [[NUW]]
 ; CHECK:   tail call void @llvm.objc.release(i8* %cond) [[NUW]]
-; CHECK: }
+; CHECK: {{^}}}
 define void @test66d(i8* %tmp5, i8* %bar, i1 %tobool, i1 %tobool1, i8* %call) {
 entry:
   br i1 %tobool, label %cond.true, label %cond.end
 
 cond.true:
   br label %cond.end
 
 cond.end:                                         ; preds = %cond.true, %entry

 ; A few real-world testcases.
 
 @.str4 = private unnamed_addr constant [33 x i8] c"-[A z] = { %f, %f, { %f, %f } }\0A\00"
 @"OBJC_IVAR_$_A.myZ" = global i64 20, section "__DATA, __objc_const", align 8
 declare i32 @printf(i8* nocapture, ...) nounwind
 declare i32 @puts(i8* nocapture) nounwind
 @str = internal constant [16 x i8] c"-[ Top0 _getX ]\00"
 
-; CHECK: define { <2 x float>, <2 x float> } @"\01-[A z]"({}* %self, i8* nocapture %_cmd) [[NUW]] {
-; CHECK-NOT: @llvm.objc.
-; CHECK: }
-
-define {<2 x float>, <2 x float>} @"\01-[A z]"({}* %self, i8* nocapture %_cmd) nounwind {
+; CHECK-LABEL: define { <2 x float>, <2 x float> } @"\01-[A z]"({}* %self, i8* nocapture %_cmd)
+; CHECK: [[SELF_CAST0:%[0-9]+]] = bitcast {}* %self to i8*
+; CHECK: tail call i8* @llvm.objc.retain(i8* [[SELF_CAST0]])
+; CHECK-NEXT: %call = tail call i32 (i8*, ...) @printf(
+; CHECK: [[SELF_CAST1:%[0-9]+]] = bitcast {}* %self to i8*
+; CHECK: tail call void @llvm.objc.release(i8* [[SELF_CAST1]])
+; CHECK: {{^}}}
+define { <2 x float>, <2 x float> } @"\01-[A z]"({}* %self, i8* nocapture %_cmd) nounwind {
 invoke.cont:
-  %0 = bitcast {}* %self to i8*
-  %1 = tail call i8* @llvm.objc.retain(i8* %0) nounwind
+  %i = bitcast {}* %self to i8*
+  %i1 = tail call i8* @llvm.objc.retain(i8* %i) nounwind
   tail call void @llvm.dbg.value(metadata {}* %self, metadata !DILocalVariable(scope: !2), metadata !DIExpression()), !dbg !DILocation(scope: !2)
   tail call void @llvm.dbg.value(metadata {}* %self, metadata !DILocalVariable(scope: !2), metadata !DIExpression()), !dbg !DILocation(scope: !2)
   %ivar = load i64, i64* @"OBJC_IVAR_$_A.myZ", align 8
-  %add.ptr = getelementptr i8, i8* %0, i64 %ivar
+  %add.ptr = getelementptr i8, i8* %i, i64 %ivar
   %tmp1 = bitcast i8* %add.ptr to float*
   %tmp2 = load float, float* %tmp1, align 4
   %conv = fpext float %tmp2 to double
   %add.ptr.sum = add i64 %ivar, 4
-  %tmp6 = getelementptr inbounds i8, i8* %0, i64 %add.ptr.sum
-  %2 = bitcast i8* %tmp6 to float*
-  %tmp7 = load float, float* %2, align 4
+  %tmp6 = getelementptr inbounds i8, i8* %i, i64 %add.ptr.sum
+  %i2 = bitcast i8* %tmp6 to float*
+  %tmp7 = load float, float* %i2, align 4
   %conv8 = fpext float %tmp7 to double
   %add.ptr.sum36 = add i64 %ivar, 8
-  %tmp12 = getelementptr inbounds i8, i8* %0, i64 %add.ptr.sum36
+  %tmp12 = getelementptr inbounds i8, i8* %i, i64 %add.ptr.sum36
   %arrayidx = bitcast i8* %tmp12 to float*
   %tmp13 = load float, float* %arrayidx, align 4
   %conv14 = fpext float %tmp13 to double
   %tmp12.sum = add i64 %ivar, 12
-  %arrayidx19 = getelementptr inbounds i8, i8* %0, i64 %tmp12.sum
-  %3 = bitcast i8* %arrayidx19 to float*
-  %tmp20 = load float, float* %3, align 4
+  %arrayidx19 = getelementptr inbounds i8, i8* %i, i64 %tmp12.sum
+  %i3 = bitcast i8* %arrayidx19 to float*
+  %tmp20 = load float, float* %i3, align 4
   %conv21 = fpext float %tmp20 to double
   %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)
   %ivar23 = load i64, i64* @"OBJC_IVAR_$_A.myZ", align 8
-  %add.ptr24 = getelementptr i8, i8* %0, i64 %ivar23
-  %4 = bitcast i8* %add.ptr24 to i128*
-  %srcval = load i128, i128* %4, align 4
-  tail call void @llvm.objc.release(i8* %0) nounwind
+  %add.ptr24 = getelementptr i8, i8* %i, i64 %ivar23
+  %i4 = bitcast i8* %add.ptr24 to i128*
+  %srcval = load i128, i128* %i4, align 4
+  tail call void @llvm.objc.release(i8* %i) nounwind
   %tmp29 = trunc i128 %srcval to i64
   %tmp30 = bitcast i64 %tmp29 to <2 x float>
-  %tmp31 = insertvalue {<2 x float>, <2 x float>} undef, <2 x float> %tmp30, 0
+  %tmp31 = insertvalue { <2 x float>, <2 x float> } undef, <2 x float> %tmp30, 0
   %tmp32 = lshr i128 %srcval, 64
   %tmp33 = trunc i128 %tmp32 to i64
   %tmp34 = bitcast i64 %tmp33 to <2 x float>
-  %tmp35 = insertvalue {<2 x float>, <2 x float>} %tmp31, <2 x float> %tmp34, 1
-  ret {<2 x float>, <2 x float>} %tmp35
+  %tmp35 = insertvalue { <2 x float>, <2 x float> } %tmp31, <2 x float> %tmp34, 1
+  ret { <2 x float>, <2 x float> } %tmp35
 }
 
-; CHECK: @"\01-[Top0 _getX]"({}* %self, i8* nocapture %_cmd) [[NUW]] {
-; CHECK-NOT: @llvm.objc.
-; CHECK: }
-
+; CHECK-LABEL: @"\01-[Top0 _getX]"({}* %self, i8* nocapture %_cmd)
+; CHECK: %i = bitcast {}* %self to i8*
+; CHECK: tail call i8* @llvm.objc.retain(i8* %i)
+; CHECK: %puts = tail call i32 @puts
+; CHECK: tail call void @llvm.objc.release(i8* %i)
 define i32 @"\01-[Top0 _getX]"({}* %self, i8* nocapture %_cmd) nounwind {
 invoke.cont:
-  %0 = bitcast {}* %self to i8*
-  %1 = tail call i8* @llvm.objc.retain(i8* %0) nounwind
+  %i = bitcast {}* %self to i8*
+  %i1 = tail call i8* @llvm.objc.retain(i8* %i) nounwind
   %puts = tail call i32 @puts(i8* getelementptr inbounds ([16 x i8], [16 x i8]* @str, i64 0, i64 0))
-  tail call void @llvm.objc.release(i8* %0) nounwind
+  tail call void @llvm.objc.release(i8* %i) nounwind
   ret i32 0
 }
 
 @"\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"
 @"\01L_OBJC_IMAGE_INFO" = internal constant [2 x i32] [i32 0, i32 16], section "__DATA, __objc_imageinfo, regular, no_dead_strip"
 @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"
 
 ; A simple loop. Eliminate the retain and release inside of it!
 
 ; CHECK: define void @loop(i8* %x, i64 %n) {
 ; CHECK: for.body:
 ; CHECK-NOT: @llvm.objc.
 ; CHECK: @objc_msgSend
 ; CHECK-NOT: @llvm.objc.
 ; CHECK: for.end:
-; CHECK: }
+; CHECK: {{^}}}
 define void @loop(i8* %x, i64 %n) {
 entry:
   %0 = tail call i8* @llvm.objc.retain(i8* %x) nounwind
   %cmp9 = icmp sgt i64 %n, 0
   br i1 %cmp9, label %for.body, label %for.end
 
 for.body:                                         ; preds = %entry, %for.body
   %i.010 = phi i64 [ %inc, %for.body ], [ 0, %entry ]
for.end:                                          ; preds = %for.body, %entry
   tail call void @llvm.objc.release(i8* %x) nounwind, !clang.imprecise_release !0
   ret void
 }
 
 ; ObjCARCOpt can delete the retain,release on self.
 
 ; CHECK: define void @TextEditTest(%2* %self, %3* %pboard) {
 ; CHECK-NOT: call i8* @llvm.objc.retain(i8* %tmp7)
-; CHECK: }
+; CHECK: {{^}}}
 
 %0 = type { i8* (i8*, %struct._message_ref_t*, ...)*, i8* }
 %1 = type opaque
 %2 = type opaque
 %3 = type opaque
 %4 = type opaque
 %5 = type opaque
 %struct.NSConstantString = type { i32*, i32, i8*, i64 }