前言

本文参考了《Ruby原理剖析》并结合 Ruby 源代码进行分析

（自定义）对象在 Ruby 虚拟机内部表示

Ruby 中的对象在虚拟机中以 RObject 结构体的形式存在：

// ruby.h

struct RObject {
    struct RBasic basic;
    union {
        struct {
            uint32_t numiv;
            VALUE *ivptr;
            void *iv_index_tbl; /* shortcut for RCLASS_IV_INDEX_TBL(rb_obj_class(obj)) */
        } heap;
        VALUE ary[ROBJECT_EMBED_LEN_MAX];
    } as;
};

struct RBasic {
    VALUE flags;
    const VALUE klass;
}

RBasic 结构体的 klass 字段指向 RObject 所属的类

对象属性

Ruby 对属性访问做了优化，对象属性存储在 RObject 的 as 联合体内。如果属性个数小于 ROBJECT_EMBED_LEN_MAX 属性值将直接存储在 ary 数组内，属性索引存储在 RClass 中（见下文）；否则属性值和索引都存储在 heap 结构体中，访问属性的过程如下：根据属性名在 iv_index_tbl 表中查询属性在 ivptr 中的索引，使用该索引在 ivptr 中获取属性，numiv 保存了属性个数

获取对象属性

我们来看一下获取对象属性的虚拟机指令

// insns.def

/**
  @c variable
  @e Get value of instance variable id of self.
     If is_local is not 0, get value of class local variable.
  @j self のインスタンス変数 id の値を得る。
 */
DEFINE_INSN
getinstancevariable
(ID id, IC ic)
()
(VALUE val)
{
    val = vm_getinstancevariable(GET_SELF(), id, ic);
}

vm_getinstancevariable 函数定义在 vm_insnhelper.c 文件中

// vm_insnhelper.c

static inline VALUE
vm_getivar(VALUE obj, ID id, IC ic, struct rb_call_cache *cc, int is_attr)
{
#if USE_IC_FOR_IVAR
    ...
#endif /* USE_IC_FOR_IVAR */
    if (is_attr)
    return rb_attr_get(obj, id);
    return rb_ivar_get(obj, id);
}

USE_IC_FOR_IVAR 里面的代码使用了优化算法来加快对象属性的获取，我们先跳过。这样在函数的底部判断要获取的是否是 attr，如果是调用 rb_attr_get 函数，否则调用 rb_ivar_get 函数

// variable.c

VALUE
rb_ivar_lookup(VALUE obj, ID id, VALUE undef)
{
    VALUE val, *ptr;
    struct st_table *iv_index_tbl;
    uint32_t len;
    st_data_t index;

    if (SPECIAL_CONST_P(obj))
        return undef;
    switch (BUILTIN_TYPE(obj)) {
      case T_OBJECT:
        len = ROBJECT_NUMIV(obj);
        ptr = ROBJECT_IVPTR(obj);
        iv_index_tbl = ROBJECT_IV_INDEX_TBL(obj);
        if (!iv_index_tbl) break;
        if (!st_lookup(iv_index_tbl, (st_data_t)id, &index)) break;
        if (len <= index) break;
        val = ptr[index];
        if (val != Qundef)
            return val;
    break;
      case T_CLASS:
      case T_MODULE:
    if (RCLASS_IV_TBL(obj) &&
        st_lookup(RCLASS_IV_TBL(obj), (st_data_t)id, &index))
        return (VALUE)index;
    break;
      default:
    if (FL_TEST(obj, FL_EXIVAR))
        return generic_ivar_get(obj, id, undef);
    break;
    }
    return undef;
}

switch 语句根据 obj 类别分别处理，这里的类别包括：

• T_OBJECT，对象

• T_CLASS，类

• T_MODULE，模块

