问题来源
在最近的一次面试过程中，被问到Apple对tagged pointer的优化的问题，当时一脸懵逼，除了说上一句“提高访问效率和节约内存成本”，就没有然后了，被问及其实现原理一概不知。一时陷入尴尬，不知道对话该怎么继续。词穷的原因，大概是因为我的无知吧！所以过后，赶紧补上这方面的知识！
探索历程
1、百度
既然打算掌握tagged pointer的相关知识，肯定要知道它是什么，干什么用的，怎么实现的，优势&劣势等等。一大堆的问题，将我湮灭，还好，我有度娘。
so...
百度.png
一看这么多，求知欲爆棚的我瞬间高潮了，内心简直。。。。。无法用言语形容。尝试着阅读了几篇，发现解释的都很片面和肤浅，和我想要的相差甚远。有点小失落。但是，我可是“好好学习天天向上”的好学生，祖国的花朵，共产主义的接班人啊，怎能轻言放弃呢。于是继续在一堆优（垃）秀（圾）中追求真理。。。
皇天不负有心人。
image.png
看到唐巧大佬也有过这方面的研究。嗯嗯，看来我和大佬之间，就差一个
tagged pointer的掌握！！！（窃喜&YY自己正走在成为大佬的路上.png）点开大佬博客，似乎好像，大佬对
tagged pointer也没有太多的解析，让读者知其大概。顿时陷入了迷茫和思考：我想要的仅仅是这些表面的知其然而不知其所以然的所谓的知识吗？脑海中闪过无数鸡汤，瞬间顿悟：去吧皮卡丘，追寻你想要的吧！
2、Developer Documention
干劲是有了，那从哪里入手呢，怎么去学习tagged pointer呢。这时，我想到了官方文档，于是打开xcode，Help-->Developer Documention，搜索Tagged Pointer:
image.png
WTF....
内心一万头草泥马奔腾而过~~~
后来想想，感觉自己好傻逼，
Developer Documention是开发者接口文档，tagged pointer又不是接口，是Apple对NSString、NSNumber、NSDate等类的优化。优化。优化。额，，好像哪里不对，优化不是底层实现的吗，探索底层，不应该去看runtime吗。诶，终究还是太年轻，为什么现在才想起来要看runtime，看来共产主义迟迟不让你接班，还是有原因的！！！
runtime源码
既然知道了路在何方，就不在迷茫~
废话不多说，先去OpenSource下载一份runtime源码。
这里下载一份最新的objc-750。
下载完后，我隐隐感觉到，我离掌握Tagged Pointer已经不远了。
于是，抑制住激动的心，控制住颤抖的手，点开objc-750源码，好吧，我又迷失在了无尽的头文件中。
image.png
这尼玛，Tagged Pointer相关的知识，在哪个头文件？总不能一个个去找吧？你可能觉得我已经在头文件中迷失自我了，我只能说：呵，天真，我可是共产主义的接班人，这就想难道我？
于是我点开了文件搜索😎~
image.png
这TM也有好几个啊啊啊啊啊啊。没办法，只能再次求助度娘。
一番查找，终于找到了
objc-internal.h。(窃喜.jpg)总算进入正题了（进入全神贯注模式.jpg）。
开始阅读源码：
image.png
这里可以看注释，文件中关于
Tagged Pointer的，大概在209行的位置：
image.png
所以直接看这里。
开始的位置，是对64位系统的判定：
#if __LP64__
#define OBJC_HAVE_TAGGED_POINTERS 1 //如果是64位系统，则定义宏OBJC_HAVE_TAGGED_POINTERS
#endif
然后下面就对OBJC_HAVE_TAGGED_POINTERS宏进行判定：
#if OBJC_HAVE_TAGGED_POINTERS //说明tagged pointer只存在于64位系统中，即Apple是在64位系统上用tagged pointer优化NSString等类的。
...
继续往下：
#if __has_feature(objc_fixed_enum) || __cplusplus >= 201103L
enum objc_tag_index_t : uint16_t
#else
typedef uint16_t objc_tag_index_t;
enum
#endif
{
// 60-bit payloads
OBJC_TAG_NSAtom = 0,
OBJC_TAG_1 = 1,
OBJC_TAG_NSString = 2,
OBJC_TAG_NSNumber = 3,
OBJC_TAG_NSIndexPath = 4,
OBJC_TAG_NSManagedObjectID = 5,
OBJC_TAG_NSDate = 6,
// 60-bit reserved
OBJC_TAG_RESERVED_7 = 7,
// 52-bit payloads
OBJC_TAG_Photos_1 = 8,
OBJC_TAG_Photos_2 = 9,
OBJC_TAG_Photos_3 = 10,
OBJC_TAG_Photos_4 = 11,
OBJC_TAG_XPC_1 = 12,
OBJC_TAG_XPC_2 = 13,
OBJC_TAG_XPC_3 = 14,
OBJC_TAG_XPC_4 = 15,
OBJC_TAG_First60BitPayload = 0,
OBJC_TAG_Last60BitPayload = 6,
OBJC_TAG_First52BitPayload = 8,
OBJC_TAG_Last52BitPayload = 263,
OBJC_TAG_RESERVED_264 = 264
};
一看到#if 、#else、#endif，就知道在做判断。
看一下具体在判断什么：
#if __has_feature(objc_fixed_enum) || __cplusplus >= 201103L
/*
__has_feature(objc_fixed_enum):
__has_feature evaluates to 1 if the feature is both supported by Clang and standardized in the current language standard or 0 if not.
翻译一下就是：__has_feature取值为1如果特性被Clang支持并且被标准化在当前的语言标准中，取值为0如果不是的话。（原谅我耿（垃）直（圾）的翻译！！！）
Use __has_feature(objc_fixed_enum) to determine whether support for fixed underlying types is available in Objective-C.
翻译：用__has_feature(objc_fixed_enum)来决定是否支持固定的基础类型在Objective-C中。（我也不知道在说啥~）
__cplusplus >= 201103L：
C++11或者更新的标准。
*/
enum objc_tag_index_t : uint16_t
/*
定义枚举objc_tag_index_t，枚举类型为：uint16_t
这是c++11之后的特性
*/
#else
typedef uint16_t objc_tag_index_t;
enum
#endif
下面是一些枚举值：
{
// 60-bit payloads
OBJC_TAG_NSAtom = 0,
OBJC_TAG_1 = 1,
OBJC_TAG_NSString = 2, //NSString
OBJC_TAG_NSNumber = 3, //NSNumber
OBJC_TAG_NSIndexPath = 4, //NSIndexPath
OBJC_TAG_NSManagedObjectID = 5,
OBJC_TAG_NSDate = 6,//NSDate
// 60-bit reserved
OBJC_TAG_RESERVED_7 = 7,
// 52-bit payloads
OBJC_TAG_Photos_1 = 8,
OBJC_TAG_Photos_2 = 9,
OBJC_TAG_Photos_3 = 10,
OBJC_TAG_Photos_4 = 11,
OBJC_TAG_XPC_1 = 12,
OBJC_TAG_XPC_2 = 13,
OBJC_TAG_XPC_3 = 14,
OBJC_TAG_XPC_4 = 15,
OBJC_TAG_First60BitPayload = 0,
OBJC_TAG_Last60BitPayload = 6,
OBJC_TAG_First52BitPayload = 8,
OBJC_TAG_Last52BitPayload = 263,
OBJC_TAG_RESERVED_264 = 264
};
接下来，就是一些关于tagged pointer的函数了：
// Returns true if tagged pointers are enabled.
// The other functions below must not be called if tagged pointers are disabled.
static inline bool
_objc_taggedPointersEnabled(void);
// Register a class for a tagged pointer tag.
// Aborts if the tag is invalid or already in use.
OBJC_EXPORT void
_objc_registerTaggedPointerClass(objc_tag_index_t tag, Class _Nonnull cls)
OBJC_AVAILABLE(10.9, 7.0, 9.0, 1.0, 2.0);
// Returns the registered class for the given tag.
// Returns nil if the tag is valid but has no registered class.
// Aborts if the tag is invalid.
OBJC_EXPORT Class _Nullable
_objc_getClassForTag(objc_tag_index_t tag)
OBJC_AVAILABLE(10.9, 7.0, 9.0, 1.0, 2.0);
// Create a tagged pointer object with the given tag and payload.
// Assumes the tag is valid.
// Assumes tagged pointers are enabled.
// The payload will be silently truncated to fit.
static inline void * _Nonnull
_objc_makeTaggedPointer(objc_tag_index_t tag, uintptr_t payload);
// Return true if ptr is a tagged pointer object.
// Does not check the validity of ptr's class.
static inline bool
_objc_isTaggedPointer(const void * _Nullable ptr);
// Extract the tag value from the given tagged pointer object.
// Assumes ptr is a valid tagged pointer object.
// Does not check the validity of ptr's tag.
static inline objc_tag_index_t
_objc_getTaggedPointerTag(const void * _Nullable ptr);
// Extract the payload from the given tagged pointer object.
// Assumes ptr is a valid tagged pointer object.
// The payload value is zero-extended.
static inline uintptr_t
_objc_getTaggedPointerValue(const void * _Nullable ptr);
// Extract the payload from the given tagged pointer object.
// Assumes ptr is a valid tagged pointer object.
// The payload value is sign-extended.
static inline intptr_t
_objc_getTaggedPointerSignedValue(const void * _Nullable ptr);
中间也有各个函数的注释，还算注释的比较清楚。那我们就根据注释和源码，一个个看其实现吧（下面将声明和实现的代码粘贴到一起）：
_objc_taggedPointersEnabled:
// Returns true if tagged pointers are enabled.
// The other functions below must not be called if tagged pointers are disabled.
/*
翻译：返回true如果tagged pointers 是被允许的。
下面的其它函数不能被调用如果tagged pointers被禁用。
*/
static inline bool
_objc_taggedPointersEnabled(void);
static inline bool
_objc_taggedPointersEnabled(void)
{
extern uintptr_t objc_debug_taggedpointer_mask;
//引入一个外部变量 objc_debug_taggedpointer_mask
return (objc_debug_taggedpointer_mask != 0);
//如果objc_debug_taggedpointer_mask为为0，则返回flase,否则返回true
}
这个函数的实现其实很简单，关键是objc_debug_taggedpointer_mask，这是个什么东西？
它既然被extern引入，说明他在其他文件中肯定被定义并初始化过。so，找到它。
在objc-gdb.h中找到了：
OBJC_EXPORT uintptr_t objc_debug_taggedpointer_mask
OBJC_AVAILABLE(10.9, 7.0, 9.0, 1.0, 2.0);
//这里用OBJC_EXPORT导出objc_debug_taggedpointer_mask。
//OBJC_EXPORT的定义为：
#if !defined(OBJC_EXPORT)
# define OBJC_EXPORT OBJC_EXTERN OBJC_VISIBLE
//而OBJC_EXTERN的定义为：
#if !defined(OBJC_EXTERN)
# if defined(__cplusplus)
# define OBJC_EXTERN extern "C"
# else
# define OBJC_EXTERN extern
# endif
#endif
//OBJC_VISIBLE的定义为：
#if !defined(OBJC_VISIBLE)
# define OBJC_VISIBLE __attribute__((visibility("default")))
#endif
//所以这句相当于：
extern "C" __attribute__((visibility("default"))) uintptr_t objc_debug_taggedpointer_mask
OBJC_AVAILABLE(10.9, 7.0, 9.0, 1.0, 2.0);
//同样的，OBJC_AVAILABLE也可以找到其定义：
/* OBJC_AVAILABLE: shorthand for all-OS availability */
#if !defined(OBJC_AVAILABLE)
# define OBJC_AVAILABLE(x, i, t, w, b) \
__OSX_AVAILABLE(x) __IOS_AVAILABLE(i) __TVOS_AVAILABLE(t) \
__WATCHOS_AVAILABLE(w) __BRIDGEOS_AVAILABLE(b)
#endif
/*可见，OBJC_AVAILABLE将扩展为4个宏，拿__OSX_AVAILABLE来看看吧：*/
/* for use marking APIs available info for Mac OSX */
#if defined(__has_attribute)
#if __has_attribute(availability)
#define __OSX_UNAVAILABLE __OS_AVAILABILITY(macosx,unavailable)
#define __OSX_AVAILABLE(_vers) __OS_AVAILABILITY(macosx,introduced=_vers)
#define __OSX_DEPRECATED(_start, _dep, _msg) __OSX_AVAILABLE(_start) __OS_AVAILABILITY_MSG(macosx,deprecated=_dep,_msg)
#endif
#endif
#define __OS_AVAILABILITY(_target, _availability) __attribute__((availability(_target,_availability)))
//所以：
#define __OSX_AVAILABLE(x) __attribute__((availability(macosx,x)))
//其他的也是类似的，这里就不展开多说了。其实主要目的是为了限制版本的。
//关于__attribute__((availability(macosx,x))) ：
/*
平台，可为macosx, ios, tvos, watchos；
何时引入，introduced=版本；
何时弃用，deprecated=版本；
何时废弃，obsoleted=版本；
不可用，unavailable，标识此平台不可用；
额外信息，message=字符串，可用来额外说明，如提示新的可用的替代方法。
*/
/*所以，OBJC_EXPORT uintptr_t objc_debug_taggedpointer_mask
OBJC_AVAILABLE(10.9, 7.0, 9.0, 1.0, 2.0);
扩展开来其实是这样的：
*/
extern "C" __attribute__((visibility("default"))) uintptr_t objc_debug_taggedpointer_mask __attribute__((availability(macosx,introduced=10.9))) __attribute__((availability(ios, introduced=7.0,))) __attribute__((availability(tvos,introduced=9.0))) __attribute__((availability(watchos,introduced=1.0,))) __attribute__((availability(bridgeos,introduced=2.0,)))
/*
搞了这么多，各种define套define，搞的花里胡哨的，其实句话主要就是说：
objc_debug_taggedpointer_mask这个符号被导入，可见类型为`default `，且这个符号，分别在macosx10.9、ios7.0、tvos9.0、watchos1.0、bridgeos2.0时被引入的。
*/
然而，搞了半天，还是不知道objc_debug_taggedpointer_mask的值啊。
所以继续探索。
一番寻找之后，终于找到了其赋值的位置：
uintptr_t objc_debug_taggedpointer_mask = _OBJC_TAG_MASK;
#if OBJC_MSB_TAGGED_POINTERS
# define _OBJC_TAG_MASK (1UL<<63)
#else
# define _OBJC_TAG_MASK 1UL
#if (TARGET_OS_OSX || TARGET_OS_IOSMAC) && __x86_64__
// 64-bit Mac - tag bit is LSB
//这里注释的很清楚了，64位的mac，tagged标识位位LSB（最低有效位）
# define OBJC_MSB_TAGGED_POINTERS 0
#else
// Everything else - tag bit is MSB
//其他的tagged标识位都为MSB（最高有效位）
# define OBJC_MSB_TAGGED_POINTERS 1
#endif
绕这么一大圈，居然给我说是这个？so interesting！！！
回到最最初的那个_objc_taggedPointersEnabled函数：
static inline bool
_objc_taggedPointersEnabled(void);
static inline bool
_objc_taggedPointersEnabled(void)
{
extern uintptr_t objc_debug_taggedpointer_mask;
return (objc_debug_taggedpointer_mask != 0);
/*
这里等价于：
if(64bit system)
{
return true;
}
return flase;
*/
}
这个函数算是弄清楚了，接下来看另一个函数。
_objc_registerTaggedPointerClass：
OBJC_EXPORT void
_objc_registerTaggedPointerClass(objc_tag_index_t tag, Class _Nonnull cls)
OBJC_AVAILABLE(10.9, 7.0, 9.0, 1.0, 2.0);
/***********************************************************************
* _objc_registerTaggedPointerClass
* Set the class to use for the given tagged pointer index.
* Aborts if the tag is out of range, or if the tag is already
* used by some other class.
**********************************************************************/
void
_objc_registerTaggedPointerClass(objc_tag_index_t tag, Class cls)
{
if (objc_debug_taggedpointer_mask == 0) {//首先判断系统是否支持tagged pointer 。objc_debug_taggedpointer_mask=0为tagged pointer disabled；
_objc_fatal("tagged pointers are disabled");
/*
调用_objc_fatal函数。
这是_objc_fatal的实现：
void _objc_fatal(const char *fmt, ...)
{
va_list args;
va_start(args, fmt);
_vcprintf(fmt, args);
va_end(args);
//通过va_list获取格式化参数，并输出。
_cprintf("\n");
abort();
//退出
}
*/
//所以这里的意思就是输出"tagged pointers are disabled"并退出。
}
Class *slot = classSlotForTagIndex(tag);
if (!slot) {
_objc_fatal("tag index %u is invalid", (unsigned int)tag);
}
Class oldCls = *slot;
if (cls && oldCls && cls != oldCls) {
_objc_fatal("tag index %u used for two different classes "
"(was %p %s, now %p %s)", tag,
oldCls, oldCls->nameForLogging(),
cls, cls->nameForLogging());
}
*slot = cls;
// Store a placeholder class in the basic tag slot that is
// reserved for the extended tag space, if it isn't set already.
// Do this lazily when the first extended tag is registered so
// that old debuggers characterize bogus pointers correctly more often.
if (tag < OBJC_TAG_First60BitPayload || tag > OBJC_TAG_Last60BitPayload) {
Class *extSlot = classSlotForBasicTagIndex(OBJC_TAG_RESERVED_7);
if (*extSlot == nil) {
extern objc_class OBJC_CLASS_$___NSUnrecognizedTaggedPointer;
*extSlot = (Class)&OBJC_CLASS_$___NSUnrecognizedTaggedPointer;
}
}
继续往下看的话，又遇到一个之前没有看过的函数：
Class * classSlotForTagIndex(tag);
在runtime中找到它的实现部分：
// Returns a pointer to the class's storage in the tagged class arrays,
// or nil if the tag is out of range.
/*
注释：返回一个指针给类的存储在tagged class 数组中。
*/
static Class *
classSlotForTagIndex(objc_tag_index_t tag)
{
if (tag >= OBJC_TAG_First60BitPayload && tag <= OBJC_TAG_Last60BitPayload) {
//这里判断tagged pointer的payloads位，是否为60位payloads。
/*
// 60-bit payloads
OBJC_TAG_NSAtom = 0,
OBJC_TAG_1 = 1,
OBJC_TAG_NSString = 2,
OBJC_TAG_NSNumber = 3,
OBJC_TAG_NSIndexPath = 4,
OBJC_TAG_NSManagedObjectID = 5,
OBJC_TAG_NSDate = 6,
*/
//以上7种类型都为60bit payloads（用60bit来存储数据）
return classSlotForBasicTagIndex(tag);//调用另一个函数，这里找到它的实现（在下面对其分析）
}
if (tag >= OBJC_TAG_First52BitPayload && tag <= OBJC_TAG_Last52BitPayload) {
int index = tag - OBJC_TAG_First52BitPayload;
uintptr_t tagObfuscator = ((objc_debug_taggedpointer_obfuscator
>> _OBJC_TAG_EXT_INDEX_SHIFT)
& _OBJC_TAG_EXT_INDEX_MASK);
return &objc_tag_ext_classes[index ^ tagObfuscator];
}
return nil;
}
分析classSlotForBasicTagIndex函数。
// Returns a pointer to the class's storage in the tagged class arrays.
// Assumes the tag is a valid basic tag.假设标志是一个有效的标志（在上层调用中已经判断了tag）
static Class *
classSlotForBasicTagIndex(objc_tag_index_t tag)
{
//这里又出现一个奇怪的变量objc_debug_taggedpointer_obfuscator😞。。。看看他到底是什么东西？
uintptr_t tagObfuscator = ((objc_debug_taggedpointer_obfuscator
>> _OBJC_TAG_INDEX_SHIFT)
& _OBJC_TAG_INDEX_MASK);
uintptr_t obfuscatedTag = tag ^ tagObfuscator;
// Array index in objc_tag_classes includes the tagged bit itself
#if SUPPORT_MSB_TAGGED_POINTERS
return &objc_tag_classes[0x8 | obfuscatedTag];
#else
return &objc_tag_classes[(obfuscatedTag << 1) | 1];
#endif
}
分析objc_debug_taggedpointer_obfuscator。
/***********************************************************************
* initializeTaggedPointerObfuscator（初始化initializeTaggedPointerObfuscator）
* Initialize objc_debug_taggedpointer_obfuscator with randomness.（初始化objc_debug_taggedpointer_obfuscator用随机数据）
*
* The tagged pointer obfuscator is intended to make it more difficult
* for an attacker to construct a particular object as a tagged pointer,
* in the presence of a buffer overflow or other write control over some
* memory. The obfuscator is XORed with the tagged pointers when setting
* or retrieving payload values. They are filled with randomness on first
* use.
**********************************************************************/
static void
initializeTaggedPointerObfuscator(void)
{
if (sdkIsOlderThan(10_14, 12_0, 12_0, 5_0, 3_0) ||
// Set the obfuscator to zero for apps linked against older SDKs,
// in case they're relying on the tagged pointer representation.
DisableTaggedPointerObfuscation) {
/*
// OPTION(var, env, help)
OPTION( DisableTaggedPointerObfuscation, OBJC_DISABLE_TAG_OBFUSCATION, "disable obfuscation of tagged pointers")
*/
/*
#define sdkIsOlderThan(x, i, t, w) (sdkVersion() < DYLD_OS_VERSION(x, i, t, w))
#if TARGET_OS_OSX
# define DYLD_OS_VERSION(x, i, t, w) DYLD_MACOSX_VERSION_##x
# define sdkVersion() dyld_get_program_sdk_version()
#elif TARGET_OS_IOS
# define DYLD_OS_VERSION(x, i, t, w) DYLD_IOS_VERSION_##i
# define sdkVersion() dyld_get_program_sdk_version()
#elif TARGET_OS_TV
// dyld does not currently have distinct constants for tvOS
# define DYLD_OS_VERSION(x, i, t, w) DYLD_IOS_VERSION_##t
# define sdkVersion() dyld_get_program_sdk_version()
#elif TARGET_OS_WATCH
# define DYLD_OS_VERSION(x, i, t, w) DYLD_WATCHOS_VERSION_##w
// watchOS has its own API for compatibility reasons
# define sdkVersion() dyld_get_program_sdk_watch_os_version()
#else
# error unknown OS
#endif
*/
objc_debug_taggedpointer_obfuscator = 0;
} else {
// Pull random data into the variable, then shift away all non-payload bits.（将随机数据放入变量中，然后移走所有非有效负载位。）
arc4random_buf(&objc_debug_taggedpointer_obfuscator,
sizeof(objc_debug_taggedpointer_obfuscator));
//arc4random_buf() fills the region buf of length nbytes with random data.
objc_debug_taggedpointer_obfuscator &= ~_OBJC_TAG_MASK;
//获取一个随机数，并将该随机数的tagged pointer 标识位（高1bit或者低1bit）置为0。即：
//objc_debug_taggedpointer_obfuscator = objc_debug_taggedpointer_obfuscator & (0x7FFFFFFFFFFFFFFF或者0xFFFFFFFFFFFFFFFE)
}
}
objc_debug_taggedpointer_obfuscator也算是囫囵吞枣掌握了，回到刚刚那个classSlotForBasicTagIndex函数：
static Class *
classSlotForBasicTagIndex(objc_tag_index_t tag)
{
uintptr_t tagObfuscator = ((objc_debug_taggedpointer_obfuscator
>> _OBJC_TAG_INDEX_SHIFT)
& _OBJC_TAG_INDEX_MASK);
//这里就很好理解了，将随机得到的数据（tagged标识位已置0）右移_OBJC_TAG_INDEX_SHIFT位。
/*
#if OBJC_MSB_TAGGED_POINTERS
# define _OBJC_TAG_INDEX_SHIFT 60
#else
# define _OBJC_TAG_INDEX_SHIFT 1
#endif
总是有两种情况，这里就选一种研究（“_OBJC_TAG_INDEX_SHIFT 60”）
右移60位，相当于取随机数objc_debug_taggedpointer_obfuscator的高四位。
#define _OBJC_TAG_INDEX_MASK 0x7
然后再和0x7进行位与操作。
其实质就是取60bit~62bit。（高4bit中的低3bit）
*/
uintptr_t obfuscatedTag = tag ^ tagObfuscator;
//tag 和 tagObfuscator 进行异或操作。
// Array index in objc_tag_classes includes the tagged bit itself
#if SUPPORT_MSB_TAGGED_POINTERS
return &objc_tag_classes[0x8 | obfuscatedTag];
#else
return &objc_tag_classes[(obfuscatedTag << 1) | 1];
#endif
//将标志位置1，然后在objc_tag_classes数组中取出，再取地址返回。
}
回到开始的_objc_registerTaggedPointerClass函数：
void
_objc_registerTaggedPointerClass(objc_tag_index_t tag, Class cls)
{
if (objc_debug_taggedpointer_mask == 0) {
_objc_fatal("tagged pointers are disabled");
}
Class *slot = classSlotForTagIndex(tag);
/*
这里已经知道了，slot是通过tag值，在objc_tag_classes数组中寻找对于的Class，并获取其地址，赋值给slot。
*/
if (!slot) {
_objc_fatal("tag index %u is invalid", (unsigned int)tag);
}
//如果没有获取到，则abort并告知tag index is invalid。
Class oldCls = *slot;
if (cls && oldCls && cls != oldCls) {
_objc_fatal("tag index %u used for two different classes "
"(was %p %s, now %p %s)", tag,
oldCls, oldCls->nameForLogging(),
cls, cls->nameForLogging());
}
//这里是判断该tag index是否被其他class使用。
*slot = cls;
//下面的这段，有待探究~~~
// Store a placeholder class in the basic tag slot that is
// reserved for the extended tag space, if it isn't set already.
// Do this lazily when the first extended tag is registered so
// that old debuggers characterize bogus pointers correctly more often.
if (tag < OBJC_TAG_First60BitPayload || tag > OBJC_TAG_Last60BitPayload) {
Class *extSlot = classSlotForBasicTagIndex(OBJC_TAG_RESERVED_7);
if (*extSlot == nil) {
extern objc_class OBJC_CLASS_$___NSUnrecognizedTaggedPointer;
*extSlot = (Class)&OBJC_CLASS_$___NSUnrecognizedTaggedPointer;
}
}
}
到这里，这个函数算是解析完了。其实它做的就是：
1、判断tagged pointer disabled与否。
2、用tag值在objc_tag_classes数组中查找相对应的Class（查找过程上面已经分析过）。
3、判断是否查找到。如果查找到，判断是否被占用。
下一个函数_objc_getClassForTag：
// Returns the registered class for the given tag.
// Returns nil if the tag is valid but has no registered class.
// Aborts if the tag is invalid.
OBJC_EXPORT Class _Nullable
_objc_getClassForTag(objc_tag_index_t tag)
OBJC_AVAILABLE(10.9, 7.0, 9.0, 1.0, 2.0);
/***********************************************************************
* _objc_getClassForTag
* Returns the class that is using the given tagged pointer tag.
* Returns nil if no class is using that tag or the tag is out of range.
**********************************************************************/
Class
_objc_getClassForTag(objc_tag_index_t tag)
{
Class *slot = classSlotForTagIndex(tag);
if (slot) return *slot;
else return nil;
}
嘿，巧了，classSlotForTagIndex函数，在分析上个函数的时候，分析过了。详细过程见classSlotForBasicTagIndex函数的分析过程。
下一个函数_objc_makeTaggedPointer：
// Create a tagged pointer object with the given tag and payload.
// Assumes the tag is valid.
// Assumes tagged pointers are enabled.
// The payload will be silently truncated to fit.
static inline void * _Nonnull
_objc_makeTaggedPointer(objc_tag_index_t tag, uintptr_t payload);
static inline void * _Nonnull
_objc_makeTaggedPointer(objc_tag_index_t tag, uintptr_t value)
{
// PAYLOAD_LSHIFT and PAYLOAD_RSHIFT are the payload extraction shifts.
// They are reversed here for payload insertion.
// assert(_objc_taggedPointersEnabled());
if (tag <= OBJC_TAG_Last60BitPayload) {
//这里只分析这种情况
// assert(((value << _OBJC_TAG_PAYLOAD_RSHIFT) >> _OBJC_TAG_PAYLOAD_LSHIFT) == value);
uintptr_t result =
(_OBJC_TAG_MASK |
((uintptr_t)tag << _OBJC_TAG_INDEX_SHIFT) |
((value << _OBJC_TAG_PAYLOAD_RSHIFT) >> _OBJC_TAG_PAYLOAD_LSHIFT));
return _objc_encodeTaggedPointer(result);
} else {
// assert(tag >= OBJC_TAG_First52BitPayload);
// assert(tag <= OBJC_TAG_Last52BitPayload);
// assert(((value << _OBJC_TAG_EXT_PAYLOAD_RSHIFT) >> _OBJC_TAG_EXT_PAYLOAD_LSHIFT) == value);
uintptr_t result =
(_OBJC_TAG_EXT_MASK |
((uintptr_t)(tag - OBJC_TAG_First52BitPayload) << _OBJC_TAG_EXT_INDEX_SHIFT) |
((value << _OBJC_TAG_EXT_PAYLOAD_RSHIFT) >> _OBJC_TAG_EXT_PAYLOAD_LSHIFT));
return _objc_encodeTaggedPointer(result);
}
}
先分析result的值:
uintptr_t result = (_OBJC_TAG_MASK | ((uintptr_t)tag << _OBJC_TAG_INDEX_SHIFT) | ((value << _OBJC_TAG_PAYLOAD_RSHIFT) >> _OBJC_TAG_PAYLOAD_LSHIFT));
/*
同样的，这里只分析 _OBJC_TAG_INDEX_SHIFT = 60 的情况
((uintptr_t)tag << _OBJC_TAG_INDEX_SHIFT) ：将tag的低4bit变为高4bit
((value << _OBJC_TAG_PAYLOAD_RSHIFT) >> _OBJC_TAG_PAYLOAD_LSHIFT)：将value的高4bit置0
((uintptr_t)tag << _OBJC_TAG_INDEX_SHIFT) | ((value << _OBJC_TAG_PAYLOAD_RSHIFT) >> _OBJC_TAG_PAYLOAD_LSHIFT)：将tag的低四位给value的高四位。
上面的操作就相当于：
tag:0x89abcdef
value:0x76543210
tagvalue:0xf6543210
所以result为上述操作之后的tag和value值的tagged pointer标识位（63bit）置1。
举个例子：
tag=0x76543210
value=0xf9abcdef
那么result=(1<<63) | ((tag<<60) | ((value<<4)>>4)) = 0x89abcdef
*/
再来看看_objc_encodeTaggedPointer:
static inline void * _Nonnull
_objc_encodeTaggedPointer(uintptr_t ptr)
{
return (void *)(objc_debug_taggedpointer_obfuscator ^ ptr);
/*
objc_debug_taggedpointer_obfuscator在上面也是分析过的，他有一个初始化函数initializeTaggedPointerObfuscator。
其值为一个由arc4random_buf生成的64bit随机数，然后再将_OBJC_TAG_MASK位（最高位）置0。
所以的得到的为：result^objc_debug_taggedpointer_obfuscator
*/
}
看下一个函数_objc_isTaggedPointer：
// Return true if ptr is a tagged pointer object.
// Does not check the validity of ptr's class.
static inline bool
_objc_isTaggedPointer(const void * _Nullable ptr);
static inline bool
_objc_isTaggedPointer(const void * _Nullable ptr)
{
return ((uintptr_t)ptr & _OBJC_TAG_MASK) == _OBJC_TAG_MASK;
/*
这个其实很简单，传入一个指针，判断指针的_OBJC_TAG_MASK位是否为1。
*/
}
_objc_getTaggedPointerTag：
// Extract the tag value from the given tagged pointer object.
// Assumes ptr is a valid tagged pointer object.
// Does not check the validity of ptr's tag.
static inline objc_tag_index_t
_objc_getTaggedPointerTag(const void * _Nullable ptr);
static inline objc_tag_index_t
_objc_getTaggedPointerTag(const void * _Nullable ptr)
{
// assert(_objc_isTaggedPointer(ptr));
uintptr_t value = _objc_decodeTaggedPointer(ptr);
/*
用随机数objc_debug_taggedpointer_obfuscator对指针进行decode。
*/
uintptr_t basicTag = (value >> _OBJC_TAG_INDEX_SHIFT) & _OBJC_TAG_INDEX_MASK;
// uintptr_t basicTag = (value >> 60) & 0x7;//将decode之后的value的高四位变为低四位，并将其3bit置为0。
//仅是研究NSNumber等类的话，下面的就不用去深究。
uintptr_t extTag = (value >> _OBJC_TAG_EXT_INDEX_SHIFT) & _OBJC_TAG_EXT_INDEX_MASK;
if (basicTag == _OBJC_TAG_INDEX_MASK) {
return (objc_tag_index_t)(extTag + OBJC_TAG_First52BitPayload);
} else {
return (objc_tag_index_t)basicTag;
}
}
_objc_getTaggedPointerValue：
// Extract the payload from the given tagged pointer object.
// Assumes ptr is a valid tagged pointer object.
// The payload value is zero-extended.
static inline uintptr_t
_objc_getTaggedPointerValue(const void * _Nullable ptr);
static inline uintptr_t
_objc_getTaggedPointerValue(const void * _Nullable ptr)
{
// assert(_objc_isTaggedPointer(ptr));
uintptr_t value = _objc_decodeTaggedPointer(ptr);
uintptr_t basicTag = (value >> _OBJC_TAG_INDEX_SHIFT) & _OBJC_TAG_INDEX_MASK;
if (basicTag == _OBJC_TAG_INDEX_MASK) {
return (value << _OBJC_TAG_EXT_PAYLOAD_LSHIFT) >> _OBJC_TAG_EXT_PAYLOAD_RSHIFT;
} else {
return (value << _OBJC_TAG_PAYLOAD_LSHIFT) >> _OBJC_TAG_PAYLOAD_RSHIFT;
//主要看这里，value的值是_objc_decodeTaggedPointer的返回值，然后再将这个返回值高四位置0，即得。
}
}
_objc_getTaggedPointerSignedValue
// Extract the payload from the given tagged pointer object.
// Assumes ptr is a valid tagged pointer object.
// The payload value is sign-extended.
static inline intptr_t
_objc_getTaggedPointerSignedValue(const void * _Nullable ptr);
static inline intptr_t
_objc_getTaggedPointerSignedValue(const void * _Nullable ptr)
{
// assert(_objc_isTaggedPointer(ptr));
uintptr_t value = _objc_decodeTaggedPointer(ptr);
uintptr_t basicTag = (value >> _OBJC_TAG_INDEX_SHIFT) & _OBJC_TAG_INDEX_MASK;
if (basicTag == _OBJC_TAG_INDEX_MASK) {
return ((intptr_t)value << _OBJC_TAG_EXT_PAYLOAD_LSHIFT) >> _OBJC_TAG_EXT_PAYLOAD_RSHIFT;
} else {
return ((intptr_t)value << _OBJC_TAG_PAYLOAD_LSHIFT) >> _OBJC_TAG_PAYLOAD_RSHIFT;
}
}
/*
这个函数和上面的_objc_getTaggedPointerValue是一样的。
*/
理论到这算是走完了。
这里，总结一下：
tagged pointer是Apple在64bit系统上对NSNumber类的一些优化，主要目的是为了节省内存。其实现原理为：将指针的一部分（4bit）拿出来充当tag值，标记对象指针是否为tagged pointer。并在这4bit中，还存储了该指针的所属类在objc_tag_classes数组中的index。通过一系列函数可以对其进行操作，例如判断指针是否为tagged pointer（_objc_isTaggedPointer）、获取tagged pointer的数据（_objc_getTaggedPointerValue）、获取tagged pointer的类型（_objc_getTaggedPointerTag）等等。
实践（环境：MAC，版本：10.14.5）
理论搞懂了，那就来指导一下实践吧：
- 1 由已知tagged pointer 获取其相关信息。
（1）查看tagged pointer enable or disable。
根据上述分析，判断pagged pointer是否启用，应该是调用函数_objc_taggedPointersEnabled。
但是_objc_taggedPointersEnabled函数是被static修饰的，所以不能extern并使用。只能直接重写其实现。
#import <Foundation/Foundation.h>
bool sl_objc_taggedPointersEnabled(void)
{
extern uintptr_t objc_debug_taggedpointer_mask;
return (objc_debug_taggedpointer_mask != 0);
}
int main(int argc, const char * argv[]) {
@autoreleasepool {
bool b = sl_objc_taggedPointersEnabled();
NSLog(@"Enable:%d",b);
}
return 0;
}
查看打印：
2019-07-01 17:37:14.584230+0800 AAA[10865:711050] Enable:1
可知，在mac10.14.5上，是enabled的。
（2）判断一个指针是不是Tagged Pointer。
# define _OBJC_TAG_MASK 1UL//本来需要判断的，这里测试的是已知的mac 10.14.5.所以直接定义
bool sl_objc_isTaggedPointer(const void * _Nullable ptr)
{
return ((uintptr_t)ptr & _OBJC_TAG_MASK) == _OBJC_TAG_MASK;
}
int main(int argc, const char * argv[]) {
@autoreleasepool {
NSNumber *n = @123;
NSString *s = @"123";
NSString *s_m_c = [[s mutableCopy] copy];
NSObject *o = [NSObject new];
bool nb = sl_objc_isTaggedPointer((__bridge void *)n);
bool sb = sl_objc_isTaggedPointer((__bridge void *)s);
bool smcb = sl_objc_isTaggedPointer((__bridge void *)s_m_c);
bool ob = sl_objc_isTaggedPointer((__bridge void *)o);
NSLog(@"nb(0x%lx) is TaggedPointer %d",(uintptr_t)n,nb);
NSLog(@"sb(0x%lx) is TaggedPointer %d",(uintptr_t)s,sb);
NSLog(@"smcb(0x%lx) is TaggedPointer %d",(uintptr_t)s_m_c,smcb);
NSLog(@"ob(0x%lx) is TaggedPointer %d",(uintptr_t)o,ob);
}
return 0;
}
打印：
2019-07-01 17:58:36.116391+0800 AAA[10973:719191] nb(0x56b19f9c2784f641) is TaggedPointer 1
2019-07-01 17:58:36.116530+0800 AAA[10973:719191] sb(0x100001058) is TaggedPointer 0
2019-07-01 17:58:36.116538+0800 AAA[10973:719191] smcb(0x56b19f9c14b6bc53) is TaggedPointer 1
2019-07-01 17:58:36.116544+0800 AAA[10973:719191] ob(0x10051e520) is TaggedPointer 0
（3）获取tagged pointer的类型（tag枚举值）
# define _OBJC_TAG_INDEX_SHIFT 1
#define _OBJC_TAG_INDEX_MASK 0x7
extern uintptr_t objc_debug_taggedpointer_obfuscator;
uintptr_t sl_objc_getTaggedPointerTag(const void * _Nullable ptr)
{
uintptr_t value = objc_debug_taggedpointer_obfuscator ^ (uintptr_t)ptr;
uintptr_t basicTag = (value >> _OBJC_TAG_INDEX_SHIFT) & _OBJC_TAG_INDEX_MASK;
return basicTag;
}
int main(int argc, const char * argv[]) {
@autoreleasepool {
NSNumber *n = @123;
NSString *s = @"123";
NSString *s_m_c = [[s mutableCopy] copy];
uintptr_t n_t = sl_objc_getTaggedPointerTag((__bridge void *)n);
uintptr_t s_m_c_t = sl_objc_getTaggedPointerTag((__bridge void *)s_m_c);
NSLog(@"n's type is %ld",n_t);
NSLog(@"s_m_c's type is %ld",s_m_c_t);
}
return 0;
}
log：
2019-07-04 09:41:34.017122+0800 AAA[11655:849484] n's type is 3
2019-07-04 09:41:34.017318+0800 AAA[11655:849484] s_m_c's type is 2
对比log和objc_tag_index_t：
// 60-bit payloads
OBJC_TAG_NSAtom = 0,
OBJC_TAG_1 = 1,
OBJC_TAG_NSString = 2,
OBJC_TAG_NSNumber = 3,
OBJC_TAG_NSIndexPath = 4,
OBJC_TAG_NSManagedObjectID = 5,
OBJC_TAG_NSDate = 6,
（4）获取taggedpointer的所属类：
# define _OBJC_TAG_INDEX_SHIFT 1
#define _OBJC_TAG_INDEX_MASK 0x7
extern uintptr_t objc_debug_taggedpointer_obfuscator;
uintptr_t sl_objc_getTaggedPointerTag(const void * _Nullable ptr)
{
uintptr_t value = objc_debug_taggedpointer_obfuscator ^ (uintptr_t)ptr;
uintptr_t basicTag = (value >> _OBJC_TAG_INDEX_SHIFT) & _OBJC_TAG_INDEX_MASK;
return basicTag;
}
extern Class objc_debug_taggedpointer_classes[];
Class *sl_classSlotForBasicTagIndex(uintptr_t tag)
{
uintptr_t tagObfuscator = ((objc_debug_taggedpointer_obfuscator
>> _OBJC_TAG_INDEX_SHIFT)
& _OBJC_TAG_INDEX_MASK);
uintptr_t obfuscatedTag = tag ^ tagObfuscator;
// Array index in objc_tag_classes includes the tagged bit itself
return &objc_debug_taggedpointer_classes[(obfuscatedTag << 1) | 1];
}
int main(int argc, const char * argv[]) {
@autoreleasepool {
NSNumber *n = @123;
NSString *s = @"123";
NSString *s_m_c = [[s mutableCopy] copy];
uintptr_t n_t = sl_objc_getTaggedPointerTag((__bridge void *)n);
uintptr_t s_m_c_t = sl_objc_getTaggedPointerTag((__bridge void *)s_m_c);
Class *n_t_c = sl_classSlotForBasicTagIndex(n_t);
Class *s_m_c_t_c = sl_classSlotForBasicTagIndex(s_m_c_t);
NSLog(@"n's Class is %@",*n_t_c);
NSLog(@"s_m_c's Clss is %@",*s_m_c_t_c);
}
return 0;
}
log：
2019-07-04 10:58:05.075581+0800 AAA[11913:876264] n's Class is __NSCFNumber
2019-07-04 10:58:05.075754+0800 AAA[11913:876264] s_m_c's Clss is NSTaggedPointerString
看到上面的例子，或许我该露出张狂但又不失谦虚的笑容，因为一切都那么顺利，理论得到了印证。然而，真的是这么一回事吗？下面看一个不尽人意的例子。
（5）通过taggedpointer获取value：
# define _OBJC_TAG_PAYLOAD_LSHIFT 0
# define _OBJC_TAG_PAYLOAD_RSHIFT 4
uintptr_t sl_objc_getTaggedPointerValue(const void * _Nullable ptr)
{
// assert(_objc_isTaggedPointer(ptr));
uintptr_t value = objc_debug_taggedpointer_obfuscator ^ (uintptr_t)ptr;
// uintptr_t basicTag = (value >> _OBJC_TAG_INDEX_SHIFT) & _OBJC_TAG_INDEX_MASK;
return (value << _OBJC_TAG_PAYLOAD_LSHIFT) >> _OBJC_TAG_PAYLOAD_RSHIFT;
}
int main(int argc, const char * argv[]) {
@autoreleasepool {
NSNumber *n = @123;
uintptr_t n_v = sl_objc_getTaggedPointerValue((__bridge void *)n);
NSLog(@"hex(123) = 0x%x",123);
NSLog(@"n's value is 0x%lx",n_v);
}
return 0;
}
log:
2019-07-04 11:14:59.639165+0800 AAA[11959:881845] hex(123) = 0x7b
2019-07-04 11:14:59.639316+0800 AAA[11959:881845] n's value is 0x7b2
是不是感觉有点不对劲？
换一个数据：
NSNumber *n = [NSNumber numberWithLongLong:121111];
uintptr_t n_v = sl_objc_getTaggedPointerValue((__bridge void *)n);
NSLog(@"hex(121111) = 0x%x",121111);
NSLog(@"n's value is 0x%lx",n_v);
log：
2019-07-04 11:18:03.279558+0800 AAA[11967:882991] hex(121111) = 0x1d917
2019-07-04 11:18:03.279719+0800 AAA[11967:882991] n's value is 0x1d9173
每次都发现算出来的value后面总是多一位。。。。
查了蛮多资料，只知道：
value的第1-4位是NSNumber的类型：比如，char是0、short是1、int是2、float是4。
至于为什么是这样，Apple对这一特性的实现代码，都没有找到。（原谅我的无能😔）。
当然，最大的坑，还不是这个，是NSString。考虑到篇幅问题，下篇再作细研究。
网友评论