前言
提起弱引用,大家都知道它的作用:
(1)不會添加引用計數 (2)當所引用的對象釋放後,引用者的指針自動置為nil
那麼,圍繞它背後的實作,是怎麼樣的呢?在許多公司面試時,都會問到這個問題。那麼,今天就帶大家一起分析一下weak引用是怎麼實作的,希望能夠搞清楚每一個細節。
Store as weak
當我們要weak引用一個對象,我們可以這麼做:
int main(int argc, char * argv[]) {
@autoreleasepool {
NSObject *obj = [[NSObject alloc] init];
__weak NSObject *weakObj = obj;
}
}
建立了一個NSObject對象
obj
,然後用
weakObj
對obj做弱引用。
當我們對一個對象做weak引用的時候,其背後是通過
runtime
來支援的。當把一個對象做weak引用時,會調用runtime方法
objc_initWeak
:
objc_initWeak
id objc_initWeak(id *location, id newObj)
{
if (!newObj) {
*location = nil;
return nil;
}
return storeWeak<DontHaveOld, DoHaveNew, DoCrashIfDeallocating>
(location, (objc_object*)newObj);
}
該方法接受兩個參數:
-
:__weak指針的位址,即例子中的weak指針取位址:id *location
。它是一個指針的位址。之是以要存儲指針的位址,是因為最後我們要講__weak指針指向的内容置為&weakObj
,如果僅存儲指針的話,是不能夠完成這個功能的。nil
-
:所引用的對象。即例子中的id newObj
。obj
有一個傳回值
id
: 會傳回obj自身,但其值已經做了更改(isa_t中的weak_ref位置1),參見Objective-C runtime機制(5)——iOS 記憶體管理
objc_initWeak
實質是調用了
storeWeak
方法。看這個方法的名字,就可以猜到是将weak引用存到某個地方,沒錯,實際上蘋果就是這麼做的。
storeWeak
storeWeak
方法有點長,這也是weak引用的核心實作部分。其實核心也就實作了兩個功能:
- 将weak指針的位址location存入到obj對應的
的數組(連結清單)中,用于在obj析構時,通過該數組(連結清單)找到所有其weak指針引用,并将指針指向的位址(location)置為weak_entry_t
。關于nil
,在上一篇中已有介紹。weak_entry_t
- 如果啟用了isa優化,則将obj的
的isa_t
位置1。置位1的作用主要是為了标記obj被weak引用了,當dealloc時,runtime會根據weakly_referenced
标志位來判斷是否需要查找obj對應的weakly_referenced
,并将引用置為weak_entry_t
。nil
// Template parameters.
enum HaveOld { DontHaveOld = false, DoHaveOld = true };
enum HaveNew { DontHaveNew = false, DoHaveNew = true };
enum CrashIfDeallocating {
DontCrashIfDeallocating = false, DoCrashIfDeallocating = true
};
template <HaveOld haveOld, HaveNew haveNew,
CrashIfDeallocating crashIfDeallocating>
static id
storeWeak(id *location, objc_object *newObj)
{
assert(haveOld || haveNew);
if (!haveNew) assert(newObj == nil);
Class previouslyInitializedClass = nil;
id oldObj;
SideTable *oldTable;
SideTable *newTable;
// Acquire locks for old and new values.
// Order by lock address to prevent lock ordering problems.
// Retry if the old value changes underneath us.
retry:
if (haveOld) { // 如果weak ptr之前弱引用過一個obj,則将這個obj所對應的SideTable取出,指派給oldTable
oldObj = *location;
oldTable = &SideTables()[oldObj];
} else {
oldTable = nil; // 如果weak ptr之前沒有弱引用過一個obj,則oldTable = nil
}
if (haveNew) { // 如果weak ptr要weak引用一個新的obj,則将該obj對應的SideTable取出,指派給newTable
newTable = &SideTables()[newObj];
} else {
newTable = nil; // 如果weak ptr不需要引用一個新obj,則newTable = nil
}
// 加鎖操作,防止多線程中競争沖突
SideTable::lockTwo<haveOld, haveNew>(oldTable, newTable);
// location 應該與 oldObj 保持一緻,如果不同,說明目前的 location 已經處理過 oldObj 可是又被其他線程所修改
if (haveOld && *location != oldObj) {
SideTable::unlockTwo<haveOld, haveNew>(oldTable, newTable);
goto retry;
}
// Prevent a deadlock between the weak reference machinery
// and the +initialize machinery by ensuring that no
// weakly-referenced object has an un-+initialized isa.
if (haveNew && newObj) {
Class cls = newObj->getIsa();
if (cls != previouslyInitializedClass &&
!((objc_class *)cls)->isInitialized()) // 如果cls還沒有初始化,先初始化,再嘗試設定weak
{
SideTable::unlockTwo<haveOld, haveNew>(oldTable, newTable);
_class_initialize(_class_getNonMetaClass(cls, (id)newObj));
// If this class is finished with +initialize then we're good.
// If this class is still running +initialize on this thread
// (i.e. +initialize called storeWeak on an instance of itself)
// then we may proceed but it will appear initializing and
// not yet initialized to the check above.
// Instead set previouslyInitializedClass to recognize it on retry.
previouslyInitializedClass = cls; // 這裡記錄一下previouslyInitializedClass, 防止改if分支再次進入
goto retry; // 重新擷取一遍newObj,這時的newObj應該已經初始化過了
}
}
// Clean up old value, if any.
if (haveOld) {
weak_unregister_no_lock(&oldTable->weak_table, oldObj, location); // 如果weak_ptr之前弱引用過别的對象oldObj,則調用weak_unregister_no_lock,在oldObj的weak_entry_t中移除該weak_ptr位址
}
// Assign new value, if any.
if (haveNew) { // 如果weak_ptr需要弱引用新的對象newObj
// (1) 調用weak_register_no_lock方法,将weak ptr的位址記錄到newObj對應的weak_entry_t中
newObj = (objc_object *)
weak_register_no_lock(&newTable->weak_table, (id)newObj, location,
crashIfDeallocating);
// weak_register_no_lock returns nil if weak store should be rejected
// (2) 更新newObj的isa的weakly_referenced bit标志位
// Set is-weakly-referenced bit in refcount table.
if (newObj && !newObj->isTaggedPointer()) {
newObj->setWeaklyReferenced_nolock();
}
// Do not set *location anywhere else. That would introduce a race.
// (3)*location 指派,也就是将weak ptr直接指向了newObj。可以看到,這裡并沒有将newObj的引用計數+1
*location = (id)newObj; // 将weak ptr指向object
}
else {
// No new value. The storage is not changed.
}
// 解鎖,其他線程可以通路oldTable, newTable了
SideTable::unlockTwo<haveOld, haveNew>(oldTable, newTable);
return (id)newObj; // 傳回newObj,此時的newObj與剛傳入時相比,weakly-referenced bit位置1
}
下面我們就一起來分析下
storeWeak
方法。
storeWeak
方法實質上接受5個參數,其中
HaveOld haveOld, HaveNew haveNew, CrashIfDeallocating crashIfDeallocating
這三個參數是以模闆枚舉的方式傳入的,其實這是三個bool參數,分别表示:weak ptr之前是否已經指向了一個弱引用,weak ptr是否需要指向一個新引用, 如果被弱引用的對象正在析構,此時再弱引用該對象,是否應該crash。
具體到
objc_initWeak
,這三個參數的值分别為
false
,
true
,
true
。
storeWeak
另外兩個參數是
id *location
,
objc_object *newObj
,這兩個參數和
objc_initWeak
是一樣的,分别代表weak 指針的位址,以及被weak引用的對象。
接下來函數體裡的内容,大家可以結合注釋,應該能夠看個明白。
這裡涉及到兩個關鍵的函數:
weak_unregister_no_lock // 将 weak ptr位址 從obj的weak_entry_t中移除
weak_register_no_lock // 将 weak ptr位址 注冊到obj對應的weak_entry_t中
這裡我們先看注冊函數:
weak_register_no_lock
id
weak_register_no_lock(weak_table_t *weak_table, id referent_id,
id *referrer_id, bool crashIfDeallocating)
{
objc_object *referent = (objc_object *)referent_id;
objc_object **referrer = (objc_object **)referrer_id;
// 如果referent為nil 或 referent 采用了TaggedPointer計數方式,直接傳回,不做任何操作
if (!referent || referent->isTaggedPointer()) return referent_id;
// 確定被引用的對象可用(沒有在析構,同時應該支援weak引用)
bool deallocating;
if (!referent->ISA()->hasCustomRR()) {
deallocating = referent->rootIsDeallocating();
}
else {
BOOL (*allowsWeakReference)(objc_object *, SEL) =
(BOOL(*)(objc_object *, SEL))
object_getMethodImplementation((id)referent,
SEL_allowsWeakReference);
if ((IMP)allowsWeakReference == _objc_msgForward) {
return nil;
}
deallocating =
! (*allowsWeakReference)(referent, SEL_allowsWeakReference);
}
// 正在析構的對象,不能夠被弱引用
if (deallocating) {
if (crashIfDeallocating) {
_objc_fatal("Cannot form weak reference to instance (%p) of "
"class %s. It is possible that this object was "
"over-released, or is in the process of deallocation.",
(void*)referent, object_getClassName((id)referent));
} else {
return nil;
}
}
// now remember it and where it is being stored
// 在 weak_table中找到referent對應的weak_entry,并将referrer加入到weak_entry中
weak_entry_t *entry;
if ((entry = weak_entry_for_referent(weak_table, referent))) { // 如果能找到weak_entry,則講referrer插入到weak_entry中
append_referrer(entry, referrer); // 将referrer插入到weak_entry_t的引用數組中
}
else { // 如果找不到,就建立一個
weak_entry_t new_entry(referent, referrer);
weak_grow_maybe(weak_table);
weak_entry_insert(weak_table, &new_entry);
}
// Do not set *referrer. objc_storeWeak() requires that the
// value not change.
return referent_id;
}
注意看開頭的地方:
// 如果referent為nil 或 referent 采用了TaggedPointer計數方式,直接傳回,不做任何操作
if (!referent || referent->isTaggedPointer()) return referent_id;
這裡再次出現了taggedPointer的身影,若引用計數使用了taggedPointer,則不會做任何引用計數。
接着,會判斷
referent_id
是否能夠被weak 引用。這裡主要判斷
referent_id
是否正在被析構以及
referent_id
是否支援weak引用。如果
referent_id
不能夠被weak引用,則直接傳回nil。
接下來,如果
referent_id
能夠被weak引用,則将
referent_id
對應的
weak_entry_t
從
weak_table
的weak_entry_t哈希數組中找出來,并将若
entry = weak_entry_for_referent(weak_table, referent)
如果
entry
不存在,則會建立一個
referent_id
所對應的
weak_entry_t
:
else { // 如果找不到,就建立一個
weak_entry_t new_entry(referent, referrer); // 建立一個新的weak_entry_t ,并将referrer插入到weak_entry_t的引用數組中
weak_grow_maybe(weak_table); // weak_table的weak_entry_t 數組是否需要動态增長,若需要,則會擴容一倍
weak_entry_insert(weak_table, &new_entry); // 将weak_entry_t插入到weak_table中
}
将referrer插入到對應的weak_entry_t的引用數組後,我們的weak工作基本也就結束了。
最後,隻需要傳回被引用的對象即可:
return referent_id;
關于referrer是如何插入到weak_entry_t中的,其hash算法是怎麼樣的,利用函數
append_referrer
:
static void append_referrer(weak_entry_t *entry, objc_object **new_referrer)
{
if (! entry->out_of_line()) { // 如果weak_entry 尚未使用動态數組,走這裡
// Try to insert inline.
for (size_t i = 0; i < WEAK_INLINE_COUNT; i++) {
if (entry->inline_referrers[i] == nil) {
entry->inline_referrers[i] = new_referrer;
return;
}
}
// 如果inline_referrers的位置已經存滿了,則要轉型為referrers,做動态數組。
// Couldn't insert inline. Allocate out of line.
weak_referrer_t *new_referrers = (weak_referrer_t *)
calloc(WEAK_INLINE_COUNT, sizeof(weak_referrer_t));
// This constructed table is invalid, but grow_refs_and_insert
// will fix it and rehash it.
for (size_t i = 0; i < WEAK_INLINE_COUNT; i++) {
new_referrers[i] = entry->inline_referrers[i];
}
entry->referrers = new_referrers;
entry->num_refs = WEAK_INLINE_COUNT;
entry->out_of_line_ness = REFERRERS_OUT_OF_LINE;
entry->mask = WEAK_INLINE_COUNT-1;
entry->max_hash_displacement = 0;
}
// 對于動态數組的附加處理:
assert(entry->out_of_line()); // 斷言: 此時一定使用的動态數組
if (entry->num_refs >= TABLE_SIZE(entry) * 3/4) { // 如果動态數組中元素個數大于或等于數組位置總空間的3/4,則擴充數組空間為目前長度的一倍
return grow_refs_and_insert(entry, new_referrer); // 擴容,并插入
}
// 如果不需要擴容,直接插入到weak_entry中
// 注意,weak_entry是一個哈希表,key:w_hash_pointer(new_referrer) value: new_referrer
// 細心的人可能注意到了,這裡weak_entry_t 的hash算法和 weak_table_t的hash算法是一樣的,同時擴容/減容的算法也是一樣的
size_t begin = w_hash_pointer(new_referrer) & (entry->mask); // '& (entry->mask)' 確定了 begin的位置隻能大于或等于 數組的長度
size_t index = begin; // 初始的hash index
size_t hash_displacement = 0; // 用于記錄hash沖突的次數,也就是hash再位移的次數
while (entry->referrers[index] != nil) {
hash_displacement++;
index = (index+1) & entry->mask; // index + 1, 移到下一個位置,再試一次能否插入。(這裡要考慮到entry->mask取值,一定是:0x111, 0x1111, 0x11111, ... ,因為數組每次都是*2增長,即8, 16, 32,對應動态數組空間長度-1的mask,也就是前面的取值。)
if (index == begin) bad_weak_table(entry); // index == begin 意味着數組繞了一圈都沒有找到合适位置,這時候一定是出了什麼問題。
}
if (hash_displacement > entry->max_hash_displacement) { // 記錄最大的hash沖突次數, max_hash_displacement意味着: 我們嘗試至多max_hash_displacement次,肯定能夠找到object對應的hash位置
entry->max_hash_displacement = hash_displacement;
}
// 将ref存入hash數組,同時,更新元素個數num_refs
weak_referrer_t &ref = entry->referrers[index];
ref = new_referrer;
entry->num_refs++;
}
weak_unregister_no_lock
如果
weak ptr
在指向obj之前,已經weak引用了其他的對象,則需要先将
weak ptr
從其他對象的
weak_entry_t
的hash數組中移除。在
storeWeak
方法中,會調用
weak_unregister_no_lock
來做移除操作:
if (haveOld) {
weak_unregister_no_lock(&oldTable->weak_table, oldObj, location); // 如果weak_ptr之前弱引用過别的對象oldObj,則調用weak_unregister_no_lock,在oldObj的weak_entry_t中移除該weak_ptr位址
}
weak_unregister_no_lock
的實作如下:
void
weak_unregister_no_lock(weak_table_t *weak_table, id referent_id,
id *referrer_id)
{
objc_object *referent = (objc_object *)referent_id;
objc_object **referrer = (objc_object **)referrer_id;
weak_entry_t *entry;
if (!referent) return;
if ((entry = weak_entry_for_referent(weak_table, referent))) { // 查找到referent所對應的weak_entry_t
remove_referrer(entry, referrer); // 在referent所對應的weak_entry_t的hash數組中,移除referrer
// 移除元素之後, 要檢查一下weak_entry_t的hash數組是否已經空了
bool empty = true;
if (entry->out_of_line() && entry->num_refs != 0) {
empty = false;
}
else {
for (size_t i = 0; i < WEAK_INLINE_COUNT; i++) {
if (entry->inline_referrers[i]) {
empty = false;
break;
}
}
}
if (empty) { // 如果weak_entry_t的hash數組已經空了,則需要将weak_entry_t從weak_table中移除
weak_entry_remove(weak_table, entry);
}
}
weak_unregister_no_lock
的實作邏輯比較簡單。
- 首先,它會在weak_table中找出referent對應的weak_entry_t
- 在weak_entry_t中移除referrer
- 移除元素後,判斷此時weak_entry_t中是否還有元素 (empty==true?)
- 如果此時weak_entry_t已經沒有元素了,則需要将weak_entry_t從weak_table中移除
OK,上面的所有就是當我們将一個obj作weak引用時,所發生的事情。那麼,當obj釋放時,所有weak引用它的指針又是如何自動設定為nil的呢?接下來我們來看一下obj釋放時,所發生的事情。
Dealloc
當對象引用計數為0時,runtime會調用
_objc_rootDealloc
方法來析構對象,實作如下:
void
_objc_rootDealloc(id obj)
{
assert(obj);
obj->rootDealloc();
}
它會調用
objc_object
的
rootDealloc
方法:
inline void
objc_object::rootDealloc()
{
if (isTaggedPointer()) return; // fixme necessary?
if (fastpath(isa.nonpointer &&
!isa.weakly_referenced &&
!isa.has_assoc &&
!isa.has_cxx_dtor &&
!isa.has_sidetable_rc))
{
assert(!sidetable_present());
free(this);
}
else {
object_dispose((id)this);
}
}
rootDealloc的實作邏輯如下:
- 判斷object是否采用了Tagged Pointer計數,如果是,則不進行任何析構操作。關于這一點,我們可以看出,用Tagged Pointer計數的對象,是不會析構的。Tagged Pointer計數的對象在記憶體中應該是類似于字元串常量的存在,多個對象指針其實會指向同一塊記憶體位址。雖然官方文檔中并沒有提及,但可以推測,Tagged Pointer計數的對象的記憶體位置很有可以就位于字元串常量區。
- 接下來判斷對象是否采用了優化的isa計數方式(
)。如果是,則判斷是否能夠進行快速釋放(isa.nonpointer
用C函數釋放記憶體)。可以進行快速釋放的前提是:對象沒有被weak引用free(this)
,沒有關聯對象!isa.weakly_referenced
,沒有自定義的C++析構方法!isa.has_assoc
,沒有用到sideTable來做引用計數!isa.has_cxx_dtor
。!isa.has_sidetable_rc
- 其餘的,則進入
慢釋放分支。object_dispose((id)this)
如果obj被weak引用了,應該進入
object_dispose((id)this)
分支:
id
object_dispose(id obj)
{
if (!obj) return nil;
objc_destructInstance(obj);
free(obj);
return nil;
}
object_dispose
方法中,會先調用
objc_destructInstance(obj)
來析構
obj
,再用
free(obj)
來釋放記憶體。
objc_destructInstance
的實作如下:
void *objc_destructInstance(id obj)
{
if (obj) {
// Read all of the flags at once for performance.
bool cxx = obj->hasCxxDtor();
bool assoc = obj->hasAssociatedObjects();
// This order is important.
if (cxx) object_cxxDestruct(obj); // 調用C++析構函數
if (assoc) _object_remove_assocations(obj); // 移除所有的關聯對象,并将其自身從Association Manager的map中移除
obj->clearDeallocating(); // 清理相關的引用
}
return obj;
}
在
objc_destructInstance
中,會清理相關的引用:
obj->clearDeallocating()
:
inline void
objc_object::clearDeallocating()
{
if (slowpath(!isa.nonpointer)) {
// Slow path for raw pointer isa.
sidetable_clearDeallocating();
}
else if (slowpath(isa.weakly_referenced || isa.has_sidetable_rc)) {
// Slow path for non-pointer isa with weak refs and/or side table data.
clearDeallocating_slow();
}
assert(!sidetable_present());
}
clearDeallocating中有兩個分支,先判斷obj是否采用了優化isa引用計數。沒有,則要清理obj存儲在sideTable中的引用計數等資訊,這個分支在目前64位裝置中應該不會進入,不必關系。
如果啟用了isa優化,則判斷是否使用了sideTable,使用的原因是因為做了weak引用(
isa.weakly_referenced
) 或 使用了sideTable的輔助引用計數(
isa.has_sidetable_rc
)。符合這兩種情況之一,則進入慢析構路徑:
// Slow path for non-pointer isa with weak refs and/or side table data.
clearDeallocating_slow();
NEVER_INLINE void
objc_object::clearDeallocating_slow()
{
assert(isa.nonpointer && (isa.weakly_referenced || isa.has_sidetable_rc));
SideTable& table = SideTables()[this]; // 在全局的SideTables中,以this指針為key,找到對應的SideTable
table.lock();
if (isa.weakly_referenced) { // 如果obj被弱引用
weak_clear_no_lock(&table.weak_table, (id)this); // 在SideTable的weak_table中對this進行清理工作
}
if (isa.has_sidetable_rc) { // 如果采用了SideTable做引用計數
table.refcnts.erase(this); // 在SideTable的引用計數中移除this
}
table.unlock();
}
這裡調用了
weak_clear_no_lock
來做weak_table的清理工作,同時将所有weak引用該對象的ptr置為
nil
:
void
weak_clear_no_lock(weak_table_t *weak_table, id referent_id)
{
objc_object *referent = (objc_object *)referent_id;
weak_entry_t *entry = weak_entry_for_referent(weak_table, referent); // 找到referent在weak_table中對應的weak_entry_t
if (entry == nil) {
/// XXX shouldn't happen, but does with mismatched CF/objc
//printf("XXX no entry for clear deallocating %p\n", referent);
return;
}
// zero out references
weak_referrer_t *referrers;
size_t count;
// 找出weak引用referent的weak 指針位址數組以及數組長度
if (entry->out_of_line()) {
referrers = entry->referrers;
count = TABLE_SIZE(entry);
}
else {
referrers = entry->inline_referrers;
count = WEAK_INLINE_COUNT;
}
for (size_t i = 0; i < count; ++i) {
objc_object **referrer = referrers[i]; // 取出每個weak ptr的位址
if (referrer) {
if (*referrer == referent) { // 如果weak ptr确實weak引用了referent,則将weak ptr設定為nil,這也就是為什麼weak 指針會自動設定為nil的原因
*referrer = nil;
}
else if (*referrer) { // 如果所存儲的weak ptr沒有weak 引用referent,這可能是由于runtime代碼的邏輯錯誤引起的,報錯
_objc_inform("__weak variable at %p holds %p instead of %p. "
"This is probably incorrect use of "
"objc_storeWeak() and objc_loadWeak(). "
"Break on objc_weak_error to debug.\n",
referrer, (void*)*referrer, (void*)referent);
objc_weak_error();
}
}
}
weak_entry_remove(weak_table, entry); // 由于referent要被釋放了,是以referent的weak_entry_t也要移除出weak_table
}
OK,上面就是為什麼當對象析構時,所有弱引用該對象的指針都會被設定為
nil
的原因。
總結
縱觀weak引用的底層實作,其實原理很簡單。就是将所有弱引用obj的指針位址都儲存在obj對應的
weak_entry_t
中。當obj要析構時,會周遊
weak_entry_t
中儲存的弱引用指針位址,并将弱引用指針指向
nil
,同時,将weak_entry_t移除出weak_table。
這裡涉及到runtime 四個重要的資料結構:
SideTables
,
SideTable
,
weak_table
,
weak_entry_t
.
關于它們,我們在Objective-C runtime機制(5)——iOS 記憶體管理中已有涉及。
為了加深對runtime的了解,在接下來的一章中,我們會依次分析這四個資料結構。
補充
在文章的開頭,我們舉的例子:
int main(int argc, char * argv[]) {
@autoreleasepool {
NSObject *obj = [[NSObject alloc] init];
__weak NSObject *weakObj = obj;
}
}
它底層會調用
objc_initWeak
方法,并最終會調用
storeWeak<DontHaveOld, DoHaveNew, DoCrashIfDeallocating>
(location, (objc_object*)newObj);
這是,傳入storeWeak的參數中,haveOld被設定為false,表明weakObj之前并沒有weak指向其他的對象。
那麼,什麼時候storeWeak的參數haveOld被設定為true呢?當我們的weakObj已經指向一個weak對象,又要指向新的weak對象時,storeWeak的haveOld參數會被置為true:
int main(int argc, char * argv[]) {
@autoreleasepool {
NSObject *obj = [[NSObject alloc] init];
__weak NSObject *weakObj = obj; // 這裡會調用objc_initWeak方法,storeWeak的haveOld == false
NSObject *obj2 = [[NSObject alloc] init];
weakObj = obj2; // 這裡會調用objc_storeWeak方法,storeWeak的haveOld == true,會将之前的引用先移除
}
}
objc_storeWeak
方法的實作如下:
/**
* This function stores a new value into a __weak variable. It would
* be used anywhere a __weak variable is the target of an assignment.
*
* @param location The address of the weak pointer itself
* @param newObj The new object this weak ptr should now point to
*
* @return \e newObj
*/
id
objc_storeWeak(id *location, id newObj)
{
return storeWeak<DoHaveOld, DoHaveNew, DoCrashIfDeallocating>
(location, (objc_object *)newObj);
}