上文提到如果对象属性个数小于 ROBJECT_EMBED_LEN_MAX，属性索引会被存储在 RClass 结构体中，属性值被存储在 RObject as 联合体的 ary 中，ROBJECT_NUMIV，ROBJECT_IVPTR 和 ROBJECT_IV_INDEX_TBL 宏对这两种属性访问进行了封装：

// ruby.h

#define ROBJECT_NUMIV(o) \
    ((RBASIC(o)->flags & ROBJECT_EMBED) ? \
     ROBJECT_EMBED_LEN_MAX : \
     ROBJECT(o)->as.heap.numiv)
#define ROBJECT_IVPTR(o) \
    ((RBASIC(o)->flags & ROBJECT_EMBED) ? \
     ROBJECT(o)->as.ary : \
     ROBJECT(o)->as.heap.ivptr)
#define ROBJECT_IV_INDEX_TBL(o) \
    ((RBASIC(o)->flags & ROBJECT_EMBED) ? \
     RCLASS_IV_INDEX_TBL(rb_obj_class(o)) : \
     ROBJECT(o)->as.heap.iv_index_tbl)

设置对象属性

类在 Ruby 虚拟机内部表示

Ruby 中的类在虚拟机中以 RClass 结构体的形式存在：

// internal.h

struct RClass {
    struct RBasic basic;
    VALUE super;
    rb_classext_t *ptr;
    struct rb_id_table *m_tbl;
};

结构体中第一个字段为 basic，表明 Ruby 中的类（Class）也是一个对象（Object，也有所属的类型）
super 字段指向父类，m_tal 为类的方法表，ptr 指向类在虚拟机内部的私有信息（不希望作为 API 对外公开）

类属性

为了分析 Ruby 类变量的实现，我们还是从 虚拟机指令 入手：

// insns.def

/**
  @c variable
  @e Get value of class variable id of klass as val.
  @j 現在のスコープのクラス変数 id の値を得る。
 */
DEFINE_INSN
getclassvariable
(ID id)
()
(VALUE val)
{
    val = rb_cvar_get(vm_get_cvar_base(rb_vm_get_cref(GET_EP()), GET_CFP()), id);
}

代码中的 GET_CFP，GET_EP，rb_vm_get_cref 等函数（宏）涉及到 Ruby 虚拟机运行时环境（栈帧），先略过，先看 rb_cvar_get 函数

rb_cvar_get(VALUE klass, ID id)
{
    VALUE tmp, front = 0, target = 0;
    st_data_t value;

    tmp = klass;
    CVAR_LOOKUP(&value, {if (!front) front = klass; target = klass;});
    ...
    return (VALUE)value;
}

rb_ccar_get 函数的输入参数为类 kclass 以及属性 id，我们先忽略一些条件判断和错误处理，核心逻辑在 CVAR_LOOKUP 宏定义里：

// variable.c

#define CVAR_FOREACH_ANCESTORS(klass, v, r) \
    for (klass = cvar_front_klass(klass); klass; klass = RCLASS_SUPER(klass)) { \
    if (cvar_lookup_at(klass, id, (v))) { \
        r; \
    } \
    }

#define CVAR_LOOKUP(v,r) do {\
    if (cvar_lookup_at(klass, id, (v))) {r;}\
    CVAR_FOREACH_ANCESTORS(klass, v, r);\
} while(0)

两个宏定义都涉及到 cvar_lookup_at 函数，从函数命名可以猜测该函数用于在 kclass 中查找 类属性：

// variable.c

static int cvar_lookup_at(VALUE klass, ID id, st_data_t *v)
{
    if (!RCLASS_IV_TBL(klass)) return 0;
    return st_lookup(RCLASS_IV_TBL(klass), (st_data_t)id, v);
}

st_lookup 是 Ruby hash map 查询函数，RCLASS_IV_TBL 宏定义：

// internal.h

#define RCLASS_EXT(c) (RCLASS(c)->ptr)
#define RCLASS_IV_TBL(c) (RCLASS_EXT(c)->iv_tbl)

