cast_off 0.3.7 → 0.4.0

data/README.ja

@@ -0,0 +1,177 @@
+* はじめに
+本ツール CastOff は Ruby1.9.3 用のコンパイラです。
+CastOff は、Ruby のメソッドを C 拡張形式のメソッドへと変換します。
+C 拡張に変換することで、Ruby の仮想マシンのオーバヘッドを削減し、
+対象となるメソッドを高速化することができます。
+本 README では、CastOff の基本機能について紹介します。
+ご質問、ご要望等があれば、shiba@rvm.jp もしくは
+http://github.com/soba1104/CastOff/issues まで、ご連絡ください。
+
+
+
+* ライセンス
+Ruby 処理系のライセンスに従います。
+
+
+
+* インストール方法
+$gem install cast_off
+
+CastOff は Ruby 処理系に一切手をくわえることなく、Ruby 処理系の拡張ライブラリとして実装しています。
+このため、gem コマンド経由で容易にインストールすることができます。
+ただし、脱最適化などの処理が処理系の実装依存になっているため、Ruby 1.9.3 のみの対応となっています。
+Ruby1.9.3 以外のバージョンの Ruby 処理系では動作しないため、ご注意ください。
+
+
+
+* CastOff の利用における注意点
+CastOff は現在アルファ版です。重要な場面では CastOff を利用しないでください。
+
+** 利用すると非互換になる機能
+現状、CastOff を用いた場合、Ruby 処理系との非互換性が生じる可能性があります。
+ここでは、現時点で把握できている、Ruby 処理系との非互換が生じる機能、
+特にコンパイルエラーを出すことが出来ない機能について列挙します。
+ここで列挙した機能を使用するプログラムやメソッドに対しては、CastOff を利用するべきではありません。
+ここに列挙した機能以外で非互換になる点を発見された方は、
+お手数ですが、shiba@rvm.jp もしくは http://github.com/soba1104/CastOff/issues まで、ご報告をお願い申し上げます。
+
+-定数の再定義
+CastOff は、コンパイルしたコードの読み込み時、もしくは最初に実行したときに定数解決を行います。
+性能上の理由により、CastOff は定数解決後は常に同じ値を使いまわすため、定数の再定義に対応することができません。
+定数の上書きを行うようなプログラムでは、CastOff を利用しないでください。
+定数の上書きのフック、もしくは RubyVM が管理する世代番号のチェックが高速にできるようになった場合、
+この非互換性は解消する予定です。
+
+-継続(Continuation)
+Ruby の継続(Continuation) を用いた場合、実行コンテキストの保存に失敗することが確認できています。
+継続を使用するプログラムでは、CastOff を利用しないでください。
+
+-メソッドや Proc のパラメータ取得
+コンパイル済みメソッドや Proc に対する情報を取得しようとした場合、
+コンパイル前と異なる挙動を示すメソッドがいくつかあります。
+例えば、Method#arity や Proc#arity などの、メソッドや Proc の引数に
+関する情報を取得しようとした場合、コンパイル前とコンパイル後では異なる値になります。
+
+
+** 起動時間
+CastOff は Ruby で実装しているので、CastOff を用いると、CastOff の読み込みというオーバヘッドが発生します。
+このため、実行時間が短いプログラムに対してCastOff を利用すると、逆に遅くなる可能性があります。
+
+また、CastOff を用いた場合、通常の require などの処理に加えて、CastOff がコンパイルしたメソッドの数だけ、コンパイル済みコードの読み込み、
+および、メソッド上書きのフックなどの処理（以降、初期化処理と呼ぶ）が走ります。
+閾値の設定次第では数多くのメソッドがコンパイルされるため、初期化処理に時間がかかります。
+
+
+** コンパイル時間
+CastOff は Ruby で実装しており、実装コストの兼ね合いから、コンパイル時間には配慮していません。
+このため、CastOff によるコンパイルは非常に時間がかかります。
+起動時間に関する注意でも述べたように、CastOff を利用した場合、
+閾値の設定次第では数多くのメソッドがコンパイルされます。
+閾値を低く設定しすぎると、コンパイルに非常に時間がかかるという点に、ご注意ください。
+
+
+* CastOff の利用方法
+CastOff が提供するコマンドラインツール cast_off では、
+引数に高速化したいプログラムを指定することで、容易にコンパイルを行うことができます。
+詳しくは下で解説しますが、CastOff の利用は、次のようなコマンドを繰り返し実行することで行います。
+
+-----------------------------------------------------
+$cast_off コンパイル対象のスクリプト コンパイル対象に与える引数の例
+-----------------------------------------------------
+
+例えば、次のようなスクリプトの実行を高速化したい場合、
+
+$ruby foo.rb bar
+
+次のように実行することで、foo.rb と、使用するライブラリをコンパイルすることができます。
+(この例での bar は、foo.rb に対する引数です)
+
+$cast_off foo.rb bar
+
+CastOff は、コンパイルを次の２つの手順で行います。
+1:コンパイル対象のメソッドを決定
+2:コンパイル対象のプロファイル情報を収集し、コンパイル
+この２つのステップそれぞれで対象プログラムを実行します。
+このため、上の例の場合、foo.rb を、コンパイルのために２度実行します。
+実行の回数は、今後、1-2の手順をまとめることで、削減する予定です。
+
+コンパイルした後は、--run オプションを用いることで、コンパイルしたコードを読み込んで動作させることができます。
+上の例の場合、次のようなコマンドを実行することで、コンパイル済みコードを用いて foo.rb を実行することができます。
+
+$cast_off --run foo.rb bar
+
+また、CastOff の利用で注意する必要があるのは、コンパイル時とは異なる引数を用いて実行する場合の挙動です。
+上の例では、コンパイル時に bar という引数を与えています。
+CastOff は、bar を引数として foo.rb を実行したときのプロファイル情報を基にコンパイルを行うため、
+異なる引数を与えた場合、クラス情報の不整合を起こし、例外、もしくは脱最適化を発生させる可能性があります。
+
+例えば、foo.rb が下の例のようなプログラムだった場合、bar という引数がわたってきた場合は String オブジェクトが、
+baz という引数がわたってきた場合は Symbol オブジェクトが、sample メソッドに渡されます。
+
+-----------------------------------------------------
+# 例) foo.rb
+def sample(o)
+  puts o.inspect
+end
+case ARGV.shift
+when 'bar'
+  sample('bar')
+when 'baz'
+  sample(:baz)
+end
+-----------------------------------------------------
+
+ここで、cast_off foo.rb bar として foo.rb をコンパイルすると、CastOff は、プロファイル情報から、
+sample メソッドに渡されるオブジェクトは String オブジェクトのみであるという判断を下します。
+そして、sample メソッドに渡されるオブジェクトが String オブジェクトであるという前提に基づいたコードを生成します。
+このため、foo.rb に baz という引数を渡した場合、sample メソッドに対し、想定していなかった Symbol オブジェクトが
+渡ってきてしまい、コンパイルの前提条件が崩れてしまいます。
+CastOff は、コンパイルの前提条件が崩れたことを検出したときに、例外の発生、もしくは脱最適化を行います。
+例外を発生させた場合は実行を継続させることができず、脱最適化を行った場合はパフォーマンスに対するペナルティが発生してしまいます。
+
+このような場合には、
+
+$cast_off foo.rb bar
+
+とした次に、
+
+$cast_off foo.rb baz
+
+としてください。
+このようにすることで、引数を bar とした場合、引数を baz とした場合の両方のプロファイル情報を用いてコンパイルを行うことができます。
+プロファイル情報やコンパイル結果を削除したい場合は、--clear という引数を与えて実行してください。
+
+
+***コマンドライン引数
+cast_off [options] [programfile] [arguments]
+
+
+***オプション一覧
+--run
+コンパイル済みコードを用いて、対象プログラム[programfile]を実行します。
+
+--clear
+プロファイル結果やコンパイル結果を削除します。
+name オプションによって foo と名づけたコンパイル結果を削除する場合、次のコマンドを使用してください。
+$cast_off --clear --name=foo
+
+--threshold=COUNT
+COUNT 回以上実行されたメソッドをコンパイルするよう、閾値を設定します。
+COUNT のデフォルト値は100です。
+
+--name=NAME
+コンパイル結果に NAME という名前をつけます。
+ここでつけた名前は、コンパイル済みコードが既に存在するかどうかの確認に使用します。
+コンパイル済みコードが見つかり、コンパイル対象やコンパイルやプロファイル情報
+に変更が無かった場合、CastOff はコンパイル済みコードを再利用します。
+name オプションを使用しなかった場合、CastOff は File.basename([programfile]) の結果を名前として使用します。
+
+--verbose
+コンパイルの進捗とコンパイル結果に関する内部情報を表示します。
+
+-h, --help
+ヘルプメッセージを表示します。
+
+--version
+CastOff のバージョンを表示します。
+

