1 背景

iPhone5s是首个采用 64 位架构的A7双核处理器的手机，为了节省内存和提高执行效率，苹果提出了Tagged Pointer的概念。对于 64 位程序，引入 Tagged Pointer 后，相关逻辑能减少一半以上的内存占用，以及3倍的访问速度提升，100 倍的创建、销毁速度提升。

本文将带我们来理解这个概念是怎么节省内存和提高执行效率的。（注：本篇文章所用系统皆为64位系统）

2 不使用Tagged Pointer的情况

以NSNumber *a = @(1);为例，在不使用Tagged Pointer的情况下，我们看下在内存上和访问效率上都是什么情况。

在内存上：

如下图所示， 1个小对象需要至少使用24字节（指针8字节 + 对象16字节）

栈：在栈上，占1个指针 8字节，里面存储的是堆内存的地址0x600001a92920。

堆：在堆上，占16个字节，isa指针占8个字节，1为int类型，占4个字节，但由于内存对齐机制（ios 内存对齐为16字节），堆需要16个字节的内存。

在效率上：

NSNumber对象需要动态分配内存、维护引用计数、管理它的生命周期等

方法调用需要objc_msgSend的执行流程（消息发送、动态方法解析、消息转发）

3 使用Tagged Pointer的情况

3.1 苹果对 Tagged Pointer 的介绍

苹果对 Tagged Pointer 的介绍主要有三点：

Tagged Pointer被设计的目的是用来存储较小的对象，例如NSNumber、NSDate、NSString 等；
Tagged Pointer的值不再表示地址，而是真正的值；
在内存读取上有着3倍的效率，创建时比以前快106倍；

3.2 Tagged Pointer实质

Tagged Pointer实质是一个伪指针，对象的指针中存储的数据变成了Tag+Data形式：

Tag为特殊标记，用于区分是否是Tagged Pointer指针以及区分NSNumber、NSDate、NSString等对象类型；
Data为对象对应存储的值。

在内存上：只占一个指针的大小 8字节，节省了很多内存开销；

在效率上：objc_msgSend 先识别是否为Tagged Pointer，若是，直接返回不进行其他流程；若不是，进行其他流程（消息发送、动态方法解析、消息转发）。从而节省了调用开销。

3.3 现状

一般我们在存放NsNumber和NSDate这一类变量的时候本身占用的内存大小常常不需要8个字节。4字节带符号的整数可以达到2^31=2147483648，99.999%的情况都能满足了。所以大部分都可以用Tagged Pointer类型，不满足的则申请堆内存。

4 Tagged Pointer 原理分析

4.1 设置环境变量

设置环境变量OBJC_DISABLE_TAG_OBFUSCATION为YES，为关闭Tagged Pointer的数据混淆；

设置环境变量OBJC_DISABLE_TAGGED_POINTERS为YES，来禁用Tagged Pointer（目前不生效）在以前的版本，设置OBJC_DISABLE_TAGGED_POINTERS为YES会导致程序崩溃，是runtime中进行了判断，调用_objc_fatal()导致的程序崩溃。

4.2 举例分析

// 关闭 Tagged Pointer 数据混淆前（混淆为对于数据的保护）
NSNumber *number1 = @(1);   // number1: 0x9a90d53a8ebc20bb
NSNumber *number2 = @(2);   // number2: 0x9a90d53a8ebc208d
NSNumber *number3 = @(3);   // number3: 0x9a90d53a8ebc209c
NSNumber *numberFFFF = @(0xFFFFFFFFFFFFFFFF);   // numberFFFF: 0x600000aa0b80

// 关闭 Tagged Pointer 数据混淆后
NSNumber *number1 = @(1);   // number1: 0xb000000000000012
NSNumber *number2 = @(2);   // number2: 0xb000000000000022
NSNumber *number3 = @(3);   // number3: 0xb000000000000032
NSNumber *numberFFFF = @(0xFFFFFFFFFFFFFFFF);   // numberFFFF: 0x6000032d9560

我们设置环境变量OBJC_DISABLE_TAG_OBFUSCATION为YES，关闭了数据混淆可以看出：number1的内存为0xb000000000000012、number2的内存为0xb000000000000022、number3的内存为0xb000000000000032。并且number1的值为1、number2的值为2、number3的值为3。

