借着最近开始研究JavaScriptCore的契机，我决定利用这一两天所学的JavaScript知识，在业余时间做一个简单的iOS动态执行器玩具。

题外话1：听说滴滴基于LLVM backend搞了一套中间语言解释器，不知道最后用了哪个？不过LLVM IR解释器的话，嘿嘿，还是有点意思的。

题外话2：我研究这个并不是想做iOS动态化，因为xxxxxxx。我只是纯粹想看看JavaScriptCore的一些实现而已。

效果

一张Gif图想必能最佳得展示我做的玩具，请各位大佬过目：

前置知识点

在实现我们的执行器前，我们还是要稍微要了解一下一些前置的知识点。

JSWrapper Object

大家都知道，Objective-C中的诸多类型在JavaScript的环境里是不能直接用的，需要通过JSValue进行一层包装，具体的类型转换如下图展示：

基本上图上的转换都很容易理解，唯一需要我们注意的是Wrapper Object。什么是Wrapper Object呢？

举个例子：

self.context[@"a"] = [CustomObject new]

上述代码将我们一个自定义类型CustomObject的实例以变量名a的方式注入到了JavaScript的运行环境里。但是她是怎么知道我们的定义呢，又是如何知道我们是否能调用特定的方法？

从默认的角度看，JS运行环境只会把OC中init初始化方法以及类的继承关系给同步到JS环境中（如果有JSExport我们下文说），然后这个对象会包装给一个JSWrapperValue用于JS环境中使用。而当JS环境调用OC并且涉及到这个对象的时候，JavaScriptCore会自动将其解包还原成原始的OC对象类型。

- (JSValue *)jsWrapperForObject:(id)object
{
    JSC::JSObject* jsWrapper = m_cachedJSWrappers.get(object);
    if (jsWrapper)
        return [JSValue valueWithJSValueRef:toRef(jsWrapper) inContext:m_context];

     // 注意点!!!!!!!!!!!!!!!!!!
    JSValue *wrapper;
    if (class_isMetaClass(object_getClass(object)))
        wrapper = [[self classInfoForClass:(Class)object] constructor];
    else {
        JSObjCClassInfo* classInfo = [self classInfoForClass:[object class]];
        wrapper = [classInfo wrapperForObject:object];
    }

    JSC::ExecState* exec = toJS([m_context JSGlobalContextRef]);
    jsWrapper = toJS(exec, valueInternalValue(wrapper)).toObject(exec);
    m_cachedJSWrappers.set(object, jsWrapper);
    return wrapper;
}

• 整体分析下，就是基于一个缓存来判断是否对特定的对象或类型已经构建果Wrapper Object，没有的话就进行构建，构建过程如下：

1
2
3
4
5
6
7

JSClassDefinition definition;

definition = kJSClassDefinitionEmpty;
definition.className = className;
m_classRef = JSClassCreate(&definition);

[self allocateConstructorAndPrototypeWithSuperClassInfo:superClassInfo];

• 没啥特别的，就是OC对象创建对应的JS对象，类型对类型。
• OC类型的继承关系在JS里面通过设置Constructor和Prototype进行构建，其实就是简单的JavaScript原型链继承。

JSExport协议 & JSExportAs

JSExport协议本质上只是个Protocol标记，用于让JavaScriptCore加载那些打上这个特殊标记的类，用于特定方式的注册及初始化。

上文我们提过，默认情况下，JavaScriptCore会对象创建一个默认的Wrapper Object，但是这个对象除了简单继承关系外，也就一个按照特殊格式命令的Constructor而已：

[NSString stringWithFormat:@"%sConstructor", className]

那如果我们需要将OC环境中的方法注入到JS环境中，就需要用到JSExport协议了，这个协议在运行时会按照如下逻辑进行处理，将方法和属性进行诸如注入：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

检查init方法簇的方法，并根据这么合法提供合理的

__block HashMap<String, Protocol *> initTable;
    Protocol *exportProtocol = getJSExportProtocol();
    for (Class currentClass = cls; currentClass; currentClass = class_getSuperclass(currentClass)) {
        forEachProtocolImplementingProtocol(currentClass, exportProtocol, ^(Protocol *protocol) {
            forEachMethodInProtocol(protocol, YES, YES, ^(SEL selector, const char*) {
                const char* name = sel_getName(selector);
                if (!isInitFamilyMethod(@(name)))
                    return;
                initTable.set(name, protocol);
            });
        });
    }

    for (Class currentClass = cls; currentClass; currentClass = class_getSuperclass(currentClass)) {
        __block unsigned numberOfInitsFound = 0;
        __block SEL initMethod = 0;
        __block Protocol *initProtocol = 0;
        __block const char* types = 0;
        forEachMethodInClass(currentClass, ^(Method method) {
            SEL selector = method_getName(method);
            const char* name = sel_getName(selector);
            auto iter = initTable.find(name);

            if (iter == initTable.end())
                return;

            numberOfInitsFound++;
            initMethod = selector;
            initProtocol = iter->value;
            types = method_getTypeEncoding(method);
        });

        if (!numberOfInitsFound)
            continue;

        if (numberOfInitsFound > 1) {
            NSLog(@"ERROR: Class %@ exported more than one init family method via JSExport. Class %@ will not have a callable JavaScript constructor function.", cls, cls);
            break;
        }

        JSObjectRef method = objCCallbackFunctionForInit(context, cls, initProtocol, initMethod, types);
        return [JSValue valueWithJSValueRef:method inContext:context];
    }

