mruby命令セット

対応risv:00090000

OP_NOP --> No operation

何もしない。

OP_MOVE A, B --> R(A) := R(B)

R(B)をR(A)にコピーする。コピー後のR(B)も残ったまま。

OP_LOADL A, Bx --> R(A) := Lit(Bx)

Poolにあるリテラル値[Bx]をR(A)に代入する。

OP_LOADI A, sBx --> R(A) := sBx

R(A)に整数値(-32767～+32768)を代入する。

OP_LOADSYM A, Bx --> R(A) := Sym(Bx)

R(A)にシンボルSym(Bx)を代入する。

OP_LOADNIL A --> R(A) := nil

R(A)にnilを代入する。

OP_LOADSELF A --> R(A) := self

R(A)にselfを代入する。selfはR(0)なので、OP_MOVE A,0と等価。

OP_LOADT A --> R(A) := true

R(A)にtrueを代入する。

OP_LOADF A --> R(A) := false

R(A)にfalseを代入する。

OP_GETGLOBAL A, Bx --> R(A) := getglobal(Sym(Bx))

グローバル変数Sym(Bx)を取得し、R(A)に代入する。存在しない場合はnilを代入する。

OP_SETGLOBAL A, Bx --> setglobal(Sym(Bx), R(A))

グローバル変数Sym(Bx)にR(A)を代入する。(既にあれば上書き、なければ新規作成される)

OP_GETSPECIAL A, Bx --> R(A) := Special[Bx]

現時点ではFixnumの0がR(A)に代入される。Bxは無視。

OP_SETSPECIAL A, Bx --> Special[Bx] := R(A)

現時点では何もしない。

OP_GETIV A, Bx --> R(A) := ivget(Sym(Bx))

R(0)つまりselfのインスタンス変数リストから、シンボルSym(Bx)に対応する値を取得してR(A)に代入する。selfがオブジェクトでない場合or見つからない場合はnilを代入する。

OP_SETIV A, Bx --> ivset(Sym(Bx), R(A))

R(0)つまりselfのインスタンス変数リストのシンボルSym(Bx)にR(A)を保存する。リストやシンボルが未生成の場合は作成する。 なお、selfがオブジェクトでは無い場合、ARGUMENT_ERRORでraiseする。

OP_GETCV A, Bx --> R(A) := cvget(Sym(Bx))

クラス変数Sym(Bx)を取得し、R(A)に代入する。変数が存在しない場合はNameError例外(uninitialized class variable)を発生する。 検索対象のクラスcはci→proc→target_class(NULLならばci→target_class)である。c→iv_tblから検索し、見つからなければ 上位(c→super)へと遡って検索する。

OP_SETCV A, Bx --> cvset(Sym(Bx), R(A))

OP_GETCVと同じルールでクラスを遡り、クラス変数Sym(Bx)が存在すれば、その内容をR(A)で上書きする。なお、見つからなかった場合は、ci→target_class→iv_tblに新規登録する。

OP_GETCONST A, Bx --> R(A) := constget(Sym(Bx))

定数Sym(Bx)を取得し、R(A)に代入する。以下の順序で検索し、最初に見つかった値が利用される。

1. c=ci→proc→target_classが非NULLならば、ci→proc→target_class→iv
2. c=ci→target_classが非NULLならば、ci→target_class→iv
3. cのouterモジュール(内側から外側に向かって遡る)
   • outerモジュールは ivから__outer__を参照すると得られる。
4. cと、そのsuperクラス(サブクラスからスーパークラスに向かって遡る)
5. (cがMODULEの場合のみ) Objectクラスのiv (Objectおよびそのsuperへ遡る)

見つからなかった場合、cからsuperに向かって遡りながら、const_missingというメソッドを検索する。メソッドが見つかった場合はそれを実行する。 メソッドが見つからなかった場合はNameError例外(uninitialized constant)を発生させる。

OP_SETCONST A, Bx --> constset(Sym(Bx), R(A))

定数Sym(Bx)を定義する。ci→proc→target_classまたはci→target_classのivにSym(Bx)の名前でR(A)の内容を登録する。 二重登録時の警告は？

OP_GETMCNST A, Bx --> R(A) := R(A)::Sym(Bx)