data/bin/cast_off

@@ -36,13 +36,11 @@ opt.on('--clear', <<-EOS.strip) {|v| clear = true }
                                      you should execute following command.
                                      $cast_off --clear --name=foo
 EOS
-opt.on('--step-1') {|v| step = '1' }
-opt.on('--step-2') {|v| step = '2' }
 opt.on('--verbose', <<-EOS.strip) {|v| verbose = true }
                                      Show compilation progress and internal information.
 EOS
 opt.on_tail('-h', "--help", "Show this help.") do
-  message = opt.to_s.gsub(/\n[ ]*--step-[0-9]+[ ]*/, '')
+  message = opt.to_s
   message.concat(<<-EOS)
 
   Example:
@@ -55,10 +53,13 @@ opt.on_tail('-h', "--help", "Show this help.") do
   ------------------------------------------
 
   1 Profile and compile fib.rb:
-  $cast_off fib.rb 30 # 30 is a argument of fib.rb
+  $cast_off fib.rb 10 # 10 is a argument of fib.rb.
+                      # Because profile execution is very slow,
+                      # argument of fib.rb is 10 to finish profile execution faster.
 
   2 Run fib.rb with compiled codes:
-  $cast_off --run fib.rb 30 # 30 is a argument of fib.rb
+  $cast_off --run fib.rb 35 # 35 is a argument of fib.rb.
+                            # Compiled fib is used in this execution, so fib.rb runs faster.
 
   Report bugs to <http://github.com/soba1104/CastOff/issues>.
   EOS