通过观察发现，对象的值1、2、3都存储在了对应的指针中，对应0xb000000000000012中的1、0xb000000000000022中的2、0xb000000000000032中的3。（混淆为苹果对于数据的保护）而numberFFFF的值0xFFFFFFFFFFFFFFFF，由于数据过大，导致无法1个指针 8个字节的内存根本存不下，而申请了堆内存。

我们都知道所有的oc对象都有isa指针，那么判断一个指针是否是伪指针最重要的证据是其isa指针了，我们看下他们对应的isa指针，如下图：

由上图我们可以看出，number1、number2、number3指针为Tagged Pointer类型，为伪指针，isa指针为nil。numberFFFF的isa指针真实存在，在堆内存中分配了空间，不是Tagged Pointer类型。

以上例子从内存值和 isa两方面来验证了Tagged Pointer的定义，结合例子我们做下总结：

Tagged Pointer 为 Tag+Data 形式，其中Data为内存地址中的 1、2、3 （红色），为存储对应着对象的值。（例：0xb000000000000012 中的1）

但是内存地址： 0xb000000000000012 中对应的“b” 和 “2”，代表什么？

4.3 解析

我们先看结果，再分析。

4.3.1 解析结果

以上面例子中的0xb000000000000012 为例，指针中的 b 代表什么？

b 的二进制为 1011，其中第一位 1 是 Tagged Pointer标识位，代表这个指针是Tagged Pointer；后面的011是类标识位，对应十进制为3，表示NSNumber类。

指针中的 2 代表什么？

2代表数据类型（NSNumber 为 short、 int、 long 、 float 、 double 等。NSString 为 string长度）。

以iOS中NSNumber为例，我们看下图按照位域操作，Tag 和 Data 分别显示在什么位置、代表什么。

Tagged Pointer的Tag标记，为最高4位。其余为NSNumber数据。下面会分别对标识位、类标识、数据类型做代码验证。

4.3.2 Tagged Pointer 标识位

如何判断为Tagged Pointer?

在源码objc_internal.h中可以找到判断Tagged Pointer标识位的方法，如下代码：

static inline bool 
_objc_isTaggedPointer(const void * _Nullable ptr)
{
    return ((uintptr_t)ptr & _OBJC_TAG_MASK) == _OBJC_TAG_MASK;
}

将一个指针与 _OBJC_TAG_MASK掩码进行按位与操作。这个掩码_OBJC_TAG_MASK的源码同样在objc_internal.h中可以找到：

#if (TARGET_OS_OSX || TARGET_OS_IOSMAC) && __x86_64__
    // 64-bit Mac - tag bit is LSB
#   define OBJC_MSB_TAGGED_POINTERS 0
#else
    // Everything else - tag bit is MSB
#   define OBJC_MSB_TAGGED_POINTERS 1
#endif

#if OBJC_MSB_TAGGED_POINTERS
#   define _OBJC_TAG_MASK (1UL<<63)
#else
#   define _OBJC_TAG_MASK 1UL
#endif

根据源码得知：

MacOS下采用 LSB（Least Significant Bit，即最低有效位）为Tagged Pointer标识位；（define _OBJC_TAG_MASK 1UL）

iOS下则采用 MSB（Most Significant Bit，即最高有效位）为Tagged Pointer标识位。（define _OBJC_TAG_MASK (1UL<<63)）< span="">

如下图，以NSNumber为例：

在iOS中，1个指针8个字节，64位，最高位为1，则为Tagged Pointer。

同理在上面4.3.1 Tag 解析结果一节中，以 0xb000000000000012 为例：

0xb000000000000012 为16进制指针中的最高位b的二进制为1011，最高位为1，则代表这个指针是Tagged Pointer。

且_objc_isTaggedPointer 判断 Tagged Pointer 标识位是处处优先判断的。如下面源码（下面源码只展示相关部分）所示：

ALWAYS_INLINE id 
objc_object::rootRetain(bool tryRetain, bool handleOverflow)
{
    if (isTaggedPointer()) return (id)this;
}

ALWAYS_INLINE bool 
objc_object::rootRelease(bool performDealloc, bool handleUnderflow)
{
    if (isTaggedPointer()) return false;
}

