前言
本文参考了《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).disasmcompile 方法用于编译 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 leavegetlocal_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
}
**粗体** _斜体_ [链接](http://example.com) `代码` - 列表 > 引用。你还可以使用@来通知其他用户。