@@ -113,44 +114,18 @@ CastOff.verbose(verbose)
 case step
 when nil
   STDERR.puts("-------------------------------- compilation start: threshold = #{threshold}, name = #{name}, profiling = ruby #{args} --------------------------------")
-  2.times do |i|
-    system("#{this} --step-#{i + 1} --threshold=#{threshold} --name=#{name} #{verbose ? '--verbose' : ''} #{args}")
-    unless $? == 0
-      STDERR.puts("Failed to execute 'ruby #{args}'")
-      exit
-    end
-  end
-when '1'
-  STDERR.puts("-------------------------------- step 1 --------------------------------") if verbose
   CastOff.development(true)
   CastOff.use_base_configuration(false)
   CastOff.autocompile()
-when '2'
-  STDERR.puts("-------------------------------- step 2 --------------------------------") if verbose
-  CastOff.development(true)
-  CastOff.use_base_configuration(false)
-  CastOff.autoload()
   at_exit{
-    CastOff.development(false)
-    CastOff.use_base_configuration(true)
-    # step 3
-    CastOff.load()
+    at_exit{
+      CastOff.development(false)
+      CastOff.use_base_configuration(true)
+      CastOff.re_compile_all()
+    }
   }
   fin = Object.new
   ObjectSpace.define_finalizer(fin){
-=begin
-    msg = <<-EOS
-
-----------------------------------------------------------------------------------------
-Compilation finished successfully.
-Please add following lines to top of #{script}.
-
-require 'cast_off'
-#{configuration.chomp}
-CastOff.autoload()
-----------------------------------------------------------------------------------------
-    EOS
-=end
     msg = <<-EOS
 ----------------------------------------------------------------------------------------
 Compilation finished successfully.
@@ -168,5 +143,5 @@ else
 end
 
 $0 = script
-load script if step
+load script
 

data/cast_off.gemspec

@@ -1,17 +1,20 @@
 Gem::Specification.new do |spec|
   spec.name		      = "cast_off"
-  spec.version		      = "0.3.7"
+  spec.version		      = "0.4.0"
   spec.platform		      = Gem::Platform::RUBY
   spec.summary		      = "Compiler for Ruby1.9.3"
   spec.description	      = <<-EOS
 CastOff is a compiler for Ruby1.9.3.
 Command line tool cast_off is available after installation.
 See 'cast_off --help' for more information.
+Currently, CastOff supports Ruby1.9.3 only.
+So, if you attempt to use CastOff, please install CastOff under Ruby1.9.3 runtime. 
+
   EOS
   spec.files		      = Dir['{lib/**/*,ext/**/*,bin/**/*,doc/**/*}'] + %w[
 				  cast_off.gemspec
-                                  README.en
                                   README
+                                  README.ja
 				]
   spec.bindir		      = 'bin'
   spec.executables	      << 'cast_off'
@@ -24,6 +27,6 @@ See 'cast_off --help' for more information.
   spec.email		      = 'shiba@rvm.jp'
   spec.homepage		      = 'http://github.com/soba1104/CastOff'
   #spec.rubyforge_project     = 'cast_off'
-  spec.required_ruby_version  = '>= 1.9.2'
+  spec.required_ruby_version  = '= 1.9.3'
 end
 

data/ext/cast_off/cast_off.c.rb

@@ -698,8 +698,10 @@ static VALUE cast_off_class_wrapper_to_s(VALUE self)
         return rb_class_path(obj);
       } else if (__klass == rb_cModule) {
         return rb_mod_name(obj);
-      } else {
+      } else if (obj == oMain) {
         return rb_funcall(obj, rb_intern("to_s"), 0);
+      } else if (RCLASS_M_TBL(klass)->num_entries == 0) {
+        return rb_class_path(__klass);
       }
     }
     rb_raise(rb_eCastOffCompileError, "CastOff can't handle un-marshalable object");
