[[mrubyを読む]]
#contents
*はじめに [#bdd53068]
コードも生成できたので最後にコードを実行している部分を読みます。mrb_run()がエントリポイントになります。
*RiteVM概観 [#p63559f8]
いきなりmrb_run()に入る前にRiteVMがどんな実行モデルなのかについて説明します。
RiteVMの実行モデルはレジスタマシンです。ちなみにYARVはスタックマシンです。レジスタマシンとスタックマシンの違いはWikipediaあたりをご参照ください。
例えば以下の単純なRubyスクリプトの場合、
def foo(a, b)
a * b
end
f = foo(1, 2)
irep 116 nregs=6 nlocals=3 pools=0 syms=1
000 OP_TCLASS R3
001 OP_LAMBDA R4 I(117) 1
002 OP_METHOD R3 'foo'
003 OP_LOADSELF R3
004 OP_LOADI R4 1
005 OP_LOADI R5 2
006 OP_LOADNIL R6
007 OP_SEND R3 'foo' 2
008 OP_MOVE R1 R3
009 OP_STOP
irep 117 nregs=7 nlocals=5 pools=0 syms=1
000 OP_ENTER 2:0:0:0:0:0:0
001 OP_MOVE R5 R1
002 OP_MOVE R6 R2
003 OP_LOADNIL R7
004 OP_SEND R5 '*' 1
005 OP_RETURN R5
f = foo(1, 2)の部分は以下のように実行されます。
+レジスタR3にselfをロード（レシーバを設定）
+レジスタR4に1をロード（引数を設定）
+レジスタR5に2をロード（引数を設定）
+レジスタR6にnilをロード（ブロック引数を設定）
+レジスタR3のオブジェクトに対して'foo'メソッドを引数が2つで実行
+レジスタR1（ローカル変数f）にメソッド呼び出しの結果（R3に格納されます）を設定
mrubyではレジスタの確保場所としてスタックを使用しています。そのため、RiteVMはスタックマシンであると勘違いしてしまう危険があるので注意してください。さわだもソースだけ見ていてスタックマシンだと勘違いしていました。
レジスタの確保場所としてスタックを使うとはどういうことかというと、以下のようなイメージです。（OP_SEND '*'実行直前の状態）
トップレベル実行時のスタックベース→| nil |top_self
| |ローカル変数fの格納領域
| nil |よくわからない。特殊変数用？
メソッドfoo実行時のスタックベース→| nil |'foo'のレシーバ
| 1 |'foo'の引数1 & ローカル変数a
| 2 |'foo'の引数2 & ローカル変数b
| nil |'foo'に対するブロック引数
| nil |よくわからない。特殊変数用？
| 1 |'*'のレシーバ
| 2 |'*'の引数1
| nil |'*'に対するブロック引数
以上の前提を持ってmrb_run()に挑むと理解が深まると思います。
*mrb_run(src/vm.c) [#s87bb89e]
では、mrb_run()に見ていくことにしましょう。mrb_run()は一言で言うと一つ一つ命令を実行するループと各命令の処理に振り分ける巨大なswitch文です。ただし、処理効率化のためにちょっとカラクリが施されています。
#code(C){{
INIT_DISPACTH {
CASE(OP_NOP) {
/* do nothing */
NEXT;
}
CASE(OP_MOVE) {
/* A B R(A) := R(B) */
int a = GETARG_A(i);
int b = GETARG_B(i);
regs[a].tt = regs[b].tt;
regs[a].value = regs[b].value;
NEXT;
}
...
}
END_DISPACTH;
}}
INIT_DISPACTH((スペルミスだと思うのだけど、何故修正されないのだろう？))((2012/6/10にDISPATCHに修正されましたがこのページは2012/5/24時点のソースを元に解説しているのでそのままにしておきます:-P)), CASE, NEXTの定義はmrb_run()の少し上に書かれています。
#code(C){{
#ifdef __GNUC__
#define DIRECT_THREADED
#endif
#ifndef DIRECT_THREADED
#define INIT_DISPACTH for (;;) { i = *pc; switch (GET_OPCODE(i)) {
#define CASE(op) case op:
#define NEXT mrb->arena_idx = ai; pc++; break
#define JUMP break
#define END_DISPACTH } }
#else
#define INIT_DISPACTH JUMP; return mrb_nil_value();
#define CASE(op) L_ ## op:
#define NEXT mrb->arena_idx = ai; i=*++pc; goto *optable[GET_OPCODE(i)]
#define JUMP i=*pc; goto *optable[GET_OPCODE(i)]
#define END_DISPACTH
#endif
}}
gccかどうかで定義が変ってます。めんどくさいけどちゃんとマクロ展開されたコードを示すことにします。
gccじゃない場合
#code(C){{
for (;;) { i = *pc; switch (GET_OPCODE(i)) { {
case OP_NOP: {
/* do nothing */
mrb->arena_idx = ai; pc++; break;
}
case OP_MOVE: {
/* A B R(A) := R(B) */
int a = GETARG_A(i);
int b = GETARG_B(i);
regs[a].tt = regs[b].tt;
regs[a].value = regs[b].value;
mrb->arena_idx = ai; pc++; break;
}
...
}
} };
}}
gccの場合
#code(C){{
i=*pc; goto *optable[GET_OPCODE(i)]; return mrb_nil_value(); {
L_OP_NOP: {
/* do nothing */
mrb->arena_idx = ai; i=*++pc; goto *optable[GET_OPCODE(i)];
}
L_OP_MOVE: {
/* A B R(A) := R(B) */
int a = GETARG_A(i);
int b = GETARG_B(i);
regs[a].tt = regs[b].tt;
regs[a].value = regs[b].value;
mrb->arena_idx = ai; i=*++pc; goto *optable[GET_OPCODE(i)];
}
...
}
;
}}
というわけでgccじゃない場合は無限ループ & switch文ですが、gccの場合は命令コードで決まるジャンプ先に直接飛んでいます。こうすることで命令ごとに条件分岐をするコストがなくなるため高速化が実現できます。YARVでも同じことが行われていました。
*実行してみる [#n89a9da1]
総論は終わったので後は各論、いつものように各命令についてどのような処理が行われているかを見ていくことにします。なお、例外処理関係は別で扱う予定なので飛ばします。
**OP_LOADSELF [#dc95f7c0]
mrb_run()を上から見ていくと初めはLOAD系の命令が並んでいます。その中でややわかりにくいのがLOADSELFだと思います。
#code(C){{
CASE(OP_LOADSELF) {
/* A R(A) := self */
regs[GETARG_A(i)] = mrb->stack[0];
NEXT;
}
}}
何でこれでselfを設定したことになるのか？というと、スタックベースにはselfのオブジェクトが格納されているからです。上に書いたスタックのイメージを再掲すると、
メソッドfoo実行時のスタックベース→| nil |'foo'のレシーバ
| 1 |'foo'の引数1 & ローカル変数a
| 2 |'foo'の引数2 & ローカル変数b
| nil |'foo'に対するブロック引数
というわけでstack[0]がselfになっていることがご理解いただけると思います。
このstack[0]がselfであるということは他でも使われているので覚えておくようにしてください。例えば以下のようにインスタンス変数を取得するコードでもしれっと使われています。
#code(C){{
CASE(OP_GETIV) {
/* A Bx R(A) := ivget(Bx) */
regs[GETARG_A(i)] = mrb_vm_iv_get(mrb, syms[GETARG_Bx(i)]);
NEXT;
}
}}
src/variable.c
#code(C){{
mrb_value
mrb_vm_iv_get(mrb_state *mrb, mrb_sym sym)
{
/* get self */
return mrb_iv_get(mrb, mrb->stack[0], sym);
}
}}
**OP_SEND [#gc4bdea0]
次にメソッド呼び出しを行うOP_SENDを見てみましょう。長いので例によって区切って解説します。
#code(C){{
CASE(OP_SEND) {
/* A B C R(A) := call(R(A),Sym(B),R(A+1),... ,R(A+C-1)) */
int a = GETARG_A(i);
int n = GETARG_C(i);
struct RProc *m;
struct RClass *c;
mrb_callinfo *ci;
mrb_value recv;
mrb_sym mid = syms[GETARG_B(i)];
}}
コメントに書いてあるように、OP_SENDは3引数型の命令でそれぞれ以下の内容になっています。
:第1引数|メソッドのレシーバが格納されているレジスタ
:第2引数|メソッドのシンボルテーブルへのインデックス番号
:第3引数|メソッドに渡す引数の数。引数はレシーバが格納されているレジスタの次のレジスタからn個格納する
と、これがmrubyのメソッド呼び出し規約となっているようです。スタックイメージを再々掲すると、
| nil |R(A) 'foo'のレシーバ
| 1 |R(A+1) 'foo'の引数1
| 2 |R(A+2) 'foo'の引数2
となっており、適切に呼び出す準備がされていることがわかります。((ところでコメントだと引数レジスタの末尾がR(A+C-1)になってるけど、R(A+C)では？))
先に進みます。
#code(C){{
recv = regs[a];
c = mrb_class(mrb, recv);
m = mrb_method_search_vm(mrb, &c, mid);
if (!m) {
mrb_value sym = mrb_symbol_value(mid);
mid = mrb_intern(mrb, "method_missing");
m = mrb_method_search_vm(mrb, &c, mid);
if (n == CALL_MAXARGS) {
mrb_ary_unshift(mrb, regs[a+1], sym);
}
else {
memmove(regs+a+2, regs+a+1, sizeof(mrb_value)*(n+1));
regs[a+1] = sym;
n++;
}
}
}}
呼び出すメソッドの検索をしています。メソッドがない場合はmethod_missingを呼ぶようにしています。
#code(C){{
/* push callinfo */
ci = cipush(mrb);
ci->mid = mid;
ci->proc = m;
ci->stackidx = mrb->stack - mrb->stbase;
ci->argc = n;
if (ci->argc == CALL_MAXARGS) ci->argc = -1;
ci->target_class = m->target_class;
ci->pc = pc + 1;
}}
呼び出し情報はmrb_callinfo構造体に格納されるようです。ここで覚えておくといいのはstackidxとpcがメソッドから返ってきたときの復元に使われる情報ということでしょうか。
#code(C){{
/* prepare stack */
mrb->stack += a;
}}
スタックベースを調整してレシーバが入っているスタック位置をstack[0]、すなわちselfになるようにしています。
#code(C){{
if (MRB_PROC_CFUNC_P(m)) {
mrb->stack[0] = m->body.func(mrb, recv);
mrb->arena_idx = ai;
if (mrb->exc) goto L_RAISE;
/* pop stackpos */
mrb->stack = mrb->stbase + ci->stackidx;
cipop(mrb);
NEXT;
}
}}
メソッドがCで書かれている場合です。Cで書かれたメソッドの処理はまた別に見ます。
#code(C){{
else {
/* fill callinfo */
ci->acc = a;
/* setup environment for calling method */
proc = mrb->ci->proc = m;
irep = m->body.irep;
pool = irep->pool;
syms = irep->syms;
ci->nregs = irep->nregs;
if (ci->argc < 0) {
stack_extend(mrb, (irep->nregs < 3) ? 3 : irep->nregs, 3);
}
else {
stack_extend(mrb, irep->nregs, ci->argc+2);
}
regs = mrb->stack;
pc = irep->iseq;
JUMP;
}
}
}}
メソッドがRubyで書かれている場合はこちらが実行されます。mrb_callinfo.accは先に書いてしまうとメソッドの戻り値をどこに入れるかの情報です。第1引数が保存されているのでレシーバを設定したレジスタに戻り値が格納されることがわかります。その後、各種実行時情報を呼び出し先のものに切り替えています。注意が必要なのはここでは呼び出すだけでメソッドから返ってくるのはOP_RETURNが実行されたときであるということです。
**OP_ENTER [#g17feea3]
メソッド呼び出しについて見たので次はメソッドの受け側であるOP_ENTERを見ます。
#code(C){{
CASE(OP_ENTER) {
/* Ax arg setup according to flags (24=5:5:1:5:5:1:1) */
/* number of optional arguments times OP_JMP should follow */
int ax = GETARG_Ax(i);
int m1 = (ax>>18)&0x1f;
int o = (ax>>13)&0x1f;
int r = (ax>>12)&0x1;
int m2 = (ax>>7)&0x1f;
/* unused
int k = (ax>>2)&0x1f;
int kd = (ax>>1)&0x1;
int b = (ax>>0)& 0x1;
*/
}}
まず、命令コードのオペランドから各種引数の数を取得しています。
#code(C){{
int argc = mrb->ci->argc;
mrb_value *argv = regs+1;
int len = m1 + o + r + m2;
}}
次に実際に渡された引数の取得です。
#code(C){{
if (argc < 0) {
struct RArray *ary = mrb_ary_ptr(regs[1]);
argv = ary->buf;
argc = ary->len;
regs[len+2] = regs[1]; /* save argary in register */
}
}}
引数が配列（foo(*a)みたいなの）で渡されたときの処理です。ん？上記のコードを見るとメソッド呼び出し時に存在する不自然な空きレジスタって引数配列退避用なのか？
#code(C){{
if (mrb->ci->proc && MRB_PROC_STRICT_P(mrb->ci->proc)) {
if (argc >= 0) {
if (argc < m1 + m2 || (r == 0 && argc > len)) {
argnum_error(mrb, m1+m2);
goto L_RAISE;
}
}
}
}}
引数が少ない、もしくは多過ぎるときのエラー処理です。
#code(C){{
else if (len > 1 && argc == 1 && argv[0].tt == MRB_TT_ARRAY) {
argc = mrb_ary_ptr(argv[0])->len;
argv = mrb_ary_ptr(argv[0])->buf;
}
}}
yieldの場合、*を付けなくても配列展開されるようです。上記でやっているのはその処理です。
#code(C){{
mrb->ci->argc = len;
if (argc < len) {
regs[len+1] = argv[argc]; /* move block */
memmove(®s[1], argv, sizeof(mrb_value)*(argc-m2)); /* m1 + o */
memmove(®s[len-m2+1], &argv[argc-m2], sizeof(mrb_value)*m2); /* m2 */
if (r) { /* r */
regs[m1+o+1] = mrb_ary_new_capa(mrb, 0);
}
pc += argc - m1 - m2 + 1;
}
}}
オプション引数の処理です。引数の数からメソッドの開始位置を決定しています。[[実行コード生成>mruby/実行コード生成を読む]]に載せたサンプルを再掲します。
def foo(a = 1, b = 'xxx')
end
irep 117 nregs=6 nlocals=5 pools=1 syms=0
000 OP_ENTER 0:2:0:0:0:0:0
001 OP_JMP 004
002 OP_JMP 005
003 OP_JMP 006
004 OP_LOADI R1 1
005 OP_STRING R2 'xxx'
006 OP_RETURN R4
-foo()と呼んだら001から実行される（つまり、004から実行される）
-foo(2)と呼んだら002から実行される（つまり、005から実行される）
-foo(3, 'zzz')と呼んだら003から実行される（つまり、006から実行される）
#code(C){{
else {
memmove(®s[1], argv, sizeof(mrb_value)*(m1+o)); /* m1 + o */
if (r) { /* r */
regs[m1+o+1] = mrb_ary_new_elts(mrb, argc-m1-o-m2, argv+m1+o);
}
memmove(®s[m1+o+r+1], &argv[argc-m2], sizeof(mrb_value)*m2);
regs[len+1] = argv[argc]; /* move block */
pc += o + 1;
}
}}
こっちは引数が足りているときです。余った分は残余引数に詰め込んでいます。
#code(C){{
JUMP;
}
}}
最後に、渡された引数と想定している引数から計算されたpc((わかるとは思いますが念のため、Program Counterの略です))から実行を開始です。
**OP_RETURN [#haf5ad3c]
続いて、メソッドからの復帰時に実行されるOP_RETURNを見てみましょう。なお、前半で行われている例外処理は省略します。
#code(C){{
CASE(OP_RETURN) {
/* A return R(A) */
L_RETURN:
if (mrb->exc) {
(省略)
}
else {
mrb_callinfo *ci = mrb->ci;
int acc, eidx = mrb->ci->eidx;
mrb_value v = regs[GETARG_A(i)];
}}
まず、メソッドの戻り値をレジスタから取り出しています。
#code(C){{
switch (GETARG_B(i)) {
case OP_R_NORMAL:
if (ci == mrb->cibase) {
localjump_error(mrb, "return");
goto L_RAISE;
}
ci = mrb->ci;
break;
case OP_R_BREAK:
if (proc->env->cioff < 0) {
localjump_error(mrb, "break");
goto L_RAISE;
}
ci = mrb->ci = mrb->cibase + proc->env->cioff + 1;
break;
case OP_R_RETURN:
if (proc->env->cioff < 0) {
localjump_error(mrb, "return");
goto L_RAISE;
}
ci = mrb->ci = mrb->cibase + proc->env->cioff;
break;
default:
/* cannot happen */
break;
}
}}
ブロック中でbreakを実行した場合も命令コードはOP_RETURNになります。上記ではどこまで呼び出しを巻き戻るかを調整しています。
#code(C){{
cipop(mrb);
acc = ci->acc;
pc = ci->pc;
regs = mrb->stack = mrb->stbase + ci->stackidx;
}}
各種実行時情報をメソッド呼び出し前に戻しています。
#code(C){{
while (eidx > mrb->ci->eidx) {
ecall(mrb, --eidx);
}
}}
ensure節の処理です。例外処理についてはまた今度説明します。
#code(C){{
if (acc < 0) {
mrb->jmp = prev_jmp;
return v;
}
}}
Cで書かれたメソッドから呼ばれた場合、accは-1になっています。つまり、ここではCで書かれたメソッドに戻り値を返すということをしています。
#code(C){{
DEBUG(printf("from :%s\n", mrb_sym2name(mrb, ci->mid)));
proc = mrb->ci->proc;
irep = proc->body.irep;
pool = irep->pool;
syms = irep->syms;
regs[acc] = v;
}
JUMP;
}
}}
各種実行情報復元その2。戻り値をレジスタに格納してメソッド呼び出しを行ったOP_SENDの次の命令から処理を再開しています。
**OP_BLKPUSH [#i8132f88]
次にブロック周りを見てみましょう。yieldをコンパイルするとOP_BLKPUSHが埋め込まれることがわかります。
$ ./mruby.exe --verbose -e 'def foo; yield(1); end'
irep 117 nregs=5 nlocals=3 pools=0 syms=1
000 OP_ENTER 0:0:0:0:0:0:0
001 OP_BLKPUSH R3 0:0:0:0
002 OP_LOADI R4 1
003 OP_LOADNIL R5
004 OP_SEND R3 'call' 1
005 OP_RETURN R3
というわけでOP_BLKPUSHを見てみます。
#code(C){{
CASE(OP_BLKPUSH) {
/* A Bx R(A) := block (16=6:1:5:4) */
int a = GETARG_A(i);
int bx = GETARG_Bx(i);
int m1 = (bx>>10)&0x3f;
int r = (bx>>9)&0x1;
int m2 = (bx>>4)&0x1f;
int lv = (bx>>0)&0xf;
mrb_value *stack;
if (lv == 0) stack = regs + 1;
else {
struct REnv *e = uvenv(mrb, lv-1);
stack = e->stack + 1;
}
regs[a] = stack[m1+r+m2];
NEXT;
}
}}
m1, r, m2はyieldを実行するメソッドの引数情報です。オプション引数が含まれていないように見えますがm1は通常引数の数とオプション引数の数の合計になっています。lvはfor中でyieldすると0以外になるようです。ともかく、OP_BLKPUSHの目的はメソッド呼び出し時に積まれたブロックをレジスタに設定することです。忘れていると思いますが、mrubyのメソッド呼び出し規約ではメソッドを呼ぶ際に以下のようにself、引数、ブロックを積むことになっています。
regs→|self |
|引数1 |
|・・・ |
|引数n |
|ブロック|
stack[m1+r+m2]というのがちょうどブロックの位置を指すことになります。
**OP_CALL [#h3129eab]
では次にブロックを呼び出す個所を見てみましょう。
004 OP_SEND R3 'call' 1
タイトルにあるようにOP_CALLではなく、OP_SENDが使われています。が、嘘はついていません。どういうことかはcallメソッドの実装を見るとわかります。callメソッドはmrb_init_proc()で定義されています。
src/proc.c
#code(C){{
void
mrb_init_proc(mrb_state *mrb)
{
struct RProc *m;
mrb_code *call_iseq = mrb_malloc(mrb, sizeof(mrb_code));
mrb_irep *call_irep = mrb_calloc(mrb, sizeof(mrb_irep), 1);
if ( call_iseq == NULL || call_irep == NULL )
return;
*call_iseq = MKOP_A(OP_CALL, 0);
call_irep->idx = -1;
call_irep->flags = MRB_IREP_NOFREE;
call_irep->iseq = call_iseq;
call_irep->ilen = 1;
mrb->proc_class = mrb_define_class(mrb, "Proc", mrb->object_class);
mrb_define_method(mrb, mrb->proc_class, "initialize", mrb_proc_initialize, ARGS_NONE());
m = mrb_proc_new(mrb, call_irep);
mrb_define_method_raw(mrb, mrb->proc_class, mrb_intern(mrb, "call"), m);
mrb_define_method_raw(mrb, mrb->proc_class, mrb_intern(mrb, "[]"), m);
}
}}
何をやっているかと言うと、callメソッドは呼ばれるとOP_CALLを実行するようになっています。というわけで今度はOP_CALLの処理を見てみましょう。
#code(C){{
CASE(OP_CALL) {
/* A R(A) := self.call(frame.argc, frame.argv) */
mrb_callinfo *ci;
mrb_value recv = mrb->stack[0];
struct RProc *m = mrb_proc_ptr(recv);
/* replace callinfo */
ci = mrb->ci;
ci->target_class = m->target_class;
ci->proc = m;
if (m->env) {
if (m->env->mid) {
ci->mid = m->env->mid;
}
if (!m->env->stack) {
m->env->stack = mrb->stack;
}
}
/* prepare stack */
if (MRB_PROC_CFUNC_P(m)) {
mrb->stack[0] = m->body.func(mrb, recv);
mrb->arena_idx = ai;
if (mrb->exc) goto L_RAISE;
/* pop stackpos */
regs = mrb->stack = mrb->stbase + ci->stackidx;
cipop(mrb);
NEXT;
}
else {
/* setup environment for calling method */
proc = m;
irep = m->body.irep;
pool = irep->pool;
syms = irep->syms;
ci->nregs = irep->nregs;
if (ci->argc < 0) {
stack_extend(mrb, (irep->nregs < 3) ? 3 : irep->nregs, 3);
}
else {
stack_extend(mrb, irep->nregs, ci->argc+2);
}
regs = mrb->stack;
regs[0] = m->env->stack[0];
pc = m->body.irep->iseq;
JUMP;
}
}
}}
実行時情報をブロックのものに書き換えることでブロック呼び出しを行っています。env(REnv)にはブロック定義時の環境情報が入っています。それを使ってselfを書き換えているようですね。
環境情報を作っている部分も見ておきましょう。
$ ./mruby.exe -c --verbose -e 'foo { }'
irep 116 nregs=4 nlocals=2 pools=0 syms=1
000 OP_LOADSELF R2
001 OP_LAMBDA R3 I(117) 2
002 OP_SEND R2 'foo' 0
003 OP_STOP
というわけでOP_LAMBDAが引数2(OP_L_CAPTURE)で呼ばれるようです。
#code(C){{
CASE(OP_LAMBDA) {
/* A b c R(A) := lambda(SEQ[b],c) (b:c = 14:2) */
struct RProc *p;
int c = GETARG_c(i);
if (c & OP_L_CAPTURE) {
p = mrb_closure_new(mrb, mrb->irep[irep->idx+GETARG_b(i)]);
}
else {
p = mrb_proc_new(mrb, mrb->irep[irep->idx+GETARG_b(i)]);
}
if (c & OP_L_STRICT) p->flags |= MRB_PROC_STRICT;
regs[GETARG_A(i)] = mrb_obj_value(p);
NEXT;
}
}}
src/proc.c
#code(C){{
struct RProc *
mrb_closure_new(mrb_state *mrb, mrb_irep *irep)
{
struct RProc *p = mrb_proc_new(mrb, irep);
struct REnv *e;
if (!mrb->ci->env) {
e = (struct REnv*)mrb_obj_alloc(mrb, MRB_TT_ENV, (struct RClass*)mrb->ci->proc->env);
e->flags= (unsigned int)mrb->ci->proc->body.irep->nlocals;
e->mid = mrb->ci->mid;
e->cioff = mrb->ci - mrb->cibase;
e->stack = mrb->stack;
mrb->ci->env = e;
}
else {
e = mrb->ci->env;
}
p->env = e;
return p;
}
}}
環境情報として、ブロック定義位置のスタックを記録していることがわかります。
**OP_ADD [#s90c29bd]
命令コードの最後にOP_ADDを見てみましょう。
#code(C){{
CASE(OP_ADD) {
/* A B C R(A) := R(A)+R(A+1) (Syms[B]=:+,C=1)*/
int a = GETARG_A(i);
switch (TYPES2(mrb_type(regs[a]),mrb_type(regs[a+1]))) {
case TYPES2(MRB_TT_FIXNUM,MRB_TT_FIXNUM):
OP_MATH_BODY(+,i,i);
break;
case TYPES2(MRB_TT_FIXNUM,MRB_TT_FLOAT):
{
mrb_int x = regs[a].value.i;
mrb_float y = regs[a+1].value.f;
SET_FLOAT_VALUE(regs[a], (mrb_float)x + y);
}
break;
case TYPES2(MRB_TT_FLOAT,MRB_TT_FIXNUM):
OP_MATH_BODY(+,f,i);
break;
case TYPES2(MRB_TT_FLOAT,MRB_TT_FLOAT):
OP_MATH_BODY(+,f,f);
break;
case TYPES2(MRB_TT_STRING,MRB_TT_STRING):
regs[a] = mrb_str_plus(mrb, regs[a], regs[a+1]);
break;
default:
i = MKOP_ABC(OP_SEND, a, GETARG_B(i), GETARG_C(i));
goto L_SEND;
}
NEXT;
}
}}
何をやっているかというと、オペランドがともに数値だったらメソッド呼び出しを行わずに直接計算するということをしています。文字列についても通常のOP_SENDをバイパスして文字列連結を行うメソッドを直接呼び出すことで効率アップを行っています。
*mrb_get_args(src/class.c) [#z9fe4d13]
Cで定義したメソッドがVMから引数を取得する場合、mrb_get_args()を使うと便利です。使用方法は以下のようになっています。
src/hash.c
#code(C){{
mrb_value
mrb_hash_aset(mrb_state *mrb, mrb_value self)
{
mrb_value key, val;
mrb_get_args(mrb, "oo", &key, &val);
mrb_hash_set(mrb, self, key, val);
return val;
}
}}
各引数について、何型で引数を取得したいかを指定します。詳しくはmrb_get_args()のところに書かれているコメントならびにmrb_get_args()でgrepして得られる使用サンプルをご参照ください。（適当）
*おわりに [#k818d39a]
というわけでmrubyのコード実行を見てきました。LOAD系などの単純な命令もあるのですが、やはりVM理解で鍵となるのはメソッド呼び出しの個所のようです。また、VMの実行モデルが何なのか知っておくことがソースを読み進めていく上で重要であると思いました。一瞬、スタックマシンに見てるのでYARVに関わっている人は要注意です:-P
というわけでmrubyのコード実行を見てきました。LOAD系などの単純な命令もあるのですが、やはりVM理解で鍵となるのはメソッド呼び出しの個所のようです。また、VMの実行モデルが何なのか知っておくことがソースを読み進めていく上で重要であると思いました。一瞬、スタックマシンに見えるのでYARVに関わっている人は要注意です:-P
![[PukiWiki]](image/pukiwiki.png "[PukiWiki]")