1
2
3
4
5
6

注入方法和属性
Protocol *exportProtocol = getJSExportProtocol();
forEachProtocolImplementingProtocol(m_class, exportProtocol, ^(Protocol *protocol){
  copyPrototypeProperties(m_context, m_class, protocol, prototype);
  copyMethodsToObject(m_context, m_class, protocol, NO, constructor);
});

而至于JSExportAs，就是做了个简单的名称映射而已，毕竟JS函数传参和OC有很大的区别：

static NSMutableDictionary *createRenameMap(Protocol *protocol, BOOL isInstanceMethod)
{
    NSMutableDictionary *renameMap = [[NSMutableDictionary alloc] init];

    forEachMethodInProtocol(protocol, NO, isInstanceMethod, ^(SEL sel, const char*){
        NSString *rename = @(sel_getName(sel));
        NSRange range = [rename rangeOfString:@"__JS_EXPORT_AS__"];
        if (range.location == NSNotFound)
            return;
        NSString *selector = [rename substringToIndex:range.location];
        NSUInteger begin = range.location + range.length;
        NSUInteger length = [rename length] - begin - 1;
        NSString *name = [rename substringWithRange:(NSRange){ begin, length }];
        renameMap[selector] = name;
    });

    return renameMap;
}

实现过程

说了那么多基础原理，下面让我们来看看具体实现流程：

类、实例和方法

在我看来，要实现一个动态化的执行环境，有三要素是必不可少的：

类（包括元类）、实例对象以及方法。

基于我们上文对于Wrapper Object的分析，我们可以构建特殊类型的Wrapper Object对这三个元素进行包装，具体就不说了，还是建议大家自行思考，基本上类似我上文分析JSWrapperObject的步骤。

除了上述三要素，我们还需要定义一个全局变量，WZGloablObject（大家可以理解为浏览器的window对象），用于拦截顶层的属性访问。

按照这个设计，大家可以自行思考下，如果是你做，你会如何继续下面的工作，文章下周随着代码一起发布吧。

Choose 调试

搞过逆向用过Cycript的朋友都知道，Cycript在调试时候有个非常方便的调试功能：Choose。该功能可以快速的帮助我们根据类名在堆上的对象全部查询返回。

这么实用的功能必须提供，我基本上直接照搬了Cycript的实现。代码很清晰，基本能够自解释其逻辑。核心基本上就是遍历每个malloc_zone，然后根据获取的vmaddress_range判断获取到的数据其类型是不是我们要的。

// 遍历zone
for (unsigned i = 0; i != size; ++i) {
    const malloc_zone_t * zone = reinterpret_cast<const malloc_zone_t *>(zones[i]);
    if (zone == NULL || zone->introspect == NULL)
        continue;
    zone->introspect->enumerator(mach_task_self(), &choice, MALLOC_PTR_IN_USE_RANGE_TYPE, zones[i], &read_memory, &choose_);
}

// 检查对象
for (unsigned i = 0; i < count; ++i) {
   vm_range_t &range = ranges[i];
   void * data = reinterpret_cast<void *>(range.address);
   size_t size = range.size;

   if (size < sizeof(ObjectStruct))
       continue;

   uintptr_t * pointers = reinterpret_cast<uintptr_t *>(data);
#ifdef __arm64__
   Class isa = (__bridge Class)((void *)(pointers[0] & 0x1fffffff8));
#else
   Class isa = reinterpret_cast<Class>(pointers[0]);
#endif
   std::set<Class>::const_iterator result(choice->query_.find(isa));
   if (result == choice->query_.end())
       continue;

   size_t needed = class_getInstanceSize(*result);
   size_t boundary = 496;
#ifdef __LP64__
   boundary *= 2;
#endif
   if ((needed <= boundary && (needed + 15) / 16 * 16 != size) || (needed > boundary && (needed + 511) / 512 * 512 != size))
       continue;
   choice->result_.insert((__bridge id)(data));
}

不过这里一大堆的511、512的数字构成的公式，实话说我不是很懂，有了解的大佬麻烦告知我一下。

类型转换

首先我们需要记住，JavaScript的基础类型如下：

- 字符串、
- 数字、
- 布尔、
- 数组、
- 对象、
- Null、
- Undefined

所以我们只要根据对应的进行转换就可以，如下所示：

• JS字符串 <-> NSString
• 数字 <-> NSNumber
• 数组 <-> NSArray
• Null <-> NSNull
• Undefined <-> Void (仅当返回值的时候处理，否则直接抛出异常)

题外话，JavaScript里面没有什么整数和浮点数类型区分一说，所以我们可以无脑将其通过double的方式构建NSNumber

最后再来说下对对象类型的处理：

在JavaScript，任何对象都可以简单理解为包含了属性（方法）的一个包装体，如下所示:

var a = {x:10, y:100};

因此，我们在对类型进行转换的时候，要特别注意以下几点：

• 这个对象是不是我们刚刚上文提过的类、实例、方法，是的话在其进入到Objective-C执行上下文的之前从JSWrapperObject中取出来。
• 这个对象是不是特定类型的结构体，是的话我们将其转换成结构体，比如CGRect之类的，是的话需要特别转换
• 是不是可以直接转换成特定类型的对象，比如Date <-> NSDate的转换。
• 最后，将其可遍历的属性和对应的属性值，转换到NSDictionary之中。
• 当然，别忘了，需要注意递归处理。

