test/CodeGenObjC/arc.m

   1 // RUN: %clang_cc1 -triple x86_64-apple-darwin10 -emit-llvm -fobjc-nonfragile-abi -fblocks -fobjc-arc -fobjc-runtime-has-weak -O2 -disable-llvm-optzns -o - %s | FileCheck %s
   2 // RUN: %clang_cc1 -triple x86_64-apple-darwin10 -emit-llvm -fobjc-nonfragile-abi -fblocks -fobjc-arc -fobjc-runtime-has-weak -o - %s | FileCheck -check-prefix=CHECK-GLOBALS %s
   3
   4 // CHECK: define void @test0
   5 void test0(id x) {
   6   // CHECK:      [[X:%.*]] = alloca i8*
   7   // CHECK-NEXT: [[PARM:%.*]] = call i8* @objc_retain(i8* {{.*}})
   8   // CHECK-NEXT: store i8* [[PARM]], i8** [[X]]
   9   // CHECK-NEXT: [[TMP:%.*]] = load i8** [[X]]
  10   // CHECK-NEXT: call void @objc_release(i8* [[TMP]])
  11   // CHECK-NEXT: ret void
  12 }
  13
  14 // CHECK: define i8* @test1(i8*
  15 id test1(id x) {
  16   // CHECK:      [[RET:%.*]] = alloca i8*
  17   // CHECK-NEXT: [[X:%.*]] = alloca i8*
  18   // CHECK-NEXT: [[Y:%.*]] = alloca i8*
  19   // CHECK-NEXT: alloca i32
  20   // CHECK-NEXT: [[PARM:%.*]] = call i8* @objc_retain(i8* {{%.*}})
  21   // CHECK-NEXT: store i8* [[PARM]], i8** [[X]]
  22   // CHECK-NEXT: store i8* null, i8** [[Y]]
  23   // CHECK-NEXT: [[T0:%.*]] = load i8** [[Y]]
  24   // CHECK-NEXT: [[T1:%.*]] = call i8* @objc_retain(i8* [[T0]])
  25   // CHECK-NEXT: store i8* [[T1]], i8** [[RET]]
  26   // CHECK-NEXT: store i32
  27   // CHECK-NEXT: [[T0:%.*]] = load i8** [[Y]]
  28   // CHECK-NEXT: call void @objc_release(i8* [[T0]])
  29   // CHECK-NEXT: [[T1:%.*]] = load i8** [[X]]
  30   // CHECK-NEXT: call void @objc_release(i8* [[T1]])
  31   // CHECK-NEXT: [[T0:%.*]] = load i8** [[RET]]
  32   // CHECK-NEXT: [[T1:%.*]] = call i8* @objc_autoreleaseReturnValue(i8* [[T0]])
  33   // CHECK-NEXT: ret i8* [[T1]]
  34   id y;
  35   return y;
  36 }
  37
  38 @interface Test2
  39 + (void) class_method;
  40 - (void) inst_method;
  41 @end
  42 @implementation Test2
  43
  44 // The self pointer of a class method is not retained.
  45 // CHECK: define internal void @"\01+[Test2 class_method]"
  46 // CHECK:      alloca
  47 // CHECK-NEXT: alloca
  48 // CHECK-NEXT: store
  49 // CHECK-NEXT: store
  50 // CHECK-NEXT: ret void
  51 + (void) class_method {}
  52
  53 // The self pointer of an instance method is not retained.
  54 // CHECK: define internal void @"\01-[Test2 inst_method]"
  55 // CHECK:      alloca
  56 // CHECK-NEXT: alloca
  57 // CHECK-NEXT: store
  58 // CHECK-NEXT: store
  59 // CHECK-NEXT: ret void
  60 - (void) inst_method {}
  61 @end
  62
  63 @interface Test3
  64 + (id) alloc;
  65 - (id) initWith: (int) x;
  66 - (id) copy;
  67 @end
  68
  69 // CHECK: define void @test3_unelided()
  70 void test3_unelided() {
  71   extern void test3_helper(void);
  72
  73   // CHECK:      [[X:%.*]] = alloca [[TEST3:%.*]]*
  74   // CHECK-NEXT: store [[TEST3]]* null, [[TEST3]]** [[X]], align
  75   Test3 *x;
  76
  77   // Call to +alloc.
  78   // CHECK-NEXT: load {{.*}}* @"\01L_OBJC_CLASSLIST_REFERENCES_
  79   // CHECK-NEXT: load i8** @"\01L_OBJC_SELECTOR_REFERENCES_
  80   // CHECK-NEXT: bitcast
  81   // CHECK-NEXT: [[ALLOC:%.*]] = call i8* bitcast (i8* (i8*, i8*, ...)* @objc_msgSend
  82   // CHECK-NEXT: bitcast
  83   // CHECK-NEXT: bitcast
  84   // CHECK-NEXT: call void @objc_release(i8*
  85   [Test3 alloc];
  86
  87   // CHECK-NEXT: [[T0:%.*]] = load [[TEST3]]** [[X]]
  88   // CHECK-NEXT: load i8** @"\01L_OBJC_SELECTOR_REFERENCES_
  89   // CHECK-NEXT: [[T1:%.*]] = bitcast [[TEST3]]* [[T0]] to i8*
  90   // CHECK-NEXT: [[COPY:%.*]] = call i8* bitcast (i8* (i8*, i8*, ...)* @objc_msgSend {{.*}})(i8* [[T1]],
  91   // CHECK-NEXT: call void @objc_release(i8* [[COPY]]) nounwind
  92   [x copy];
  93
  94   // CHECK-NEXT: [[T0:%.*]] = load [[TEST3]]** [[X]]
  95   // CHECK-NEXT: [[T1:%.*]] = bitcast [[TEST3]]* [[T0]] to i8*
  96   // CHECK-NEXT: call void @objc_release(i8* [[T1]]) nounwind
  97   // CHECK-NEXT: ret void
  98 }
  99
 100 // CHECK: define void @test3()
 101 void test3() {
 102   // CHECK:      [[X:%.*]] = alloca i8*
 103
 104   id x = [[Test3 alloc] initWith: 5];
 105
 106   // Call to +alloc.
 107   // CHECK-NEXT: load {{.*}}* @"\01L_OBJC_CLASSLIST_REFERENCES_
 108   // CHECK-NEXT: load i8** @"\01L_OBJC_SELECTOR_REFERENCES_
 109   // CHECK-NEXT: bitcast
 110   // CHECK-NEXT: [[ALLOC:%.*]] = call i8* bitcast (i8* (i8*, i8*, ...)* @objc_msgSend
 111   // CHECK-NEXT: bitcast
 112
 113   // Call to -initWith: with elided retain of consumed argument.
 114   // CHECK-NEXT: load i8** @"\01L_OBJC_SELECTOR_REFERENCES_
 115   // CHECK-NEXT: bitcast
 116   // CHECK-NEXT: [[INIT:%.*]] = call i8* bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to i8* (i8*, i8*, i32)*)(i8*
 117   // CHECK-NEXT: bitcast
 118   // CHECK-NEXT: [[INIT:%.*]] = bitcast
 119   // Assignment for initialization, retention elided.
 120   // CHECK-NEXT: store i8* [[INIT]], i8** [[X]]
 121
 122   // Call to -copy.
 123   // CHECK-NEXT: [[V:%.*]] = load i8** [[X]]
 124   // CHECK-NEXT: load i8** @"\01L_OBJC_SELECTOR_REFERENCES_
 125   // CHECK-NEXT: [[COPY:%.*]] = call i8* bitcast (i8* (i8*, i8*, ...)* @objc_msgSend {{.*}})(i8* [[V]],
 126
 127   // Assignment to x.
 128   // CHECK-NEXT: [[TMP:%.*]] = load i8** [[X]]
 129   // CHECK-NEXT: store i8* [[COPY]], i8** [[X]]
 130   // CHECK-NEXT: call void @objc_release(i8* [[TMP]]) nounwind
 131
 132   x = [x copy];
 133
 134   // Cleanup for x.
 135   // CHECK-NEXT: [[TMP:%.*]] = load i8** [[X]]
 136   // CHECK-NEXT: call void @objc_release(i8* [[TMP]]) nounwind
 137
 138   // CHECK-NEXT: ret void
 139 }
 140
 141 // CHECK: define i8* @test4()
 142 id test4() {
 143   // Call to +alloc.
 144   // CHECK:      load {{.*}}* @"\01L_OBJC_CLASSLIST_REFERENCES_
 145   // CHECK-NEXT: load i8** @"\01L_OBJC_SELECTOR_REFERENCES_
 146   // CHECK-NEXT: bitcast
 147   // CHECK-NEXT: [[ALLOC:%.*]] = call i8* bitcast (i8* (i8*, i8*, ...)* @objc_msgSend
 148   // CHECK-NEXT: [[ALLOC:%.*]] = bitcast
 149
 150   // Call to -initWith: with elided retain of consumed argument.
 151   // CHECK-NEXT: load i8** @"\01L_OBJC_SELECTOR_REFERENCES_
 152   // CHECK-NEXT: [[ALLOC:%.*]] = bitcast
 153   // CHECK-NEXT: [[INIT:%.*]] = call i8* bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to i8* (i8*, i8*, i32)*)(i8* [[ALLOC]],
 154
 155   // Initialization of return value, occuring within full-expression.
 156   // Retain/release elided.
 157   // CHECK-NEXT: bitcast
 158   // CHECK-NEXT: [[INIT:%.*]] = bitcast
 159   // CHECK-NEXT: [[RET:%.*]] = call i8* @objc_autoreleaseReturnValue(i8* [[INIT]])
 160
 161   // CHECK-NEXT: ret i8* [[RET]]
 162
 163   return [[Test3 alloc] initWith: 6];
 164 }
 165
 166 @interface Test5 {
 167 @public
 168   id var;
 169 }
 170 @end
 171
 172 // CHECK: define void @test5
 173 void test5(Test5 *x, id y) {
 174   // Prologue.
 175   // CHECK:      [[X:%.*]] = alloca [[TEST5:%.*]]*,
 176   // CHECK-NEXT: [[Y:%.*]] = alloca i8*
 177   // CHECK-NEXT: bitcast [[TEST5]]* {{%.*}} to i8*
 178   // CHECK-NEXT: call i8* @objc_retain
 179   // CHECK-NEXT: [[PARMX:%.*]] = bitcast i8* {{%.*}} to [[TEST5]]*
 180   // CHECK-NEXT: store [[TEST5]]* [[PARMX]], [[TEST5]]** [[X]]
 181   // CHECK-NEXT: call i8* @objc_retain
 182   // CHECK-NEXT: store
 183
 184   // CHECK-NEXT: load [[TEST5]]** [[X]]
 185   // CHECK-NEXT: load i64* @"OBJC_IVAR_$_Test5.var"
 186   // CHECK-NEXT: bitcast
 187   // CHECK-NEXT: getelementptr
 188   // CHECK-NEXT: [[VAR:%.*]] = bitcast
 189   // CHECK-NEXT: [[TMP:%.*]] = load i8** [[VAR]]
 190   // CHECK-NEXT: store i8* null, i8** [[VAR]]
 191   // CHECK-NEXT: call void @objc_release(i8* [[TMP]]) nounwind
 192   x->var = 0;
 193
 194   // CHECK-NEXT: [[YVAL:%.*]] = load i8** [[Y]]
 195   // CHECK-NEXT: load [[TEST5]]** [[X]]
 196   // CHECK-NEXT: load i64* @"OBJC_IVAR_$_Test5.var"
 197   // CHECK-NEXT: bitcast
 198   // CHECK-NEXT: getelementptr
 199   // CHECK-NEXT: [[VAR:%.*]] = bitcast
 200   // CHECK-NEXT: [[T0:%.*]] = call i8* @objc_retain(i8* [[YVAL]]) nounwind
 201   // CHECK-NEXT: [[TMP:%.*]] = load i8** [[VAR]]
 202   // CHECK-NEXT: store i8* [[T0]], i8** [[VAR]]
 203   // CHECK-NEXT: call void @objc_release(i8* [[TMP]]) nounwind
 204   x->var = y;
 205
 206   // Epilogue.
 207   // CHECK-NEXT: [[TMP:%.*]] = load i8** [[Y]]
 208   // CHECK-NEXT: call void @objc_release(i8* [[TMP]]) nounwind
 209   // CHECK-NEXT: [[T0:%.*]] = load [[TEST5]]** [[X]]
 210   // CHECK-NEXT: [[T1:%.*]] = bitcast [[TEST5]]* [[T0]] to i8*
 211   // CHECK-NEXT: call void @objc_release(i8* [[T1]]) nounwind
 212   // CHECK-NEXT: ret void
 213 }
 214
 215 id test6_helper(void) __attribute__((ns_returns_retained));
 216 // CHECK: define void @test6()
 217 void test6() {
 218   // CHECK:      [[X:%.*]] = alloca i8*
 219   // CHECK-NEXT: [[CALL:%.*]] = call i8* @test6_helper()
 220   // CHECK-NEXT: store i8* [[CALL]], i8** [[X]]
 221   // CHECK-NEXT: [[T1:%.*]] = load i8** [[X]]
 222   // CHECK-NEXT: call void @objc_release(i8* [[T1]]) nounwind, !clang.imprecise_release
 223   // CHECK-NEXT: ret void
 224   id x = test6_helper();
 225 }
 226
 227 void test7_helper(id __attribute__((ns_consumed)));
 228 // CHECK: define void @test7()
 229 void test7() {
 230   // CHECK:      [[X:%.*]] = alloca i8*
 231   // CHECK-NEXT: store i8* null, i8** [[X]]
 232   // CHECK-NEXT: [[T0:%.*]] = load i8** [[X]]
 233   // CHECK-NEXT: [[T1:%.*]] = call i8* @objc_retain(i8* [[T0]]) nounwind
 234   // CHECK-NEXT: call void @test7_helper(i8* [[T1]])
 235   // CHECK-NEXT: [[T1:%.*]] = load i8** [[X]]
 236   // CHECK-NEXT: call void @objc_release(i8* [[T1]]) nounwind, !clang.imprecise_release
 237   // CHECK-NEXT: ret void
 238   id x;
 239   test7_helper(x);
 240 }
 241
 242 id test8_helper(void) __attribute__((ns_returns_retained));
 243 void test8() {
 244   __unsafe_unretained id x = test8_helper();
 245   // CHECK:      [[X:%.*]] = alloca i8*
 246   // CHECK-NEXT: [[T0:%.*]] = call i8* @test8_helper()
 247   // CHECK-NEXT: store i8* [[T0]], i8** [[X]]
 248   // CHECK-NEXT: call void @objc_release(i8* [[T0]]) nounwind
 249   // CHECK-NOT:  imprecise_release
 250   // CHECK-NEXT: ret void
 251 }
 252
 253 id test9_helper(void) __attribute__((ns_returns_retained));
 254 void test9() {
 255   id x __attribute__((objc_precise_lifetime)) = test9_helper();
 256   x = 0;
 257   // CHECK:      [[X:%.*]] = alloca i8*
 258   // CHECK-NEXT: [[CALL:%.*]] = call i8* @test9_helper()
 259   // CHECK-NEXT: store i8* [[CALL]], i8** [[X]]
 260
 261   // CHECK-NEXT: [[T1:%.*]] = load i8** [[X]]
 262   // CHECK-NEXT: store i8* null, i8** [[X]]
 263   // CHECK-NEXT: call void @objc_release(i8* [[T1]]) nounwind, !clang.imprecise_release
 264
 265   // CHECK-NEXT: [[T1:%.*]] = load i8** [[X]]
 266   // CHECK-NEXT: call void @objc_release(i8* [[T1]]) nounwind
 267   // CHECK-NOT:  clang.imprecise_release
 268
 269   // CHECK-NEXT: ret void
 270 }
 271
 272 @interface Test10
 273 @property (retain) Test10 *me;
 274 @end
 275 void test10() {
 276   Test10 *x;
 277   id y = x.me.me;
 278
 279   // CHECK:      define void @test10()
 280   // CHECK:      [[X:%.*]] = alloca [[TEST10:%.*]]*, align
 281   // CHECK-NEXT: [[Y:%.*]] = alloca i8*, align
 282   // CHECK-NEXT: store [[TEST10]]* null, [[TEST10]]** [[X]]
 283   // CHECK-NEXT: load [[TEST10]]** [[X]], align
 284   // CHECK-NEXT: load i8** @"\01L_OBJC_SELECTOR_REFERENCES_{{[0-9]*}}"
 285   // CHECK-NEXT: bitcast
 286   // CHECK-NEXT: [[T0:%.*]] = call [[TEST10]]* bitcast (i8* (i8*, i8*, ...)* @objc_msgSend
 287   // CHECK-NEXT: [[T1:%.*]] = bitcast [[TEST10]]* [[T0]] to i8*
 288   // CHECK-NEXT: [[T2:%.*]] = call i8* @objc_retainAutoreleasedReturnValue(i8* [[T1]])
 289   // CHECK-NEXT: [[V:%.*]] = bitcast i8* [[T2]] to [[TEST10]]*
 290   // CHECK-NEXT: load i8** @"\01L_OBJC_SELECTOR_REFERENCES_{{[0-9]*}}"
 291   // CHECK-NEXT: bitcast
 292   // CHECK-NEXT: [[T0:%.*]] = call [[TEST10]]* bitcast (i8* (i8*, i8*, ...)* @objc_msgSend
 293   // CHECK-NEXT: [[T1:%.*]] = bitcast [[TEST10]]* [[T0]] to i8*
 294   // CHECK-NEXT: [[T2:%.*]] = call i8* @objc_retainAutoreleasedReturnValue(i8* [[T1]])
 295   // CHECK-NEXT: [[T3:%.*]] = bitcast i8* [[T2]] to [[TEST10]]*
 296   // CHECK-NEXT: [[T4:%.*]] = bitcast [[TEST10]]* [[T3]] to i8*
 297   // CHECK-NEXT: store i8* [[T4]], i8** [[Y]]
 298   // CHECK-NEXT: [[T0:%.*]] = bitcast [[TEST10]]* [[V]] to i8*
 299   // CHECK-NEXT: call void @objc_release(i8* [[T0]])
 300   // CHECK-NEXT: [[T0:%.*]] = load i8** [[Y]]
 301   // CHECK-NEXT: call void @objc_release(i8* [[T0]])
 302   // CHECK-NEXT: [[T0:%.*]] = load [[TEST10]]** [[X]]
 303   // CHECK-NEXT: [[T1:%.*]] = bitcast [[TEST10]]* [[T0]] to i8*
 304   // CHECK-NEXT: call void @objc_release(i8* [[T1]])
 305   // CHECK-NEXT: ret void
 306 }
 307
 308 void test11(id (*f)(void) __attribute__((ns_returns_retained))) {
 309   // CHECK:      define void @test11(
 310   // CHECK:      [[F:%.*]] = alloca i8* ()*, align
 311   // CHECK-NEXT: [[X:%.*]] = alloca i8*, align
 312   // CHECK-NEXT: store i8* ()* {{%.*}}, i8* ()** [[F]], align
 313   // CHECK-NEXT: [[T0:%.*]] = load i8* ()** [[F]], align
 314   // CHECK-NEXT: [[T1:%.*]] = call i8* [[T0]]()
 315   // CHECK-NEXT: store i8* [[T1]], i8** [[X]], align
 316   // CHECK-NEXT: [[T3:%.*]] = load i8** [[X]]
 317   // CHECK-NEXT: call void @objc_release(i8* [[T3]]) nounwind, !clang.imprecise_release
 318   // CHECK-NEXT: ret void
 319   id x = f();
 320 }
 321
 322 void test12(void) {
 323   extern id test12_helper(void);
 324
 325   // CHECK:      define void @test12()
 326   // CHECK:      [[X:%.*]] = alloca i8*, align
 327   // CHECK-NEXT: [[Y:%.*]] = alloca i8*, align
 328
 329   __weak id x = test12_helper();
 330   // CHECK-NEXT: [[T0:%.*]] = call i8* @test12_helper()
 331   // CHECK-NEXT: [[T1:%.*]] = call i8* @objc_retainAutoreleasedReturnValue(i8* [[T0]])
 332   // CHECK-NEXT: call i8* @objc_initWeak(i8** [[X]], i8* [[T1]])
 333   // CHECK-NEXT: call void @objc_release(i8* [[T1]])
 334
 335   x = test12_helper();
 336   // CHECK-NEXT: [[T0:%.*]] = call i8* @test12_helper()
 337   // CHECK-NEXT: [[T1:%.*]] = call i8* @objc_retainAutoreleasedReturnValue(i8* [[T0]])
 338   // CHECK-NEXT: call i8* @objc_storeWeak(i8** [[X]], i8* [[T1]])
 339   // CHECK-NEXT: call void @objc_release(i8* [[T1]])
 340
 341   id y = x;
 342   // CHECK-NEXT: [[T2:%.*]] = call i8* @objc_loadWeakRetained(i8** [[X]])
 343   // CHECK-NEXT: store i8* [[T2]], i8** [[Y]], align
 344
 345   // CHECK-NEXT: [[T4:%.*]] = load i8** [[Y]]
 346   // CHECK-NEXT: call void @objc_release(i8* [[T4]]) nounwind, !clang.imprecise_release
 347   // CHECK-NEXT: call void @objc_destroyWeak(i8** [[X]])
 348   // CHECK-NEXT: ret void
 349 }
 350
 351 // Indirect consuming calls.
 352 void test13(void) {
 353   // CHECK:      define void @test13()
 354   // CHECK:      [[X:%.*]] = alloca i8*, align
 355   // CHECK-NEXT: store i8* null, i8** [[X]], align
 356   id x;
 357
 358   typedef void fnty(id __attribute__((ns_consumed)));
 359   extern fnty *test13_func;
 360   // CHECK-NEXT: [[FN:%.*]] = load void (i8*)** @test13_func, align
 361   // CHECK-NEXT: [[X_VAL:%.*]] = load i8** [[X]], align
 362   // CHECK-NEXT: [[X_TMP:%.*]] = call i8* @objc_retain(i8* [[X_VAL]]) nounwind
 363   // CHECK-NEXT: call void [[FN]](i8* [[X_TMP]])
 364   test13_func(x);
 365
 366   extern fnty ^test13_block;
 367   // CHECK-NEXT: [[TMP:%.*]] = load void (i8*)** @test13_block, align
 368   // CHECK-NEXT: [[BLOCK:%.*]] = bitcast void (i8*)* [[TMP]] to [[BLOCKTY:%.*]]*
 369   // CHECK-NEXT: [[BLOCK_FN_PTR:%.*]] = getelementptr inbounds [[BLOCKTY]]* [[BLOCK]], i32 0, i32 3
 370   // CHECK-NEXT: [[BLOCK_OPAQUE:%.*]] = bitcast [[BLOCKTY]]* [[BLOCK]] to i8*
 371   // CHECK-NEXT: [[X_VAL:%.*]] = load i8** [[X]], align
 372   // CHECK-NEXT: [[X_TMP:%.*]] = call i8* @objc_retain(i8* [[X_VAL]]) nounwind
 373   // CHECK-NEXT: [[BLOCK_FN_TMP:%.*]] = load i8** [[BLOCK_FN_PTR]]
 374   // CHECK-NEXT: [[BLOCK_FN:%.*]] = bitcast i8* [[BLOCK_FN_TMP]] to void (i8*, i8*)*
 375   // CHECK-NEXT: call void [[BLOCK_FN]](i8* [[BLOCK_OPAQUE]], i8* [[X_TMP]])
 376   test13_block(x);
 377
 378   // CHECK-NEXT: [[T0:%.*]] = load i8** [[X]]
 379   // CHECK-NEXT: call void @objc_release(i8* [[T0]]) nounwind
 380   // CHECK-NEXT: ret void
 381 }
 382
 383 @interface Test16_super @end
 384 @interface Test16 : Test16_super {
 385   id z;
 386 }
 387 @property (assign) int x;
 388 @property (retain) id y;
 389 - (void) dealloc;
 390 @end
 391 @implementation Test16
 392 @synthesize x;
 393 @synthesize y;
 394 - (void) dealloc {
 395   // CHECK:    define internal void @"\01-[Test16 dealloc]"(
 396   // CHECK:      [[SELF:%.*]] = alloca [[TEST16:%.*]]*, align
 397   // CHECK-NEXT: [[CMD:%.*]] = alloca i8*, align
 398   // CHECK-NEXT: alloca
 399   // CHECK-NEXT: store [[TEST16]]* {{%.*}}, [[TEST16]]** [[SELF]], align
 400   // CHECK-NEXT: store i8* {{%.*}}, i8** [[CMD]]
 401   // CHECK-NEXT: [[BASE:%.*]] = load [[TEST16]]** [[SELF]]
 402
 403   // Call super.
 404   // CHECK-NEXT: [[BASE2:%.*]] = bitcast [[TEST16]]* [[BASE]] to i8*
 405   // CHECK-NEXT: [[T0:%.*]] = getelementptr
 406   // CHECK-NEXT: store i8* [[BASE2]], i8** [[T0]]
 407   // CHECK-NEXT: load {{%.*}}** @"\01L_OBJC_CLASSLIST_SUP_REFS_$_
 408   // CHECK-NEXT: bitcast
 409   // CHECK-NEXT: getelementptr
 410   // CHECK-NEXT: store
 411   // CHECK-NEXT: load i8** @"\01L_OBJC_SELECTOR_REFERENCES_
 412   // CHECK-NEXT: call void bitcast (i8* ({{.*}})* @objc_msgSendSuper2 to void (
 413   // CHECK-NEXT: ret void
 414 }
 415
 416 // .cxx_destruct
 417   // CHECK:    define internal void @"\01-[Test16 .cxx_destruct]"(
 418   // CHECK:      [[SELF:%.*]] = alloca [[TEST16:%.*]]*, align
 419   // CHECK-NEXT: [[CMD:%.*]] = alloca i8*, align
 420   // CHECK-NEXT: store [[TEST16]]* {{%.*}}, [[TEST16]]** [[SELF]], align
 421   // CHECK-NEXT: store i8* {{%.*}}, i8** [[CMD]]
 422   // CHECK-NEXT: [[BASE:%.*]] = load [[TEST16]]** [[SELF]]
 423
 424   // Destroy y.
 425   // CHECK-NEXT: [[Y_OFF:%.*]] = load i64* @"OBJC_IVAR_$_Test16.y"
 426   // CHECK-NEXT: [[T0:%.*]] = bitcast [[TEST16]]* [[BASE]] to i8*
 427   // CHECK-NEXT: [[T1:%.*]] = getelementptr inbounds i8* [[T0]], i64 [[Y_OFF]]
 428   // CHECK-NEXT: [[T2:%.*]] = bitcast i8* [[T1]] to i8**
 429   // CHECK-NEXT: call void @objc_storeStrong(i8** [[T2]], i8* null) nounwind
 430
 431   // Destroy z.
 432   // CHECK-NEXT: [[Z_OFF:%.*]] = load i64* @"OBJC_IVAR_$_Test16.z"
 433   // CHECK-NEXT: [[T0:%.*]] = bitcast [[TEST16]]* [[BASE]] to i8*
 434   // CHECK-NEXT: [[T1:%.*]] = getelementptr inbounds i8* [[T0]], i64 [[Z_OFF]]
 435   // CHECK-NEXT: [[T2:%.*]] = bitcast i8* [[T1]] to i8**
 436   // CHECK-NEXT: call void @objc_storeStrong(i8** [[T2]], i8* null) nounwind
 437
 438   // CHECK-NEXT: ret void
 439
 440 @end
 441
 442 // This shouldn't crash.
 443 @interface Test17A
 444 @property (assign) int x;
 445 @end
 446 @interface Test17B : Test17A
 447 @end
 448 @implementation Test17B
 449 - (int) x { return super.x + 1; }
 450 @end
 451
 452 // This shouldn't crash.
 453 void test18(id (^maker)(void)) {
 454   maker();
 455 }
 456
 457 void test19() {
 458   // CHECK: define void @test19()
 459   // CHECK:      [[X:%.*]] = alloca [5 x i8*], align 16
 460   // CHECK-NEXT: [[T0:%.*]] = bitcast [5 x i8*]* [[X]] to i8*
 461   // CHECK-NEXT: call void @llvm.memset.p0i8.i64(i8* [[T0]], i8 0, i64 40, i32 16, i1 false)
 462   id x[5];
 463
 464   extern id test19_helper(void);
 465   x[2] = test19_helper();
 466
 467   // CHECK-NEXT: [[CALL:%.*]] = call i8* @test19_helper()
 468   // CHECK-NEXT: [[T1:%.*]] = call i8* @objc_retainAutoreleasedReturnValue(i8* [[CALL]]) nounwind
 469   // CHECK-NEXT: [[SLOT:%.*]] = getelementptr inbounds [5 x i8*]* [[X]], i32 0, i64 2
 470   // CHECK-NEXT: [[T0:%.*]] = load i8** [[SLOT]]
 471   // CHECK-NEXT: store i8* [[T1]], i8** [[SLOT]]
 472   // CHECK-NEXT: call void @objc_release(i8* [[T0]]) nounwind
 473
 474   // CHECK-NEXT: [[BEGIN:%.*]] = getelementptr inbounds [5 x i8*]* [[X]], i32 0, i32 0
 475   // CHECK-NEXT: [[END:%.*]] = getelementptr inbounds i8** [[BEGIN]], i64 5
 476   // CHECK-NEXT: br label
 477
 478   // CHECK:      [[AFTER:%.*]] = phi i8** [ [[END]], {{%.*}} ], [ [[NEXT:%.*]], {{%.*}} ]
 479   // CHECK-NEXT: [[CUR:%.*]] = getelementptr inbounds i8** [[AFTER]], i64 -1
 480   // CHECK-NEXT: [[T0:%.*]] = load i8** [[CUR]]
 481   // CHECK-NEXT: call void @objc_release(i8* [[T0]]) nounwind, !clang.imprecise_release
 482   // CHECK-NEXT: [[EQ:%.*]] = icmp eq i8** [[CUR]], [[BEGIN]]
 483   // CHECK-NEXT: br i1 [[EQ]],
 484
 485   // CHECK:      ret void
 486 }
 487
 488 void test20(unsigned n) {
 489   // CHECK: define void @test20
 490   // CHECK:      [[N:%.*]] = alloca i32, align 4
 491   // CHECK-NEXT: [[SAVED_STACK:%.*]] = alloca i8*
 492   // CHECK-NEXT: store i32 {{%.*}}, i32* [[N]], align 4
 493
 494   id x[n];
 495
 496   // Capture the VLA size.
 497   // CHECK-NEXT: [[T0:%.*]] = load i32* [[N]], align 4
 498   // CHECK-NEXT: [[DIM:%.*]] = zext i32 [[T0]] to i64
 499
 500   // Save the stack pointer.
 501   // CHECK-NEXT: [[T0:%.*]] = call i8* @llvm.stacksave()
 502   // CHECK-NEXT: store i8* [[T0]], i8** [[SAVED_STACK]]
 503
 504   // Allocate the VLA.
 505   // CHECK-NEXT: [[VLA:%.*]] = alloca i8*, i64 [[DIM]], align 16
 506
 507   // Zero-initialize.
 508   // CHECK-NEXT: [[T0:%.*]] = bitcast i8** [[VLA]] to i8*
 509   // CHECK-NEXT: [[T1:%.*]] = mul nuw i64 [[DIM]], 8
 510   // CHECK-NEXT: call void @llvm.memset.p0i8.i64(i8* [[T0]], i8 0, i64 [[T1]], i32 8, i1 false)
 511
 512   // Destroy.
 513   // CHECK-NEXT: [[END:%.*]] = getelementptr inbounds i8** [[VLA]], i64 [[DIM]]
 514   // CHECK-NEXT: br label
 515
 516   // CHECK:      [[AFTER:%.*]] = phi i8** [ [[END]], {{%.*}} ], [ [[CUR:%.*]], {{%.*}} ]
 517   // CHECK-NEXT: [[CUR:%.*]] = getelementptr inbounds i8** [[AFTER]], i64 -1
 518   // CHECK-NEXT: [[T0:%.*]] = load i8** [[CUR]]
 519   // CHECK-NEXT: call void @objc_release(i8* [[T0]]) nounwind, !clang.imprecise_release
 520   // CHECK-NEXT: [[EQ:%.*]] = icmp eq i8** [[CUR]], [[VLA]]
 521   // CHECK-NEXT: br i1 [[EQ]],
 522
 523   // CHECK:      [[T0:%.*]] = load i8** [[SAVED_STACK]]
 524   // CHECK-NEXT: call void @llvm.stackrestore(i8* [[T0]])
 525   // CHECK-NEXT: ret void
 526 }
 527
 528 void test21(unsigned n) {
 529   // CHECK: define void @test21
 530   // CHECK:      [[N:%.*]] = alloca i32, align 4
 531   // CHECK-NEXT: [[SAVED_STACK:%.*]] = alloca i8*
 532   // CHECK-NEXT: store i32 {{%.*}}, i32* [[N]], align 4
 533
 534   id x[2][n][3];
 535
 536   // Capture the VLA size.
 537   // CHECK-NEXT: [[T0:%.*]] = load i32* [[N]], align 4
 538   // CHECK-NEXT: [[DIM:%.*]] = zext i32 [[T0]] to i64
 539
 540   // CHECK-NEXT: [[T0:%.*]] = call i8* @llvm.stacksave()
 541   // CHECK-NEXT: store i8* [[T0]], i8** [[SAVED_STACK]]
 542
 543
 544   // Allocate the VLA.
 545   // CHECK-NEXT: [[T0:%.*]] = mul nuw i64 2, [[DIM]]
 546   // CHECK-NEXT: [[VLA:%.*]] = alloca [3 x i8*], i64 [[T0]], align 16
 547
 548   // Zero-initialize.
 549   // CHECK-NEXT: [[T0:%.*]] = bitcast [3 x i8*]* [[VLA]] to i8*
 550   // CHECK-NEXT: [[T1:%.*]] = mul nuw i64 2, [[DIM]]
 551   // CHECK-NEXT: [[T2:%.*]] = mul nuw i64 [[T1]], 24
 552   // CHECK-NEXT: call void @llvm.memset.p0i8.i64(i8* [[T0]], i8 0, i64 [[T2]], i32 8, i1 false)
 553
 554   // Destroy.
 555   // CHECK-NEXT: [[T0:%.*]] = mul nuw i64 2, [[DIM]]
 556   // CHECK-NEXT: [[BEGIN:%.*]] = getelementptr inbounds [3 x i8*]* [[VLA]], i32 0, i32 0
 557   // CHECK-NEXT: [[T1:%.*]] = mul nuw i64 [[T0]], 3
 558   // CHECK-NEXT: [[END:%.*]] = getelementptr inbounds i8** [[BEGIN]], i64 [[T1]]
 559   // CHECK-NEXT: br label
 560
 561   // CHECK:      [[AFTER:%.*]] = phi i8** [ [[END]], {{%.*}} ], [ [[CUR:%.*]], {{%.*}} ]
 562   // CHECK-NEXT: [[CUR:%.*]] = getelementptr inbounds i8** [[AFTER]], i64 -1
 563   // CHECK-NEXT: [[T0:%.*]] = load i8** [[CUR]]
 564   // CHECK-NEXT: call void @objc_release(i8* [[T0]]) nounwind, !clang.imprecise_release
 565   // CHECK-NEXT: [[EQ:%.*]] = icmp eq i8** [[CUR]], [[BEGIN]]
 566   // CHECK-NEXT: br i1 [[EQ]],
 567
 568   // CHECK:      [[T0:%.*]] = load i8** [[SAVED_STACK]]
 569   // CHECK-NEXT: call void @llvm.stackrestore(i8* [[T0]])
 570   // CHECK-NEXT: ret void
 571 }
 572
 573 void test22(_Bool cond) {
 574   id test22_helper(void) __attribute__((ns_returns_retained));
 575
 576   // CHECK:      define void @test22(
 577   // CHECK:      [[COND:%.*]] = alloca i8,
 578   // CHECK-NEXT: [[X:%.*]] = alloca i8*,
 579   // CHECK-NEXT: [[RELCOND:%.*]] = alloca i1
 580   // CHECK-NEXT: [[RELVAL:%.*]] = alloca i8*
 581   // CHECK-NEXT: store i1 false, i1* [[RELCOND]]
 582   // CHECK-NEXT: zext
 583   // CHECK-NEXT: store
 584   // CHECK-NEXT: [[T0:%.*]] = load i8* [[COND]]
 585   // CHECK-NEXT: [[T1:%.*]] = trunc i8 [[T0]] to i1
 586   // CHECK-NEXT: br i1 [[T1]],
 587   // CHECK:      br label
 588   // CHECK:      [[CALL:%.*]] = call i8* @test22_helper()
 589   // CHECK-NEXT: store i1 true, i1* [[RELCOND]]
 590   // CHECK-NEXT: store i8* [[CALL]], i8** [[RELVAL]]
 591   // CHECK-NEXT: br label
 592   // CHECK:      [[T0:%.*]] = phi i8* [ null, {{%.*}} ], [ [[CALL]], {{%.*}} ]
 593   // CHECK-NEXT: [[T1:%.*]] = call i8* @objc_retain(i8* [[T0]]) nounwind
 594   // CHECK-NEXT: store i8* [[T1]], i8** [[X]],
 595   // CHECK-NEXT: [[REL:%.*]] = load i1* [[RELCOND]]
 596   // CHECK-NEXT: br i1 [[REL]],
 597   // CHECK:      [[T0:%.*]] = load i8** [[RELVAL]]
 598   // CHECK-NEXT: call void @objc_release(i8* [[T0]]) nounwind
 599   // CHECK-NEXT: br label
 600   // CHECK:      [[T0:%.*]] = load i8** [[X]]
 601   // CHECK-NEXT: call void @objc_release(i8* [[T0]]) nounwind
 602   // CHECK-NEXT: ret void
 603   id x = (cond ? 0 : test22_helper());
 604 }
 605
 606 // rdar://problem/8922540
 607 //   Note that we no longer emit .release_ivars flags.
 608 // CHECK-GLOBALS: @"\01l_OBJC_CLASS_RO_$_Test23" = internal global [[RO_T:%.*]] { i32 134,
 609 @interface Test23 { id x; } @end
 610 @implementation Test23 @end
 611
 612 // CHECK-GLOBALS: @"\01l_OBJC_CLASS_RO_$_Test24" = internal global [[RO_T:%.*]] { i32 130,
 613 @interface Test24 {} @end
 614 @implementation Test24 @end
 615
 616 int (^test25(int x))(void) {
 617   // CHECK:    define i32 ()* @test25(
 618   // CHECK:      [[X:%.*]] = alloca i32,
 619   // CHECK-NEXT: [[BLOCK:%.*]] = alloca [[BLOCK_T:<{.*}>]],
 620   // CHECK-NEXT: store i32 {{%.*}}, i32* [[X]]
 621   // CHECK:      [[T0:%.*]] = bitcast [[BLOCK_T]]* [[BLOCK]] to i32 ()*
 622   // CHECK-NEXT: [[T1:%.*]] = bitcast i32 ()* [[T0]] to i8*
 623   // CHECK-NEXT: [[T2:%.*]] = call i8* @objc_retainBlock(i8* [[T1]]) nounwind
 624   // CHECK-NEXT: [[T3:%.*]] = bitcast i8* [[T2]] to i32 ()*
 625   // CHECK-NEXT: [[T4:%.*]] = bitcast i32 ()* [[T3]] to i8*
 626   // CHECK-NEXT: [[T5:%.*]] = call i8* @objc_autoreleaseReturnValue(i8* [[T4]]) nounwind
 627   // CHECK-NEXT: [[T6:%.*]] = bitcast i8* [[T5]] to i32 ()*
 628   // CHECK-NEXT: ret i32 ()* [[T6]]
 629   return ^{ return x; };
 630 }
 631
 632 // rdar://problem/8941012
 633 @interface Test26 { id x[4]; } @end
 634 @implementation Test26 @end
 635 // CHECK:    define internal void @"\01-[Test26 .cxx_destruct]"(
 636 // CHECK:      [[SELF:%.*]] = load [[TEST26:%.*]]**
 637 // CHECK-NEXT: [[OFFSET:%.*]] = load i64* @"OBJC_IVAR_$_Test26.x"
 638 // CHECK-NEXT: [[T0:%.*]] = bitcast [[TEST26]]* [[SELF]] to i8*
 639 // CHECK-NEXT: [[T1:%.*]] = getelementptr inbounds i8* [[T0]], i64 [[OFFSET]]
 640 // CHECK-NEXT: [[X:%.*]] = bitcast i8* [[T1]] to [4 x i8*]*
 641 // CHECK-NEXT: [[BEGIN:%.*]] = getelementptr inbounds [4 x i8*]* [[X]], i32 0, i32 0
 642 // CHECK-NEXT: [[END:%.*]] = getelementptr inbounds i8** [[BEGIN]], i64 4
 643 // CHECK-NEXT: br label
 644 // CHECK:      [[CUR:%.*]] = phi i8**
 645 // CHECK-NEXT: [[ISDONE:%.*]] = icmp eq i8** [[CUR]], [[END]]
 646 // CHECK-NEXT: br i1 [[ISDONE]],
 647 // CHECK:      call void @objc_storeStrong(i8** [[CUR]], i8* null)
 648 // CHECK-NEXT: [[NEXT:%.*]] = getelementptr inbounds i8** [[CUR]], i32 1
 649 // CHECK-NEXT: br label
 650 // CHECK:      ret void
 651
 652 // Check that 'init' retains self.
 653 @interface Test27
 654 - (id) init;
 655 @end
 656 @implementation Test27
 657 - (id) init { return self; }
 658 // CHECK:    define internal i8* @"\01-[Test27 init]"
 659 // CHECK:      [[RET:%.*]] = alloca i8*,
 660 // CHECK-NEXT: [[SELF:%.*]] = alloca [[TEST27:%.*]]*,
 661 // CHECK-NEXT: [[CMD:%.*]] = alloca i8*,
 662 // CHECK-NEXT: [[DEST:%.*]] = alloca i32
 663 // CHECK-NEXT: store [[TEST27]]* {{%.*}}, [[TEST27]]** [[SELF]]
 664 // CHECK-NEXT: store i8* {{%.*}}, i8** [[CMD]]
 665 // CHECK-NEXT: [[T0:%.*]] = load [[TEST27]]** [[SELF]]
 666 // CHECK-NEXT: [[T1:%.*]] = bitcast [[TEST27]]* [[T0]] to i8*
 667 // CHECK-NEXT: [[T2:%.*]] = call i8* @objc_retain(i8* [[T1]])
 668 // CHECK-NEXT: [[T3:%.*]] = bitcast i8* [[T2]]
 669 // CHECK-NEXT: [[T2:%.*]] = bitcast
 670 // CHECK-NEXT: store i8* [[T2]], i8** [[RET]]
 671 // CHECK-NEXT: store i32 {{[0-9]+}}, i32* [[DEST]]
 672 // CHECK-NEXT: [[T0:%.*]] = load [[TEST27]]** [[SELF]]
 673 // CHECK-NEXT: [[T1:%.*]] = bitcast [[TEST27]]* [[T0]] to i8*
 674 // CHECK-NEXT: call void @objc_release(i8* [[T1]])
 675 // CHECK-NEXT: [[T0:%.*]] = load i8** [[RET]]
 676 // CHECK-NEXT: ret i8* [[T0]]
 677
 678 @end
 679
 680 // rdar://problem/8087194
 681 @interface Test28
 682 @property (copy) id prop;
 683 @end
 684 @implementation Test28
 685 @synthesize prop;
 686 @end
 687 // CHECK:    define internal void @"\01-[Test28 .cxx_destruct]"
 688 // CHECK:      [[SELF:%.*]] = load [[TEST28:%.*]]**
 689 // CHECK-NEXT: [[OFFSET:%.*]] = load i64* @"OBJC_IVAR_$_Test28.prop"
 690 // CHECK-NEXT: [[T0:%.*]] = bitcast [[TEST28]]* [[SELF]] to i8*
 691 // CHECK-NEXT: [[T1:%.*]] = getelementptr inbounds i8* [[T0]], i64 [[OFFSET]]
 692 // CHECK-NEXT: [[T2:%.*]] = bitcast i8* [[T1]] to i8**
 693 // CHECK-NEXT: call void @objc_storeStrong(i8** [[T2]], i8* null)
 694 // CHECK-NEXT: ret void
 695
 696 @interface Test29_super
 697 - (id) initWithAllocator: (id) allocator;
 698 @end
 699 @interface Test29 : Test29_super
 700 - (id) init;
 701 - (id) initWithAllocator: (id) allocator;
 702 @end
 703 @implementation Test29
 704 static id _test29_allocator = 0;
 705 - (id) init {
 706 // CHECK:    define internal i8* @"\01-[Test29 init]"([[TEST29:%.*]]* {{%.*}},
 707 // CHECK:      [[RET:%.*]] = alloca i8*, align 8
 708 // CHECK-NEXT: [[SELF:%.*]] = alloca [[TEST29]]*, align 8
 709 // CHECK-NEXT: [[CMD:%.*]] = alloca i8*, align 8
 710 // CHECK-NEXT: [[CLEANUP:%.*]] = alloca i32
 711 // CHECK-NEXT: store [[TEST29]]* {{%.*}}, [[TEST29]]** [[SELF]]
 712 // CHECK-NEXT: store i8* {{%.*}}, i8** [[CMD]]
 713
 714 // Evaluate arguments.  Note that the send argument is evaluated
 715 // before the zeroing of self.
 716 // CHECK-NEXT: [[T0:%.*]] = load [[TEST29]]** [[SELF]], align 8
 717 // CHECK-NEXT: [[T1:%.*]] = load i8** @_test29_allocator, align 8
 718
 719 // Implicit null of 'self', i.e. direct transfer of ownership.
 720 // CHECK-NEXT: store [[TEST29]]* null, [[TEST29]]** [[SELF]]
 721
 722 // Actual message send.
 723 // CHECK-NEXT: [[T2:%.*]] = load i8** @"\01L_OBJC_SELECTOR_REFERENCES_
 724 // CHECK-NEXT: [[T3:%.*]] = bitcast [[TEST29]]* [[T0]] to i8*
 725 // CHECK-NEXT: [[CALL:%.*]] = call i8* bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to i8* (i8*, i8*, i8*)*)(i8* [[T3]], i8* [[T2]], i8* [[T1]])
 726
 727 // Implicit write of result back into 'self'.  This is not supposed to
 728 // be detectable because we're supposed to ban accesses to the old
 729 // self value past the delegate init call.
 730 // CHECK-NEXT: [[T0:%.*]] = bitcast i8* [[CALL]] to [[TEST29]]*
 731 // CHECK-NEXT: store [[TEST29]]* [[T0]], [[TEST29]]** [[SELF]]
 732
 733 // Return statement.
 734 // CHECK-NEXT: [[T2:%.*]] = bitcast i8* [[CALL]]
 735 // CHECK-NEXT: [[CALL:%.*]] = bitcast
 736 // CHECK-NEXT: [[T1:%.*]] = call i8* @objc_retain(i8* [[CALL]]) nounwind
 737 // CHECK-NEXT: [[T2:%.*]] = bitcast i8* [[T1]]
 738 // CHECK-NEXT: [[T1:%.*]] = bitcast
 739 // CHECK-NEXT: store i8* [[T1]], i8** [[RET]]
 740 // CHECK-NEXT: store i32 1, i32* [[CLEANUP]]
 741
 742 // Cleanup.
 743 // CHECK-NEXT: [[T0:%.*]] = load [[TEST29]]** [[SELF]]
 744 // CHECK-NEXT: [[T1:%.*]] = bitcast [[TEST29]]* [[T0]] to i8*
 745 // CHECK-NEXT: call void @objc_release(i8* [[T1]]) nounwind, !clang.imprecise_release
 746
 747 // Return.
 748 // CHECK-NEXT: [[T0:%.*]] = load i8** [[RET]]
 749 // CHECK-NEXT: ret i8* [[T0]]
 750   return [self initWithAllocator: _test29_allocator];
 751 }
 752 - (id) initWithAllocator: (id) allocator {
 753 // CHECK:    define internal i8* @"\01-[Test29 initWithAllocator:]"(
 754 // CHECK:      [[RET:%.*]] = alloca i8*, align 8
 755 // CHECK-NEXT: [[SELF:%.*]] = alloca [[TEST29]]*, align 8
 756 // CHECK-NEXT: [[CMD:%.*]] = alloca i8*, align 8
 757 // CHECK-NEXT: [[ALLOCATOR:%.*]] = alloca i8*, align 8
 758 // CHECK-NEXT: alloca
 759 // CHECK-NEXT: [[CLEANUP:%.*]] = alloca i32
 760 // CHECK-NEXT: store [[TEST29]]* {{%.*}}, [[TEST29]]** [[SELF]]
 761 // CHECK-NEXT: store i8* {{%.*}}, i8** [[CMD]]
 762 // CHECK-NEXT: [[T0:%.*]] = call i8* @objc_retain(i8* {{%.*}})
 763 // CHECK-NEXT: store i8* [[T0]], i8** [[ALLOCATOR]]
 764
 765 // Evaluate arguments.  Note that the send argument is evaluated
 766 // before the zeroing of self.
 767 // CHECK-NEXT: [[T0:%.*]] = load [[TEST29]]** [[SELF]]
 768 // CHECK-NEXT: [[T1:%.*]] = load i8** [[ALLOCATOR]], align 8
 769
 770 // Implicit null of 'self', i.e. direct transfer of ownership.
 771 // CHECK-NEXT: store [[TEST29]]* null, [[TEST29]]** [[SELF]]
 772
 773 // Actual message send.
 774 // CHECK:      [[CALL:%.*]] = call {{.*}} @objc_msgSendSuper2
 775
 776 // Implicit write of result back into 'self'.  This is not supposed to
 777 // be detectable because we're supposed to ban accesses to the old
 778 // self value past the delegate init call.
 779 // CHECK-NEXT: [[T0:%.*]] = bitcast i8* [[CALL]] to [[TEST29]]*
 780 // CHECK-NEXT: store [[TEST29]]* [[T0]], [[TEST29]]** [[SELF]]
 781
 782 // Assignment.
 783 // CHECK-NEXT: [[T0:%.*]] = bitcast i8* [[CALL]] to [[TEST29]]*
 784 // CHECK-NEXT: [[T1:%.*]] = bitcast [[TEST29]]* [[T0]] to i8*
 785 // CHECK-NEXT: [[T2:%.*]] = call i8* @objc_retain(i8* [[T1]]) nounwind
 786 // CHECK-NEXT: [[T3:%.*]] = bitcast i8* [[T2]] to [[TEST29]]*
 787 // CHECK-NEXT: [[T4:%.*]] = load [[TEST29]]** [[SELF]], align
 788 // CHECK-NEXT: store [[TEST29]]* [[T3]], [[TEST29]]** [[SELF]], align
 789 // CHECK-NEXT: [[T5:%.*]] = bitcast [[TEST29]]* [[T4]] to i8*
 790 // CHECK-NEXT: call void @objc_release(i8* [[T5]])
 791
 792 // Return statement.
 793 // CHECK-NEXT: [[T0:%.*]] = load [[TEST29]]** [[SELF]]
 794 // CHECK-NEXT: [[T1:%.*]] = bitcast [[TEST29]]* [[T0]] to i8*
 795 // CHECK-NEXT: [[T2:%.*]] = call i8* @objc_retain(i8* [[T1]]) nounwind
 796 // CHECK-NEXT: [[T3:%.*]] = bitcast i8* [[T2]]
 797 // CHECK-NEXT: [[T2:%.*]] = bitcast
 798 // CHECK-NEXT: store i8* [[T2]], i8** [[RET]]
 799 // CHECK-NEXT: store i32 1, i32* [[CLEANUP]]
 800
 801 // Cleanup.
 802 // CHECK-NEXT: [[T0:%.*]] = load i8** [[ALLOCATOR]]
 803 // CHECK-NEXT: call void @objc_release(i8* [[T0]]) nounwind, !clang.imprecise_release
 804
 805 // CHECK-NEXT: [[T0:%.*]] = load [[TEST29]]** [[SELF]]
 806 // CHECK-NEXT: [[T1:%.*]] = bitcast [[TEST29]]* [[T0]] to i8*
 807 // CHECK-NEXT: call void @objc_release(i8* [[T1]]) nounwind, !clang.imprecise_release
 808
 809 // Return.
 810 // CHECK-NEXT: [[T0:%.*]] = load i8** [[RET]]
 811 // CHECK-NEXT: ret i8* [[T0]]
 812   self = [super initWithAllocator: allocator];
 813   return self;
 814 }
 815 @end
 816
 817 typedef struct Test30_helper Test30_helper;
 818 @interface Test30
 819 - (id) init;
 820 - (Test30_helper*) initHelper;
 821 @end
 822 @implementation Test30 {
 823 char *helper;
 824 }
 825 - (id) init {
 826 // CHECK:    define internal i8* @"\01-[Test30 init]"([[TEST30:%.*]]* {{%.*}},
 827 // CHECK:      [[RET:%.*]] = alloca i8*
 828 // CHECK-NEXT: [[SELF:%.*]] = alloca [[TEST30]]*
 829 // CHECK-NEXT: alloca i8*
 830 // CHECK-NEXT: alloca i32
 831 // CHECK-NEXT: store [[TEST30]]* {{%.*}}, [[TEST30]]** [[SELF]]
 832 // CHECK-NEXT: store
 833
 834 // Call.
 835 // CHECK-NEXT: [[T0:%.*]] = load [[TEST30]]** [[SELF]]
 836 // CHECK-NEXT: [[T1:%.*]] = load i8** @"\01L_OBJC_SELECTOR_REFERENCES_
 837 // CHECK-NEXT: [[T2:%.*]] = bitcast [[TEST30]]* [[T0]] to i8*
 838 // CHECK-NEXT: [[CALL:%.*]] = call [[TEST30_HELPER:%.*]]* bitcast {{.*}} @objc_msgSend {{.*}}(i8* [[T2]], i8* [[T1]])
 839
 840 // Assignment.
 841 // CHECK-NEXT: [[T0:%.*]] = bitcast [[TEST30_HELPER]]* [[CALL]] to i8*
 842 // CHECK-NEXT: [[T1:%.*]] = load [[TEST30]]** [[SELF]]
 843 // CHECK-NEXT: [[IVAR:%.*]] = load i64* @"OBJC_IVAR_$_Test30.helper"
 844 // CHECK-NEXT: [[T2:%.*]] = bitcast [[TEST30]]* [[T1]] to i8*
 845 // CHECK-NEXT: [[T3:%.*]] = getelementptr inbounds i8* [[T2]], i64 [[IVAR]]
 846 // CHECK-NEXT: [[T4:%.*]] = bitcast i8* [[T3]] to i8**
 847 // CHECK-NEXT#: [[T5:%.*]] = load i8** [[T4]]
 848 // CHECK-NEXT#: [[T6:%.*]] = call i8* @objc_retain(i8* [[T0]])
 849 // CHECK-NEXT#: call void @objc_release(i8* [[T5]])
 850 // CHECK-NEXT: store i8* [[T0]], i8** [[T4]]
 851
 852 // Return.
 853 // CHECK-NEXT: [[T0:%.*]] = load [[TEST30]]** [[SELF]]
 854 // CHECK-NEXT: [[T1:%.*]] = bitcast [[TEST30]]* [[T0]] to i8*
 855 // CHECK-NEXT: [[T2:%.*]] = call i8* @objc_retain(i8* [[T1]])
 856 // CHECK-NEXT: [[T3:%.*]] = bitcast i8* [[T2]]
 857 // CHECK-NEXT: [[T2:%.*]] = bitcast
 858 // CHECK-NEXT: store i8* [[T2]], i8** [[RET]]
 859 // CHECK-NEXT: store i32 1
 860
 861 // Cleanup.
 862 // CHECK-NEXT: [[T0:%.*]] = load [[TEST30]]** [[SELF]]
 863 // CHECK-NEXT: [[T1:%.*]] = bitcast [[TEST30]]* [[T0]] to i8*
 864 // CHECK-NEXT: call void @objc_release(i8* [[T1]])
 865
 866 // Epilogue.
 867 // CHECK-NEXT: [[T0:%.*]] = load i8** [[RET]]
 868 // CHECK-NEXT: ret i8* [[T0]]
 869   self->helper = [self initHelper];
 870   return self;
 871 }
 872 - (Test30_helper*) initHelper {
 873 // CHECK:    define internal [[TEST30_HELPER]]* @"\01-[Test30 initHelper]"(
 874 // CHECK:      alloca
 875 // CHECK-NEXT: alloca
 876 // CHECK-NEXT: store
 877 // CHECK-NEXT: store
 878 // CHECK-NEXT: ret [[TEST30_HELPER]]* null
 879   return 0;
 880 }
 881
 882 @end
 883
 884 void test31(id x) {
 885 // CHECK:    define void @test31(
 886 // CHECK:      [[X:%.*]] = alloca i8*,
 887 // CHECK-NEXT: [[BLOCK:%.*]] = alloca [[BLOCK_T:<{.*}>]],
 888 // CHECK-NEXT: [[PARM:%.*]] = call i8* @objc_retain(i8* {{%.*}})
 889 // CHECK-NEXT: store i8* [[PARM]], i8** [[X]]
 890 // CHECK:      [[SLOT:%.*]] = getelementptr inbounds [[BLOCK_T]]* [[BLOCK]], i32 0, i32 5
 891 // CHECK-NEXT: [[T0:%.*]] = load i8** [[X]],
 892 // CHECK-NEXT: [[T1:%.*]] = call i8* @objc_retain(i8* [[T0]])
 893 // CHECK-NEXT: store i8* [[T1]], i8** [[SLOT]],
 894 // CHECK-NEXT: bitcast
 895 // CHECK-NEXT: call void @test31_helper(
 896 // CHECK-NEXT: [[T0:%.*]] = load i8** [[SLOT]]
 897 // CHECK-NEXT: call void @objc_release(i8* [[T0]]) nounwind, !clang.imprecise_release
 898 // CHECK-NEXT: [[T0:%.*]] = load i8** [[X]]
 899 // CHECK-NEXT: call void @objc_release(i8* [[T0]]) nounwind, !clang.imprecise_release
 900 // CHECK-NEXT: ret void
 901   extern void test31_helper(id (^)(void));
 902   test31_helper(^{ return x; });
 903 }
 904
 905 __attribute__((ns_returns_retained)) id test32(void) {
 906 // CHECK:    define i8* @test32()
 907 // CHECK:      [[CALL:%.*]] = call i8* @test32_helper()
 908 // CHECK-NEXT: [[T0:%.*]] = call i8* @objc_retainAutoreleasedReturnValue(i8* [[CALL]])
 909 // CHECK-NEXT: ret i8* [[T0]]
 910   extern id test32_helper(void);
 911   return test32_helper();
 912 }
 913
 914 @class Test33_a;
 915 @interface Test33
 916 - (void) give: (Test33_a **) x;
 917 - (void) take: (Test33_a **) x;
 918 - (void) giveStrong: (out __strong Test33_a **) x;
 919 - (void) takeStrong: (inout __strong Test33_a **) x;
 920 - (void) giveOut: (out Test33_a **) x;
 921 @end
 922 void test33(Test33 *ptr) {
 923   Test33_a *a;
 924   [ptr give: &a];
 925   [ptr take: &a];
 926   [ptr giveStrong: &a];
 927   [ptr takeStrong: &a];
 928   [ptr giveOut: &a];
 929
 930   // CHECK:    define void @test33([[TEST33:%.*]]*
 931   // CHECK:      [[PTR:%.*]] = alloca [[TEST33]]*
 932   // CHECK-NEXT: [[A:%.*]] = alloca [[A_T:%.*]]*
 933   // CHECK-NEXT: [[TEMP0:%.*]] = alloca [[A_T]]*
 934   // CHECK-NEXT: [[TEMP1:%.*]] = alloca [[A_T]]*
 935   // CHECK-NEXT: [[TEMP2:%.*]] = alloca [[A_T]]*
 936   // CHECK-NEXT: bitcast
 937   // CHECK-NEXT: objc_retain
 938   // CHECK-NEXT: bitcast
 939   // CHECK-NEXT: store
 940   // CHECK-NEXT: store [[A_T]]* null, [[A_T]]** [[A]]
 941
 942   // CHECK-NEXT: load [[TEST33]]** [[PTR]]
 943   // CHECK-NEXT: [[T0:%.*]] = load [[A_T]]** [[A]]
 944   // CHECK-NEXT: store [[A_T]]* [[T0]], [[A_T]]** [[TEMP0]]
 945   // CHECK-NEXT: load i8** @"\01L_OBJC_SELECTOR_REFERENCES_
 946   // CHECK-NEXT: bitcast
 947   // CHECK-NEXT: objc_msgSend{{.*}}, [[A_T]]** [[TEMP0]])
 948   // CHECK-NEXT: [[T0:%.*]] = load [[A_T]]** [[TEMP0]]
 949   // CHECK-NEXT: [[T1:%.*]] = bitcast [[A_T]]* [[T0]] to i8*
 950   // CHECK-NEXT: [[T2:%.*]] = call i8* @objc_retain(i8* [[T1]])
 951   // CHECK-NEXT: [[T3:%.*]] = bitcast i8* [[T2]] to [[A_T]]*
 952   // CHECK-NEXT: [[T4:%.*]] = load [[A_T]]** [[A]]
 953   // CHECK-NEXT: store [[A_T]]* [[T3]], [[A_T]]** [[A]]
 954   // CHECK-NEXT: [[T5:%.*]] = bitcast [[A_T]]* [[T4]] to i8*
 955   // CHECK-NEXT: call void @objc_release(i8* [[T5]])
 956
 957   // CHECK-NEXT: load [[TEST33]]** [[PTR]]
 958   // CHECK-NEXT: [[T0:%.*]] = load [[A_T]]** [[A]]
 959   // CHECK-NEXT: store [[A_T]]* [[T0]], [[A_T]]** [[TEMP1]]
 960   // CHECK-NEXT: load i8** @"\01L_OBJC_SELECTOR_REFERENCES_
 961   // CHECK-NEXT: bitcast
 962   // CHECK-NEXT: objc_msgSend{{.*}}, [[A_T]]** [[TEMP1]])
 963   // CHECK-NEXT: [[T0:%.*]] = load [[A_T]]** [[TEMP1]]
 964   // CHECK-NEXT: [[T1:%.*]] = bitcast [[A_T]]* [[T0]] to i8*
 965   // CHECK-NEXT: [[T2:%.*]] = call i8* @objc_retain(i8* [[T1]])
 966   // CHECK-NEXT: [[T3:%.*]] = bitcast i8* [[T2]] to [[A_T]]*
 967   // CHECK-NEXT: [[T4:%.*]] = load [[A_T]]** [[A]]
 968   // CHECK-NEXT: store [[A_T]]* [[T3]], [[A_T]]** [[A]]
 969   // CHECK-NEXT: [[T5:%.*]] = bitcast [[A_T]]* [[T4]] to i8*
 970   // CHECK-NEXT: call void @objc_release(i8* [[T5]])
 971
 972   // CHECK-NEXT: load [[TEST33]]** [[PTR]]
 973   // CHECK-NEXT: load i8** @"\01L_OBJC_SELECTOR_REFERENCES_
 974   // CHECK-NEXT: bitcast
 975   // CHECK-NEXT: objc_msgSend{{.*}}, [[A_T]]** [[A]])
 976
 977   // CHECK-NEXT: load [[TEST33]]** [[PTR]]
 978   // CHECK-NEXT: load i8** @"\01L_OBJC_SELECTOR_REFERENCES_
 979   // CHECK-NEXT: bitcast
 980   // CHECK-NEXT: objc_msgSend{{.*}}, [[A_T]]** [[A]])
 981
 982   // 'out'
 983   // CHECK-NEXT: load [[TEST33]]** [[PTR]]
 984   // CHECK-NEXT: store [[A_T]]* null, [[A_T]]** [[TEMP2]]
 985   // CHECK-NEXT: load i8** @"\01L_OBJC_SELECTOR_REFERENCES_
 986   // CHECK-NEXT: bitcast
 987   // CHECK-NEXT: objc_msgSend{{.*}}, [[A_T]]** [[TEMP2]])
 988   // CHECK-NEXT: [[T0:%.*]] = load [[A_T]]** [[TEMP2]]
 989   // CHECK-NEXT: [[T1:%.*]] = bitcast [[A_T]]* [[T0]] to i8*
 990   // CHECK-NEXT: [[T2:%.*]] = call i8* @objc_retain(i8* [[T1]])
 991   // CHECK-NEXT: [[T3:%.*]] = bitcast i8* [[T2]] to [[A_T]]*
 992   // CHECK-NEXT: [[T4:%.*]] = load [[A_T]]** [[A]]
 993   // CHECK-NEXT: store [[A_T]]* [[T3]], [[A_T]]** [[A]]
 994   // CHECK-NEXT: [[T5:%.*]] = bitcast [[A_T]]* [[T4]] to i8*
 995   // CHECK-NEXT: call void @objc_release(i8* [[T5]])
 996
 997   // CHECK-NEXT: load
 998   // CHECK-NEXT: bitcast
 999   // CHECK-NEXT: objc_release
1000   // CHECK-NEXT: load
1001   // CHECK-NEXT: bitcast
1002   // CHECK-NEXT: objc_release
1003   // CHECK-NEXT: ret void
1004 }
1005
1006 void test34(int cond) {
1007   __strong id strong;
1008   __weak id weak;
1009   extern void test34_sink(id *);
1010   test34_sink(cond ? &strong : 0);
1011   test34_sink(cond ? &weak : 0);
1012
1013   // CHECK:    define void @test34(
1014   // CHECK:      [[COND:%.*]] = alloca i32
1015   // CHECK-NEXT: [[STRONG:%.*]] = alloca i8*
1016   // CHECK-NEXT: [[WEAK:%.*]] = alloca i8*
1017   // CHECK-NEXT: [[TEMP1:%.*]] = alloca i8*
1018   // CHECK-NEXT: [[TEMP2:%.*]] = alloca i8*
1019   // CHECK-NEXT: store i32
1020   // CHECK-NEXT: store i8* null, i8** [[STRONG]]
1021   // CHECK-NEXT: call i8* @objc_initWeak(i8** [[WEAK]], i8* null)
1022
1023   // CHECK-NEXT: [[T0:%.*]] = load i32* [[COND]]
1024   // CHECK-NEXT: [[T1:%.*]] = icmp ne i32 [[T0]], 0
1025   // CHECK:      [[ARG:%.*]] = phi i8**
1026   // CHECK-NEXT: [[T0:%.*]] = icmp eq i8** [[ARG]], null
1027   // CHECK-NEXT: [[T1:%.*]] = select i1 [[T0]], i8** null, i8** [[TEMP1]]
1028   // CHECK-NEXT: br i1 [[T0]],
1029   // CHECK:      [[T0:%.*]] = load i8** [[ARG]]
1030   // CHECK-NEXT: store i8* [[T0]], i8** [[TEMP1]]
1031   // CHECK-NEXT: br label
1032   // CHECK:      call void @test34_sink(i8** [[T1]])
1033   // CHECK-NEXT: [[T0:%.*]] = icmp eq i8** [[ARG]], null
1034   // CHECK-NEXT: br i1 [[T0]],
1035   // CHECK:      [[T0:%.*]] = load i8** [[TEMP1]]
1036   // CHECK-NEXT: [[T1:%.*]] = call i8* @objc_retain(i8* [[T0]])
1037   // CHECK-NEXT: [[T2:%.*]] = load i8** [[ARG]]
1038   // CHECK-NEXT: store i8* [[T1]], i8** [[ARG]]
1039   // CHECK-NEXT: call void @objc_release(i8* [[T2]])
1040   // CHECK-NEXT: br label
1041
1042   // CHECK:      [[T0:%.*]] = load i32* [[COND]]
1043   // CHECK-NEXT: [[T1:%.*]] = icmp ne i32 [[T0]], 0
1044   // CHECK:      [[ARG:%.*]] = phi i8**
1045   // CHECK-NEXT: [[T0:%.*]] = icmp eq i8** [[ARG]], null
1046   // CHECK-NEXT: [[T1:%.*]] = select i1 [[T0]], i8** null, i8** [[TEMP2]]
1047   // CHECK-NEXT: br i1 [[T0]],
1048   // CHECK:      [[T0:%.*]] = call i8* @objc_loadWeak(i8** [[ARG]])
1049   // CHECK-NEXT: store i8* [[T0]], i8** [[TEMP2]]
1050   // CHECK-NEXT: br label
1051   // CHECK:      call void @test34_sink(i8** [[T1]])
1052   // CHECK-NEXT: [[T0:%.*]] = icmp eq i8** [[ARG]], null
1053   // CHECK-NEXT: br i1 [[T0]],
1054   // CHECK:      [[T0:%.*]] = load i8** [[TEMP2]]
1055   // CHECK-NEXT: call i8* @objc_storeWeak(i8** [[ARG]], i8* [[T0]])
1056   // CHECK-NEXT: br label
1057
1058   // CHECK:      call void @objc_destroyWeak(i8** [[WEAK]])
1059   // CHECK:      ret void
1060 }
1061
1062 void test35(void (^sink)(id*)) {
1063   __strong id strong;
1064   sink(&strong);
1065
1066   // CHECK:    define void @test35(
1067   // CHECK:      [[SINK:%.*]] = alloca void (i8**)*
1068   // CHECK-NEXT: [[STRONG:%.*]] = alloca i8*
1069   // CHECK-NEXT: [[TEMP:%.*]] = alloca i8*
1070   // CHECK-NEXT: bitcast void (i8**)* {{%.*}} to i8*
1071   // CHECK-NEXT: call i8* @objc_retain(
1072   // CHECK-NEXT: bitcast i8*
1073   // CHECK-NEXT: store void (i8**)* {{%.*}}, void (i8**)** [[SINK]]
1074   // CHECK-NEXT: store i8* null, i8** [[STRONG]]
1075
1076   // CHECK-NEXT: load void (i8**)** [[SINK]]
1077   // CHECK-NEXT: bitcast
1078   // CHECK-NEXT: getelementptr
1079   // CHECK-NEXT: [[BLOCK:%.*]] = bitcast
1080   // CHECK-NEXT: [[T0:%.*]] = load i8** [[STRONG]]
1081   // CHECK-NEXT: store i8* [[T0]], i8** [[TEMP1]]
1082   // CHECK-NEXT: [[F0:%.*]] = load i8**
1083   // CHECK-NEXT: [[F1:%.*]] = bitcast i8* [[F0]] to void (i8*, i8**)*
1084   // CHECK-NEXT: call void [[F1]](i8* [[BLOCK]], i8** [[TEMP1]])
1085   // CHECK-NEXT: [[T0:%.*]] = load i8** [[TEMP1]]
1086   // CHECK-NEXT: [[T1:%.*]] = call i8* @objc_retain(i8* [[T0]])
1087   // CHECK-NEXT: [[T2:%.*]] = load i8** [[STRONG]]
1088   // CHECK-NEXT: store i8* [[T1]], i8** [[STRONG]]
1089   // CHECK-NEXT: call void @objc_release(i8* [[T2]])
1090
1091   // CHECK-NEXT: [[T0:%.*]] = load i8** [[STRONG]]
1092   // CHECK-NEXT: call void @objc_release(i8* [[T0]])
1093
1094   // CHECK-NEXT: load void (i8**)** [[SINK]]
1095   // CHECK-NEXT: bitcast
1096   // CHECK-NEXT: call void @objc_release
1097   // CHECK-NEXT: ret void
1098
1099 }
1100
1101 // CHECK: define void @test36
1102 void test36(id x) {
1103   // CHECK: [[X:%.*]] = alloca i8*
1104
1105   // CHECK: call i8* @objc_retain
1106   // CHECK: call i8* @objc_retain
1107   // CHECK: call i8* @objc_retain
1108   id array[3] = { @"A", x, @"y" };
1109
1110   // CHECK:      [[T0:%.*]] = load i8** [[X]]
1111   // CHECK-NEXT: store i8* null, i8** [[X]]
1112   // CHECK-NEXT: call void @objc_release(i8* [[T0]])
1113   x = 0;
1114
1115   // CHECK: br label
1116   // CHECK: call void @objc_release
1117   // CHECK: br i1
1118
1119   // CHECK: call void @objc_release
1120   // CHECK-NEXT: ret void
1121 }
1122
1123 @class Test37;
1124 void test37(void) {
1125   extern void test37_helper(id *);
1126   Test37 *var;
1127   test37_helper(&var);
1128
1129   // CHECK:    define void @test37()
1130   // CHECK:      [[VAR:%.*]] = alloca [[TEST37:%.*]]*,
1131   // CHECK-NEXT: [[TEMP:%.*]] = alloca i8*
1132   // CHECK-NEXT: store [[TEST37]]* null, [[TEST37]]** [[VAR]]
1133
1134   // CHECK-NEXT: [[T0:%.*]] = load [[TEST37]]** [[VAR]]
1135   // CHECK-NEXT: [[T1:%.*]] = bitcast [[TEST37]]* [[T0]] to i8*
1136   // CHECK-NEXT: store i8* [[T1]], i8** [[TEMP]]
1137   // CHECK-NEXT: call void @test37_helper(i8** [[TEMP]])
1138   // CHECK-NEXT: [[T0:%.*]] = load i8** [[TEMP]]
1139   // CHECK-NEXT: [[T1:%.*]] = bitcast i8* [[T0]] to [[TEST37]]*
1140   // CHECK-NEXT: [[T2:%.*]] = bitcast [[TEST37]]* [[T1]] to i8*
1141   // CHECK-NEXT: [[T3:%.*]] = call i8* @objc_retain(i8* [[T2]])
1142   // CHECK-NEXT: [[T4:%.*]] = bitcast i8* [[T3]] to [[TEST37]]*
1143   // CHECK-NEXT: [[T5:%.*]] = load [[TEST37]]** [[VAR]]
1144   // CHECK-NEXT: store [[TEST37]]* [[T4]], [[TEST37]]** [[VAR]]
1145   // CHECK-NEXT: [[T6:%.*]] = bitcast [[TEST37]]* [[T5]] to i8*
1146   // CHECK-NEXT: call void @objc_release(i8* [[T6]])
1147
1148   // CHECK-NEXT: [[T0:%.*]] = load [[TEST37]]** [[VAR]]
1149   // CHECK-NEXT: [[T1:%.*]] = bitcast [[TEST37]]* [[T0]] to i8*
1150   // CHECK-NEXT: call void @objc_release(i8* [[T1]])
1151   // CHECK-NEXT: ret void
1152 }
1153
1154 void test38(void) {
1155   id test38_source(void);
1156   void test38_helper(void (^)(void));
1157   __block id var = test38_source();
1158   test38_helper(^{ var = 0; });
1159
1160   // CHECK:    define void @test38()
1161   // CHECK:      [[VAR:%.*]] = alloca [[BYREF_T:%.*]],
1162   // CHECK-NEXT: [[BLOCK:%.*]] = alloca [[BLOCK_T:<{.*}>]],
1163   // CHECK:      [[T0:%.*]] = getelementptr inbounds [[BYREF_T]]* [[VAR]], i32 0, i32 2
1164   // 0x02000000 - has copy/dispose helpers
1165   // CHECK-NEXT: store i32 33554432, i32* [[T0]]
1166   // CHECK:      [[SLOT:%.*]] = getelementptr inbounds [[BYREF_T]]* [[VAR]], i32 0, i32 6
1167   // CHECK-NEXT: [[T0:%.*]] = call i8* @test38_source()
1168   // CHECK-NEXT: [[T1:%.*]] = call i8* @objc_retainAutoreleasedReturnValue(i8* [[T0]])
1169   // CHECK-NEXT: store i8* [[T1]], i8** [[SLOT]]
1170   // CHECK-NEXT: [[SLOT:%.*]] = getelementptr inbounds [[BYREF_T]]* [[VAR]], i32 0, i32 6
1171   // 0x42000000 - has signature, copy/dispose helpers
1172   // CHECK:      store i32 1107296256,
1173   // CHECK:      [[T0:%.*]] = bitcast [[BYREF_T]]* [[VAR]] to i8*
1174   // CHECK-NEXT: store i8* [[T0]], i8**
1175   // CHECK:      call void @test38_helper(
1176   // CHECK:      [[T0:%.*]] = bitcast [[BYREF_T]]* [[VAR]] to i8*
1177   // CHECK-NEXT: call void @_Block_object_dispose(i8* [[T0]], i32 8)
1178   // CHECK-NEXT: [[T0:%.*]] = load i8** [[SLOT]]
1179   // CHECK-NEXT: call void @objc_release(i8* [[T0]])
1180   // CHECK-NEXT: ret void
1181
1182   // CHECK:    define internal void @__Block_byref_object_copy_
1183   // CHECK:      [[T0:%.*]] = getelementptr inbounds [[BYREF_T]]* {{%.*}}, i32 0, i32 6
1184   // CHECK-NEXT: load i8**
1185   // CHECK-NEXT: bitcast i8* {{%.*}} to [[BYREF_T]]*
1186   // CHECK-NEXT: [[T1:%.*]] = getelementptr inbounds [[BYREF_T]]* {{%.*}}, i32 0, i32 6
1187   // CHECK-NEXT: [[T2:%.*]] = load i8** [[T1]]
1188   // CHECK-NEXT: store i8* [[T2]], i8** [[T0]]
1189   // CHECK-NEXT: store i8* null, i8** [[T1]]
1190
1191   // CHECK:    define internal void @__Block_byref_object_dispose_
1192   // CHECK:      [[T0:%.*]] = getelementptr inbounds [[BYREF_T]]* {{%.*}}, i32 0, i32 6
1193   // CHECK-NEXT: [[T1:%.*]] = load i8** [[T0]]
1194   // CHECK-NEXT: call void @objc_release(i8* [[T1]])
1195
1196   // CHECK:    define internal void @__test38_block_invoke_
1197   // CHECK:      [[SLOT:%.*]] = getelementptr inbounds {{.*}}, i32 0, i32 6
1198   // CHECK-NEXT: [[T0:%.*]] = load i8** [[SLOT]], align 8
1199   // CHECK-NEXT: store i8* null, i8** [[SLOT]],
1200   // CHECK-NEXT: call void @objc_release(i8* [[T0]])
1201   // CHECK-NEXT: ret void
1202
1203   // CHECK:    define internal void @__copy_helper_block_
1204   // CHECK:      call void @_Block_object_assign(i8* {{%.*}}, i8* {{%.*}}, i32 8)
1205
1206   // CHECK:    define internal void @__destroy_helper_block_
1207   // CHECK:      call void @_Block_object_dispose(i8* {{%.*}}, i32 8)
1208 }
1209
1210 void test39(void) {
1211   extern id test39_source(void);
1212   void test39_helper(void (^)(void));
1213   __unsafe_unretained id var = test39_source();
1214   test39_helper(^{ (void) var; });
1215
1216   // CHECK:    define void @test39()
1217   // CHECK:      [[VAR:%.*]] = alloca i8*
1218   // CHECK-NEXT: [[BLOCK:%.*]] = alloca [[BLOCK_T:<{.*}>]],
1219   // CHECK: [[T0:%.*]] = call i8* @test39_source()
1220   // CHECK-NEXT: [[T1:%.*]] = call i8* @objc_retainAutoreleasedReturnValue(i8* [[T0]])
1221   // CHECK-NEXT: store i8* [[T1]], i8** [[VAR]],
1222   // CHECK-NEXT: call void @objc_release(i8* [[T1]])
1223   // 0x40000000 - has signature but no copy/dispose
1224   // CHECK:      store i32 1073741824, i32*
1225   // CHECK:      [[CAPTURE:%.*]] = getelementptr inbounds [[BLOCK_T]]* [[BLOCK]], i32 0, i32 5
1226   // CHECK-NEXT: [[T0:%.*]] = load i8** [[VAR]]
1227   // CHECK-NEXT: store i8* [[T0]], i8** [[CAPTURE]]
1228   // CHECK-NEXT: [[T0:%.*]] = bitcast [[BLOCK_T]]* [[BLOCK]] to
1229   // CHECK: call void @test39_helper
1230   // CHECK-NEXT: ret void
1231 }
1232
1233 void test40(void) {
1234   id test40_source(void);
1235   void test40_helper(void (^)(void));
1236   __block __weak id var = test40_source();
1237   test40_helper(^{ var = 0; });
1238
1239   // CHECK:    define void @test40()
1240   // CHECK:      [[VAR:%.*]] = alloca [[BYREF_T:%.*]],
1241   // CHECK-NEXT: [[BLOCK:%.*]] = alloca [[BLOCK_T:<{.*}>]],
1242   // CHECK:      [[T0:%.*]] = getelementptr inbounds [[BYREF_T]]* [[VAR]], i32 0, i32 2
1243   // 0x02000000 - has copy/dispose helpers
1244   // CHECK-NEXT: store i32 33554432, i32* [[T0]]
1245   // CHECK:      [[SLOT:%.*]] = getelementptr inbounds [[BYREF_T]]* [[VAR]], i32 0, i32 6
1246   // CHECK-NEXT: [[T0:%.*]] = call i8* @test40_source()
1247   // CHECK-NEXT: [[T1:%.*]] = call i8* @objc_retainAutoreleasedReturnValue(i8* [[T0]])
1248   // CHECK-NEXT: call i8* @objc_initWeak(i8** [[SLOT]], i8* [[T1]])
1249   // CHECK-NEXT: call void @objc_release(i8* [[T1]])
1250   // CHECK-NEXT: [[SLOT:%.*]] = getelementptr inbounds [[BYREF_T]]* [[VAR]], i32 0, i32 6
1251   // 0x42000000 - has signature, copy/dispose helpers
1252   // CHECK:      store i32 1107296256,
1253   // CHECK:      [[T0:%.*]] = bitcast [[BYREF_T]]* [[VAR]] to i8*
1254   // CHECK-NEXT: store i8* [[T0]], i8**
1255   // CHECK:      call void @test40_helper(
1256   // CHECK:      [[T0:%.*]] = bitcast [[BYREF_T]]* [[VAR]] to i8*
1257   // CHECK-NEXT: call void @_Block_object_dispose(i8* [[T0]], i32 8)
1258   // CHECK-NEXT: call void @objc_destroyWeak(i8** [[SLOT]])
1259   // CHECK-NEXT: ret void
1260
1261   // CHECK:    define internal void @__Block_byref_object_copy_
1262   // CHECK:      [[T0:%.*]] = getelementptr inbounds [[BYREF_T]]* {{%.*}}, i32 0, i32 6
1263   // CHECK-NEXT: load i8**
1264   // CHECK-NEXT: bitcast i8* {{%.*}} to [[BYREF_T]]*
1265   // CHECK-NEXT: [[T1:%.*]] = getelementptr inbounds [[BYREF_T]]* {{%.*}}, i32 0, i32 6
1266   // CHECK-NEXT: call void @objc_moveWeak(i8** [[T0]], i8** [[T1]])
1267
1268   // CHECK:    define internal void @__Block_byref_object_dispose_
1269   // CHECK:      [[T0:%.*]] = getelementptr inbounds [[BYREF_T]]* {{%.*}}, i32 0, i32 6
1270   // CHECK-NEXT: call void @objc_destroyWeak(i8** [[T0]])
1271
1272   // CHECK:    define internal void @__test40_block_invoke_
1273   // CHECK:      [[SLOT:%.*]] = getelementptr inbounds {{.*}}, i32 0, i32 6
1274   // CHECK-NEXT: call i8* @objc_storeWeak(i8** [[SLOT]], i8* null)
1275   // CHECK-NEXT: ret void
1276
1277   // CHECK:    define internal void @__copy_helper_block_
1278   // 0x8 - FIELD_IS_BYREF (no FIELD_IS_WEAK because clang in control)
1279   // CHECK:      call void @_Block_object_assign(i8* {{%.*}}, i8* {{%.*}}, i32 8)
1280
1281   // CHECK:    define internal void @__destroy_helper_block_
1282   // 0x8 - FIELD_IS_BYREF (no FIELD_IS_WEAK because clang in control)
1283   // CHECK:      call void @_Block_object_dispose(i8* {{%.*}}, i32 8)
1284 }
1285
1286 void test41(void) {
1287   id test41_source(void);
1288   void test41_helper(void (^)(void));
1289   void test41_consume(id);
1290   __weak id var = test41_source();
1291   test41_helper(^{ test41_consume(var); });
1292
1293   // CHECK:    define void @test41()
1294   // CHECK:      [[VAR:%.*]] = alloca i8*,
1295   // CHECK-NEXT: [[BLOCK:%.*]] = alloca [[BLOCK_T:<{.*}>]],
1296   // CHECK:      [[T0:%.*]] = call i8* @test41_source()
1297   // CHECK-NEXT: [[T1:%.*]] = call i8* @objc_retainAutoreleasedReturnValue(i8* [[T0]])
1298   // CHECK-NEXT: call i8* @objc_initWeak(i8** [[VAR]], i8* [[T1]])
1299   // CHECK-NEXT: call void @objc_release(i8* [[T1]])
1300   // 0x42000000 - has signature, copy/dispose helpers
1301   // CHECK:      store i32 1107296256,
1302   // CHECK:      [[SLOT:%.*]] = getelementptr inbounds [[BLOCK_T]]* [[BLOCK]], i32 0, i32 5
1303   // CHECK-NEXT: [[T0:%.*]] = call i8* @objc_loadWeak(i8** [[VAR]])
1304   // CHECK-NEXT: call i8* @objc_initWeak(i8** [[SLOT]], i8* [[T0]])
1305   // CHECK:      call void @test41_helper(
1306   // CHECK-NEXT: call void @objc_destroyWeak(i8** [[SLOT]])
1307   // CHECK-NEXT: call void @objc_destroyWeak(i8** [[VAR]])
1308   // CHECK-NEXT: ret void
1309
1310   // CHECK:    define internal void @__test41_block_invoke_
1311   // CHECK:      [[SLOT:%.*]] = getelementptr inbounds [[BLOCK_T]]* {{%.*}}, i32 0, i32 5
1312   // CHECK-NEXT: [[T0:%.*]] = call i8* @objc_loadWeak(i8** [[SLOT]])
1313   // CHECK-NEXT: call void @test41_consume(i8* [[T0]])
1314   // CHECK-NEXT: ret void
1315
1316   // CHECK:    define internal void @__copy_helper_block_
1317   // CHECK:      getelementptr
1318   // CHECK-NEXT: getelementptr
1319   // CHECK-NEXT: call void @objc_copyWeak(
1320
1321   // CHECK:    define internal void @__destroy_helper_block_
1322   // CHECK:      getelementptr
1323   // CHECK-NEXT: call void @objc_destroyWeak(
1324 }
1325
1326 @interface Test42 @end
1327 @implementation Test42
1328 - (void) test {
1329 // CHECK:    define internal void @"\01-[Test42 test]"
1330 // CHECK:      [[SELF:%.*]] = alloca [[TEST42:%.*]]*,
1331 // CHECK-NEXT: alloca i8*
1332 // CHECK-NEXT: [[BLOCK:%.*]] = alloca [[BLOCK_T:<{.*}>]],
1333 // CHECK: store
1334 // CHECK-NEXT: store
1335 // CHECK:      [[T0:%.*]] = getelementptr inbounds [[BLOCK_T]]* [[BLOCK]], i32 0, i32 5
1336 // CHECK-NEXT: [[T1:%.*]] = load [[TEST42]]** [[SELF]],
1337 // CHECK-NEXT: [[T2:%.*]] = bitcast [[TEST42]]* [[T1]] to i8*
1338 // CHECK-NEXT: [[T3:%.*]] = call i8* @objc_retain(i8* [[T2]])
1339 // CHECK-NEXT: [[T4:%.*]] = bitcast i8* [[T3]] to [[TEST42]]*
1340 // CHECK-NEXT: store [[TEST42]]* [[T4]], [[TEST42]]** [[T0]]
1341 // CHECK-NEXT: bitcast [[BLOCK_T]]* [[BLOCK]] to
1342 // CHECK: call void @test42_helper(
1343 // CHECK-NEXT: [[T1:%.*]] = load [[TEST42]]** [[T0]]
1344 // CHECK-NEXT: [[T2:%.*]] = bitcast [[TEST42]]* [[T1]] to i8*
1345 // CHECK-NEXT: call void @objc_release(i8* [[T2]])
1346 // CHECK-NEXT: ret void
1347
1348   extern void test42_helper(void (^)(void));
1349   test42_helper(^{ (void) self; });
1350 }
1351 @end
1352
1353 @interface Test43 @end
1354 @implementation Test43
1355 - (id) test __attribute__((ns_returns_retained)) {
1356   extern id test43_produce(void);
1357   return test43_produce();
1358   // CHECK:      call i8* @test43_produce()
1359   // CHECK-NEXT: call i8* @objc_retainAutoreleasedReturnValue(
1360   // CHECK-NEXT: ret
1361 }
1362 @end
1363
1364 id test44(void) {
1365   typedef id __attribute__((ns_returns_retained)) blocktype(void);
1366   extern test44_consume_block(blocktype^);
1367   return ^blocktype {
1368       extern id test44_produce(void);
1369       return test44_produce();
1370   }();
1371
1372 // CHECK:    define i8* @test44(
1373 // CHECK:      load i8** getelementptr
1374 // CHECK-NEXT: bitcast i8*
1375 // CHECK-NEXT: call i8*
1376 // CHECK-NEXT: call i8* @objc_autoreleaseReturnValue
1377 // CHECK-NEXT: ret i8*
1378
1379 // CHECK:      call i8* @test44_produce()
1380 // CHECK-NEXT: call i8* @objc_retain
1381 // CHECK-NEXT: ret i8*
1382 }
1383
1384 @interface Test45
1385 @property (retain) id x;
1386 @end
1387 @implementation Test45
1388 @synthesize x;
1389 @end
1390 // CHECK:    define internal i8* @"\01-[Test45 x]"(
1391 // CHECK:      [[CALL:%.*]] = call i8* @objc_getProperty(
1392 // CHECK-NEXT: ret i8* [[CALL]]
1393
1394 // rdar://problem/9315552
1395 void test46(__weak id *wp, __weak volatile id *wvp) {
1396   extern id test46_helper(void);
1397
1398   // TODO: this is sub-optimal, we should retain at the actual call site.
1399
1400   // CHECK:      [[T0:%.*]] = call i8* @test46_helper()
1401   // CHECK-NEXT: [[T1:%.*]] = call i8* @objc_retainAutoreleasedReturnValue(i8* [[T0]])
1402   // CHECK-NEXT: [[T2:%.*]] = load i8*** {{%.*}}, align 8
1403   // CHECK-NEXT: [[T3:%.*]] = call i8* @objc_storeWeak(i8** [[T2]], i8* [[T1]])
1404   // CHECK-NEXT: [[T4:%.*]] = call i8* @objc_retain(i8* [[T3]])
1405   // CHECK-NEXT: store i8* [[T4]], i8**
1406   // CHECK-NEXT: call void @objc_release(i8* [[T1]])
1407   id x = *wp = test46_helper();
1408
1409   // CHECK:      [[T0:%.*]] = call i8* @test46_helper()
1410   // CHECK-NEXT: [[T1:%.*]] = call i8* @objc_retainAutoreleasedReturnValue(i8* [[T0]])
1411   // CHECK-NEXT: [[T2:%.*]] = load i8*** {{%.*}}, align 8
1412   // CHECK-NEXT: [[T3:%.*]] = call i8* @objc_storeWeak(i8** [[T2]], i8* [[T1]])
1413   // CHECK-NEXT: [[T4:%.*]] = call i8* @objc_retain(i8* [[T3]])
1414   // CHECK-NEXT: store i8* [[T4]], i8**
1415   // CHECK-NEXT: call void @objc_release(i8* [[T1]])
1416   id y = *wvp = test46_helper();
1417 }
1418
1419 // rdar://problem/9378887
1420 void test47(void) {
1421   extern id test47_helper(void);
1422   id x = x = test47_helper();
1423
1424   // CHECK:    define void @test47()
1425   // CHECK:      [[X:%.*]] = alloca i8*
1426   // CHECK-NEXT: store i8* null, i8** [[X]]
1427   // CHECK-NEXT: [[CALL:%.*]] = call i8* @test47_helper()
1428   // CHECK-NEXT: [[T0:%.*]] = call i8* @objc_retainAutoreleasedReturnValue(i8* [[CALL]])
1429   // CHECK-NEXT: [[T1:%.*]] = load i8** [[X]]
1430   // CHECK-NEXT: store i8* [[T0]], i8** [[X]]
1431   // CHECK-NEXT: call void @objc_release(i8* [[T1]])
1432   // CHECK-NEXT: [[T2:%.*]] = call i8* @objc_retain(i8* [[T0]])
1433   // CHECK-NEXT: [[T3:%.*]] = load i8** [[X]]
1434   // CHECK-NEXT: store i8* [[T2]], i8** [[X]]
1435   // CHECK-NEXT: call void @objc_release(i8* [[T3]])
1436   // CHECK-NEXT: [[T4:%.*]] = load i8** [[X]]
1437   // CHECK-NEXT: call void @objc_release(i8* [[T4]])
1438   // CHECK-NEXT: ret void
1439 }
1440
1441 void test48(void) {
1442   extern id test48_helper(void);
1443   __weak id x = x = test48_helper();
1444   // CHECK:    define void @test48()
1445   // CHECK:      [[X:%.*]] = alloca i8*
1446   // CHECK-NEXT: [[T0:%.*]] = call i8* @objc_initWeak(i8** [[X]], i8* null)
1447   // CHECK-NEXT: [[T1:%.*]] = call i8* @test48_helper()
1448   // CHECK-NEXT: [[T2:%.*]] = call i8* @objc_retainAutoreleasedReturnValue(i8* [[T1]])
1449   // CHECK-NEXT: [[T3:%.*]] = call i8* @objc_storeWeak(i8** [[X]], i8* [[T2]])
1450   // CHECK-NEXT: [[T4:%.*]] = call i8* @objc_storeWeak(i8** [[X]], i8* [[T3]])
1451   // CHECK-NEXT: call void @objc_release(i8* [[T2]])
1452   // CHECK-NEXT: call void @objc_destroyWeak(i8** [[X]])
1453   // CHECK-NEXT: ret void
1454 }
1455
1456 void test49(void) {
1457   extern id test49_helper(void);
1458   __autoreleasing id x = x = test49_helper();
1459   // CHECK:    define void @test49()
1460   // CHECK:      [[X:%.*]] = alloca i8*
1461   // CHECK-NEXT: store i8* null, i8** [[X]]
1462   // CHECK-NEXT: [[CALL:%.*]] = call i8* @test49_helper()
1463   // CHECK-NEXT: [[T0:%.*]] = call i8* @objc_retainAutoreleasedReturnValue(i8* [[CALL]])
1464   // CHECK-NEXT: [[T1:%.*]] = call i8* @objc_autorelease(i8* [[T0]])
1465   // CHECK-NEXT: store i8* [[T2]], i8** [[X]]
1466   // CHECK-NEXT: [[T3:%.*]] = call i8* @objc_retainAutorelease(i8* [[T1]])
1467   // CHECK-NEXT: store i8* [[T3]], i8** [[X]]
1468   // CHECK-NEXT: ret void
1469 }
1470
1471 // rdar://9380136
1472 id x();
1473 void test50(id y) {
1474   ({x();});
1475 // CHECK: [[T0:%.*]] = call i8* @objc_retain
1476 // CHECK: call void @objc_release
1477 }
1478
1479
1480 // rdar://9400762
1481 struct CGPoint {
1482   float x;
1483   float y;
1484 };
1485 typedef struct CGPoint CGPoint;
1486
1487 @interface Foo
1488 @property (assign) CGPoint point;
1489 @end
1490
1491 @implementation Foo
1492 @synthesize point;
1493 @end
1494
1495 // rdar://problem/9400398
1496 id test52(void) {
1497   id test52_helper(int) __attribute__((ns_returns_retained));
1498   return ({ int x = 5; test52_helper(x); });
1499
1500 // CHECK:    define i8* @test52()
1501 // CHECK:      [[X:%.*]] = alloca i32
1502 // CHECK-NEXT: store i32 5, i32* [[X]],
1503 // CHECK-NEXT: [[T0:%.*]] = load i32* [[X]],
1504 // CHECK-NEXT: [[T1:%.*]] = call i8* @test52_helper(i32 [[T0]])
1505 // CHECK-NEXT: [[T2:%.*]] = call i8* @objc_autoreleaseReturnValue(i8* [[T1]])
1506 // CHECK-NEXT: ret i8* [[T2]]
1507 }
1508
1509 // rdar://problem/9400644
1510 void test53(void) {
1511   id test53_helper(void);
1512   id x = ({ id y = test53_helper(); y; });
1513   (void) x;
1514 // CHECK:    define void @test53()
1515 // CHECK:      [[X:%.*]] = alloca i8*,
1516 // CHECK-NEXT: [[Y:%.*]] = alloca i8*,
1517 // CHECK-NEXT: [[T0:%.*]] = call i8* @test53_helper()
1518 // CHECK-NEXT: [[T1:%.*]] = call i8* @objc_retainAutoreleasedReturnValue(i8* [[T0]])
1519 // CHECK-NEXT: store i8* [[T1]], i8** [[Y]],
1520 // CHECK-NEXT: [[T0:%.*]] = load i8** [[Y]],
1521 // CHECK-NEXT: [[T1:%.*]] = call i8* @objc_retain(i8* [[T0]])
1522 // CHECK-NEXT: [[T2:%.*]] = load i8** [[Y]]
1523 // CHECK-NEXT: call void @objc_release(i8* [[T2]])
1524 // CHECK-NEXT: store i8* [[T1]], i8** [[X]],
1525 // CHECK-NEXT: load i8** [[X]],
1526 // CHECK-NEXT: [[T0:%.*]] = load i8** [[X]]
1527 // CHECK-NEXT: call void @objc_release(i8* [[T0]])
1528 // CHECK-NEXT: ret void
1529 }