1// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -emit-llvm -fblocks -fobjc-arc -fobjc-runtime-has-weak -O2 -disable-llvm-passes -o - %s | FileCheck -check-prefix=CHECK -check-prefix=CHECK-HEAP -check-prefix=CHECK-COMMON %s 2// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -emit-llvm -fblocks -fobjc-arc -fobjc-runtime-has-weak -O2 -disable-llvm-passes -fobjc-avoid-heapify-local-blocks -o - %s | FileCheck -check-prefix=CHECK -check-prefix=CHECK-NOHEAP -check-prefix=CHECK-COMMON %s 3// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -emit-llvm -fblocks -fobjc-arc -fobjc-runtime-has-weak -o - %s | FileCheck -check-prefix=CHECK-UNOPT -check-prefix=CHECK-COMMON %s 4 5// CHECK-COMMON: %[[STRUCT_BLOCK_DESCRIPTOR:.*]] = type { i64, i64 } 6// CHECK-COMMON: @[[BLOCK_DESCRIPTOR_TMP44:.*]] = linkonce_odr hidden unnamed_addr constant { i64, i64, i8*, i8*, i8*, i64 } { i64 0, i64 40, i8* bitcast (void (i8*, i8*)* @__copy_helper_block_8_32s to i8*), i8* bitcast (void (i8*)* @__destroy_helper_block_8_32s to i8*), i8* getelementptr inbounds ([6 x i8], [6 x i8]* @{{.*}}, i32 0, i32 0), i64 256 }, align 8 7// CHECK-COMMON: @[[BLOCK_DESCRIPTOR_TMP9:.*]] = linkonce_odr hidden unnamed_addr constant { i64, i64, i8*, i8*, i8*, i64 } { i64 0, i64 40, i8* bitcast (void (i8*, i8*)* @__copy_helper_block_8_32r to i8*), i8* bitcast (void (i8*)* @__destroy_helper_block_8_32r to i8*), i8* getelementptr inbounds ([6 x i8], [6 x i8]* @{{.*}}, i32 0, i32 0), i64 16 }, align 8 8// CHECK-COMMON: @[[BLOCK_DESCRIPTOR_TMP46:.*]] = linkonce_odr hidden unnamed_addr constant { i64, i64, i8*, i8*, i8*, i8* } { i64 0, i64 48, i8* bitcast (void (i8*, i8*)* @__copy_helper_block_8_32s to i8*), i8* bitcast (void (i8*)* @__destroy_helper_block_8_32s to i8*), i8* getelementptr inbounds ([6 x i8], [6 x i8]* @{{.*}}, i32 0, i32 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @{{.*}}, i32 0, i32 0) }, align 8 9// CHECK-COMMON: @[[BLOCK_DESCRIPTOR_TMP48:.*]] = linkonce_odr hidden unnamed_addr constant { i64, i64, i8*, i8*, i8*, i64 } { i64 0, i64 40, i8* bitcast (void (i8*, i8*)* @__copy_helper_block_8_32b to i8*), i8* bitcast (void (i8*)* @__destroy_helper_block_8_32s to i8*), i8* getelementptr inbounds ([9 x i8], [9 x i8]* @{{.*}}, i32 0, i32 0), i64 256 }, align 8 10 11// This shouldn't crash. 12void test0(id (^maker)(void)) { 13 maker(); 14} 15 16int (^test1(int x))(void) { 17 // CHECK-LABEL: define{{.*}} i32 ()* @test1( 18 // CHECK: [[X:%.*]] = alloca i32, 19 // CHECK-NEXT: [[BLOCK:%.*]] = alloca [[BLOCK_T:<{.*}>]], 20 // CHECK-NEXT: store i32 {{%.*}}, i32* [[X]] 21 // CHECK: [[T0:%.*]] = bitcast [[BLOCK_T]]* [[BLOCK]] to i32 ()* 22 // CHECK-NEXT: [[T1:%.*]] = bitcast i32 ()* [[T0]] to i8* 23 // CHECK-NEXT: [[T2:%.*]] = call i8* @llvm.objc.retainBlock(i8* [[T1]]) [[NUW:#[0-9]+]] 24 // CHECK-NEXT: [[T3:%.*]] = bitcast i8* [[T2]] to i32 ()* 25 // CHECK-NEXT: [[T4:%.*]] = bitcast i32 ()* [[T3]] to i8* 26 // CHECK-NEXT: [[T5:%.*]] = tail call i8* @llvm.objc.autoreleaseReturnValue(i8* [[T4]]) [[NUW]] 27 // CHECK-NEXT: [[T6:%.*]] = bitcast i8* [[T5]] to i32 ()* 28 // CHECK-NEXT: ret i32 ()* [[T6]] 29 return ^{ return x; }; 30} 31 32void test2(id x) { 33// CHECK-LABEL: define{{.*}} void @test2( 34// CHECK: [[X:%.*]] = alloca i8*, 35// CHECK-NEXT: [[BLOCK:%.*]] = alloca [[BLOCK_T:<{.*}>]], 36// CHECK-NEXT: [[PARM:%.*]] = call i8* @llvm.objc.retain(i8* {{%.*}}) 37// CHECK-NEXT: store i8* [[PARM]], i8** [[X]] 38// CHECK: [[SLOT:%.*]] = getelementptr inbounds [[BLOCK_T]], [[BLOCK_T]]* [[BLOCK]], i32 0, i32 5 39// CHECK-NEXT: [[T0:%.*]] = load i8*, i8** [[X]], 40// CHECK-NEXT: [[T1:%.*]] = call i8* @llvm.objc.retain(i8* [[T0]]) 41// CHECK-NEXT: store i8* [[T1]], i8** [[SLOT]], 42// CHECK-NEXT: bitcast 43// CHECK-NEXT: call void @test2_helper( 44// CHECK-NEXT: [[T0:%.*]] = load i8*, i8** [[SLOT]] 45// CHECK-NEXT: call void @llvm.objc.release(i8* [[T0]]) [[NUW]], !clang.imprecise_release 46// CHECK-NEXT: [[T0:%.*]] = load i8*, i8** [[X]] 47// CHECK-NEXT: call void @llvm.objc.release(i8* [[T0]]) [[NUW]], !clang.imprecise_release 48// CHECK-NEXT: ret void 49 extern void test2_helper(id (^)(void)); 50 test2_helper(^{ return x; }); 51 52// CHECK: define linkonce_odr hidden void @__copy_helper_block_8_32s(i8* %0, i8* %1) unnamed_addr #{{[0-9]+}} { 53// CHECK: [[T0:%.*]] = load i8*, i8** 54// CHECK-NEXT: [[SRC:%.*]] = bitcast i8* [[T0]] to [[BLOCK_T]]* 55// CHECK-NEXT: [[T0:%.*]] = load i8*, i8** 56// CHECK-NEXT: [[DST:%.*]] = bitcast i8* [[T0]] to [[BLOCK_T]]* 57// CHECK-NEXT: [[T0:%.*]] = getelementptr inbounds [[BLOCK_T]], [[BLOCK_T]]* [[SRC]], i32 0, i32 5 58// CHECK-NEXT: [[T1:%.*]] = load i8*, i8** [[T0]] 59// CHECK-NEXT: [[T2:%.*]] = call i8* @llvm.objc.retain(i8* [[T1]]) [[NUW]] 60// CHECK-NEXT: ret void 61 62 63// CHECK: define linkonce_odr hidden void @__destroy_helper_block_8_32s(i8* %0) unnamed_addr #{{[0-9]+}} { 64// CHECK: [[T0:%.*]] = load i8*, i8** 65// CHECK-NEXT: [[T1:%.*]] = bitcast i8* [[T0]] to [[BLOCK_T]]* 66// CHECK-NEXT: [[T2:%.*]] = getelementptr inbounds [[BLOCK_T]], [[BLOCK_T]]* [[T1]], i32 0, i32 5 67// CHECK-NEXT: [[T3:%.*]] = load i8*, i8** [[T2]] 68// CHECK-NEXT: call void @llvm.objc.release(i8* [[T3]]) 69// CHECK-NEXT: ret void 70} 71 72void test3(void (^sink)(id*)) { 73 __strong id strong; 74 sink(&strong); 75 76 // CHECK-LABEL: define{{.*}} void @test3( 77 // CHECK: [[SINK:%.*]] = alloca void (i8**)* 78 // CHECK-NEXT: [[STRONG:%.*]] = alloca i8* 79 // CHECK-NEXT: [[TEMP:%.*]] = alloca i8* 80 // CHECK-NEXT: bitcast void (i8**)* {{%.*}} to i8* 81 // CHECK-NEXT: call i8* @llvm.objc.retain( 82 // CHECK-NEXT: bitcast i8* 83 // CHECK-NEXT: store void (i8**)* {{%.*}}, void (i8**)** [[SINK]] 84 // CHECK-NEXT: [[STRONGPTR1:%.*]] = bitcast i8** [[STRONG]] to i8* 85 // CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 8, i8* [[STRONGPTR1]]) 86 // CHECK-NEXT: store i8* null, i8** [[STRONG]] 87 88 // CHECK-NEXT: load void (i8**)*, void (i8**)** [[SINK]] 89 // CHECK-NEXT: bitcast 90 // CHECK-NEXT: getelementptr 91 // CHECK-NEXT: [[BLOCK:%.*]] = bitcast 92 // CHECK-NEXT: [[V:%.*]] = load i8*, i8** [[STRONG]] 93 // CHECK-NEXT: store i8* [[V]], i8** [[TEMP]] 94 // CHECK-NEXT: [[F0:%.*]] = load i8*, i8** 95 // CHECK-NEXT: [[F1:%.*]] = bitcast i8* [[F0]] to void (i8*, i8**)* 96 // CHECK-NEXT: call void [[F1]](i8* [[BLOCK]], i8** [[TEMP]]) 97 // CHECK-NEXT: [[T0:%.*]] = load i8*, i8** [[TEMP]] 98 // CHECK-NEXT: [[T1:%.*]] = call i8* @llvm.objc.retain(i8* [[T0]]) 99 // CHECK-NEXT: call void (...) @llvm.objc.clang.arc.use(i8* [[V]]) [[NUW]] 100 // CHECK-NEXT: [[T2:%.*]] = load i8*, i8** [[STRONG]] 101 // CHECK-NEXT: store i8* [[T1]], i8** [[STRONG]] 102 // CHECK-NEXT: call void @llvm.objc.release(i8* [[T2]]) 103 104 // CHECK-NEXT: [[T0:%.*]] = load i8*, i8** [[STRONG]] 105 // CHECK-NEXT: call void @llvm.objc.release(i8* [[T0]]) 106 // CHECK-NEXT: [[STRONGPTR2:%.*]] = bitcast i8** [[STRONG]] to i8* 107 // CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 8, i8* [[STRONGPTR2]]) 108 109 // CHECK-NEXT: load void (i8**)*, void (i8**)** [[SINK]] 110 // CHECK-NEXT: bitcast 111 // CHECK-NEXT: call void @llvm.objc.release 112 // CHECK-NEXT: ret void 113 114} 115 116void test4(void) { 117 id test4_source(void); 118 void test4_helper(void (^)(void)); 119 __block id var = test4_source(); 120 test4_helper(^{ var = 0; }); 121 122 // CHECK-LABEL: define{{.*}} void @test4() 123 // CHECK: [[VAR:%.*]] = alloca [[BYREF_T:%.*]], 124 // CHECK-NEXT: [[BLOCK:%.*]] = alloca [[BLOCK_T:<{.*}>]], 125 // CHECK: [[T0:%.*]] = getelementptr inbounds [[BYREF_T]], [[BYREF_T]]* [[VAR]], i32 0, i32 2 126 // 0x02000000 - has copy/dispose helpers strong 127 // CHECK-NEXT: store i32 838860800, i32* [[T0]] 128 // CHECK: [[SLOT:%.*]] = getelementptr inbounds [[BYREF_T]], [[BYREF_T]]* [[VAR]], i32 0, i32 6 129 // CHECK-NEXT: [[T0:%.*]] = call i8* @test4_source() [ "clang.arc.attachedcall"(i8* (i8*)* @llvm.objc.retainAutoreleasedReturnValue) ] 130 // CHECK-NEXT: call void (...) @llvm.objc.clang.arc.noop.use(i8* [[T0]]) 131 // CHECK-NEXT: store i8* [[T0]], i8** [[SLOT]] 132 // CHECK-NEXT: [[SLOT:%.*]] = getelementptr inbounds [[BYREF_T]], [[BYREF_T]]* [[VAR]], i32 0, i32 6 133 // 0x42800000 - has signature, copy/dispose helpers, as well as BLOCK_HAS_EXTENDED_LAYOUT 134 // CHECK: store i32 -1040187392, 135 // CHECK: [[T0:%.*]] = bitcast [[BYREF_T]]* [[VAR]] to i8* 136 // CHECK-NEXT: store i8* [[T0]], i8** 137 // CHECK: call void @test4_helper( 138 // CHECK: [[T0:%.*]] = bitcast [[BYREF_T]]* [[VAR]] to i8* 139 // CHECK-NEXT: call void @_Block_object_dispose(i8* [[T0]], i32 8) 140 // CHECK-NEXT: [[T0:%.*]] = load i8*, i8** [[SLOT]] 141 // CHECK-NEXT: call void @llvm.objc.release(i8* [[T0]]) 142 // CHECK: ret void 143 144 // CHECK-LABEL: define internal void @__Block_byref_object_copy_(i8* %0, i8* %1) #{{[0-9]+}} { 145 // CHECK: [[T0:%.*]] = getelementptr inbounds [[BYREF_T]], [[BYREF_T]]* {{%.*}}, i32 0, i32 6 146 // CHECK-NEXT: load i8*, i8** 147 // CHECK-NEXT: bitcast i8* {{%.*}} to [[BYREF_T]]* 148 // CHECK-NEXT: [[T1:%.*]] = getelementptr inbounds [[BYREF_T]], [[BYREF_T]]* {{%.*}}, i32 0, i32 6 149 // CHECK-NEXT: [[T2:%.*]] = load i8*, i8** [[T1]] 150 // CHECK-NEXT: store i8* [[T2]], i8** [[T0]] 151 // CHECK-NEXT: store i8* null, i8** [[T1]] 152 153 // CHECK-LABEL: define internal void @__Block_byref_object_dispose_(i8* %0) #{{[0-9]+}} { 154 // CHECK: [[T0:%.*]] = getelementptr inbounds [[BYREF_T]], [[BYREF_T]]* {{%.*}}, i32 0, i32 6 155 // CHECK-NEXT: [[T1:%.*]] = load i8*, i8** [[T0]] 156 // CHECK-NEXT: call void @llvm.objc.release(i8* [[T1]]) 157 158 // CHECK-LABEL: define internal void @__test4_block_invoke 159 // CHECK: [[SLOT:%.*]] = getelementptr inbounds {{.*}}, i32 0, i32 6 160 // CHECK-NEXT: [[T0:%.*]] = load i8*, i8** [[SLOT]], align 8 161 // CHECK-NEXT: store i8* null, i8** [[SLOT]], 162 // CHECK-NEXT: call void @llvm.objc.release(i8* [[T0]]) 163 // CHECK-NEXT: ret void 164 165 // CHECK-LABEL: define linkonce_odr hidden void @__copy_helper_block_8_32r(i8* %0, i8* %1) unnamed_addr #{{[0-9]+}} { 166 // CHECK: call void @_Block_object_assign(i8* {{%.*}}, i8* {{%.*}}, i32 8) 167 168 // CHECK-LABEL: define linkonce_odr hidden void @__destroy_helper_block_8_32r(i8* %0) unnamed_addr #{{[0-9]+}} { 169 // CHECK: call void @_Block_object_dispose(i8* {{%.*}}, i32 8) 170} 171 172void test5(void) { 173 extern id test5_source(void); 174 void test5_helper(void (^)(void)); 175 __unsafe_unretained id var = test5_source(); 176 test5_helper(^{ (void) var; }); 177 178 // CHECK-LABEL: define{{.*}} void @test5() 179 // CHECK: [[VAR:%.*]] = alloca i8* 180 // CHECK-NEXT: [[BLOCK:%.*]] = alloca [[BLOCK_T:<{.*}>]], 181 // CHECK-NEXT: [[VARPTR1:%.*]] = bitcast i8** [[VAR]] to i8* 182 // CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 8, i8* [[VARPTR1]]) 183 // CHECK: [[T1:%.*]] = call i8* @test5_source() [ "clang.arc.attachedcall"(i8* (i8*)* @llvm.objc.retainAutoreleasedReturnValue) ] 184 // CHECK-NEXT: call void (...) @llvm.objc.clang.arc.noop.use(i8* [[T1]]) 185 // CHECK-NEXT: store i8* [[T1]], i8** [[VAR]], 186 // CHECK-NEXT: call void @llvm.objc.release(i8* [[T1]]) 187 // 0x40800000 - has signature but no copy/dispose, as well as BLOCK_HAS_EXTENDED_LAYOUT 188 // CHECK: store i32 -1073741824, i32* 189 // CHECK: [[CAPTURE:%.*]] = getelementptr inbounds [[BLOCK_T]], [[BLOCK_T]]* [[BLOCK]], i32 0, i32 5 190 // CHECK-NEXT: [[T0:%.*]] = load i8*, i8** [[VAR]] 191 // CHECK-NEXT: store i8* [[T0]], i8** [[CAPTURE]] 192 // CHECK-NEXT: [[T0:%.*]] = bitcast [[BLOCK_T]]* [[BLOCK]] to 193 // CHECK: call void @test5_helper 194 // CHECK-NEXT: [[VARPTR2:%.*]] = bitcast i8** [[VAR]] to i8* 195 // CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 8, i8* [[VARPTR2]]) 196 // CHECK-NEXT: ret void 197} 198 199void test6(void) { 200 id test6_source(void); 201 void test6_helper(void (^)(void)); 202 __block __weak id var = test6_source(); 203 test6_helper(^{ var = 0; }); 204 205 // CHECK-LABEL: define{{.*}} void @test6() 206 // CHECK: [[VAR:%.*]] = alloca [[BYREF_T:%.*]], 207 // CHECK-NEXT: [[BLOCK:%.*]] = alloca [[BLOCK_T:<{.*}>]], 208 // CHECK-NEXT: [[VARPTR1:%.*]] = bitcast [[BYREF_T]]* [[VAR]] to i8* 209 // CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 48, i8* [[VARPTR1]]) 210 // CHECK: [[T0:%.*]] = getelementptr inbounds [[BYREF_T]], [[BYREF_T]]* [[VAR]], i32 0, i32 2 211 // 0x02000000 - has copy/dispose helpers weak 212 // CHECK-NEXT: store i32 1107296256, i32* [[T0]] 213 // CHECK: [[SLOT:%.*]] = getelementptr inbounds [[BYREF_T]], [[BYREF_T]]* [[VAR]], i32 0, i32 6 214 // CHECK-NEXT: [[T1:%.*]] = call i8* @test6_source() [ "clang.arc.attachedcall"(i8* (i8*)* @llvm.objc.retainAutoreleasedReturnValue) ] 215 // CHECK-NEXT: call void (...) @llvm.objc.clang.arc.noop.use(i8* [[T1]]) 216 // CHECK-NEXT: call i8* @llvm.objc.initWeak(i8** [[SLOT]], i8* [[T1]]) 217 // CHECK-NEXT: call void @llvm.objc.release(i8* [[T1]]) 218 // CHECK-NEXT: [[SLOT:%.*]] = getelementptr inbounds [[BYREF_T]], [[BYREF_T]]* [[VAR]], i32 0, i32 6 219 // 0x42800000 - has signature, copy/dispose helpers, as well as BLOCK_HAS_EXTENDED_LAYOUT 220 // CHECK: store i32 -1040187392, 221 // CHECK: %[[BLOCK_DESCRIPTOR:.*]] = getelementptr inbounds <{ i8*, i32, i32, i8*, %[[STRUCT_BLOCK_DESCRIPTOR]]*, i8* }>, <{ i8*, i32, i32, i8*, %[[STRUCT_BLOCK_DESCRIPTOR]]*, i8* }>* %{{.*}}, i32 0, i32 4 222// CHECK: store %[[STRUCT_BLOCK_DESCRIPTOR]]* bitcast ({ i64, i64, i8*, i8*, i8*, i64 }* @[[BLOCK_DESCRIPTOR_TMP9]] to %[[STRUCT_BLOCK_DESCRIPTOR]]*), %[[STRUCT_BLOCK_DESCRIPTOR]]** %[[BLOCK_DESCRIPTOR]], align 8 223 // CHECK: [[T0:%.*]] = bitcast [[BYREF_T]]* [[VAR]] to i8* 224 // CHECK-NEXT: store i8* [[T0]], i8** 225 // CHECK: call void @test6_helper( 226 // CHECK: [[T0:%.*]] = bitcast [[BYREF_T]]* [[VAR]] to i8* 227 // CHECK-NEXT: call void @_Block_object_dispose(i8* [[T0]], i32 8) 228 // CHECK-NEXT: call void @llvm.objc.destroyWeak(i8** [[SLOT]]) 229 // CHECK-NEXT: [[VARPTR2:%.*]] = bitcast [[BYREF_T]]* [[VAR]] to i8* 230 // CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 48, i8* [[VARPTR2]]) 231 // CHECK-NEXT: ret void 232 233 // CHECK-LABEL: define internal void @__Block_byref_object_copy_.{{[0-9]+}}(i8* %0, i8* %1) #{{[0-9]+}} { 234 // CHECK: [[T0:%.*]] = getelementptr inbounds [[BYREF_T]], [[BYREF_T]]* {{%.*}}, i32 0, i32 6 235 // CHECK-NEXT: load i8*, i8** 236 // CHECK-NEXT: bitcast i8* {{%.*}} to [[BYREF_T]]* 237 // CHECK-NEXT: [[T1:%.*]] = getelementptr inbounds [[BYREF_T]], [[BYREF_T]]* {{%.*}}, i32 0, i32 6 238 // CHECK-NEXT: call void @llvm.objc.moveWeak(i8** [[T0]], i8** [[T1]]) 239 240 // CHECK-LABEL: define internal void @__Block_byref_object_dispose_.{{[0-9]+}}(i8* %0) #{{[0-9]+}} { 241 // CHECK: [[T0:%.*]] = getelementptr inbounds [[BYREF_T]], [[BYREF_T]]* {{%.*}}, i32 0, i32 6 242 // CHECK-NEXT: call void @llvm.objc.destroyWeak(i8** [[T0]]) 243 244 // CHECK-LABEL: define internal void @__test6_block_invoke 245 // CHECK: [[SLOT:%.*]] = getelementptr inbounds {{.*}}, i32 0, i32 6 246 // CHECK-NEXT: call i8* @llvm.objc.storeWeak(i8** [[SLOT]], i8* null) 247 // CHECK-NEXT: ret void 248} 249 250void test7(void) { 251 id test7_source(void); 252 void test7_helper(void (^)(void)); 253 void test7_consume(id); 254 __weak id var = test7_source(); 255 test7_helper(^{ test7_consume(var); }); 256 257 // CHECK-LABEL: define{{.*}} void @test7() 258 // CHECK: [[VAR:%.*]] = alloca i8*, 259 // CHECK-NEXT: [[BLOCK:%.*]] = alloca [[BLOCK_T:<{.*}>]], 260 // CHECK: [[T1:%.*]] = call i8* @test7_source() [ "clang.arc.attachedcall"(i8* (i8*)* @llvm.objc.retainAutoreleasedReturnValue) ] 261 // CHECK-NEXT: call void (...) @llvm.objc.clang.arc.noop.use(i8* [[T1]]) 262 // CHECK-NEXT: call i8* @llvm.objc.initWeak(i8** [[VAR]], i8* [[T1]]) 263 // CHECK-NEXT: call void @llvm.objc.release(i8* [[T1]]) 264 // 0x42800000 - has signature, copy/dispose helpers, as well as BLOCK_HAS_EXTENDED_LAYOUT 265 // CHECK: store i32 -1040187392, 266 // CHECK: [[SLOT:%.*]] = getelementptr inbounds [[BLOCK_T]], [[BLOCK_T]]* [[BLOCK]], i32 0, i32 5 267 // CHECK-NEXT: call void @llvm.objc.copyWeak(i8** [[SLOT]], i8** [[VAR]]) 268 // CHECK: call void @test7_helper( 269 // CHECK-NEXT: call void @llvm.objc.destroyWeak(i8** {{%.*}}) 270 // CHECK-NEXT: call void @llvm.objc.destroyWeak(i8** [[VAR]]) 271 // CHECK: ret void 272 273 // CHECK-LABEL: define internal void @__test7_block_invoke 274 // CHECK: [[SLOT:%.*]] = getelementptr inbounds [[BLOCK_T]], [[BLOCK_T]]* {{%.*}}, i32 0, i32 5 275 // CHECK-NEXT: [[T0:%.*]] = call i8* @llvm.objc.loadWeakRetained(i8** [[SLOT]]) 276 // CHECK-NEXT: call void @test7_consume(i8* [[T0]]) 277 // CHECK-NEXT: call void @llvm.objc.release(i8* [[T0]]) 278 // CHECK: ret void 279 280 // CHECK-LABEL: define linkonce_odr hidden void @__copy_helper_block_8_32w(i8* %0, i8* %1) unnamed_addr #{{[0-9]+}} { 281 // CHECK: getelementptr 282 // CHECK-NEXT: getelementptr 283 // CHECK-NEXT: call void @llvm.objc.copyWeak( 284 285 // CHECK-LABEL: define linkonce_odr hidden void @__destroy_helper_block_8_32w(i8* %0) unnamed_addr #{{[0-9]+}} { 286 // CHECK: getelementptr 287 // CHECK-NEXT: call void @llvm.objc.destroyWeak( 288} 289 290@interface Test8 @end 291@implementation Test8 292- (void) test { 293// CHECK: define internal void @"\01-[Test8 test]" 294// CHECK: [[SELF:%.*]] = alloca [[TEST8:%.*]]*, 295// CHECK-NEXT: alloca i8* 296// CHECK-NEXT: [[BLOCK:%.*]] = alloca [[BLOCK_T:<{.*}>]], 297// CHECK: store 298// CHECK-NEXT: store 299// CHECK: [[T0:%.*]] = getelementptr inbounds [[BLOCK_T]], [[BLOCK_T]]* [[BLOCK]], i32 0, i32 5 300// CHECK-NEXT: [[T1:%.*]] = load [[TEST8]]*, [[TEST8]]** [[SELF]], 301// CHECK-NEXT: store %0* [[T1]], %0** [[T0]] 302// CHECK-NEXT: bitcast [[BLOCK_T]]* [[BLOCK]] to 303// CHECK: call void @test8_helper( 304// CHECK-NEXT: [[T2:%.*]] = load [[TEST8]]*, [[TEST8]]** [[T0]] 305// CHECK-NEXT: call void (...) @llvm.objc.clang.arc.use([[TEST8]]* [[T2]]) 306// CHECK: ret void 307 308 extern void test8_helper(void (^)(void)); 309 test8_helper(^{ (void) self; }); 310} 311@end 312 313id test9(void) { 314 typedef id __attribute__((ns_returns_retained)) blocktype(void); 315 extern void test9_consume_block(blocktype^); 316 return ^blocktype { 317 extern id test9_produce(void); 318 return test9_produce(); 319 }(); 320 321// CHECK-LABEL: define{{.*}} i8* @test9( 322// CHECK: load i8*, i8** getelementptr 323// CHECK-NEXT: bitcast i8* 324// CHECK-NEXT: call i8* 325// CHECK-NEXT: tail call i8* @llvm.objc.autoreleaseReturnValue 326// CHECK-NEXT: ret i8* 327 328// CHECK: call i8* @test9_produce() [ "clang.arc.attachedcall"(i8* (i8*)* @llvm.objc.retainAutoreleasedReturnValue) ] 329// CHECK-NEXT: call void (...) @llvm.objc.clang.arc.noop.use( 330// CHECK-NEXT: ret i8* 331} 332 333// rdar://problem/9814099 334// Test that we correctly initialize __block variables 335// when the initialization captures the variable. 336void test10a(void) { 337 __block void (^block)(void) = ^{ block(); }; 338 // CHECK-LABEL: define{{.*}} void @test10a() 339 // CHECK: [[BYREF:%.*]] = alloca [[BYREF_T:%.*]], 340 // CHECK-NOHEAP: [[BLOCK1:%.*]] = alloca <{ i8*, i32, i32, i8*, %[[STRUCT_BLOCK_DESCRIPTOR]]*, i8* }>, align 8 341 342 // Zero-initialization before running the initializer. 343 // CHECK: [[T0:%.*]] = getelementptr inbounds [[BYREF_T]], [[BYREF_T]]* [[BYREF]], i32 0, i32 6 344 // CHECK-NEXT: store void ()* null, void ()** [[T0]], align 8 345 346 // Run the initializer as an assignment. 347 // CHECK-HEAP: [[T0:%.*]] = bitcast void ()* {{%.*}} to i8* 348 // CHECK-HEAP-NEXT: [[T1:%.*]] = call i8* @llvm.objc.retainBlock(i8* [[T0]]) 349 // CHECK-HEAP-NEXT: [[T2:%.*]] = bitcast i8* [[T1]] to void ()* 350 // CHECK-NOHEAP: [[T2:%.*]] = bitcast <{ i8*, i32, i32, i8*, %[[STRUCT_BLOCK_DESCRIPTOR]]*, i8* }>* [[BLOCK1]] to void ()* 351 // CHECK-NEXT: [[T3:%.*]] = getelementptr inbounds [[BYREF_T]], [[BYREF_T]]* [[BYREF]], i32 0, i32 1 352 // CHECK-NEXT: [[T4:%.*]] = load [[BYREF_T]]*, [[BYREF_T]]** [[T3]] 353 // CHECK-NEXT: [[T5:%.*]] = getelementptr inbounds [[BYREF_T]], [[BYREF_T]]* [[T4]], i32 0, i32 6 354 // CHECK-NEXT: [[T6:%.*]] = load void ()*, void ()** [[T5]], align 8 355 // CHECK-HEAP-NEXT: store void ()* {{%.*}}, void ()** [[T5]], align 8 356 // CHECK-NOHEAP-NEXT: store void ()* [[T2]], void ()** [[T5]], align 8 357 // CHECK-NEXT: [[T7:%.*]] = bitcast void ()* [[T6]] to i8* 358 // CHECK-NEXT: call void @llvm.objc.release(i8* [[T7]]) 359 360 // Destroy at end of function. 361 // CHECK-NEXT: [[SLOT:%.*]] = getelementptr inbounds [[BYREF_T]], [[BYREF_T]]* [[BYREF]], i32 0, i32 6 362 // CHECK-NEXT: [[T0:%.*]] = bitcast [[BYREF_T]]* [[BYREF]] to i8* 363 // CHECK-NEXT: call void @_Block_object_dispose(i8* [[T0]], i32 8) 364 // CHECK-NEXT: [[T1:%.*]] = load void ()*, void ()** [[SLOT]] 365 // CHECK-NEXT: [[T2:%.*]] = bitcast void ()* [[T1]] to i8* 366 // CHECK-NEXT: call void @llvm.objc.release(i8* [[T2]]) 367 // CHECK: ret void 368} 369 370// <rdar://problem/10402698>: do this copy and dispose with 371// objc_retainBlock/release instead of _Block_object_assign/destroy. 372// We can also use _Block_object_assign/destroy with 373// BLOCK_FIELD_IS_BLOCK as long as we don't pass BLOCK_BYREF_CALLER. 374 375// CHECK-LABEL: define internal void @__Block_byref_object_copy_.{{[0-9]+}}(i8* %0, i8* %1) #{{[0-9]+}} { 376// CHECK: [[D0:%.*]] = load i8*, i8** {{%.*}} 377// CHECK-NEXT: [[D1:%.*]] = bitcast i8* [[D0]] to [[BYREF_T]]* 378// CHECK-NEXT: [[D2:%.*]] = getelementptr inbounds [[BYREF_T]], [[BYREF_T]]* [[D1]], i32 0, i32 6 379// CHECK-NEXT: [[S0:%.*]] = load i8*, i8** {{%.*}} 380// CHECK-NEXT: [[S1:%.*]] = bitcast i8* [[S0]] to [[BYREF_T]]* 381// CHECK-NEXT: [[S2:%.*]] = getelementptr inbounds [[BYREF_T]], [[BYREF_T]]* [[S1]], i32 0, i32 6 382// CHECK-NEXT: [[T0:%.*]] = load void ()*, void ()** [[S2]], align 8 383// CHECK-NEXT: [[T1:%.*]] = bitcast void ()* [[T0]] to i8* 384// CHECK-NEXT: [[T2:%.*]] = call i8* @llvm.objc.retainBlock(i8* [[T1]]) 385// CHECK-NEXT: [[T3:%.*]] = bitcast i8* [[T2]] to void ()* 386// CHECK-NEXT: store void ()* [[T3]], void ()** [[D2]], align 8 387// CHECK: ret void 388 389// CHECK-LABEL: define internal void @__Block_byref_object_dispose_.{{[0-9]+}}(i8* %0) #{{[0-9]+}} { 390// CHECK: [[T0:%.*]] = load i8*, i8** {{%.*}} 391// CHECK-NEXT: [[T1:%.*]] = bitcast i8* [[T0]] to [[BYREF_T]]* 392// CHECK-NEXT: [[T2:%.*]] = getelementptr inbounds [[BYREF_T]], [[BYREF_T]]* [[T1]], i32 0, i32 6 393// CHECK-NEXT: [[T3:%.*]] = load void ()*, void ()** [[T2]] 394// CHECK-NEXT: [[T4:%.*]] = bitcast void ()* [[T3]] to i8* 395// CHECK-NEXT: call void @llvm.objc.release(i8* [[T4]]) 396// CHECK-NEXT: ret void 397 398// Test that we correctly assign to __block variables when the 399// assignment captures the variable. 400void test10b(void) { 401 __block void (^block)(void); 402 block = ^{ block(); }; 403 404 // CHECK-LABEL: define{{.*}} void @test10b() 405 // CHECK: [[BYREF:%.*]] = alloca [[BYREF_T:%.*]], 406 // CHECK-NOHEAP: [[BLOCK3:%.*]] = alloca <{ i8*, i32, i32, i8*, %[[STRUCT_BLOCK_DESCRIPTOR]]*, i8* }>, align 8 407 408 // Zero-initialize. 409 // CHECK: [[T0:%.*]] = getelementptr inbounds [[BYREF_T]], [[BYREF_T]]* [[BYREF]], i32 0, i32 6 410 // CHECK-NEXT: store void ()* null, void ()** [[T0]], align 8 411 412 // CHECK-NEXT: [[SLOT:%.*]] = getelementptr inbounds [[BYREF_T]], [[BYREF_T]]* [[BYREF]], i32 0, i32 6 413 414 // The assignment. 415 // CHECK-HEAP: [[T0:%.*]] = bitcast void ()* {{%.*}} to i8* 416 // CHECK-HEAP-NEXT: [[T1:%.*]] = call i8* @llvm.objc.retainBlock(i8* [[T0]]) 417 // CHECK-HEAP-NEXT: [[T2:%.*]] = bitcast i8* [[T1]] to void ()* 418 // CHECK-NOHEAP: [[T2:%.*]] = bitcast <{ i8*, i32, i32, i8*, %[[STRUCT_BLOCK_DESCRIPTOR]]*, i8* }>* [[BLOCK3]] to void ()* 419 // CHECK-NEXT: [[T3:%.*]] = getelementptr inbounds [[BYREF_T]], [[BYREF_T]]* [[BYREF]], i32 0, i32 1 420 // CHECK-NEXT: [[T4:%.*]] = load [[BYREF_T]]*, [[BYREF_T]]** [[T3]] 421 // CHECK-NEXT: [[T5:%.*]] = getelementptr inbounds [[BYREF_T]], [[BYREF_T]]* [[T4]], i32 0, i32 6 422 // CHECK-NEXT: [[T6:%.*]] = load void ()*, void ()** [[T5]], align 8 423 // CHECK-HEAP-NEXT: store void ()* {{%.*}}, void ()** [[T5]], align 8 424 // CHECK-NOHEAP-NEXT: store void ()* [[T2]], void ()** [[T5]], align 8 425 // CHECK-NEXT: [[T7:%.*]] = bitcast void ()* [[T6]] to i8* 426 // CHECK-NEXT: call void @llvm.objc.release(i8* [[T7]]) 427 428 // Destroy at end of function. 429 // CHECK-NEXT: [[T0:%.*]] = bitcast [[BYREF_T]]* [[BYREF]] to i8* 430 // CHECK-NEXT: call void @_Block_object_dispose(i8* [[T0]], i32 8) 431 // CHECK-NEXT: [[T1:%.*]] = load void ()*, void ()** [[SLOT]] 432 // CHECK-NEXT: [[T2:%.*]] = bitcast void ()* [[T1]] to i8* 433 // CHECK-NEXT: call void @llvm.objc.release(i8* [[T2]]) 434 // CHECK: ret void 435} 436 437// rdar://problem/10088932 438void test11_helper(id); 439void test11a(void) { 440 int x; 441 test11_helper(^{ (void) x; }); 442 443 // CHECK-LABEL: define{{.*}} void @test11a() 444 // CHECK: [[X:%.*]] = alloca i32, align 4 445 // CHECK-NEXT: [[BLOCK:%.*]] = alloca [[BLOCK_T:<{.*}>]], align 8 446 // CHECK: [[T0:%.*]] = bitcast [[BLOCK_T]]* [[BLOCK]] to void ()* 447 // CHECK-NEXT: [[T1:%.*]] = bitcast void ()* [[T0]] to i8* 448 // CHECK-NEXT: [[T2:%.*]] = call i8* @llvm.objc.retainBlock(i8* [[T1]]) 449 // CHECK-NEXT: [[T3:%.*]] = bitcast i8* [[T2]] to void ()* 450 // CHECK-NEXT: [[T4:%.*]] = bitcast void ()* [[T3]] to i8* 451 // CHECK-NEXT: call void @test11_helper(i8* [[T4]]) 452 // CHECK-NEXT: [[T5:%.*]] = bitcast void ()* [[T3]] to i8* 453 // CHECK-NEXT: call void @llvm.objc.release(i8* [[T5]]) 454 // CHECK: ret void 455} 456void test11b(void) { 457 int x; 458 id b = ^{ (void) x; }; 459 460 // CHECK-LABEL: define{{.*}} void @test11b() 461 // CHECK: [[X:%.*]] = alloca i32, align 4 462 // CHECK-NEXT: [[B:%.*]] = alloca i8*, align 8 463 // CHECK-NEXT: [[BLOCK:%.*]] = alloca [[BLOCK_T:<{.*}>]], align 8 464 // CHECK: [[T0:%.*]] = bitcast [[BLOCK_T]]* [[BLOCK]] to void ()* 465 // CHECK-NEXT: [[T1:%.*]] = bitcast void ()* [[T0]] to i8* 466 // CHECK-NEXT: [[T2:%.*]] = call i8* @llvm.objc.retainBlock(i8* [[T1]]) 467 // CHECK-NEXT: [[T3:%.*]] = bitcast i8* [[T2]] to void ()* 468 // CHECK-NEXT: [[T4:%.*]] = bitcast void ()* [[T3]] to i8* 469 // CHECK-NEXT: store i8* [[T4]], i8** [[B]], align 8 470 // CHECK-NEXT: [[T5:%.*]] = load i8*, i8** [[B]] 471 // CHECK-NEXT: call void @llvm.objc.release(i8* [[T5]]) 472 // CHECK: ret void 473} 474 475// rdar://problem/9979150 476@interface Test12 477@property (strong) void(^ablock)(void); 478@property (nonatomic, strong) void(^nblock)(void); 479@end 480@implementation Test12 481@synthesize ablock, nblock; 482// CHECK: define internal void ()* @"\01-[Test12 ablock]"( 483// CHECK: call i8* @objc_getProperty(i8* {{%.*}}, i8* {{%.*}}, i64 {{%.*}}, i1 zeroext true) 484 485// CHECK: define internal void @"\01-[Test12 setAblock:]"( 486// CHECK: call void @objc_setProperty(i8* {{%.*}}, i8* {{%.*}}, i64 {{%.*}}, i8* {{%.*}}, i1 zeroext true, i1 zeroext true) 487 488// CHECK: define internal void ()* @"\01-[Test12 nblock]"( 489// CHECK: %add.ptr = getelementptr inbounds i8, i8* %1, i64 %ivar 490 491// CHECK: define internal void @"\01-[Test12 setNblock:]"( 492// CHECK: call void @objc_setProperty(i8* {{%.*}}, i8* {{%.*}}, i64 {{%.*}}, i8* {{%.*}}, i1 zeroext false, i1 zeroext true) 493@end 494 495// rdar://problem/10131784 496void test13(id x) { 497 extern void test13_helper(id); 498 extern void test13_use(void(^)(void)); 499 500 void (^b)(void) = (x ? ^{test13_helper(x);} : 0); 501 test13_use(b); 502 503 // CHECK-LABEL: define{{.*}} void @test13( 504 // CHECK: [[X:%.*]] = alloca i8*, align 8 505 // CHECK-NEXT: [[B:%.*]] = alloca void ()*, align 8 506 // CHECK-NEXT: [[BLOCK:%.*]] = alloca [[BLOCK_T:.*]], align 8 507 // CHECK-NEXT: [[CLEANUP_ACTIVE:%.*]] = alloca i1 508 // CHECK-NEXT: [[COND_CLEANUP_SAVE:%.*]] = alloca i8**, 509 // CHECK-NEXT: [[T0:%.*]] = call i8* @llvm.objc.retain(i8* {{%.*}}) 510 // CHECK-NEXT: store i8* [[T0]], i8** [[X]], align 8 511 // CHECK-NEXT: [[BPTR1:%.*]] = bitcast void ()** [[B]] to i8* 512 // CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 8, i8* [[BPTR1]]) 513 // CHECK-NEXT: [[T0:%.*]] = load i8*, i8** [[X]], align 8 514 // CHECK-NEXT: [[T1:%.*]] = icmp ne i8* [[T0]], null 515 // CHECK-NEXT: store i1 false, i1* [[CLEANUP_ACTIVE]] 516 // CHECK-NEXT: br i1 [[T1]], 517 518 // CHECK-NOT: br 519 // CHECK: [[CAPTURE:%.*]] = getelementptr inbounds [[BLOCK_T]], [[BLOCK_T]]* [[BLOCK]], i32 0, i32 5 520 // CHECK-NEXT: [[T0:%.*]] = load i8*, i8** [[X]], align 8 521 // CHECK-NEXT: [[T1:%.*]] = call i8* @llvm.objc.retain(i8* [[T0]]) 522 // CHECK-NEXT: store i8* [[T1]], i8** [[CAPTURE]], align 8 523 // CHECK-NEXT: store i1 true, i1* [[CLEANUP_ACTIVE]] 524 // CHECK-NEXT: store i8** [[CAPTURE]], i8*** [[COND_CLEANUP_SAVE]], align 8 525 // CHECK-NEXT: bitcast [[BLOCK_T]]* [[BLOCK]] to void ()* 526 // CHECK-NEXT: br label 527 // CHECK: br label 528 // CHECK: [[T0:%.*]] = phi void ()* 529 // CHECK-NEXT: [[T1:%.*]] = bitcast void ()* [[T0]] to i8* 530 // CHECK-NEXT: [[T2:%.*]] = call i8* @llvm.objc.retainBlock(i8* [[T1]]) 531 // CHECK-NEXT: [[T3:%.*]] = bitcast i8* [[T2]] to void ()* 532 // CHECK-NEXT: store void ()* [[T3]], void ()** [[B]], align 8 533 // CHECK-NEXT: [[T0:%.*]] = load void ()*, void ()** [[B]], align 8 534 // CHECK-NEXT: call void @test13_use(void ()* [[T0]]) 535 // CHECK-NEXT: [[T0:%.*]] = load void ()*, void ()** [[B]] 536 // CHECK-NEXT: [[T1:%.*]] = bitcast void ()* [[T0]] to i8* 537 // CHECK-NEXT: call void @llvm.objc.release(i8* [[T1]]) 538 539 // CHECK-NEXT: [[T0:%.*]] = load i1, i1* [[CLEANUP_ACTIVE]] 540 // CHECK-NEXT: br i1 [[T0]] 541 // CHECK: [[V12:%.*]] = load i8**, i8*** [[COND_CLEANUP_SAVE]], align 8 542 // CHECK: [[T0:%.*]] = load i8*, i8** [[V12]] 543 // CHECK-NEXT: call void @llvm.objc.release(i8* [[T0]]) 544 // CHECK-NEXT: br label 545 546 // CHECK: [[BPTR2:%.*]] = bitcast void ()** [[B]] to i8* 547 // CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 8, i8* [[BPTR2]]) 548 // CHECK-NEXT: [[T0:%.*]] = load i8*, i8** [[X]] 549 // CHECK-NEXT: call void @llvm.objc.release(i8* [[T0]]) 550 // CHECK-NEXT: ret void 551} 552 553// <rdar://problem/10907510> 554void test14() { 555 void (^const x[1])(void) = { ^{} }; 556} 557 558// rdar://11149025 559// Don't make invalid ASTs and crash. 560void test15_helper(void (^block)(void), int x); 561void test15(int a) { 562 test15_helper(^{ (void) a; }, ({ a; })); 563} 564 565// rdar://11016025 566void test16() { 567 void (^BLKVAR)(void) = ^{ BLKVAR(); }; 568 569 // CHECK-LABEL: define{{.*}} void @test16( 570 // CHECK: [[BLKVAR:%.*]] = alloca void ()*, align 8 571 // CHECK-NEXT: [[BLOCK:%.*]] = alloca [[BLOCK_T:<{.*}>]], 572 // CHECK-NEXT: [[BLKVARPTR1:%.*]] = bitcast void ()** [[BLKVAR]] to i8* 573 // CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 8, i8* [[BLKVARPTR1]]) 574 // CHECK-NEXT: store void ()* null, void ()** [[BLKVAR]], align 8 575} 576 577// rdar://12151005 578// 579// This is an intentional exception to our conservative jump-scope 580// checking for full-expressions containing block literals with 581// non-trivial cleanups: if the block literal appears in the operand 582// of a return statement, there's no need to extend its lifetime. 583id (^test17(id self, int which))(void) { 584 switch (which) { 585 case 1: return ^{ return self; }; 586 case 0: return ^{ return self; }; 587 } 588 return (void*) 0; 589} 590// CHECK-LABEL: define{{.*}} i8* ()* @test17( 591// CHECK: [[RET:%.*]] = alloca i8* ()*, align 592// CHECK-NEXT: [[SELF:%.*]] = alloca i8*, 593// CHECK: [[B0:%.*]] = alloca [[BLOCK:<.*>]], align 594// CHECK: [[B1:%.*]] = alloca [[BLOCK]], align 595// CHECK: [[T0:%.*]] = call i8* @llvm.objc.retain(i8* 596// CHECK-NEXT: store i8* [[T0]], i8** [[SELF]], align 597// CHECK-NOT: objc_retain 598// CHECK-NOT: objc_release 599// CHECK: [[CAPTURED:%.*]] = getelementptr inbounds [[BLOCK]], [[BLOCK]]* [[B0]], i32 0, i32 5 600// CHECK-NEXT: [[T1:%.*]] = load i8*, i8** [[SELF]], align 601// CHECK-NEXT: [[T2:%.*]] = call i8* @llvm.objc.retain(i8* [[T1]]) 602// CHECK-NEXT: store i8* [[T2]], i8** [[CAPTURED]], 603// CHECK-NEXT: [[T0:%.*]] = bitcast [[BLOCK]]* [[B0]] to i8* ()* 604// CHECK-NEXT: [[T1:%.*]] = bitcast i8* ()* [[T0]] to i8* 605// CHECK-NEXT: [[T2:%.*]] = call i8* @llvm.objc.retainBlock(i8* [[T1]]) 606// CHECK-NEXT: [[T3:%.*]] = bitcast i8* [[T2]] to i8* ()* 607// CHECK-NEXT: store i8* ()* [[T3]], i8* ()** [[RET]] 608// CHECK-NEXT: [[T0:%.*]] = load i8*, i8** [[CAPTURED]] 609// CHECK-NEXT: call void @llvm.objc.release(i8* [[T0]]) 610// CHECK-NEXT: store i32 611// CHECK-NEXT: br label 612// CHECK-NOT: objc_retain 613// CHECK-NOT: objc_release 614// CHECK: [[CAPTURED:%.*]] = getelementptr inbounds [[BLOCK]], [[BLOCK]]* [[B1]], i32 0, i32 5 615// CHECK-NEXT: [[T1:%.*]] = load i8*, i8** [[SELF]], align 616// CHECK-NEXT: [[T2:%.*]] = call i8* @llvm.objc.retain(i8* [[T1]]) 617// CHECK-NEXT: store i8* [[T2]], i8** [[CAPTURED]], 618// CHECK-NEXT: [[T0:%.*]] = bitcast [[BLOCK]]* [[B1]] to i8* ()* 619// CHECK-NEXT: [[T1:%.*]] = bitcast i8* ()* [[T0]] to i8* 620// CHECK-NEXT: [[T2:%.*]] = call i8* @llvm.objc.retainBlock(i8* [[T1]]) 621// CHECK-NEXT: [[T3:%.*]] = bitcast i8* [[T2]] to i8* ()* 622// CHECK-NEXT: store i8* ()* [[T3]], i8* ()** [[RET]] 623// CHECK-NEXT: [[T0:%.*]] = load i8*, i8** [[CAPTURED]] 624// CHECK-NEXT: call void @llvm.objc.release(i8* [[T0]]) 625// CHECK-NEXT: store i32 626// CHECK-NEXT: br label 627 628void test18(id x) { 629// CHECK-UNOPT-LABEL: define{{.*}} void @test18( 630// CHECK-UNOPT: [[X:%.*]] = alloca i8*, 631// CHECK-UNOPT-NEXT: [[BLOCK:%.*]] = alloca [[BLOCK_T:<{.*}>]], 632// CHECK-UNOPT-NEXT: store i8* null, i8** [[X]] 633// CHECK-UNOPT-NEXT: call void @llvm.objc.storeStrong(i8** [[X]], 634// CHECK-UNOPT: %[[BLOCK_DESCRIPTOR:.*]] = getelementptr inbounds [[BLOCK_T]], [[BLOCK_T]]* [[BLOCK]], i32 0, i32 4 635// CHECK-UNOPT: store %[[STRUCT_BLOCK_DESCRIPTOR]]* bitcast ({ i64, i64, i8*, i8*, i8*, i64 }* @[[BLOCK_DESCRIPTOR_TMP44]] to %[[STRUCT_BLOCK_DESCRIPTOR]]*), %[[STRUCT_BLOCK_DESCRIPTOR]]** %[[BLOCK_DESCRIPTOR]], align 8 636// CHECK-UNOPT: [[SLOT:%.*]] = getelementptr inbounds [[BLOCK_T]], [[BLOCK_T]]* [[BLOCK]], i32 0, i32 5 637// CHECK-UNOPT-NEXT: [[T0:%.*]] = load i8*, i8** [[X]], 638// CHECK-UNOPT-NEXT: [[T1:%.*]] = call i8* @llvm.objc.retain(i8* [[T0]]) 639// CHECK-UNOPT-NEXT: store i8* [[T1]], i8** [[SLOT]], 640// CHECK-UNOPT-NEXT: bitcast 641// CHECK-UNOPT-NEXT: call void @test18_helper( 642// CHECK-UNOPT-NEXT: call void @llvm.objc.storeStrong(i8** [[SLOT]], i8* null) [[NUW:#[0-9]+]] 643// CHECK-UNOPT-NEXT: call void @llvm.objc.storeStrong(i8** [[X]], i8* null) [[NUW]] 644// CHECK-UNOPT-NEXT: ret void 645 extern void test18_helper(id (^)(void)); 646 test18_helper(^{ return x; }); 647} 648 649// Ensure that we don't emit helper code in copy/dispose routines for variables 650// that are const-captured. 651void testUnsafeUnretainedLifetimeInCopyAndDestroyHelpers(id x, id y) { 652 id __unsafe_unretained unsafeObject = x; 653 (^ { testUnsafeUnretainedLifetimeInCopyAndDestroyHelpers(x, unsafeObject); })(); 654} 655 656// CHECK-LABEL: define{{.*}} void @testUnsafeUnretainedLifetimeInCopyAndDestroyHelpers 657// %[[BLOCK_DESCRIPTOR:.*]] = getelementptr inbounds <{ i8*, i32, i32, i8*, %[[STRUCT_BLOCK_DESCRIPTOR]]*, i8*, i8* }>, <{ i8*, i32, i32, i8*, %[[STRUCT_BLOCK_DESCRIPTOR]]*, i8*, i8* }>* %{{.*}}, i32 0, i32 4 658// CHECK: store %[[STRUCT_BLOCK_DESCRIPTOR]]* bitcast ({ i64, i64, i8*, i8*, i8*, i8* }* @[[BLOCK_DESCRIPTOR_TMP46]] to %[[STRUCT_BLOCK_DESCRIPTOR]]*), %[[STRUCT_BLOCK_DESCRIPTOR]]** %[[BLOCK_DESCRIPTOR]], align 8 659 660// CHECK-LABEL: define internal void @__testUnsafeUnretainedLifetimeInCopyAndDestroyHelpers_block_invoke 661// CHECK-UNOPT-LABEL: define internal void @__testUnsafeUnretainedLifetimeInCopyAndDestroyHelpers_block_invoke 662 663// rdar://13588325 664void test19_sink(void (^)(int)); 665void test19(void (^b)(void)) { 666// CHECK-LABEL: define{{.*}} void @test19( 667// Prologue. 668// CHECK: [[B:%.*]] = alloca void ()*, 669// CHECK-NEXT: [[BLOCK:%.*]] = alloca [[BLOCK_T:<{.*}>]], 670// CHECK-NEXT: [[T0:%.*]] = bitcast void ()* {{%.*}} to i8* 671// CHECK-NEXT: [[T1:%.*]] = call i8* @llvm.objc.retain(i8* [[T0]]) 672// CHECK-NEXT: [[T2:%.*]] = bitcast i8* [[T1]] to void ()* 673// CHECK-NEXT: store void ()* [[T2]], void ()** [[B]] 674 675// Block setup. We skip most of this. Note the bare retain. 676// CHECK: %[[BLOCK_DESCRIPTOR:.*]] = getelementptr inbounds [[BLOCK_T]], [[BLOCK_T]]* [[BLOCK]], i32 0, i32 4 677// CHECK: store %[[STRUCT_BLOCK_DESCRIPTOR]]* bitcast ({ i64, i64, i8*, i8*, i8*, i64 }* @[[BLOCK_DESCRIPTOR_TMP48]] to %[[STRUCT_BLOCK_DESCRIPTOR]]*), %[[STRUCT_BLOCK_DESCRIPTOR]]** %[[BLOCK_DESCRIPTOR]], align 8 678// CHECK: [[SLOT:%.*]] = getelementptr inbounds [[BLOCK_T]], [[BLOCK_T]]* [[BLOCK]], i32 0, i32 5 679// CHECK-NEXT: [[T0:%.*]] = load void ()*, void ()** [[B]], 680// CHECK-NEXT: [[T1:%.*]] = bitcast void ()* [[T0]] to i8* 681// CHECK-NEXT: [[T2:%.*]] = call i8* @llvm.objc.retain(i8* [[T1]]) 682// CHECK-NEXT: [[T3:%.*]] = bitcast i8* [[T2]] to void ()* 683// CHECK-NEXT: store void ()* [[T3]], void ()** [[SLOT]], 684// Call. 685// CHECK-NEXT: [[T0:%.*]] = bitcast [[BLOCK_T]]* [[BLOCK]] to void (i32)* 686// CHECK-NEXT: call void @test19_sink(void (i32)* [[T0]]) 687 688 test19_sink(^(int x) { b(); }); 689 690// Block teardown. 691// CHECK-NEXT: [[T0:%.*]] = load void ()*, void ()** [[SLOT]] 692// CHECK-NEXT: [[T1:%.*]] = bitcast void ()* [[T0]] to i8* 693// CHECK-NEXT: call void @llvm.objc.release(i8* [[T1]]) 694 695// Local cleanup. 696// CHECK-NEXT: [[T0:%.*]] = load void ()*, void ()** [[B]] 697// CHECK-NEXT: [[T1:%.*]] = bitcast void ()* [[T0]] to i8* 698// CHECK-NEXT: call void @llvm.objc.release(i8* [[T1]]) 699 700// CHECK-NEXT: ret void 701} 702 703// CHECK-LABEL: define{{.*}} void @test20( 704// CHECK: [[XADDR:%.*]] = alloca i8* 705// CHECK-NEXT: [[BLOCK:%.*]] = alloca <[[BLOCKTY:.*]]> 706// CHECK-NEXT: [[RETAINEDX:%.*]] = call i8* @llvm.objc.retain(i8* %{{.*}}) 707// CHECK-NEXT: store i8* [[RETAINEDX]], i8** [[XADDR]] 708// CHECK: [[BLOCKCAPTURED:%.*]] = getelementptr inbounds <[[BLOCKTY]]>, <[[BLOCKTY]]>* [[BLOCK]], i32 0, i32 5 709// CHECK: [[CAPTURED:%.*]] = load i8*, i8** [[XADDR]] 710// CHECK: store i8* [[CAPTURED]], i8** [[BLOCKCAPTURED]] 711// CHECK: [[CAPTURE:%.*]] = load i8*, i8** [[BLOCKCAPTURED]] 712// CHECK-NEXT: call void (...) @llvm.objc.clang.arc.use(i8* [[CAPTURE]]) 713// CHECK-NEXT: [[X:%.*]] = load i8*, i8** [[XADDR]] 714// CHECK-NEXT: call void @llvm.objc.release(i8* [[X]]) 715// CHECK-NEXT: ret void 716 717// CHECK-UNOPT-LABEL: define{{.*}} void @test20( 718// CHECK-UNOPT: [[XADDR:%.*]] = alloca i8* 719// CHECK-UNOPT-NEXT: [[BLOCK:%.*]] = alloca <[[BLOCKTY:.*]]> 720// CHECK-UNOPT: [[BLOCKCAPTURED:%.*]] = getelementptr inbounds <[[BLOCKTY]]>, <[[BLOCKTY]]>* [[BLOCK]], i32 0, i32 5 721// CHECK-UNOPT: [[CAPTURED:%.*]] = load i8*, i8** [[XADDR]] 722// CHECK-UNOPT: [[RETAINED:%.*]] = call i8* @llvm.objc.retain(i8* [[CAPTURED]]) 723// CHECK-UNOPT: store i8* [[RETAINED]], i8** [[BLOCKCAPTURED]] 724// CHECK-UNOPT: call void @llvm.objc.storeStrong(i8** [[BLOCKCAPTURED]], i8* null) 725 726void test20_callee(void (^)()); 727void test20(const id x) { 728 test20_callee(^{ (void)x; }); 729} 730 731// CHECK-LABEL: define{{.*}} void @test21( 732// CHECK: %[[V6:.*]] = call i8* @llvm.objc.retainBlock( 733// CHECK: %[[V7:.*]] = bitcast i8* %[[V6]] to void ()* 734// CHECK: call void (i32, ...) @test21_callee(i32 1, void ()* %[[V7]]), 735 736void test21_callee(int n, ...); 737void test21(id x) { 738 test21_callee(1, ^{ (void)x; }); 739} 740 741// The lifetime of 'x', which is captured by the block in the statement 742// expression, should be extended. 743 744// CHECK-COMMON-LABEL: define{{.*}} i8* @test22( 745// CHECK-COMMON: %[[BLOCK_CAPTURED:.*]] = getelementptr inbounds <{ i8*, i32, i32, i8*, %{{.*}}*, i8* }>, <{ i8*, i32, i32, i8*, %{{.*}}*, i8* }>* %{{.*}}, i32 0, i32 5 746// CHECK-COMMON: %[[V3:.*]] = call i8* @llvm.objc.retain(i8* %{{.*}}) 747// CHECK-COMMON: store i8* %[[V3]], i8** %[[BLOCK_CAPTURED]], align 8 748// CHECK-COMMON: call void @test22_1() 749// CHECK-UNOPT: call void @llvm.objc.storeStrong(i8** %[[BLOCK_CAPTURED]], i8* null) 750// CHECK: %[[V15:.*]] = load i8*, i8** %[[BLOCK_CAPTURED]], align 8 751// CHECK: call void @llvm.objc.release(i8* %[[V15]]) 752 753id test22(int c, id x) { 754 extern id test22_0(void); 755 extern void test22_1(void); 756 return c ? test22_0() : ({ id (^b)(void) = ^{ return x; }; test22_1(); b(); }); 757} 758 759@interface Test23 760-(void)m:(int)i, ...; 761@end 762 763// CHECK-COMMON-LABEL: define{{.*}} void @test23( 764// CHECK-COMMON: %[[V9:.*]] = call i8* @llvm.objc.retainBlock( 765// CHECK-COMMON: %[[V10:.*]] = bitcast i8* %[[V9]] to void ()* 766// CHECK-COMMON: call void (i8*, i8*, i32, ...) bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to void (i8*, i8*, i32, ...)*)(i8* %{{.*}}, i8* %{{.*}}, i32 123, void ()* %[[V10]]) 767 768void test23(id x, Test23 *t) { 769 [t m:123, ^{ (void)x; }]; 770} 771 772// CHECK: attributes [[NUW]] = { nounwind } 773// CHECK-UNOPT: attributes [[NUW]] = { nounwind } 774