R(A)が指すクラス(またはモジュール)レベルの定数Sym(Bx)を取得し、R(A)に代入する。なお、命令実行前のR(A)がクラス/モジュールでは無い¹⁾場合、TypeError例外(constant look-up for non class/module)を発生させる。定数検索のルールは、OP_GETCONSTの4,5と同じ。

OP_SETMCNST A, Bx --> R(A+1)::Sym(Bx) := R(A)

R(A+1)の指すクラス/モジュールに属する定数Sym(Bx)を定義する。OP_GETMCNSTと同じ方法でR(A+1)がクラス/モジュールであることを確認し、インスタンス変数としてSym(Bx)=R(A)を登録する。 R(A+1)がクラス/モジュールでない場合は、OP_GETMCNSTと同じく例外を発生させる。

OP_GETUPVAR A, B, C --> R(A) := uvget(B, C)

C段分上位のメソッド/ブロックの変数R(B)を取得し、現在のブロックのR(A)に代入する。
なお、C=0はci→proc→env、C=1はci→proc→env→c、C=2は( (REnv*)Ci→proc→env→c)→c、以下同様。対応するenvが存在しない場合はR(A)にnilを代入する。

OP_SETUPVAR A, B, C --> uvset(B, C, R(A))

C段分上位のメソッド/ブロックの変数R(B)に、R(A)の内容を代入する。C段の遡り方はOP_GETUPVARに同じ。 対応するenvが存在しない場合は、何もしない。(エラーにもならない)

OP_JMP sBx --> pc += sBx

PCを変更し、現在のirep中でジャンプする。なお、変更前のPCはこのJMP命令がある場所そのものであり、PC++する前の値である。 また、JMP命令なのでPC++は実施されない。従って、-32767個前～JMP命令自身～+32768個後まで合計65536通りの場所にジャンプできる。

OP_JMPIF A, sBx --> if R(A) pc += sBx

R(A)がfalseまたはnilのときは、ジャンプしない(つまりPC++)。それ以外の時はJMP命令と同様にジャンプする。

OP_JMPNOT A, sBx --> if !R(A) pc += sBx

R(A)がfalseまたはnilのとき、JMP命令と同様にジャンプする。それ以外の時はジャンプしない(つまりPC++)。

OP_ONERR sBx --> rescue_push(pc + sBx)

rescue節を登録する。登録先のmrb→rescueが未生成の場合、サイズ16で作成。mrb→rescueのサイズ(mrb→rsize)が足りない場合、自動的に2倍に拡張する。 登録はPC+sBxの計算結果をrescueの現在位置(0から昇順)に記録する。mrb→ci→ridxは次のrescue保存位置を指す。

OP_RESCUE A --> clear(exc); R(A) := exception (ignore when A=0)

R(A)に現在のRObject* mrb→excの内容を設定する。mrb→excはNULLに設定される。

OP_POPERR A --> A.times { rescue_pop() }

mrb→ci→ridxをAだけ減らす。ONERRで登録したrescue節を通らずに抜けるのに利用する。

OP_RAISE A --> raise(R(A))

例外を投げる。投げる例外オブジェクトはR(A)。なお、これは例外オブジェクトでなければならない。つまり、 NilClass,TrueClass,FalseClass,Fixnumといった型は渡せず、内部表現が mrb_value.value.p を用いる型しか渡せない(これは言語仕様でも規定されている)。

OP_EPUSH Bx --> ensure_push(SEQ[Bx])

ensure節を登録する。(irep→idx+Bx)番目のirepのクロージャを新規作成し、それをmrb→ensureに登録する。 mrb→ensureバッファはrescueバッファ同様に、未作成ならサイズ16で作成、個数オーバーなら2倍拡張となる。 mrb→ci→eidxは次の登録番号(つまり現在の登録個数)を指す。

OP_EPOP A --> A.times { ensure_pop().call }

ensureバッファの最後尾にあるクロージャをpopしてecallする作業をA回繰り返す。ensure付きのブロックを抜ける(つまりensure節が実行される)ときに利用する。

(1) OP_SEND A, B, C (C=0)     --> R(A) := call(R(A), mSym(B))
(3) OP_SEND A, B, C (0<C<127) --> R(A) := call(R(A), mSym(B), R(A+1), ..., R(A+C))
(2) OP_SEND A, B, C (C=127)   --> R(A) := call(R(A), mSym(B), *R(A+1))