inline bool 
objc_object::isTaggedPointer() 
{
    return _objc_isTaggedPointer(this);
}

在源码objc_object.h中可以找到的objc_object::rootRetain方法，该方法为引用计数+1的方法，在这个方法中，优先判断是否是Tagged Pointer，Tagged Pointer为伪指针，不需要记录引用计数。

在源码objc_object.h中可以找到的objc_object::rootRelease方法，该方法为引用计数-1的方法，在这个方法中，优先判断是否是Tagged Pointer，Tagged Pointer为伪指针，不需要记录引用计数。

objc_msgSend为汇编代码，但其实里面也优先做了Tagged Pointer标识位判断。如果不是Tagged Pointer则进行消息转发等流程。

Tagged Pointer的判断是如此的简单，只是二进制的与运算。

4.3.3 Tagged Pointer 类标识

从苹果官方介绍来看， Tagged Pointer被设计的目的是用来存储较小的对象，例如NSNumber、NSDate、NSString 等；那么Tagged Pointer 只是一个伪指针，一个64位的二进制，如何来区分是NSNumber呢？还是NSString等呢？

在源码objc_internal.h中可以查看到NSNumber、NSDate、NSString等类的标识位，这里只展示我们关心的类型，全面的在4.4里有介绍。

{
    // 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,
    // 保留位
    OBJC_TAG_RESERVED_7        = 7,
    。。。
}

下面让我们举例验证，不同的类型，输出一下看看地址：

// number1: 0xb000000000000012 
NSNumber *number1 = @(1); 

// string: 0xa000000000000611
NSString *string = [NSString stringWithFormat:@"a"];

根据输出我们可以看到：

NSNumber 指针 0xb000000000000012，b 的二进制为 1011，后面的011是类标识位，对应十进制为3，表示 NSNumber 类；

NSString 指针 0xa000000000000611， a 的二进制为 1010，后面的010是类标识位，对应十进制为2，表示 NSString 类。

如图，类标识位置如下：

4.3.4 Tagged Pointer 数据类型

我们知道了以NSNumber为例的地址 0xb000000000000012 的数据数值、Tagged Pointer 标识位、Tagged Pointer 类标识。那么最后一位 2 代表的是什么呢？

16进制的最后一位（即2进制的最后四位）表示数据类型。同样我们举例验证：

char a = 1;
short b = 1;
int c = 1;
long d = 1;
float e = 1.0;
double f = 1.00;

NSNumber *number1 = @(a);   // 0xb000000000000010
NSNumber *number2 = @(b);   // 0xb000000000000011
NSNumber *number3 = @(c);   // 0xb000000000000012
NSNumber *number4 = @(d);   // 0xb000000000000013
NSNumber *number5 = @(e);   // 0xb000000000000014
NSNumber *number6 = @(f);   // 0xb000000000000015

可以看到，我们都用NSNumber类，用不同数据类型做测试，内存地址16进制只有最后一位发生了变化。其对应的数据类型分别为：

数据类型	内存地址二进制最后四位
char	0
short	1
int	2
long	3
float	4
double	5

NSString、NSDate的二进制最后四位都是数据类型么？你可以自己去验证一下～

如图，数据类型位置如下：

至此我们就把 Tagged Pointer 实质 Tag+Data 完整地解析了一遍。

4.4 Tagged pointer 注释

在源码objc-runtime-new.mm中有一段注释对Tagged pointer objects 进行了解释，原文如下：

/***********************************************************************
* Tagged pointer objects.
*
* Tagged pointer objects store the class and the object value in the
* object pointer; the "pointer" does not actually point to anything.
*
* Tagged pointer objects currently use this representation:
* (LSB)
*  1 bit   set if tagged, clear if ordinary object pointer
*  3 bits  tag index
* 60 bits  payload
* (MSB)
* The tag index defines the object's class.
* The payload format is defined by the object's class.
*
* If the tag index is 0b111, the tagged pointer object uses an
* "extended" representation, allowing more classes but with smaller payloads:
* (LSB)
*  1 bit   set if tagged, clear if ordinary object pointer
*  3 bits  0b111
*  8 bits  extended tag index
* 52 bits  payload
* (MSB)
*
* Some architectures reverse the MSB and LSB in these representations.
*
* This representation is subject to change. Representation-agnostic SPI is:
* objc-internal.h for class implementers.
* objc-gdb.h for debuggers.
**********************************************************************/