可以看出类属性存储在 RClass 中 ptr 指向的 rb_classext_struct 结构体（iv_tbl字段）内

对象方法

上文分析了对象属性的存储以及 Ruby 是如何获取和设置对象属性的。现在我们换一种思路来分析对象方法，
我们将跟踪 对象方法 的生命周期，从定义，编译成虚拟机指令到它被添加到 类结构（RClass）中
在这个过程中我们将使用以下 Ruby 代码片段：

class MyClass
    def my_method
        a + b
    end
end

为了查看最终生成的虚拟机指令，我们使用 Ruby 提供的 RubyVM::InstructionSequence 类来"编译"和"反汇编"这段类定义代码
启动 irb 交互式执行环境，并输入如下代码

irb> code=<<EOF
class MyClass
    def my_method
        a + b
    end
end
EOF
irb> puts RubyVM::InstructionSequence.compile(code).disasm

compile 方法用于编译 code 并生成二进制指令序列，disasm 方法用于将"反汇编"指令序列生成 程序员 可读的格式

== disasm: #<ISeq:<compiled>@<compiled>>================================
0000 trace            1                                               (   1)
0002 putspecialobject 3
0004 putnil           
0005 defineclass      :MyClass, <class:MyClass>, 0
0009 leave            
== disasm: #<ISeq:<class:MyClass>@<compiled>>===========================
0000 trace            2                                               (   1)
0002 trace            1                                               (   2)
0004 putspecialobject 1
0006 putobject        :my_method
0008 putiseq          my_method
0010 opt_send_without_block <callinfo!mid:core#define_method, argc:2, ARGS_SIMPLE>, <callcache>
0013 trace            4                                               (   5)
0015 leave                                                            (   2)
== disasm: #<ISeq:my_method@<compiled>>=================================
0000 trace            8                                               (   2)
0002 trace            1                                               (   3)
0004 putself          
0005 opt_send_without_block <callinfo!mid:a, argc:0, FCALL|VCALL|ARGS_SIMPLE>, <callcache>
0008 putself          
0009 opt_send_without_block <callinfo!mid:b, argc:0, FCALL|VCALL|ARGS_SIMPLE>, <callcache>
0012 opt_plus         <callinfo!mid:+, argc:1, ARGS_SIMPLE>, <callcache>
0015 trace            16                                              (   4)
0017 leave                                                            (   3)

输出结果显示有 3 个指令序列，代码片段间使用 == disasm 头来分割，这 3 个代码片段从上到下依次为：

• 主指令序列

• MyClass 类内部指令序列，用于定义字段和方法 .etc

• my_method 内部指令序列

主指令序列中的 defineclass 指令用于定义一个类，Ruby 每次遇到一个类定义时都会生成一条 defineclass 指令;
MyClass 类内部指令序列虽然没有类似的 definemethod 指令，但是有个 opt_send_without_block 指令，这个指令是 send 指令的优化版，它用于进行方法调用，后面的参数<callinfo!mid:core#define_method> 表明要调用 core#define_method 方法，大家应该能够猜到该方法就是用来添加方法到类结构里的，在方法调用之前有 3 条 put 指令将参数压入操作数栈：

• putspecialobject，将接收 define_method 的对象压入堆栈（类似于 this）

• putobject，将操作数压入堆栈

• putiseq，将方法对应的 指令序列 压入堆栈

现在问题来了，define_method native 方法在哪定义的的？回顾之前的文章Ruby 2.x 源代码学习：bootstrap，Ruby 在启动的时候会预先定义一些 C 语言实现的内置类和方法

// vm.c

void Init_VM(void) {
    ...
    rb_define_method_id(klass, id_core_define_method, m_core_define_method, 2);
}

继续跟踪 m_core_define_method 函数, 它调用 vm_define_method 最终将方法"附着"在 类结构上

// vm.c