Calling Convention

关于Calling Convention，本文就不再赘述，有兴趣的读者可以参考我和同事一起写的知乎专栏iOS调试进阶

简单来重新描述下就是：

一个函数的调用过程中，函数的参数既可以使用栈传递，也可以使用寄存器传递，参数压栈的顺序可以从左到右也可以从右到左，函数调用后参数从栈弹出这个工作可以由函数调用方完成，也可以由被调用方完成。如果函数的调用方和被调用方(函数本身)不遵循统一的约定，有这么多分歧这个函数调用就没法完成。这个双方必须遵守的统一约定就叫做调用惯例(Calling Convention)，调用惯例规定了参数的传递的顺序和方式，以及栈的维护方式。

由于业界已经有知名大佬写的libffi，所以我们不需要重复发明轮子，直接使用即可。如果真的要了解具体原理，也可以参考我的文章，具体分析objc_msgSend的实现流程。

其他

为了偷懒，我直接用JavaScript实现了这些的效果。其实理论上，如果我完整的实现编译前端，构建抽象语法树分析执行上下文，将Objective-C的代码转换成JavaScript，那么就能实现动态执行Objective-C代码了。(当然本质上还是障眼法)

其实更快的方式，且不能保证完全正确的方式，就是调用一下JSPatchConvertor就好了，哈哈哈。

大水文一篇
大水文一篇
大水文一篇

起因

最近对Block的一些实现细节又进行了一次复习，主要涉及的是捕捉变量的部分。有一个点我之前一直没太关注：对ivar变量的直接访问为啥会产生循环引用。

在我原先的理解中，之所以会产生循环引用，绝大多数场景都是由于block里面涉及了self关键字，比如[self doSomething]（同理，对于property的访问本质也是一堆方法），但是为啥对ivar的访问也会导致循环引用呢？

不是直接采用 *(void *)address = xxx这样的直接对编译好的静态地址赋值就好了？

当时傻逼了，写完本文后想想就算编译成地址了，基地址从哪算还是要依赖self变量。

谈谈ivar的访问是啥形式

还是回到runtime来看看吧，万变不离其宗，从objc_class结构体看起：

struct objc_class : objc_object {
    // Class ISA; // 8byte
    Class superclass; // 8byte
    cache_t cache;             // formerly cache pointer and vtable // 4 + 4 + 8
    class_data_bits_t bits;    // class_rw_t * plus custom rr/alloc flags

    class_rw_t *data() { 
        return bits.data();
    }

主要的运行时数据都是class_rw_t表示，继续瞅瞅：

struct class_rw_t {
    // Be warned that Symbolication knows the layout of this structure.
    uint32_t flags;
    uint32_t version;

    const class_ro_t *ro;

其中class_ro_t基本上是从二进制产物中读取的“副本”数据，我们看看：

struct class_ro_t {
    uint32_t flags;
    uint32_t instanceStart;
    uint32_t instanceSize;
#ifdef __LP64__
    uint32_t reserved;
#endif

    const uint8_t * ivarLayout;

    const char * name;
    method_list_t * baseMethodList;
    protocol_list_t * baseProtocols;
    const ivar_list_t * ivars;

看起来ivar_list_t就是存放ivar的列表，他的实现是一个模版类，看看具体结构表示：

struct entsize_list_tt {
    uint32_t entsizeAndFlags;
    uint32_t count;
    Element first;

具体对应ivar，替换掉模版就是：

struct ivar_list_t {
    uint32_t entsizeAndFlags;
    uint32_t count;
    ivar_t first;

其中，ivar_t表征的就是我们每个ivar，

int32_t *offset;
const char *name;
const char *type;

嗯，从这里开始offset是用一个int32_t *的指针来表示，就开始有意思了。这里我们先暂时忽略

看起来，如果按照这种方式访问ivar，整个流程要经过好多次指针转移：

class -> class.rw_data -> class.rw_data.ro_data -> class.rw_data.ro_data.ivars -> 
-> class.rw_data.ro_data.ivars.first[n]

如果是这样，大量使用ivar肯定很耗时。那么，对于ivar的访问究竟是怎么玩的呢？

全局变量

我们用如下这个非常简单的例子来瞅瞅：

typedef void(^MyBlock)(void);

@interface MyObject : NSObject
@property (nonatomic) NSUInteger haha;
@property (nonatomic, copy) MyBlock block;

- (void)inits;

@end

@implementation MyObject
- (void)inits
{
    self.block = ^{
        _haha = 5;
    };
}
@end

int main(int argc, char * argv[]) {
    MyObject *object = [MyObject new];
    [object inits];
}

重写一把，基本转化成如下的形式：

typedef void(*MyBlock)(void);


#ifndef _REWRITER_typedef_MyObject
#define _REWRITER_typedef_MyObject
typedef struct objc_object MyObject;
typedef struct {} _objc_exc_MyObject;
#endif

// 注意点1!!!!!!!!!!!!!!!!!!!!
extern "C" unsigned long OBJC_IVAR_$_MyObject$_haha;
extern "C" unsigned long OBJC_IVAR_$_MyObject$_block;
struct MyObject_IMPL {
    struct NSObject_IMPL NSObject_IVARS;
    NSUInteger _haha;
    MyBlock _block;
};

// @property (nonatomic) NSUInteger haha;
// @property (nonatomic, copy) MyBlock block;

// - (void)inits;

/* @end */


// @implementation MyObject

struct __MyObject__inits_block_impl_0 {
  struct __block_impl impl;
  struct __MyObject__inits_block_desc_0* Desc;
  MyObject *self;

