What are the rules that affect __weak variables in a block with regard to GCC_OPTIMIZATION_LEVEL? - objective-c

Question

In the code below, when I run it with the GCC_OPTIMIZATION_LEVEL set to None, execution works as I expect and it prints the following to the console:
My Obj - SomeObj
However, when I set the GCC_OPTIMIZATION_LEVEL to Fastest, Smallest in the Xcode target configuration (as one typically does for Release builds) I end up with the following printed to the console:
My obj - (null)
The object appears to be getting released when I store it into the __weak id myObj variable in [Foo doSomething]. If I remove the __weak flag from the myObj variable the code runs as expected when the GCC_OPTIMIZATION_LEVEL is set to Fastest, Smallest.
I built this example based on a similar pattern I had in another project and added the __weak flag because I was encountering a retain cycle. The retain cycle warning went away, but when I built for Release, I found that myObj would be nil by the time it got to the spot where I am logging it in this example.
What rules am I violating by setting the __weak flag?
#import "FFAppDelegate.h"
///////////////////////////////////////////////////////
#interface SomeObject : NSObject
#end
#implementation SomeObject
- (NSString *)description; {
return #"SomeObject";
}
#end
///////////////////////////////////////////////////////
#interface Factory : NSObject
#end
#implementation Factory
- (id)generateObj {
id myObj = nil;
if (!myObj) {
SomeObject *anObj = [[SomeObject alloc] init];
myObj = anObj;
}
return myObj;
}
#end
///////////////////////////////////////////////////////
#interface Bar : NSObject
- (id)barObj;
#end
#implementation Bar
{
Factory *factory;
}
- (id)init {
self = [super init];
if (self) {
factory = [[Factory alloc] init];
}
return self;
}
- (id)barObj {
id anObj = [factory generateObj];
return anObj;
}
#end
///////////////////////////////////////////////////////
#interface Foo : NSObject
#property (strong) Bar *aBar;
- (void)doSomething;
#end
#implementation Foo
- (id)init {
self = [super init];
if (self) {
_aBar = [[Bar alloc] init];
}
return self;
}
- (void)doSomething {
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0), ^{
__weak id myObj = [self.aBar barObj];
NSLog(#"My Obj - %#", myObj);
});
}
#end
///////////////////////////////////////////////////////
#implementation FFAppDelegate
- (void)applicationDidFinishLaunching:(NSNotification *)aNotification
{
Foo *f = [[Foo alloc] init];
[f doSomething];
}
#end

Answer 1

What rules am I violating by setting the __weak flag?
In your example, there is no strong reference to the instance returned from [self.aBar barObj]. Therefore, you cannot assume the instance will be alive by the time you read the myObj variable.
In the unoptimized build, the returned instance has been added to an autorelease pool and is therefore still alive when you print myObj. You can verify this by setting a breakpoint in -[SomeObject dealloc].
In the optimized build, ARC has avoided the autorelease pool and the returned instance is therefore deallocated immediately.
See section 3.2.3 in the Clang ARC documentation for more info. Specifically:
When returning from such a function or method, ARC retains the value at the point of evaluation of the return statement, then leaves all local scopes, and then balances out the retain while ensuring that the value lives across the call boundary. In the worst case, this may involve an autorelease, but callers must not assume that the value is actually in the autorelease pool.
When using __weak to avoid a retain cycle, you must ensure that there is a strong reference somewhere else to keep the object alive.

Answer 2

Maybe you should use Apple's default compiler LLVM and not GCC.
Edit: Also your "factory" method looks wrong. For example, the object is always nil in that if. Take a tour: http://developer.apple.com/library/ios/#documentation/general/conceptual/CocoaEncyclopedia/ClassFactoryMethods/ClassFactoryMethods.html