对应注释翻译：

Tagged pointer 指针对象将class和对象数据存储在对象指针中；指针实际上不指向任何东西。
Tagged pointer 当前使用此表示形式：
- (LSB)(macOS)64位分布如下：
  - 1 bit 标记是 Tagged Pointer
  - 3 bits 标记类型
  - 60 bits 负载数据容量，（存储对象数据）
- (MSB)(iOS)64位分布如下：
  - tag index 表示对象所属的 class
  - 负载格式由对象的 class 定义
  - 如果 tag index 是 0b111(7)， tagged pointer 对象使用 “扩展” 表示形式
  - 允许更多类，但有效载荷更小
- (LSB)(macOS)(带有扩展内容)64位分布如下：
  - 1 bit 标记是 Tagged Pointer
  - 3 bits 是 0b111
  - 8 bits 扩展标记格式
  - 52 bits 负载数据容量，（存储对象数据）
在这些表示中，某些体系结构反转了MSB和LSB。

从注释中我们得知：

Tagged pointer 存储对象数据目前分为60bits负载容量和52bits负载容量。
类标识允许使用扩展形式。

那么如何判断负载容量？类标识的扩展类型有那些？我们来看下全面的objc_tag_index_t源码：

// 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,
    // 保留位
    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_NSColor           = 16,
    OBJC_TAG_UIColor           = 17,
    OBJC_TAG_CGColor           = 18,
    OBJC_TAG_NSIndexSet        = 19,
    // 前60位负载内容
    OBJC_TAG_First60BitPayload = 0, 
    // 后60位负载内容
    OBJC_TAG_Last60BitPayload  = 6, 
    // 前52位负载内容
    OBJC_TAG_First52BitPayload = 8, 
    // 后52位负载内容
    OBJC_TAG_Last52BitPayload  = 263, 
    // 保留位
    OBJC_TAG_RESERVED_264      = 264
}

小结：

区分什么位置为负载内容位

MacOS下采用 LSB 即OBJC_TAG_First60BitPayload、OBJC_TAG_First52BitPayload。

iOS下则采用 MSB 即OBJC_TAG_Last60BitPayload、OBJC_TAG_Last52BitPayload。

区分负载数据容量

当类标识为0-6时，负载数据容量为60bits。

当类标识为7时(对应二进制为 0b111)，负载数据容量为52bits。

类标识的扩展类型有哪些？

如果tag index 是 0b111(7)， tagged pointer对象使用 “扩展” 表示形式

类标识的扩展类型为上面OBJC_TAG_Photos_1 ～OBJC_TAG_NSIndexSet。

类标识与负载数据容量对应关系

当类标识为0-6时，负载数据容量为 60bits。即OBJC_TAG_First60BitPayload 和 OBJC_TAG_Last60BitPayload，负载数据容量的取值区间也为 0 - 6。

当类标识为7时，负载数据容量为52bits。即OBJC_TAG_First52BitPayload 和 OBJC_TAG_Last52BitPayload，负载数据容量的取值区间为 8 - 263。

你品，你细品这里。只要一个tag，既可以区分负载数据容量，也可以区分类标识，就是这么滴强大～

5 创建 Tagged Pointer

我们知道了Tagged Pointer 的实质 Tag+Data，知道了Tag对应什么，Data对应什么。那么为什么NSNumber、NSDate、NSString会转成为伪指针呢？其他的为什么不会呢？NSNumber、NSDate、NSString是如何生成 Tagged Pointer 的？下面让我们继续探索 Tagged Pointer。

5.1 Tagged Pointer初始化

5.1.1 初始变量设置

在_read_images()方法中，有两处关键代码如下：

void _read_images(header_info **hList, uint32_t hCount, int totalClasses, int unoptimizedTotalClasses)
{
    if (DisableTaggedPointers) {
        disableTaggedPointers();
    }

    initializeTaggedPointerObfuscator();
}

上面方法主要分两部分：