static VALUE m_core_define_method(VALUE self, VALUE sym, VALUE iseqval)
{
    REWIND_CFP({
    vm_define_method(GET_THREAD(), Qnil, SYM2ID(sym), iseqval, FALSE);
    });
    return sym;
}

查找对象方法

我们以同样的方式解析一段 Ruby 代码来分析当调用对象的方法时虚拟机内部发生了什么：

// ruby code

class MyClass
    def my_method
        a + b
    end
end

mc = MyClass.new
mc.my_method

我们忽略上文已经分析过的类及方法定义指令，直接列出方法调用的指令：

0024 trace            1                                               (   7)
0026 getlocal_OP__WC__0 2
0028 opt_send_without_block <callinfo!mid:method, argc:0, ARGS_SIMPLE>, <callcache>
0031 leave

getlocal_OP__WC__0 指令是 getlocal 指令的优化指令，它将局部变量 mc （作为 this）压入堆栈
opt_send_without_block 指令调用 mc 的 method 方法，通过查看 vm.inc（参考Ruby 2.x 源代码学习：YARV 虚拟机指令）来看看 send 指令都干了些啥：

// vm.inc

INSN_ENTRY(opt_send_without_block){
{
  VALUE val;

  // 获取第 2 个指令操作数，call cache，加速方法调用的结构体，后面再仔细分析
  CALL_CACHE cc = (CALL_CACHE)GET_OPERAND(2);

  // 获取第 1 个指令操作数，call info，后面再仔细分析
  CALL_INFO ci = (CALL_INFO)GET_OPERAND(1);

  // 递增指令指针，1 个操作码 + 2 个操作数
  ADD_PC(1+2);

  // 编译器 hack，起到类似指令预取的作用
  PREFETCH(GET_PC());
{
#line 1063 "insns.def"
    struct rb_calling_info calling;
    // 上面提到过这个版本的 send 是不带 block 的，所以直接设置 bolcok_handler 为 NONE
    calling.block_handler = VM_BLOCK_HANDLER_NONE;
    // 主角登场，调用该方法进行方法查找，calling.recv 非常重要！！！
    vm_search_method(ci, cc, calling.recv = TOPN(calling.argc = ci->orig_argc));
    // 方法调用
    CALL_METHOD(&calling, ci, cc);

#line 1579 "vm.inc"
  PUSH(val);
  END_INSN(opt_send_without_block);}}}

为了便于分析，特意去掉了一些宏定义。熟悉面向对象的同学应该能猜的出来 calling.recv 相当于 Java/C++ 中的 this 引用 or 指针，所以 TOPN 宏就是为了取得这个指针：

// vm_insnhelper.h

#define TOPN(n) (*(GET_SP() - (n) - 1))

对于本例，my_method 方法参数个数为 0，即 ci->orig_argc = 0，所以 TOPN(0) = *(GET_SP() - 1)，所以 calling.recv(this) 指向栈顶第一个元素，这也就是为什么在 send 指令之前有一条 getlocal 指令：

0026 getlocal_OP__WC__0 2

最后我们来看看 vm_search_method 方法，CLASS_OF 宏用于通过 对象（RObject）获取对应的类（RClass），如果忘了的话可以回到顶部看看对象在 Ruby 额你不的布局，获取到 klass 后调用 rb_callable_method_entry 方法查找 method id 为 mid 的方法，这里暂不展开 rb_callable_method_entry 方法

// vm_insnhelper.c

static void
vm_search_method(const struct rb_call_info *ci, struct rb_call_cache *cc, VALUE recv)
{
    VALUE klass = CLASS_OF(recv);

#if OPT_INLINE_METHOD_CACHE
    ...
#endif

    cc->me = rb_callable_method_entry(klass, ci->mid);
    VM_ASSERT(callable_method_entry_p(cc->me));
    cc->call = vm_call_general;
#if OPT_INLINE_METHOD_CACHE
    ...
#endif
}

类方法

继承