Index: lib/CodeGen/CGBlocks.cpp =================================================================== --- lib/CodeGen/CGBlocks.cpp +++ lib/CodeGen/CGBlocks.cpp @@ -1585,6 +1585,64 @@ } } +namespace { +/// Release a __block variable. +struct CallBlockRelease final : EHScopeStack::Cleanup { + Address Addr; + BlockFieldFlags FieldFlags; + bool LoadBlockVarAddr; + + CallBlockRelease(Address Addr, BlockFieldFlags Flags, bool LoadValue) + : Addr(Addr), FieldFlags(Flags), LoadBlockVarAddr(LoadValue) {} + + void Emit(CodeGenFunction &CGF, Flags flags) override { + llvm::Value *BlockVarAddr; + if (LoadBlockVarAddr) { + BlockVarAddr = CGF.Builder.CreateLoad(Addr); + BlockVarAddr = CGF.Builder.CreateBitCast(BlockVarAddr, CGF.VoidPtrTy); + } else { + BlockVarAddr = Addr.getPointer(); + } + + CGF.BuildBlockRelease(BlockVarAddr, FieldFlags); + } +}; +} // end anonymous namespace + +static void pushCaptureCleanup(BlockCaptureEntityKind CaptureKind, + Address Field, QualType CaptureType, + BlockFieldFlags Flags, bool EHOnly, + CodeGenFunction &CGF) { + switch (CaptureKind) { + case BlockCaptureEntityKind::CXXRecord: + case BlockCaptureEntityKind::ARCWeak: + case BlockCaptureEntityKind::NonTrivialCStruct: + case BlockCaptureEntityKind::ARCStrong: { + if (CaptureType.isDestructedType() && + (!EHOnly || CGF.needsEHCleanup(CaptureType.isDestructedType()))) { + CodeGenFunction::Destroyer *Destroyer = + CaptureKind == BlockCaptureEntityKind::ARCStrong + ? CodeGenFunction::destroyARCStrongImprecise + : CGF.getDestroyer(CaptureType.isDestructedType()); + CleanupKind Kind = + EHOnly ? EHCleanup + : CGF.getCleanupKind(CaptureType.isDestructedType()); + CGF.pushDestroy(Kind, Field, CaptureType, Destroyer, Kind & EHCleanup); + } + break; + } + case BlockCaptureEntityKind::BlockObject: { + if (!EHOnly || CGF.getLangOpts().Exceptions) { + CleanupKind Kind = EHOnly ? EHCleanup : NormalAndEHCleanup; + CGF.enterByrefCleanup(Kind, Field, Flags, /*LoadBlockVarAddr*/ true); + } + break; + } + case BlockCaptureEntityKind::None: + llvm_unreachable("unexpected BlockCaptureEntityKind"); + } +} + /// Generate the copy-helper function for a block closure object: /// static void block_copy_helper(block_t *dst, block_t *src); /// The runtime will have previously initialized 'dst' by doing a @@ -1648,6 +1706,7 @@ for (const auto &CopiedCapture : CopiedCaptures) { const BlockDecl::Capture &CI = CopiedCapture.CI; const CGBlockInfo::Capture &capture = CopiedCapture.Capture; + QualType captureType = CI.getVariable()->getType(); BlockFieldFlags flags = CopiedCapture.Flags; unsigned index = capture.getIndex(); @@ -1685,9 +1744,11 @@ } else { EmitARCRetainNonBlock(srcValue); - // We don't need this anymore, so kill it. It's not quite - // worth the annoyance to avoid creating it in the first place. - cast(dstField.getPointer())->eraseFromParent(); + // Unless EH cleanup is required, we don't need this anymore, so kill + // it. It's not quite worth the annoyance to avoid creating it in the + // first place. + if (!needsEHCleanup(captureType.isDestructedType())) + cast(dstField.getPointer())->eraseFromParent(); } } else { assert(CopiedCapture.Kind == BlockCaptureEntityKind::BlockObject); @@ -1715,6 +1776,11 @@ } } } + + // Ensure that we destroy the copied object if an exception is thrown later + // in the helper function. + pushCaptureCleanup(CopiedCapture.Kind, dstField, captureType, flags, /*EHOnly*/ true, + *this); } FinishFunction(); @@ -1830,36 +1896,8 @@ Address srcField = Builder.CreateStructGEP(src, capture.getIndex(), capture.getOffset()); - // If the captured record has a destructor then call it. - if (DestroyedCapture.Kind == BlockCaptureEntityKind::CXXRecord) { - const auto *Dtor = - CI.getVariable()->getType()->getAsCXXRecordDecl()->getDestructor(); - PushDestructorCleanup(Dtor, srcField); - - // If this is a __weak capture, emit the release directly. - } else if (DestroyedCapture.Kind == BlockCaptureEntityKind::ARCWeak) { - EmitARCDestroyWeak(srcField); - - // Destroy strong objects with a call if requested. - } else if (DestroyedCapture.Kind == BlockCaptureEntityKind::ARCStrong) { - EmitARCDestroyStrong(srcField, ARCImpreciseLifetime); - - // If this is a C struct that requires non-trivial destruction, emit a call - // to its destructor. - } else if (DestroyedCapture.Kind == - BlockCaptureEntityKind::NonTrivialCStruct) { - QualType varType = CI.getVariable()->getType(); - pushDestroy(varType.isDestructedType(), srcField, varType); - - // Otherwise we call _Block_object_dispose. It wouldn't be too - // hard to just emit this as a cleanup if we wanted to make sure - // that things were done in reverse. - } else { - assert(DestroyedCapture.Kind == BlockCaptureEntityKind::BlockObject); - llvm::Value *value = Builder.CreateLoad(srcField); - value = Builder.CreateBitCast(value, VoidPtrTy); - BuildBlockRelease(value, flags); - } + pushCaptureCleanup(DestroyedCapture.Kind, srcField, + CI.getVariable()->getType(), flags, /*EHOnly*/ false, *this); } cleanups.ForceCleanup(); @@ -2538,30 +2576,10 @@ EmitNounwindRuntimeCall(F, args); // FIXME: throwing destructors? } -namespace { - /// Release a __block variable. - struct CallBlockRelease final : EHScopeStack::Cleanup { - llvm::Value *Addr; - CallBlockRelease(llvm::Value *Addr) : Addr(Addr) {} - - void Emit(CodeGenFunction &CGF, Flags flags) override { - // Should we be passing FIELD_IS_WEAK here? - CGF.BuildBlockRelease(Addr, BLOCK_FIELD_IS_BYREF); - } - }; -} // end anonymous namespace - -/// Enter a cleanup to destroy a __block variable. Note that this -/// cleanup should be a no-op if the variable hasn't left the stack -/// yet; if a cleanup is required for the variable itself, that needs -/// to be done externally. -void CodeGenFunction::enterByrefCleanup(const AutoVarEmission &emission) { - // We don't enter this cleanup if we're in pure-GC mode. - if (CGM.getLangOpts().getGC() == LangOptions::GCOnly) - return; - - EHStack.pushCleanup(NormalAndEHCleanup, - emission.Addr.getPointer()); +void CodeGenFunction::enterByrefCleanup(CleanupKind Kind, Address Addr, + BlockFieldFlags Flags, + bool LoadBlockVarAddr) { + EHStack.pushCleanup(Kind, Addr, Flags, LoadBlockVarAddr); } /// Adjust the declaration of something from the blocks API. Index: lib/CodeGen/CGDecl.cpp =================================================================== --- lib/CodeGen/CGDecl.cpp +++ lib/CodeGen/CGDecl.cpp @@ -1710,9 +1710,15 @@ } // If this is a block variable, call _Block_object_destroy - // (on the unforwarded address). - if (emission.IsByRef) - enterByrefCleanup(emission); + // (on the unforwarded address). Don't enter this cleanup if we're in pure-GC + // mode. + if (emission.IsByRef && CGM.getLangOpts().getGC() != LangOptions::GCOnly) { + BlockFieldFlags Flags = BLOCK_FIELD_IS_BYREF; + if (emission.Variable->getType().isObjCGCWeak()) + Flags |= BLOCK_FIELD_IS_WEAK; + enterByrefCleanup(NormalAndEHCleanup, emission.Addr, Flags, + /*LoadBlockVarAddr*/ false); + } } CodeGenFunction::Destroyer * Index: lib/CodeGen/CodeGenFunction.h =================================================================== --- lib/CodeGen/CodeGenFunction.h +++ lib/CodeGen/CodeGenFunction.h @@ -1758,7 +1758,25 @@ class AutoVarEmission; void emitByrefStructureInit(const AutoVarEmission &emission); - void enterByrefCleanup(const AutoVarEmission &emission); + + /// Enter a cleanup to destroy a __block variable. Note that this + /// cleanup should be a no-op if the variable hasn't left the stack + /// yet; if a cleanup is required for the variable itself, that needs + /// to be done externally. + /// + /// \param Kind Cleanup kind. + /// + /// \param Addr When \p LoadBlockVarAddr is false, the address of the __block + /// structure that will be passed to _Block_object_dispose. When + /// \p LoadBlockVarAddr is true, the address of the field of the block + /// structure that holds the address of the __block structure. + /// + /// \param Flags The flag that will be passed to _Block_object_dispose. + /// + /// \param LoadBlockVarAddr Indicates whether we need to emit a load from + /// \p Addr to get the address of the __block structure. + void enterByrefCleanup(CleanupKind Kind, Address Addr, BlockFieldFlags Flags, + bool LoadBlockVarAddr); void setBlockContextParameter(const ImplicitParamDecl *D, unsigned argNum, llvm::Value *ptr); Index: test/CodeGenObjC/blocks.m =================================================================== --- test/CodeGenObjC/blocks.m +++ test/CodeGenObjC/blocks.m @@ -79,10 +79,9 @@ // Then we initialize the block, blah blah blah. // CHECK: call void @test2_helper( - // Finally, kill the variable with BLOCK_FIELD_IS_BYREF. We're not - // supposed to pass BLOCK_FIELD_IS_WEAK here. + // Finally, kill the variable with BLOCK_FIELD_IS_BYREF. // CHECK: [[T0:%.*]] = bitcast [[WEAK_T]]* [[WEAKX]] to i8* - // CHECK: call void @_Block_object_dispose(i8* [[T0]], i32 8) + // CHECK: call void @_Block_object_dispose(i8* [[T0]], i32 24) __attribute__((objc_gc(weak))) __block Test2 *weakX = x; test2_helper(^{ [weakX destroy]; }); Index: test/CodeGenObjCXX/arc-blocks.mm =================================================================== --- test/CodeGenObjCXX/arc-blocks.mm +++ test/CodeGenObjCXX/arc-blocks.mm @@ -1,6 +1,9 @@ -// RUN: %clang_cc1 -std=gnu++98 -triple x86_64-apple-darwin10 -emit-llvm -fobjc-runtime-has-weak -fblocks -fobjc-arc -o - %s | FileCheck %s +// RUN: %clang_cc1 -std=gnu++98 -triple x86_64-apple-darwin10 -emit-llvm -fobjc-runtime-has-weak -fblocks -fobjc-arc -fexceptions -fobjc-arc-exceptions -o - %s | FileCheck -check-prefix CHECK %s +// RUN: %clang_cc1 -std=gnu++98 -triple x86_64-apple-darwin10 -emit-llvm -fobjc-runtime-has-weak -fblocks -fobjc-arc -fexceptions -fobjc-arc-exceptions -O1 -o - %s | FileCheck -check-prefix CHECK-O1 %s // CHECK: [[A:.*]] = type { i64, [10 x i8*] } +// CHECK: %[[STRUCT_TEST1_S0:.*]] = type { i32 } +// CHECK: %[[STRUCT_BLOCK_DESCRIPTOR:.*]] = type { i64, i64 } // CHECK: [[LAYOUT0:@.*]] = private unnamed_addr constant [3 x i8] c" 9\00" @@ -47,3 +50,133 @@ // CHECK-NEXT: call void @_ZN5test01AD1Ev([[A]]* [[T1]]) // CHECK-NEXT: ret void } + +namespace test1 { + +// Check that copy/dispose helper functions are exception safe. + +// CHECK-LABEL: define internal void @__copy_helper_block_( +// CHECK: %[[BLOCK_SOURCE:.*]] = bitcast i8* %{{.*}} to <{ i8*, i32, i32, i8*, %[[STRUCT_BLOCK_DESCRIPTOR]]*, i8*, i8*, i8*, %[[STRUCT_TEST1_S0]], %[[STRUCT_TEST1_S0]] }>* +// CHECK: %[[BLOCK_DEST:.*]] = bitcast i8* %{{.*}} to <{ i8*, i32, i32, i8*, %[[STRUCT_BLOCK_DESCRIPTOR]]*, i8*, i8*, i8*, %[[STRUCT_TEST1_S0]], %[[STRUCT_TEST1_S0]] }>* + +// CHECK: %[[V4:.*]] = getelementptr inbounds <{ i8*, i32, i32, i8*, %[[STRUCT_BLOCK_DESCRIPTOR]]*, i8*, i8*, i8*, %[[STRUCT_TEST1_S0]], %[[STRUCT_TEST1_S0]] }>, <{ i8*, i32, i32, i8*, %[[STRUCT_BLOCK_DESCRIPTOR]]*, i8*, i8*, i8*, %[[STRUCT_TEST1_S0]], %[[STRUCT_TEST1_S0]] }>* %[[BLOCK_SOURCE]], i32 0, i32 6 +// CHECK: %[[V5:.*]] = getelementptr inbounds <{ i8*, i32, i32, i8*, %[[STRUCT_BLOCK_DESCRIPTOR]]*, i8*, i8*, i8*, %[[STRUCT_TEST1_S0]], %[[STRUCT_TEST1_S0]] }>, <{ i8*, i32, i32, i8*, %[[STRUCT_BLOCK_DESCRIPTOR]]*, i8*, i8*, i8*, %[[STRUCT_TEST1_S0]], %[[STRUCT_TEST1_S0]] }>* %[[BLOCK_DEST]], i32 0, i32 6 +// CHECK: %[[BLOCKCOPY_SRC:.*]] = load i8*, i8** %[[V4]], align 8 +// CHECK: %[[V6:.*]] = bitcast i8** %[[V5]] to i8* +// CHECK: call void @_Block_object_assign(i8* %[[V6]], i8* %[[BLOCKCOPY_SRC]], i32 8) + +// CHECK: %[[V7:.*]] = getelementptr inbounds <{ i8*, i32, i32, i8*, %[[STRUCT_BLOCK_DESCRIPTOR]]*, i8*, i8*, i8*, %[[STRUCT_TEST1_S0]], %[[STRUCT_TEST1_S0]] }>, <{ i8*, i32, i32, i8*, %[[STRUCT_BLOCK_DESCRIPTOR]]*, i8*, i8*, i8*, %[[STRUCT_TEST1_S0]], %[[STRUCT_TEST1_S0]] }>* %[[BLOCK_SOURCE]], i32 0, i32 7 +// CHECK: %[[V8:.*]] = getelementptr inbounds <{ i8*, i32, i32, i8*, %[[STRUCT_BLOCK_DESCRIPTOR]]*, i8*, i8*, i8*, %[[STRUCT_TEST1_S0]], %[[STRUCT_TEST1_S0]] }>, <{ i8*, i32, i32, i8*, %[[STRUCT_BLOCK_DESCRIPTOR]]*, i8*, i8*, i8*, %[[STRUCT_TEST1_S0]], %[[STRUCT_TEST1_S0]] }>* %[[BLOCK_DEST]], i32 0, i32 7 +// CHECK: call void @objc_copyWeak(i8** %[[V8]], i8** %[[V7]]) + +// CHECK: %[[V9:.*]] = getelementptr inbounds <{ i8*, i32, i32, i8*, %[[STRUCT_BLOCK_DESCRIPTOR]]*, i8*, i8*, i8*, %[[STRUCT_TEST1_S0]], %[[STRUCT_TEST1_S0]] }>, <{ i8*, i32, i32, i8*, %[[STRUCT_BLOCK_DESCRIPTOR]]*, i8*, i8*, i8*, %[[STRUCT_TEST1_S0]], %[[STRUCT_TEST1_S0]] }>* %[[BLOCK_SOURCE]], i32 0, i32 5 +// CHECK: %[[V10:.*]] = getelementptr inbounds <{ i8*, i32, i32, i8*, %[[STRUCT_BLOCK_DESCRIPTOR]]*, i8*, i8*, i8*, %[[STRUCT_TEST1_S0]], %[[STRUCT_TEST1_S0]] }>, <{ i8*, i32, i32, i8*, %[[STRUCT_BLOCK_DESCRIPTOR]]*, i8*, i8*, i8*, %[[STRUCT_TEST1_S0]], %[[STRUCT_TEST1_S0]] }>* %[[BLOCK_DEST]], i32 0, i32 5 +// CHECK: %[[BLOCKCOPY_SRC2:.*]] = load i8*, i8** %[[V9]], align 8 +// CHECK: store i8* null, i8** %[[V10]], align 8 +// CHECK: call void @objc_storeStrong(i8** %[[V10]], i8* %[[BLOCKCOPY_SRC2]]) + +// CHECK: %[[V11:.*]] = getelementptr inbounds <{ i8*, i32, i32, i8*, %[[STRUCT_BLOCK_DESCRIPTOR]]*, i8*, i8*, i8*, %[[STRUCT_TEST1_S0]], %[[STRUCT_TEST1_S0]] }>, <{ i8*, i32, i32, i8*, %[[STRUCT_BLOCK_DESCRIPTOR]]*, i8*, i8*, i8*, %[[STRUCT_TEST1_S0]], %[[STRUCT_TEST1_S0]] }>* %[[BLOCK_SOURCE]], i32 0, i32 8 +// CHECK: %[[V12:.*]] = getelementptr inbounds <{ i8*, i32, i32, i8*, %[[STRUCT_BLOCK_DESCRIPTOR]]*, i8*, i8*, i8*, %[[STRUCT_TEST1_S0]], %[[STRUCT_TEST1_S0]] }>, <{ i8*, i32, i32, i8*, %[[STRUCT_BLOCK_DESCRIPTOR]]*, i8*, i8*, i8*, %[[STRUCT_TEST1_S0]], %[[STRUCT_TEST1_S0]] }>* %[[BLOCK_DEST]], i32 0, i32 8 +// CHECK: invoke void @_ZN5test12S0C1ERKS0_(%[[STRUCT_TEST1_S0]]* %[[V12]], %[[STRUCT_TEST1_S0]]* dereferenceable(4) %[[V11]]) +// CHECK: to label %[[INVOKE_CONT:.*]] unwind label %[[LPAD:.*]] + +// CHECK: [[INVOKE_CONT]]: +// CHECK: %[[V13:.*]] = getelementptr inbounds <{ i8*, i32, i32, i8*, %[[STRUCT_BLOCK_DESCRIPTOR]]*, i8*, i8*, i8*, %[[STRUCT_TEST1_S0]], %[[STRUCT_TEST1_S0]] }>, <{ i8*, i32, i32, i8*, %[[STRUCT_BLOCK_DESCRIPTOR]]*, i8*, i8*, i8*, %[[STRUCT_TEST1_S0]], %[[STRUCT_TEST1_S0]] }>* %[[BLOCK_SOURCE]], i32 0, i32 9 +// CHECK: %[[V14:.*]] = getelementptr inbounds <{ i8*, i32, i32, i8*, %[[STRUCT_BLOCK_DESCRIPTOR]]*, i8*, i8*, i8*, %[[STRUCT_TEST1_S0]], %[[STRUCT_TEST1_S0]] }>, <{ i8*, i32, i32, i8*, %[[STRUCT_BLOCK_DESCRIPTOR]]*, i8*, i8*, i8*, %[[STRUCT_TEST1_S0]], %[[STRUCT_TEST1_S0]] }>* %[[BLOCK_DEST]], i32 0, i32 9 +// CHECK: invoke void @_ZN5test12S0C1ERKS0_(%[[STRUCT_TEST1_S0]]* %[[V14]], %[[STRUCT_TEST1_S0]]* dereferenceable(4) %[[V13]]) +// CHECK: to label %[[INVOKE_CONT4:.*]] unwind label %[[LPAD3:.*]] + +// CHECK: [[INVOKE_CONT4]]: +// CHECK: ret void + +// CHECK: [[LPAD]]: +// CHECK: br label %[[EHCLEANUP:.*]] + +// CHECK: [[LPAD3]]: +// CHECK: invoke void @_ZN5test12S0D1Ev(%[[STRUCT_TEST1_S0]]* %[[V12]]) +// CHECK: to label %[[INVOKE_CONT5:.*]] unwind label %[[TERMINATE_LPAD:.*]] + +// CHECK: [[INVOKE_CONT5]]: +// CHECK: br label %[[EHCLEANUP]] + +// CHECK: [[EHCLEANUP]]: +// CHECK: call void @objc_storeStrong(i8** %[[V10]], i8* null) +// CHECK: call void @objc_destroyWeak(i8** %[[V8]]) +// CHECK: %[[V21:.*]] = load i8*, i8** %[[V5]], align 8 +// CHECK: call void @_Block_object_dispose(i8* %[[V21]], i32 8) +// CHECK: br label %[[EH_RESUME:.*]] + +// CHECK: [[EH_RESUME]]: +// CHECK: resume { i8*, i32 } + +// CHECK: [[TERMINATE_LPAD]]: +// CHECK: call void @__clang_call_terminate( + +// CHECK-O1-LABEL: define internal void @__copy_helper_block_( +// CHECK-O1: tail call void @objc_release({{.*}}) {{.*}} !clang.imprecise_release + +// CHECK: define internal void @__destroy_helper_block_( +// CHECK: %[[BLOCK:.*]] = bitcast i8* %{{.*}} to <{ i8*, i32, i32, i8*, %[[STRUCT_BLOCK_DESCRIPTOR]]*, i8*, i8*, i8*, %[[STRUCT_TEST1_S0]], %[[STRUCT_TEST1_S0]] }>* +// CHECK: %[[V2:.*]] = getelementptr inbounds <{ i8*, i32, i32, i8*, %[[STRUCT_BLOCK_DESCRIPTOR]]*, i8*, i8*, i8*, %[[STRUCT_TEST1_S0]], %[[STRUCT_TEST1_S0]] }>, <{ i8*, i32, i32, i8*, %[[STRUCT_BLOCK_DESCRIPTOR]]*, i8*, i8*, i8*, %[[STRUCT_TEST1_S0]], %[[STRUCT_TEST1_S0]] }>* %[[BLOCK]], i32 0, i32 6 +// CHECK: %[[V3:.*]] = getelementptr inbounds <{ i8*, i32, i32, i8*, %[[STRUCT_BLOCK_DESCRIPTOR]]*, i8*, i8*, i8*, %[[STRUCT_TEST1_S0]], %[[STRUCT_TEST1_S0]] }>, <{ i8*, i32, i32, i8*, %[[STRUCT_BLOCK_DESCRIPTOR]]*, i8*, i8*, i8*, %[[STRUCT_TEST1_S0]], %[[STRUCT_TEST1_S0]] }>* %[[BLOCK]], i32 0, i32 7 +// CHECK: %[[V4:.*]] = getelementptr inbounds <{ i8*, i32, i32, i8*, %[[STRUCT_BLOCK_DESCRIPTOR]]*, i8*, i8*, i8*, %[[STRUCT_TEST1_S0]], %[[STRUCT_TEST1_S0]] }>, <{ i8*, i32, i32, i8*, %[[STRUCT_BLOCK_DESCRIPTOR]]*, i8*, i8*, i8*, %[[STRUCT_TEST1_S0]], %[[STRUCT_TEST1_S0]] }>* %[[BLOCK]], i32 0, i32 5 +// CHECK: %[[V5:.*]] = getelementptr inbounds <{ i8*, i32, i32, i8*, %[[STRUCT_BLOCK_DESCRIPTOR]]*, i8*, i8*, i8*, %[[STRUCT_TEST1_S0]], %[[STRUCT_TEST1_S0]] }>, <{ i8*, i32, i32, i8*, %[[STRUCT_BLOCK_DESCRIPTOR]]*, i8*, i8*, i8*, %[[STRUCT_TEST1_S0]], %[[STRUCT_TEST1_S0]] }>* %[[BLOCK]], i32 0, i32 8 +// CHECK: %[[V6:.*]] = getelementptr inbounds <{ i8*, i32, i32, i8*, %[[STRUCT_BLOCK_DESCRIPTOR]]*, i8*, i8*, i8*, %[[STRUCT_TEST1_S0]], %[[STRUCT_TEST1_S0]] }>, <{ i8*, i32, i32, i8*, %[[STRUCT_BLOCK_DESCRIPTOR]]*, i8*, i8*, i8*, %[[STRUCT_TEST1_S0]], %[[STRUCT_TEST1_S0]] }>* %[[BLOCK]], i32 0, i32 9 +// CHECK: invoke void @_ZN5test12S0D1Ev(%[[STRUCT_TEST1_S0]]* %[[V6]]) +// CHECK: to label %[[INVOKE_CONT:.*]] unwind label %[[LPAD:.*]] + +// CHECK: [[INVOKE_CONT]]: +// CHECK: invoke void @_ZN5test12S0D1Ev(%[[STRUCT_TEST1_S0]]* %[[V5]]) +// CHECK: to label %[[INVOKE_CONT2:.*]] unwind label %[[LPAD1:.*]] + +// CHECK: [[INVOKE_CONT2]]: +// CHECK: call void @objc_storeStrong(i8** %[[V4]], i8* null) +// CHECK: call void @objc_destroyWeak(i8** %[[V3]]) +// CHECK: %[[V7:.*]] = load i8*, i8** %[[V2]], align 8 +// CHECK: call void @_Block_object_dispose(i8* %[[V7]], i32 8) +// CHECK: ret void + +// CHECK: [[LPAD]]: +// CHECK: invoke void @_ZN5test12S0D1Ev(%[[STRUCT_TEST1_S0]]* %[[V5]]) +// CHECK: to label %[[INVOKE_CONT3:.*]] unwind label %[[TERMINATE_LPAD]] + +// CHECK: [[LPAD1]] +// CHECK: br label %[[EHCLEANUP:.*]] + +// CHECK: [[INVOKE_CONT3]]: +// CHECK: br label %[[EHCLEANUP]] + +// CHECK: [[EHCLEANUP]]: +// CHECK: call void @objc_storeStrong(i8** %[[V4]], i8* null) +// CHECK: call void @objc_destroyWeak(i8** %[[V3]]) +// CHECK: %[[V14:.*]] = load i8*, i8** %[[V2]], align 8 +// CHECK: call void @_Block_object_dispose(i8* %[[V14]], i32 8) +// CHECK: br label %[[EH_RESUME]] + +// CHECK: [[EH_RESUME]]: +// CHECK: resume { i8*, i32 } + +// CHECK: [[TERMINATE_LPAD]]: +// CHECK: call void @__clang_call_terminate( + +// CHECK-O1-LABEL: define internal void @__destroy_helper_block_( +// CHECK-O1: tail call void @objc_release({{.*}}) {{.*}} !clang.imprecise_release +// CHECK-O1: tail call void @objc_release({{.*}}) {{.*}} !clang.imprecise_release + +struct S0 { + S0(); + S0(const S0 &); + ~S0(); + int f0; +}; + +id getObj(); + +void foo1() { + __block id t0 = getObj(); + __weak id t1 = getObj(); + id t2 = getObj(); + S0 t3, t4; + ^{ (void)t0; (void)t1; (void)t2; (void)t3; (void)t4; }; +} +}