@@ -1245,112 +1247,11 @@ static VALUE cast_off_should_not_be_reached(VALUE self)
   rb_bug("should not be reached");
 }
 
-static void cast_off_class_definition_end_handler(rb_event_flag_t event, VALUE proc, VALUE self, ID id, VALUE klass)
-{
-  /* self = target class */
-  /* id = klass = 0 */
-
-  static VALUE args = Qnil;
-
-  if (args == Qnil) {
-    args = rb_ary_new();
-    rb_gc_register_mark_object(args);
-  }
-
-  rb_proc_call(proc, args);
-}
-
-static VALUE cast_off_hook_class_definition_end(VALUE self, VALUE proc)
-{
-  static int hook = 0;
-
-  if (proc == Qnil) {
-    if (!hook) {
-      return Qfalse;
-    }
-    hook = 0;
-    rb_remove_event_hook(&cast_off_class_definition_end_handler);
-    return Qtrue;
-  }
-
-  if (hook) {
-    return Qfalse;
-  }
-
-  if (rb_class_of(proc) != rb_cProc) {
-    rb_bug("cast_off_hook_class_definition_end: should not be reached(0)");
-  }
-
-  rb_add_event_hook(&cast_off_class_definition_end_handler, RUBY_EVENT_END, proc);
-  hook = 1;
-
-  return Qtrue;
-}
-
-#define IN_HEAP_P(th, ptr)  \
-  (!((th)->stack < (ptr) && (ptr) < ((th)->stack + (th)->stack_size)))
-
-static VALUE caller_info(rb_thread_t *th)
-{
-  rb_control_frame_t *cfp;
-  VALUE *lfp = NULL;
-  VALUE recv, name;
-  VALUE klass;
-  ID mid;
-  rb_method_entry_t *me;
-
-  cfp = th->cfp; /* this method frame */
-  cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp);
-  while (1) {
-    if ((VALUE *) cfp >= th->stack + th->stack_size) {
-      if (lfp && IN_HEAP_P(th, lfp)) {
-        return Qnil;
-      }
-      rb_bug("caller_info: should not be reached (0) %p", cfp->lfp);
-    }
-    if (lfp && cfp->dfp != lfp) {
-      cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp);
-      continue;
-    }
-    lfp = NULL;
-    switch(VM_FRAME_TYPE(cfp)) {
-    case VM_FRAME_MAGIC_METHOD:
-      recv = cfp->self;
-      name = cfp->iseq->name;
-      klass = rb_class_of(recv);
-      mid = rb_intern(RSTRING_PTR(name));
-      me = search_method(klass, mid);
-      if (!me) {
-        rb_bug("caller_info: should not be reached (1)");
-      }
-      klass = me->klass;
-      return rb_ary_new3(2, klass, ID2SYM(mid));
-    case VM_FRAME_MAGIC_BLOCK:
-    case VM_FRAME_MAGIC_PROC:
-    case VM_FRAME_MAGIC_LAMBDA:
-      lfp = cfp->lfp;
-      cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp);
-      continue;
-    case VM_FRAME_MAGIC_FINISH:
-      cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp);
-      continue;
-    case VM_FRAME_MAGIC_CLASS:
-    case VM_FRAME_MAGIC_TOP:
-    case VM_FRAME_MAGIC_CFUNC:
-    case VM_FRAME_MAGIC_IFUNC:
-    case VM_FRAME_MAGIC_EVAL:
-      return Qnil;
-    default:
-      rb_bug("caller_info: should not be reached (2)");
-    }
-  }
-}
-
 static void cast_off_method_invocation_handler(rb_event_flag_t event, VALUE proc, VALUE self, ID id, VALUE klass)
 {
   const char *srcfile;
-  VALUE filename, need_binding;
-  VALUE argv[6];
+  VALUE need_binding;
+  VALUE argv[3];
   int line;
 
   if (klass == 0) {
@@ -1372,23 +1273,18 @@ static void cast_off_method_invocation_handler(rb_event_flag_t event, VALUE proc
 
   srcfile = rb_sourcefile();
   if (!srcfile) return;
-  filename = rb_str_new2(srcfile);
 
   line = rb_sourceline();
   if (line < 0) return;
 
-  argv[0] = filename;
-  argv[1] = INT2FIX(line);
-  argv[2] = ID2SYM(id);
-  argv[3] = Qnil;
-  argv[4] = klass;
-  /* argv[5] = caller_info(th); */
+  argv[0] = klass;
+  argv[1] = ID2SYM(id);
+  argv[2] = Qnil;
 
-  /* rb_proc_call_with_block(proc, 6, argv, Qnil); */
-  need_binding = rb_proc_call_with_block(proc, 5, argv, Qnil);
+  need_binding = rb_proc_call_with_block(proc, 3, argv, Qnil);
   if (RTEST(need_binding)) {
-    argv[3] = (self && srcfile) ? rb_binding_new() : Qnil;
-    need_binding = rb_proc_call_with_block(proc, 5, argv, Qnil);
+    argv[2] = (self && srcfile) ? rb_binding_new() : Qnil;
+    need_binding = rb_proc_call_with_block(proc, 3, argv, Qnil);
   }
   if (RTEST(need_binding)) {
     rb_bug("cast_off_method_invocation_handler: should not be reached");
@@ -1509,6 +1405,175 @@ VALUE cast_off_same_method_p(VALUE dummy, VALUE obj, VALUE mid)
   }
 }
 
+static VALUE cast_off_override_target_of_current_method(VALUE dummy, VALUE obj)
+{
+  VALUE klass = rb_class_of(obj);
+  VALUE thval = rb_thread_current();
+  rb_thread_t *th = DATA_PTR(thval);
+  rb_control_frame_t *cfp;
+  const rb_method_entry_t *me0, *me1;
+  ID mid;
+
+  cfp = th->cfp; /* this method frame */
+  cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp); /* target frame */
+  if (!cfp->me) {
+    rb_bug("cast_off_target_of_current_method: should not be reached(0)");
+  }
+  if (cfp->me->def->type != VM_METHOD_TYPE_BMETHOD) {
+    rb_bug("cast_off_target_of_current_method: should not be reached(1)");
+  }
+  me0 = cfp->me;
+
+  mid = cfp->me->called_id;
+  if (!mid) {
+    rb_bug("cast_off_target_of_current_method: should not be reached(2)");
+  }
+
+  while(1) {
+    if (!klass) return Qnil;
+    me1 = search_method(klass, mid);
+    if (!me1) return Qnil; /* maybe method object */
+    if (rb_method_definition_eq(me0->def, me1->def)) {
+      VALUE target = me1->klass;
+      if (rb_obj_class(target) != rb_cClass && rb_obj_class(target) != rb_cModule) {
+        rb_bug("cast_off_target_of_current_method: should not be reached(3)");
+      }
+      return target;
+    }
+    klass = RCLASS_SUPER(klass);
+  }
+
+  rb_bug("cast_off_target_of_current_method: should not be reached(4)");
+}
+
+static VALUE cast_off_singleton_class_p(VALUE dummy, VALUE klass)
+{
+  if (rb_obj_class(klass) != rb_cClass && rb_obj_class(klass) != rb_cModule) {
+    rb_bug("cast_off_singleton_class_p: should not be reached");
+  }
+  return FL_TEST(klass, FL_SINGLETON) ? Qtrue : Qfalse;
+}
+
+static VALUE cast_off_current_bmethod_proc(VALUE dummy)
+{
+  VALUE thval = rb_thread_current();
+  rb_thread_t *th = DATA_PTR(thval);
+  rb_control_frame_t *cfp;
+
+  cfp = th->cfp; /* this method frame */
+  cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp); /* target frame */
+  if (!cfp->me) {
+    rb_bug("cast_off_create_current_bmethod_proc: should not be reached(0)");
+  }
+  if (cfp->me->def->type != VM_METHOD_TYPE_BMETHOD) {
+    rb_bug("cast_off_create_current_bmethod_proc: should not be reached(1)");
+  }
+  if (rb_obj_class(cfp->me->def->body.proc) != rb_cProc) {
+    rb_bug("cast_off_create_current_bmethod_proc: should not be reached(2)");
+  }
+  return cfp->me->def->body.proc;
+}
+
+/* copy of ruby source */
+struct METHOD {
+  VALUE recv;
+  VALUE rclass;
+  ID id;
+%if RUBY_VERSION == "1.9.3"
+  rb_method_entry_t *me;
+  struct unlinked_method_entry_list_entry *ume;
+%else
+  rb_method_entry_t me;
+%end
+};
+
+static VALUE cast_off_instance_bmethod_proc(VALUE dummy, VALUE bmethod)
+{
+  struct METHOD *method = DATA_PTR(bmethod);
+%if RUBY_VERSION == "1.9.3"
+  rb_method_entry_t *me = method->me;
+%else
+  rb_method_entry_t *me = &method->me;
+%end
+
+  if (me->def->type != VM_METHOD_TYPE_BMETHOD) {
+    rb_bug("cast_off_instance_bmethod_proc: should not be reached(0)");
+  }
+  if (rb_obj_class(me->def->body.proc) != rb_cProc) {
+    rb_bug("cast_off_instance_bmethod_proc: should not be reached(1)");
+  }
+  return me->def->body.proc;
+}
+
+static VALUE cast_off_rewrite_method_object(VALUE dummy, VALUE dst, VALUE src, VALUE proc)
+{
+  rb_method_entry_t *dst_me, *src_me;
+  struct METHOD *dst_mptr, *src_mptr;
+
+  if (rb_obj_class(dst) != rb_cMethod ||
+      rb_obj_class(src) != rb_cUnboundMethod ||
+      rb_obj_class(proc) != rb_cProc) {
+    rb_bug("cast_off_rewrite_method_object: should not be reached(0)");
+  }
+
+  dst_mptr = DATA_PTR(dst);
+%if RUBY_VERSION == "1.9.3"
+  dst_me = dst_mptr->me;
+%else
+  dst_me = &dst_mptr->me;
+%end
+  if (dst_me->def->type != VM_METHOD_TYPE_BMETHOD) {
+    return Qfalse;
+  }
+  if (dst_me->def->body.proc != proc) {
+    return Qfalse;
+  }
+
+  src_mptr = DATA_PTR(src);
+%if RUBY_VERSION == "1.9.3"
+  src_me = src_mptr->me;
+%else
+  src_me = &src_mptr->me;
+%end
+
+%if RUBY_VERSION == "1.9.3"
+  {
+    /* copy of bm_free: proc.c */
+    VALUE thval = rb_thread_current();
+    rb_thread_t *th = DATA_PTR(thval);
+    rb_vm_t *vm = th->vm;
+    struct unlinked_method_entry_list_entry *ume = dst_mptr->ume;
+
+    ume->me = dst_me;
+    ume->next = vm->unlinked_method_entry_list;
+    vm->unlinked_method_entry_list = ume;
+    dst_mptr->ume = ALLOC(struct unlinked_method_entry_list_entry);
+  }
+
+  /* copy of mnew: proc.c */
+  dst_mptr->me = ALLOC(rb_method_entry_t);
+  dst_me = dst_mptr->me;
+%end
+  *dst_me = *src_me;
+  dst_me->def->alias_count++;
+
+  return Qtrue;
+}
+
+static VALUE cast_off_rewrite_rclass_of_unbound_method_object(VALUE dummy, VALUE mobj, VALUE rclass)
+{
+  struct METHOD *mptr;
+
+  if (rb_obj_class(mobj) != rb_cUnboundMethod || rb_obj_class(rclass) != rb_cClass) {
+    rb_bug("cast_off_rewrite_rclass_of_unbound_method_object(0)");
+  }
+
+  mptr = DATA_PTR(mobj);
+  mptr->rclass = rclass;
+
+  return Qnil;
+}
+
 /* for deoptimization */
 rb_iseq_t *cast_off_Fixnum_times_iseq;
 rb_iseq_t *cast_off_Array_each_iseq;