disableTaggedPointers()：禁用Tagged Pointer，与环境变量OBJC_DISABLE_TAGGED_POINTERS相关。这里就不详述了～
initializeTaggedPointerObfuscator()：初始化 TaggedPointer 混淆器：用于保护 Tagged Pointer 上的数据。我们看下这个方法的源码：

static void
initializeTaggedPointerObfuscator(void)
{
    if (sdkIsOlderThan(10_14, 12_0, 12_0, 5_0, 3_0) ||
        DisableTaggedPointerObfuscation) {
        objc_debug_taggedpointer_obfuscator = 0;
    } else {
        arc4random_buf(&objc_debug_taggedpointer_obfuscator,
                       sizeof(objc_debug_taggedpointer_obfuscator));
        objc_debug_taggedpointer_obfuscator &= ~_OBJC_TAG_MASK;
    }
}

上面方法主要分三部分：

objc_debug_taggedpointer_obfuscator 是一个 unsigned long 类型的全局变量。objc_debug_taggedpointer_obfuscator的用处，下面有用到～
对于一些旧版本和环境变量(OBJC_DISABLE_TAG_OBFUSCATION)，禁用 tagged pointers 混淆。设置 objc_debug_taggedpointer_obfuscator 为0，不混淆。
获得 objc_debug_taggedpointer_obfuscator的值：
- 将随机数据放入变量中，然后移走所有非有效位。
- 和 ~_OBJC_TAG_MASK 作一次与操作。

5.1.2 Tagged Pointer注册校验

为什么NSNumber、NSDate、NSString会转成为伪指针呢？其他的为什么不会呢？

加载程序时，从dyld库的_dyld_start()函数开始，经历了多般步骤，开始调用_objc_registerTaggedPointerClass() 函数。下面我们来看下在源码objc-runtime-new.mm中该方法的实现：

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);
    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;
    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;
        }
    }
}

方法主要分为以下三部分：

判断是否禁用 Tagged Pointer，若禁用，则终止程序。
根据指定 tag 获取类指针。若tag 被用于两个不同的类，则终止程序。
判断负载数据容量如果是52bits进行特殊处理，在OBJC_TAG_RESERVED_7处存储占位类 OBJC_CLASS_$___NSUnrecognizedTaggedPointer。

其实这个方法起的名字是注册，在我看来，应该叫校验。校验在全局数组（以tag 进行位操作为索引，类为value，的全局数组）中，用tag 取出来的类指针与注册的类是否相符。

这里我们主要关注下_objc_registerTaggedPointerClass()方法的精髓第二点、根据指定tag 获取类指针。我们看下classSlotForTagIndex 的源码实现：