mSym(B)で指定された関数/メソッドを呼び出す。レシーバがR(A)、R(A+1)～R(A+C)が引数(C=0のときは無し)、 R(A+C+1)がブロック(SENDならnilを自動代入、SENDBならブロック)となる。ただしこれは引数が126個以下の場合で、 引数が127個以上の場合は、引数を収めたArrayをR(A+1)に、R(A+2)にブロックを格納し、C=127とする。

レシーバの型内でメソッド(シンボルmSym(B))の検索を行い、該当するものが存在しない場合は、method_missingというメソッドの 呼び出しにすり替えて実行する。すり替えを実施する場合、見つからなかったシンボルが第1引数となり、第2引数以降が元々の引数となる。

1. callinfoバッファに1つpush。
   • これから呼ぶメソッドのシンボルをci→mid、そのprocをci→proc、現在のスタックトップをci→stackidx、引数の個数²⁾をci→argc、レシーバのクラスをci→target_class、現在のpc+1をci→pc、A値をci→accにそれぞれ代入する。
2. スタックをAずらす。つまり、呼び出し先のR'(0)が現在のR(A)となる。(だから、R(A)にレシーバを入れると丁度いいわけだ。)
3. 呼び出し自体は、呼び出し先の種類(C実装のfunction/Ruby実装のmethod)によって異なる。
   • 呼び出し先がC実装関数(function)である場合
     1. 引数の個数³⁾+2をci→nregsに記憶
     2. mrbとレシーバを渡して該当関数を呼ぶ
     3. スタック末尾(つまりR(A))に関数の戻り値を格納
     4. mrc→excが設定されていればOP_RAISE処理へジャンプ
     5. レジスタ先頭位置、スタック位置をci→stackidxを用いて元に戻す。
     6. callinfoバッファから1つpopする。
   • 呼び出し先がrubyのmethodである場合。
     1. 実行中proc、irep、pool、symsを呼び出し先メソッドの内容に変更する。
     2. irep→nregsをci→nregsに記憶
     3. スタックを拡張する
        • Array渡しの場合、[irep→nregs,3].max 個確保(room)し、そのうち3個をkeepする。
        • レジスタ渡しの場合、irep→nregs個確保(room)し、そのうち(ci→argc+2)個をkeepする。
     4. レジスタ先頭位置をスタック末尾(つまりR(A)==R'(0))の位置にする。
     5. PCをirepの先頭にする。

(1) OP_SENDB A, B, C (C=0)     --> R(A) := call(R(A), mSym(B), &R(A+1))
(3) OP_SENDB A, B, C (0<C<127) --> R(A) := call(R(A), mSym(B), R(A+1), ..., R(A+C), &R(A+C+1))
(2) OP_SENDB A, B, C (C=127)   --> R(A) := call(R(A), mSym(B), *R(A+1), &R(A+2))

説明は OP_SEND を参照。

未実装。現時点ではNOPと同じ。

OP_CALL --> self.call(frame.argc, frame.argv)

Proc#callの実装用命令。codegenで生成されることはなく、Proc#call(またはProc#[])の内部実装のみに使われている。 これの命令が実行された場合、selfつまりR(0)はProcのインスタンスを指しており、それが保持しているクロージャmへのcallにすり替える作業を行う。

• ci→target_classにm→target_classを上書き
• ci→procにmを上書き
• (m→envが存在すれば) ci→midにm→env→midを上書き
• (m→envが存在し、m→env→stackが存在しなければ) m→env→stackにmrb→stackを代入
• あとはSENDと同じ。

OP_SUPER A, C --> R(A) := super(R(A+1), ..., R(A+C+1))

self(==R(0))をレシーバとし、ci→target_class→superからci→midのシンボルを探して実行する。 呼び出し本体の挙動はSENDと同じ。

OP_ENTER Ax --> argument setup (m1:o:r:m2:k:kd:b)

メソッドやブロックの先頭で用いられ、スタックに積まれた引数を使用できるようにする命令。 各パラメータの意味は以下の通り。

• m1 : 引数(省略不可)の個数
• o : 引数(省略可)の個数
• r : 可変長引数を受け取るとき1
• m2 : 不明。0以外を使っているところを見たことがない…。
• k : 未使用
• kd : 未使用
• b : ブロック引数(&block)を受け取るとき1

現在のproc(ci→proc)のフラグがMRB_PROC_STRICTを持っているときは、引数の個数チェックを行う。 逆に言うと、STRICTフラグがないのはeachなどのイテレータブロックを呼び出す場合。Hash#eachだと受け側ブロックの引数が一つだと [key, value]で受け取れるし、二つだと key, value となる。この曖昧さはSTRICTを外すことで得られている。

受け取り側の引数の数でci→argcを上書きしたあと、引数の個数差に応じて調整を行う。

• 実際に与えられた個数(argc)が受け取り数(len)より少ない場合
  1. ブロック引数を適切な位置(regs[len+1])にコピーする
  2. (argc-m2)個を、argvからregs[1]にコピーする(配列渡しなど、argvとregs[1]が別領域の場合のみ)
  3. (m2)個をargv[argc-m2]からregs[len-m2-1]に移動する(m2>0の場合)
  4. regs[m1+o+1]に空の配列を作成する(r==1の場合)
  5. ジャンプする
     • o==0の場合、通常どおりpc++して次の命令へ
     • o!=0の場合、pc+=(argc-m1-m2+1)してその命令へ。
       • 省略可能引数がある場合、その省略値をロードする命令群が含まれる。それらへのJMP命令をENTER命令の直後に省略可能引数の個数(o)だけ並べるルール。
• 実際に与えられた個数(argc)が受け取り数(len)以上の場合
  1. (m1+o)個を、argvからregs[1]にコピーする(配列渡しなど、argvとregs[1]が別領域の場合のみ)
  2. 可変長引数がある場合、regs[m1+o+1]に配列を作成する(配列の内容は(argv+m1+o)から、(argc-m1-o-m2)個)
  3. (m2)個をargv[argc-m2]からregs[m1+o+r+1]に移動する(m2>0の場合)
  4. ブロック引数を適切な位置(regs[len+1])にコピーする
  5. pc+=(o+1)して、その命令へ (省略可能引数のジャンプテーブル末端へ飛ばす)

未実装

未実装

OP_RETURN A --> retrun R(A)

* 例外(mrb→exc)がある場合【L_RAISE処理】

1. 例外オブジェクト(以下exc)の@lastpcにpcを保存
2. excの@ciidxに現在のciの位置(cibaseからのインデックス)を保存
3. ciがcibaseと同じ(つまり最上位フレームに居る)場合、ci→ridxが非0であればL_RESCUE処理へ。ci→irdxが0であればL_STOPへ。
4. 現在のridxと一つ上位(ci[-1])のridxが異なる値になるまで、以下を繰り返し
   1. callinfoバッファから1つpop
   2. popしたciのaccが-1かつmrb_run開始時のmrb→jmpが非NULLの場合、上位のmrb_runにてsetjmpが設定されている(≒擬似的なtryブロックの中にいる)とみなし、longjmp(1)でthrowする。
      • 上位mrb_runのcatch節はL_RAISEの先頭へ飛んでくる。
      • 要するに、mrb_runの再帰呼び出しで処理している間に起きた例外を、最上位のmrb_runで吸収するための機構と思われる。
   3. ensureバッファにある内容について、pop後の最下位ci→eidxより大きいものをすべてecall
   4. mrb→ciがmrb→cibaseに達していたら、ループ終了しL_RESCUE処理へ
      • このとき、ci→ridx==0の場合はregs、stackをスタック先頭に戻し、L_STOP処理へ。
5. ここから【L_RESCUE処理】
   1. irepをci→procのirepに設定、pool,symsも新irepに合わせて変更する
   2. regs、stackをci[1].stackidxを用いて戻す。
   3. pcをrescueバッファの[–ci→ridx]番目に設定してそこから実行再開

• 例外がない場合
• B=OP_R_RETURN(2)の場合
  1. proc→envがNULL、または、現在いるprocがSTRICTの場合はOP_R_NOMRALの処理へ移動
  2. 
• B=OP_R_NORMAL(0)の場合
  1. mrb→ciがcallinfoバッファの先頭の場合、returnできない所にいるはずなので“LocalJumpError: unexpected return”を起こすためL_RAISEへ。
  2. ローカル変数ciをmrb→ciとする。
• B=OP_R_BREAK(1)の場合
  1. proc→env→cioffが負の場合、breakするべきブロック内に居ないことになるので“LocalJumpError: unexpected break”を起こすためL_RAISEへ。
  2. ローカル変数ci、mrb→ciをcallinfoバッファの[proc→env→cioff+1]番目とする。

1. callinfoバッファを1つpop

01/16現在、ディスアセンブリのみ対応。コード生成箇所無し。

OP_EQ A, B, C --> R(A) := R(A) == R(A+1)

OP_EQ A, B, C --> R(A) := R(A) == R(A+1)

OP_EQ A, B, C --> R(A) := R(A) == R(A+1)

OP_EQ A, B, C --> R(A) := R(A) == R(A+1)

OP_EQ A, B, C --> R(A) := R(A) == R(A+1)

OP_ARRAY A, B, C (C>0) --> R(A) := ary_new(R(B), R(B+1), ..., R(B+C))

OP_ARYCAT A, B --> ary_cat(R(A), R(B))

OP_ARYPUSH A, B --> ary_push(R(A), R(B))

OP_AREF A, B, C --> R(A) := R(B)[C]

配列の要素参照。ただし、言語仕様上で配列扱いとなる部分に対して使われる。なお、R(B)が配列では無い場合、エラーとはならずR(A)にnilが代入される。

# 次の例はOP_AREFではなく、ただの[]メソッド呼び出しである。
b = a[1]
# 000 OP_MOVE     R4      (a)
# 001 OP_LOADI    R5      1
# 002 OP_SEND     R4      :[]     1
 
# 次のように多重代入を行う場合は、a,b,cに代入すべき値の取り出しがOP_AREFで行われる。
a,b,c = foo
# 000 OP_MOVE     R4      (foo)
# 001 OP_AREF     R1      R4      0
# 002 OP_AREF     R2      R4      1
# 003 OP_AREF     R3      R4      2

OP_ASET A, B, C --> R(B)[C] := R(A)

OP_AREFの反対で、配列への代入。 現時点では使われている様子がない。

OP_APOST A, B, C --> *R(A), R(A+1), ..., R(A+C) := R(A)

OP_STRING A, Bx --> R(A) := str_dup(Lit(Bx))

Lit(Bx)にある文字列をもつStringのインスタンスを生成し、R(A)に代入する。

OP_STRCAT A, B --> str_cat(R(A), R(B))

文字列R(A)の末端に文字列R(B)を連結する。R(A)に対しては破壊的。R(B)は破壊されない。 R(A)やR(B)がStringでなかった場合は？

OP_HASH A, B, C --> R(A) := hash_new(R(B), R(B+1), ..., R(B+C))

OP_LAMBDA A, b, c--> R(A) := lambda(SEQ[b], c)

OP_RANGE A, B, C --> R(A) := range_new(R(B), R(B+1), C)

OP_OCLASS A --> R(A) := ::Object

::ObjectをR(A)に代入する。

OP_CLASS A, B --> R(A) := newclass(R(A), mSym(B), R(A+1))

クラスを定義する。R(A)はbase(たいていnil入れてるけど何これ？)、R(A+1)はsuper。

OP_MODULE A, B --> R(A) := newmodule(R(A), mSym(B))

OP_EXEC A, Bx --> R(A) := blockexec(R(A), SEQ[Bx])

OP_METHOD A, B --> R(A).newmethod(mSym(B), R(A+1))

OP_SCLASS A, B --> R(A) := R(B).singleton_class

R(B)のクラスを元として、singletonクラスを作成する。singletonクラスとは、元のクラスと同じ機能を継承した上で、特異メソッドなどを持つインスタンス固有のクラス。 なお、singletonクラスに対して OP_SCLASS を実行すると、

OP_TCLASS A --> R(A) := target_class

OP_DEBUG A --> print R(A)

OP_STOP --> Stop VM

OP_ERR Bx --> raise RuntimeError with message Lit(Bx)

Reserved instruction #1

Reserved instruction #2

Reserved instruction #3

Reserved instruction #4

Reserved instruction #5