  // 注意点2！！！！！！！！！！！！！！！
  __MyObject__inits_block_impl_0(void *fp, struct __MyObject__inits_block_desc_0 *desc, MyObject *_self, int flags=0) : self(_self) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};

／／ 注意点3！！！！！！！！！！！！
static void __MyObject__inits_block_func_0(struct __MyObject__inits_block_impl_0 *__cself) {
  MyObject *self = __cself->self; // bound by copy

        (*(NSUInteger *)((char *)self + OBJC_IVAR_$_MyObject$_haha)) = 5;
    }
static void __MyObject__inits_block_copy_0(struct __MyObject__inits_block_impl_0*dst, struct __MyObject__inits_block_impl_0*src) {_Block_object_assign((void*)&dst->self, (void*)src->self, 3/*BLOCK_FIELD_IS_OBJECT*/);}

static void __MyObject__inits_block_dispose_0(struct __MyObject__inits_block_impl_0*src) {_Block_object_dispose((void*)src->self, 3/*BLOCK_FIELD_IS_OBJECT*/);}

static struct __MyObject__inits_block_desc_0 {
  size_t reserved;
  size_t Block_size;
  void (*copy)(struct __MyObject__inits_block_impl_0*, struct __MyObject__inits_block_impl_0*);
  void (*dispose)(struct __MyObject__inits_block_impl_0*);
} __MyObject__inits_block_desc_0_DATA = { 0, sizeof(struct __MyObject__inits_block_impl_0), __MyObject__inits_block_copy_0, __MyObject__inits_block_dispose_0};

static void _I_MyObject_inits(MyObject * self, SEL _cmd) {
    ((void (*)(id, SEL, MyBlock))(void *)objc_msgSend)((id)self, sel_registerName("setBlock:"), ((void (*)())&__MyObject__inits_block_impl_0((void *)__MyObject__inits_block_func_0, &__MyObject__inits_block_desc_0_DATA, self, 570425344)));
}

static NSUInteger _I_MyObject_haha(MyObject * self, SEL _cmd) { return (*(NSUInteger *)((char *)self + OBJC_IVAR_$_MyObject$_haha)); }
static void _I_MyObject_setHaha_(MyObject * self, SEL _cmd, NSUInteger haha) { (*(NSUInteger *)((char *)self + OBJC_IVAR_$_MyObject$_haha)) = haha; }

static void(* _I_MyObject_block(MyObject * self, SEL _cmd) )(){ return (*(MyBlock *)((char *)self + OBJC_IVAR_$_MyObject$_block)); }
extern "C" __declspec(dllimport) void objc_setProperty (id, SEL, long, id, bool, bool);

static void _I_MyObject_setBlock_(MyObject * self, SEL _cmd, MyBlock block) { objc_setProperty (self, _cmd, __OFFSETOFIVAR__(struct MyObject, _block), (id)block, 0, 1); }
// @end

int main(int argc, char * argv[]) {
    MyObject *object = ((MyObject *(*)(id, SEL))(void *)objc_msgSend)((id)objc_getClass("MyObject"), sel_registerName("new"));
    ((void (*)(id, SEL))(void *)objc_msgSend)((id)object, sel_registerName("inits"));
}

一大堆东西，没啥特别的地方，我们只要关注几个地方：

• 对于每个ivar，都有对应的全局变量

  extern "C" unsigned long OBJC_IVAR_$_MyObject$_haha;
  extern "C" unsigned long OBJC_IVAR_$_MyObject$_block;
  

• block_invoke对应的实现是通过对象自身作为基地址，全局变量作为偏移去对haha这个ivar进行赋值。

  static void __MyObject__inits_block_func_0(struct __MyObject__inits_block_impl_0 *__cself) {
    MyObject *self = __cself->self; // bound by copy
  
          (*(NSUInteger *)((char *)self + OBJC_IVAR_$_MyObject$_haha)) = 5;
      }
  

• block的构造函数，确实捕捉了self