@@ -1541,9 +1606,14 @@ void Init_cast_off(void)
   rb_define_method(rb_mCastOffCompiler, "load_compiled_file", cast_off_load_compiled_file, 1);
   rb_define_method(rb_mCastOffCompiler, "get_caller", cast_off_get_caller, 0);
   rb_define_method(rb_mCastOffCompiler, "hook_method_invocation", cast_off_hook_method_invocation, 1);
-  rb_define_method(rb_mCastOffCompiler, "hook_class_definition_end", cast_off_hook_class_definition_end, 1);
   rb_define_method(rb_mCastOffCompiler, "current_method_id", cast_off_current_method_id, 0);
   rb_define_method(rb_mCastOffCompiler, "same_method?", cast_off_same_method_p, 2);
+  rb_define_method(rb_mCastOffCompiler, "singleton_class?", cast_off_singleton_class_p, 1);
+  rb_define_method(rb_mCastOffCompiler, "override_target_of_current_method", cast_off_override_target_of_current_method, 1);
+  rb_define_method(rb_mCastOffCompiler, "current_bmethod_proc", cast_off_current_bmethod_proc, 0);
+  rb_define_method(rb_mCastOffCompiler, "instance_bmethod_proc", cast_off_instance_bmethod_proc, 1);
+  rb_define_method(rb_mCastOffCompiler, "rewrite_method_object", cast_off_rewrite_method_object, 3);
+  rb_define_method(rb_mCastOffCompiler, "rewrite_rclass_of_unbound_method_object", cast_off_rewrite_rclass_of_unbound_method_object, 2);
   rb_define_method(rb_mCastOffCompilerInstruction, "get_child_iseq", cast_off_get_child_iseq, 2);
   rb_define_const(rb_mCastOffCompilerInstruction, "ROBJECT_EMBED_LEN_MAX", LONG2FIX(ROBJECT_EMBED_LEN_MAX));
   rb_define_const(rb_mCastOffCompilerInstruction, "THROW_TAG_RETURN", LONG2FIX(TAG_RETURN));