static Class *  
classSlotForTagIndex(objc_tag_index_t tag)
{
    if (tag >= OBJC_TAG_First60BitPayload && tag <= OBJC_TAG_Last60BitPayload) {
        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;
}

以上方法主要分为三部分：

根据负载数据容量是60bits还是52bits，区分为类标识是基础类标识还是扩展类标识。也可以说根据tag类标识区间判断。
tag是基础类标识，返回classSlotForBasicTagIndex(tag)的结果;
tag是扩展类标识，对tag进行位操作，然后取出存在objc_tag_ext_classes数组里的结果返回。

这里有两个重要的全局数组：

#if SUPPORT_TAGGED_POINTERS

extern "C" { 
    extern Class objc_debug_taggedpointer_classes[_OBJC_TAG_SLOT_COUNT];
    extern Class objc_debug_taggedpointer_ext_classes[_OBJC_TAG_EXT_SLOT_COUNT];
}
#define objc_tag_classes objc_debug_taggedpointer_classes
#define objc_tag_ext_classes objc_debug_taggedpointer_ext_classes

#endif

数组objc_tag_classes：存储苹果定义的几个基础类；

数组objc_tag_ext_classes：存储苹果预留的扩展类；

在源码中，包括源码中的汇编位置，都没有找到初始化这两个数组的代码～了解这两个全局数组的初始化位置的，请告知笔者，非常感谢～

我们继续看classSlotForBasicTagIndex的源码：

static Class *
classSlotForBasicTagIndex(objc_tag_index_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
#if SUPPORT_MSB_TAGGED_POINTERS
    return &objc_tag_classes[0x8 | obfuscatedTag];
#else
    return &objc_tag_classes[(obfuscatedTag << 1) | 1];
#endif
}

以上方法主要分为以下两个部分：

对tag类标识，进行了一系列的位运算。(运算里面的宏定义在5.2中有讲～有兴趣的可以自己算算哦～)
根据判断是macOS or iOS，来获取objc_tag_classes数组里面的类指针。

5.2 生成 Tagged Pointer 指针

static inline void * _Nonnull
_objc_makeTaggedPointer(objc_tag_index_t tag, uintptr_t value)
{
    if (tag <= OBJC_TAG_Last60BitPayload) {
        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 {
        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);
    }
}

方法主要分为以下三部分：

根据负载内容位进行区分：

传入的tag为类标识，同时也可以用于区分负载数据容量，苹果根据不同的负载数据容量对Tagged Pointer 进行了不同的处理。

对传入objc_tag_index_t tag和value进行位运算：

以NSNumber *a = @(1); 为例：
- tag 为OBJC_TAG_NSNumber(3) 二进制：0b011，16进制为 0x0000000000000003，负载数据容量为 OBJC_TAG_Last60BitPayload。
- value 为数据数值(1) + 数据类型(int 为 2) 16进制为 0x0000000000000012。
在 iOS 下源码中的宏定义：(有兴趣的可以源码走一波～)
- _OBJC_TAG_MASK ：#define _OBJC_TAG_MASK (1UL<<63)
- _OBJC_TAG_INDEX_SHIFT：#define _OBJC_TAG_INDEX_SHIFT 60
- _OBJC_TAG_PAYLOAD_RSHIFT：#define _OBJC_TAG_PAYLOAD_RSHIFT 4
对tag 和 value进行运算得到指针result：uintptr_t result = (_OBJC_TAG_MASK | ((uintptr_t)tag << _OBJC_TAG_INDEX_SHIFT) | ((value << _OBJC_TAG_PAYLOAD_RSHIFT) >> _OBJC_TAG_PAYLOAD_LSHIFT));
- (uintptr_t)tag << _OBJC_TAG_INDEX_SHIFT)：tag 为 0x0000000000000003 左移 _OBJC_TAG_INDEX_SHIFT(60) 得到十六进制： 0x3000000000000000；
- ((value << _OBJC_TAG_PAYLOAD_RSHIFT) >> _OBJC_TAG_PAYLOAD_LSHIFT)：value 为0x0000000000000012，位运算后为 0x0000000000000012；
- result 为 _OBJC_TAG_MASK(1UL<<63) 和 0x3000000000000000 和 0x0000000000000012 进行 “或” 操作；
- result 为 0xb000000000000012；

进行编码（数据混淆，数据保护）：对result （0xb000000000000012）进行编码，我们看下：

static inline void * _Nonnull
_objc_encodeTaggedPointer(uintptr_t ptr)
{
    return (void *)(objc_debug_taggedpointer_obfuscator ^ ptr);
}

static inline uintptr_t
_objc_decodeTaggedPointer(const void * _Nullable ptr)
{
    return (uintptr_t)ptr ^ objc_debug_taggedpointer_obfuscator;
}

无论是编码还是解码，都是对tagged pointers与objc_debug_taggedpointer_obfuscator 来进行 “异或” 操作。

源码里面还有很多别的方法，例如取Tagged Pointer指针里面的tag方法，获取Tagged Pointer指针里面的value方法等，有兴趣的可以去看看，在这里不一一叙述。

6 Tagged Pointer 使用注意

我们使用Tagged Pointer的时候需要注意什么呢？

所有的oc对象都有isa指针，而Tagged Pointer并不是真正的对象，是伪指针，它没有isa指针。所以通过LLDB打印Tagged Pointer的isa，会提示下图所示的错误。打印OC对象的isa没有问题，对于Tagged Pointer，应该换成相应的方法调用，如isKindOfClass和object_getClass。

至此，关于 Tagged Pointer，已经讲完～♥️

本文转载自公众号贝壳产品技术（ID：beikeTC）。

原文链接：

iOS内存管理之Tagged Pointer

创作场景

iOS 内存管理之 Tagged Pointer