  __MyObject__inits_block_impl_0(void *fp, struct __MyObject__inits_block_desc_0 *desc, MyObject *_self, int flags=0) : self(_self) {
      impl.isa = &_NSConcreteStackBlock;
      impl.Flags = flags;
      impl.FuncPtr = fp;
      Desc = desc;
    }
  

由于全局变量的地址是在编译期就确定了，所以这里也就不难解释ivar_t里面为什么要保存int32_t *，保存的就是对应的全局变量地址。而全局变量的值则是对应的动态偏移。

结语

水完了，其实虽然runtime的结构体设计的比较绕，但是最后对于变量的访问和很多静态语言设计一样，也不会损失很多性能。

从另外一个角度看，如果声明了巨多的ivar，看来也会对包大小产生不可忽视的影响。

欢迎加入我们手淘／天猫的架构组来内网阅读

提起iOS的内存管理，大多数人第一反应想到的都是引用计数、ARC、AutoreleasePool之类的词眼。但是事实上，这只是iOS内存管理的冰山一角，今天就让我们来探究水面之下的内存管理。

虚拟内存的限制

我之所以想研究这个议题，主要还是之前有个UC同事问了我一个问题：

“现在绝大多数都是ARM64的设备，即64位寻址空间，而且iOS上的通过malloc申请的内存只是虚拟内存，还不是真正物理内存，为什么分配了两三G就会失败了。”

按照他的想法，我在我的iPhone上测试了如下代码：

void *buffer = malloc(2000 * 1024 * 1024);

果不其然，报出了如下错误：

malloc: *** mach_vm_map(size=2097152000) failed (error code=3)
*** error: can't allocate region

次奥，我xxxxx分配一个2G虚拟内存就懵逼？

还是赶紧翻翻看源码，由于我分配的是一个超大的内存，所以按照nano_zone和scalable_zone的设计理念，

• 小于256byte的走nano_zone进行分配。
• 剩下的我记不得了

赶紧翻翻scalable_zone看看源码，如下所示：

void *    szone_malloc_should_clear(szone_t *szone, size_t size, boolean_t cleared_requested)
{
    void *ptr;
    msize_t msize;

    if (size <= SMALL_THRESHOLD) {
        // tiny size: <1024 bytes (64-bit), <512 bytes (32-bit)
        // think tiny
        msize = TINY_MSIZE_FOR_BYTES(size + TINY_QUANTUM - 1);
        if (!msize) {
            msize = 1;
        }
        ptr = tiny_malloc_should_clear(szone, msize, cleared_requested);
    } else if (size <= szone->large_threshold) {
        // small size: <15k (<1GB machines), <127k (>1GB machines)
        // think small
        msize = SMALL_MSIZE_FOR_BYTES(size + SMALL_QUANTUM - 1);
        if (!msize) {
            msize = 1;
        }
        ptr = small_malloc_should_clear(szone, msize, cleared_requested);
    } else {
        // large: all other allocations
        size_t num_kernel_pages = round_page_quanta(size) >> vm_page_quanta_shift;
        if (num_kernel_pages == 0) { /* Overflowed */
            ptr = 0;
        } else {
            ptr = large_malloc(szone, num_kernel_pages, 0, cleared_requested);
        }
    }
#if DEBUG_MALLOC
    if (LOG(szone, ptr)) {
        malloc_printf("szone_malloc returned %p\n", ptr);
    }
#endif
    /*
     * If requested, scribble on allocated memory.
     */
    if ((szone->debug_flags & MALLOC_DO_SCRIBBLE) && ptr && !cleared_requested && size) {
        memset(ptr, SCRIBBLE_BYTE, szone_size(szone, ptr));
    }

    return ptr;
}

• 小于1k的走tiny_malloc
• 小于15k或者127k的走small_malloc（视具体不同的设备内存上限不同）
• 剩下的走large_malloc。

OK，由于我们分配的非常大，我们可以确定我们的逻辑是落入large_malloc中。需要特别注意的是：large_malloc分配内存的基本单位是一页大小，而对于其他的几种分配方式，则不是必须按照页大小进行分配。

由于large_malloc这个函数本身并没有特殊需要注意的地方，我们直接关注其真正分配内存的地方，即allocate_pages，如下所示：

vm_addr = vm_page_quanta_size;
kr = mach_vm_map(mach_task_self(), &vm_addr, allocation_size, allocation_mask, alloc_flags, MEMORY_OBJECT_NULL, 0, FALSE,
            VM_PROT_DEFAULT, VM_PROT_ALL, VM_INHERIT_DEFAULT);
if (kr) {
    szone_error(szone, 0, "can't allocate region", NULL, "*** mach_vm_map(size=%lu) failed (error code=%d)\n", size, kr);
    return NULL;
}
addr = (uintptr_t)vm_addr;

从上我们不难看出，如果分配失败，就是提示报错。而mach_vm_map则是整个内存的分配核心。

可能你一开始看到这个mach_vm_map会比较懵逼，可以先看下我下面这张图：

OK，是不是有冒出很多名词。没关系，你其实只要记住两点：vm_map代表就是一个进程运行时候涉及的虚拟内存，pmap代表的就是和具体硬件架构相关的物理内存。（这里我们暂时先不考虑submap这种情况）。

好，vm_map本身是进程（或者从Mach内核的角度看是task的地址分布图）。这个地址分布图维护着一个双向列表，列表的每一项都是vm_entry_t，代表着虚拟地址上连续的一个范围。而pmap这个结构体代表了个硬件相关的内存转换：即利用pmap这个结构体来描述抽象的物理地址访问和使用。

进程（任务）的创建

在继续深入我们的话题之前，我们还需要具备一个额外的知识，就是iOS上的进程创建和加载执行Mach-O过程。

类UNIX系统本质上是没法无缘无故创建出一个全新的进程的，基本上必须要通过fork的形式来创建。(这块不太熟悉，有错请指正)。

在XNU的实现里，不论用户态调用posix相关API还是别的API，落入到内核里面都走的是fork_create_child函数来创建属于Mach内核的任务（task）。其实现如下：

thread_t
fork_create_child(task_t parent_task, coalition_t *parent_coalitions, proc_t child_proc, int inherit_memory, int is64bit, int in_exec)
{
    thread_t    child_thread = NULL;
    task_t        child_task;
    kern_return_t    result;

    /* Create a new task for the child process */
    result = task_create_internal(parent_task,
                    parent_coalitions,
                    inherit_memory,
                    is64bit,
                    TF_LRETURNWAIT | TF_LRETURNWAITER,         /* All created threads will wait in task_wait_to_return */
                    in_exec ? TPF_EXEC_COPY : TPF_NONE,   /* Mark the task exec copy if in execve */
                    &child_task);

    if (result != KERN_SUCCESS) {
        printf("%s: task_create_internal failed.  Code: %d\n",
            __func__, result);
        goto bad;
    }

    if (!in_exec) {
        /*
         * Set the child process task to the new task if not in exec,
         * will set the task for exec case in proc_exec_switch_task after image activation.
         */

         // 注意点：
        child_proc->task = child_task;
    }

• 这个函数本身实现并没什么出彩的，我们唯一要注意的就是Mach内核里面没有进程的概念，只有任务，进程是属于BSD之上的抽象。它们之间的联系就是通过指针建立，child_proc->task = child_task。

fork出来的进程更像是一个空壳，我们需要利用这个进程壳去执行可执行文件变成我们通常意义上理解的程序进程。

从XNU上来看，可执行的文件种类如下：

{ exec_mach_imgact,        "Mach-o Binary" },
{ exec_fat_imgact,        "Fat Binary" },
{ exec_shell_imgact,    "Interpreter Script" }

这里咱们先只看最常用的Mach-O文件：

exec_mach_imgact(struct image_params *imgp)
{
    ... 省略无数

    if ((mach_header->magic == MH_CIGAM) ||
        (mach_header->magic == MH_CIGAM_64)) {
        error = EBADARCH;
        goto bad;
    }

    if ((mach_header->magic != MH_MAGIC) &&
        (mach_header->magic != MH_MAGIC_64)) {
        error = -1;
        goto bad;
    }

    if (mach_header->filetype != MH_EXECUTE) {
        error = -1;
        goto bad;
    }

    if (imgp->ip_origcputype != 0) {
        /* Fat header previously had an idea about this thin file */
        if (imgp->ip_origcputype != mach_header->cputype ||
            imgp->ip_origcpusubtype != mach_header->cpusubtype) {
            error = EBADARCH;
            goto bad;
        }
    } else {
        imgp->ip_origcputype = mach_header->cputype;
        imgp->ip_origcpusubtype = mach_header->cpusubtype;
    }

    task = current_task();
    thread = current_thread();
    uthread = get_bsdthread_info(thread);

    if ((mach_header->cputype & CPU_ARCH_ABI64) == CPU_ARCH_ABI64)
        imgp->ip_flags |= IMGPF_IS_64BIT;

    /* If posix_spawn binprefs exist, respect those prefs. */
    psa = (struct _posix_spawnattr *) imgp->ip_px_sa;
    if (psa != NULL && psa->psa_binprefs[0] != 0) {
        int pr = 0;
        for (pr = 0; pr < NBINPREFS; pr++) {
            cpu_type_t pref = psa->psa_binprefs[pr];
            if (pref == 0) {
                /* No suitable arch in the pref list */
                error = EBADARCH;
                goto bad;
            }

            if (pref == CPU_TYPE_ANY) {
                /* Jump to regular grading */
                goto grade;
            }

            if (pref == imgp->ip_origcputype) {
                /* We have a match! */
                goto grade;
            }
        }
        error = EBADARCH;
        goto bad;
    }
grade:
    if (!grade_binary(imgp->ip_origcputype, imgp->ip_origcpusubtype & ~CPU_SUBTYPE_MASK)) {
        error = EBADARCH;
        goto bad;
    }

    /* Copy in arguments/environment from the old process */
    error = exec_extract_strings(imgp);
    if (error)
        goto bad;

    AUDIT_ARG(argv, imgp->ip_startargv, imgp->ip_argc, 
        imgp->ip_endargv - imgp->ip_startargv);
    AUDIT_ARG(envv, imgp->ip_endargv, imgp->ip_envc,
        imgp->ip_endenvv - imgp->ip_endargv);

    /* reset local idea of thread, uthread, task */
    thread = imgp->ip_new_thread;
    uthread = get_bsdthread_info(thread);
    task = new_task = get_threadtask(thread);

    // 注意点：
    lret = load_machfile(imgp, mach_header, thread, &map, &load_result);

    ... 省略无数

整个代码都没啥用，就是做些检查，分配个进程壳，然后通过load_machfile加载真正的二进制文件。

load_return_t
load_machfile(
    struct image_params    *imgp,
    struct mach_header    *header,
    thread_t         thread,
    vm_map_t         *mapp,
    load_result_t        *result
)
{
    ... 省略一大堆

    if (macho_size > file_size) {
        return(LOAD_BADMACHO);
    }

    result->is64bit = ((imgp->ip_flags & IMGPF_IS_64BIT) == IMGPF_IS_64BIT);

    task_t ledger_task;
    if (imgp->ip_new_thread) {
        ledger_task = get_threadtask(imgp->ip_new_thread);
    } else {
        ledger_task = task;
    }

    // 注意点1
    pmap = pmap_create(get_task_ledger(ledger_task),
               (vm_map_size_t) 0,
               result->is64bit);

    // 注意点2
    map = vm_map_create(pmap,
            0,
            vm_compute_max_offset(result->is64bit),
            TRUE);

#if defined(__arm64__)
    // 注意点三
    if (result->is64bit) {
        /* enforce 16KB alignment of VM map entries */
        vm_map_set_page_shift(map, SIXTEENK_PAGE_SHIFT);
    } else {
        vm_map_set_page_shift(map, page_shift_user32);
    }

• 利用pmap_create创建硬件相关的物理内存抽象。
• 利用vmap_create创建虚拟内存的地址图。
• ARM64下的页是16k一个虚拟页对应一个物理页。

别的没啥关注，我们重点关注vm_map_create0和vm_compute_max_offset(result->is64bit)。

因为这个代表了这个任务分配的虚拟地址上下限！这个函数的实现如下：

vm_map_offset_t
vm_compute_max_offset(boolean_t is64)
{
#if defined(__arm__) || defined(__arm64__)
    return (pmap_max_offset(is64, ARM_PMAP_MAX_OFFSET_DEVICE));
#else
    return (is64 ? (vm_map_offset_t)MACH_VM_MAX_ADDRESS : (vm_map_offset_t)VM_MAX_ADDRESS);
#endif
}

继续往下看：

vm_map_offset_t pmap_max_offset(
    boolean_t    is64 __unused,
    unsigned int    option)
{
    vm_map_offset_t    max_offset_ret = 0;

#if defined(__arm64__)
    assert (is64);
    vm_map_offset_t min_max_offset = SHARED_REGION_BASE_ARM64 + SHARED_REGION_SIZE_ARM64 + 0x20000000; // end of shared region + 512MB for various purposes
    if (option == ARM_PMAP_MAX_OFFSET_DEFAULT) {
        max_offset_ret = arm64_pmap_max_offset_default;
    } else if (option == ARM_PMAP_MAX_OFFSET_MIN) {
        max_offset_ret = min_max_offset;
    } else if (option == ARM_PMAP_MAX_OFFSET_MAX) {
        max_offset_ret = MACH_VM_MAX_ADDRESS;
    } else if (option == ARM_PMAP_MAX_OFFSET_DEVICE) {
        if (arm64_pmap_max_offset_default) {
            max_offset_ret = arm64_pmap_max_offset_default;
        } else if (max_mem > 0xC0000000) {
            max_offset_ret = 0x0000000318000000ULL;     // Max offset is 12.375GB for devices with > 3GB of memory
        } else if (max_mem > 0x40000000) {
            max_offset_ret = 0x0000000218000000ULL;     // Max offset is 8.375GB for devices with > 1GB and <= 3GB of memory
        } else {
            max_offset_ret = min_max_offset;
        }
    } else if (option == ARM_PMAP_MAX_OFFSET_JUMBO) {
        max_offset_ret = 0x0000000518000000ULL;     // Max offset is 20.375GB for pmaps with special "jumbo" blessing
    } else {
        panic("pmap_max_offset illegal option 0x%x\n", option);
    }

    assert(max_offset_ret >= min_max_offset);
    return max_offset_ret;

其实关键点就是这里的代码：

if (max_mem > 0xC0000000) {
    max_offset_ret = 0x0000000318000000ULL;     // Max offset is 12.375GB for devices with > 3GB of memory
} else if (max_mem > 0x40000000) {
    max_offset_ret = 0x0000000218000000ULL;     // Max offset is 8.375GB for devices with > 1GB and <= 3GB of memory
} else {
    max_offset_ret = min_max_offset;
}

max_offset_ret这个值就代表了我们任务对应的vm_map_t的最大地址范围，比如说这里是8.375GB。

虚拟内存分配的限制

好，在说了那么多前置知识后，我们言归正传，来谈谈为什么虚拟内存有限制。

之前我们提到了large_malloc会走入到最后的vm_map_enter，那么我们来看看vm_map_enter的实现：

vm_map_enter(
    vm_map_t        map,
    vm_map_offset_t        *address,    /* IN/OUT */
    vm_map_size_t        size,
    vm_map_offset_t        mask,
    int            flags,
    vm_map_kernel_flags_t    vmk_flags,
    vm_tag_t        alias,
    vm_object_t        object,
    vm_object_offset_t    offset,
    boolean_t        needs_copy,
    vm_prot_t        cur_protection,
    vm_prot_t        max_protection,
    vm_inherit_t        inheritance)
{

#if CONFIG_EMBEDDED
    // 注意点1:检查页的权限
    if (cur_protection & VM_PROT_WRITE){
        if ((cur_protection & VM_PROT_EXECUTE) && !entry_for_jit){
            printf("EMBEDDED: %s: curprot cannot be write+execute. "
                   "turning off execute\n",
                   __FUNCTION__);
            cur_protection &= ~VM_PROT_EXECUTE;
        }
    }
#endif /* CONFIG_EMBEDDED */

    if (resilient_codesign || resilient_media) {
        if ((cur_protection & (VM_PROT_WRITE | VM_PROT_EXECUTE)) ||
            (max_protection & (VM_PROT_WRITE | VM_PROT_EXECUTE))) {
            return KERN_PROTECTION_FAILURE;
        }
    }

    // 1. 获取任务的可用的地址最小值和最大值
    effective_min_offset = map->min_offset;
    effective_max_offset = map->max_offset;

    if (map->pmap == kernel_pmap) {
        user_alias = VM_KERN_MEMORY_NONE;
    } else {
        user_alias = alias;
    }

#define    RETURN(value)    { result = value; goto BailOut; }

    assert(page_aligned(*address));
    assert(page_aligned(size));

    if (!VM_MAP_PAGE_ALIGNED(size, VM_MAP_PAGE_MASK(map))) {
        clear_map_aligned = TRUE;
    }

StartAgain: ;

    start = *address;

    if (anywhere) {
        vm_map_lock(map);
        map_locked = TRUE;

        if (start < effective_min_offset)
            start = effective_min_offset;
        if (start > effective_max_offset)
            RETURN(KERN_NO_SPACE);


        if( FALSE ) {

        } else {

            if (map->holelistenabled) {
                hole_entry = (vm_map_entry_t)map->holes_list;

                if (hole_entry == NULL) {
                    /*
                     * No more space in the map?
                     */
                    result = KERN_NO_SPACE;
                    goto BailOut;
                } else {

                    boolean_t found_hole = FALSE;

                    do {
                        if (hole_entry->vme_start >= start) {
                            start = hole_entry->vme_start;
                            found_hole = TRUE;
                            break;
                        }

                        if (hole_entry->vme_end > start) {
                            found_hole = TRUE;
                            break;
                        }
                        hole_entry = hole_entry->vme_next;

                    } while (hole_entry != (vm_map_entry_t) map->holes_list);

                    if (found_hole == FALSE) {
                        result = KERN_NO_SPACE;
                        goto BailOut;
                    }

                    entry = hole_entry;

                    if (start == 0)
                        start += PAGE_SIZE_64;
                }
            }
        }

        while (TRUE) {
            vm_map_entry_t    next;

            end = ((start + mask) & ~mask);
            end = vm_map_round_page(end,
                        VM_MAP_PAGE_MASK(map));

            if (end < start)
                RETURN(KERN_NO_SPACE);

            start = end;
            end += size;

            if ((end > effective_max_offset) || (end < start)) {
                RETURN(KERN_NO_SPACE);
            }

            next = entry->vme_next;

            if (map->holelistenabled) {
                if (entry->vme_end >= end)
                    break;
            } else {

                if (next == vm_map_to_entry(map))
                    break;

                if (next->vme_start >= end)
                    break;
            }

            entry = next;

            if (map->holelistenabled) {
                if (entry == (vm_map_entry_t) map->holes_list) {
                    result = KERN_NO_SPACE;
                    goto BailOut;
                }
                start = entry->vme_start;
            } else {
                start = entry->vme_end;
            }

            start = vm_map_round_page(start,
                          VM_MAP_PAGE_MASK(map));
        }

        if (map->holelistenabled) {
            if (vm_map_lookup_entry(map, entry->vme_start, &entry)) {
                panic("Found an existing entry (%p) instead of potential hole at address: 0x%llx.\n", entry, (unsigned long long)entry->vme_start);
            }
        }

        *address = start;
    } 

• 注意点1：基本上就是检查页的权限啥的，iOS上不允许可写和可执行并存。
• 剩下的就是作各种前置检查

老实说，我一开始看苹果这最新的XNU代码，我压根没读懂。这一堆hole啥的在干啥，后来我就往之前XNU版本翻了翻，果然好懂了很多：

entry = map->first_free;

if (entry == vm_map_to_entry(map)) {
    entry = NULL;
} else {
       if (entry->vme_next == vm_map_to_entry(map)){
            entry = NULL;
       } else {
            if (start < (entry->vme_next)->vme_start ) {
                start = entry->vme_end;
                start = vm_map_round_page(start,
                              VM_MAP_PAGE_MASK(map));
            } else {
                entry = NULL;
            }
       }
}

if (entry == NULL) {
    vm_map_entry_t    tmp_entry;
    if (vm_map_lookup_entry(map, start, &tmp_entry)) {
        assert(!entry_for_jit);
        start = tmp_entry->vme_end;
        start = vm_map_round_page(start,
                      VM_MAP_PAGE_MASK(map));
    }
    entry = tmp_entry;
}

• 整个这段代码的意思是，就是要我们要找个一个比我们这个start地址大的vm_entry_t。(这句话比较绕口)，我们最终的目的是为了在两个已经存在vm_entry_t之间尝试插入一个能包含从start到start + size的新的vm_entry_t

• 如果没找到的话，就尝试利用vm_map_lookup_entry找一个preceding我们地址的的vm_entry_t。

好，现在我们找到了一个满足start其实地址条件的vm_entry_t了，剩下就是要满足分配大小size的需求了。

while (TRUE) {
    register vm_map_entry_t    next;

    end = ((start + mask) & ~mask);
    end = vm_map_round_page(end,
                VM_MAP_PAGE_MASK(map));
    if (end < start)
        RETURN(KERN_NO_SPACE);

    start = end;
    end += size;

    if ((end > effective_max_offset) || (end < start)) {
        RETURN(KERN_NO_SPACE);
    }

    next = entry->vme_next;

    // 如果是空的头
    if (next == vm_map_to_entry(map))
        break;

    // 如果下一个的start 
    if (next->vme_start >= end)
        break;

    entry = next;
    start = entry->vme_end;
    start = vm_map_round_page(start,
                  VM_MAP_PAGE_MASK(map));
}
*address = start;
assert(VM_MAP_PAGE_ALIGNED(*address,
               VM_MAP_PAGE_MASK(map)));

这段代码相对来说就很简单了，我们判断start + size是不是可以正好插入在vm_entry_t代表的地址范围的空隙内，如果一直遍历到最后的任务地址上限都找不到，那就说明不存在我们需求的连续的虚拟内存空间用于作分配了。

其他

除了本文说明的虚拟内存分配的连续性限制以外，虚拟内存作为堆内存分配的一种，在布局范围上也有限制。此文不表，且听下回分解。