From 9cbd6ee09770be3d73a17ab1195a094c59c9f9ee Mon Sep 17 00:00:00 2001 From: ktsj Date: Sat, 5 Nov 2016 13:15:27 +0000 Subject: * vm_trace.c (tracepoint_attr_callee_id, rb_tracearg_callee_id): add TracePoint#callee_id. [ruby-core:77241] [Feature #12747] * cont.c, eval.c, gc.c, include/ruby/intern.h, insns.def, thread.c, vm.c, vm_backtrace.c, vm_core.h, vm_eval.c, vm_insnhelper.c, vm_trace.c: ditto. * test/ruby/test_settracefunc.rb: tests for above. git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@56593 b2dd03c8-39d4-4d8f-98ff-823fe69b080e --- ChangeLog | 10 ++++ NEWS | 4 ++ cont.c | 4 +- eval.c | 4 +- gc.c | 2 +- include/ruby/intern.h | 2 +- insns.def | 2 +- test/ruby/test_settracefunc.rb | 111 +++++++++++++++++++++++++++++++++++++++++ thread.c | 6 +-- vm.c | 29 ++++++----- vm_backtrace.c | 2 +- vm_core.h | 20 ++++---- vm_eval.c | 8 +-- vm_insnhelper.c | 4 +- vm_trace.c | 23 +++++++-- 15 files changed, 189 insertions(+), 42 deletions(-) diff --git a/ChangeLog b/ChangeLog index 743f87d6fb..aeda10e39a 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,3 +1,13 @@ +Sat Nov 5 22:11:33 2016 Kazuki Tsujimoto + + * vm_trace.c (tracepoint_attr_callee_id, rb_tracearg_callee_id): + add TracePoint#callee_id. [ruby-core:77241] [Feature #12747] + + * cont.c, eval.c, gc.c, include/ruby/intern.h, insns.def, thread.c, + vm.c, vm_backtrace.c, vm_core.h, vm_eval.c, vm_insnhelper.c, vm_trace.c: ditto. + + * test/ruby/test_settracefunc.rb: tests for above. + Sat Nov 5 22:09:48 2016 Kazuki Tsujimoto * eval.c, method.h, proc.c, vm.c, vm_eval.c, vm_insnhelper.c, vm_method.c: diff --git a/NEWS b/NEWS index 3f4c64b8b1..014e2141a0 100644 --- a/NEWS +++ b/NEWS @@ -160,6 +160,10 @@ with all sufficient information, see the ChangeLog file or Redmine * Thread#report_on_exception and Thread.report_on_exception [Feature #6647] +* TracePoint + + * TracePoint#callee_id [Feature #12747] + * Warning * New module named Warning is introduced. By default it has only diff --git a/cont.c b/cont.c index 85d376653e..2d8b98dbf4 100644 --- a/cont.c +++ b/cont.c @@ -1284,7 +1284,7 @@ rb_fiber_start(void) th->root_svar = Qfalse; fib->status = RUNNING; - EXEC_EVENT_HOOK(th, RUBY_EVENT_FIBER_SWITCH, th->self, 0, 0, Qnil); + EXEC_EVENT_HOOK(th, RUBY_EVENT_FIBER_SWITCH, th->self, 0, 0, 0, Qnil); cont->value = rb_vm_invoke_proc(th, proc, argc, argv, VM_BLOCK_HANDLER_NONE); } TH_POP_TAG(); @@ -1474,7 +1474,7 @@ fiber_switch(rb_fiber_t *fib, int argc, const VALUE *argv, int is_resume) value = fiber_store(fib, th); RUBY_VM_CHECK_INTS(th); - EXEC_EVENT_HOOK(th, RUBY_EVENT_FIBER_SWITCH, th->self, 0, 0, Qnil); + EXEC_EVENT_HOOK(th, RUBY_EVENT_FIBER_SWITCH, th->self, 0, 0, 0, Qnil); return value; } diff --git a/eval.c b/eval.c index 187b9ed6ce..feac81024c 100644 --- a/eval.c +++ b/eval.c @@ -563,7 +563,7 @@ setup_exception(rb_thread_t *th, int tag, volatile VALUE mesg, VALUE cause) if (tag != TAG_FATAL) { RUBY_DTRACE_HOOK(RAISE, rb_obj_classname(th->errinfo)); - EXEC_EVENT_HOOK(th, RUBY_EVENT_RAISE, th->cfp->self, 0, 0, mesg); + EXEC_EVENT_HOOK(th, RUBY_EVENT_RAISE, th->cfp->self, 0, 0, 0, mesg); } } @@ -749,7 +749,7 @@ rb_raise_jump(VALUE mesg, VALUE cause) ID mid = me->called_id; rb_vm_pop_frame(th); - EXEC_EVENT_HOOK(th, RUBY_EVENT_C_RETURN, self, me->def->original_id, klass, Qnil); + EXEC_EVENT_HOOK(th, RUBY_EVENT_C_RETURN, self, me->def->original_id, mid, klass, Qnil); setup_exception(th, TAG_RAISE, mesg, cause); diff --git a/gc.c b/gc.c index 9f1e2b3419..847062557f 100644 --- a/gc.c +++ b/gc.c @@ -1755,7 +1755,7 @@ rb_objspace_set_event_hook(const rb_event_flag_t event) static void gc_event_hook_body(rb_thread_t *th, rb_objspace_t *objspace, const rb_event_flag_t event, VALUE data) { - EXEC_EVENT_HOOK(th, event, th->cfp->self, 0, 0, data); + EXEC_EVENT_HOOK(th, event, th->cfp->self, 0, 0, 0, data); } #define gc_event_hook_available_p(objspace) ((objspace)->flags.has_hook) diff --git a/include/ruby/intern.h b/include/ruby/intern.h index efa8f4058c..8776a596f0 100644 --- a/include/ruby/intern.h +++ b/include/ruby/intern.h @@ -969,7 +969,7 @@ VALUE rb_mod_remove_cvar(VALUE, VALUE); ID rb_frame_callee(void); VALUE rb_str_succ(VALUE); VALUE rb_time_succ(VALUE); -int rb_frame_method_id_and_class(ID *idp, VALUE *klassp); +int rb_frame_method_id_and_class(ID *idp, ID *called_idp, VALUE *klassp); VALUE rb_make_backtrace(void); VALUE rb_make_exception(int, const VALUE*); diff --git a/insns.def b/insns.def index ecd60f02f3..fdda7d25de 100644 --- a/insns.def +++ b/insns.def @@ -831,7 +831,7 @@ trace } } - EXEC_EVENT_HOOK(th, flag, GET_SELF(), 0, 0 /* id and klass are resolved at callee */, + EXEC_EVENT_HOOK(th, flag, GET_SELF(), 0, 0, 0 /* id and klass are resolved at callee */, (flag & (RUBY_EVENT_RETURN | RUBY_EVENT_B_RETURN)) ? TOPN(0) : Qundef); } diff --git a/test/ruby/test_settracefunc.rb b/test/ruby/test_settracefunc.rb index 855b904e36..0930a2232d 100644 --- a/test/ruby/test_settracefunc.rb +++ b/test/ruby/test_settracefunc.rb @@ -1488,4 +1488,115 @@ class TestSetTraceFunc < Test::Unit::TestCase assert_equal ev, :fiber_switch } end + + def test_tracepoint_callee_id + events = [] + capture_events = Proc.new{|tp| + events << [tp.event, tp.method_id, tp.callee_id] + } + + o = Class.new{ + def m + raise + end + alias alias_m m + }.new + TracePoint.new(:raise, :call, :return, &capture_events).enable{ + o.alias_m rescue nil + } + assert_equal [[:call, :m, :alias_m], [:raise, :m, :alias_m], [:return, :m, :alias_m]], events + events.clear + + o = Class.new{ + alias alias_raise raise + def m + alias_raise + end + }.new + TracePoint.new(:c_return, &capture_events).enable{ + o.m rescue nil + } + assert_equal [:c_return, :raise, :alias_raise], events[0] + events.clear + + o = Class.new(String){ + include Enumerable + alias each each_char + }.new('foo') + TracePoint.new(:c_return, &capture_events).enable{ + o.find{true} + } + assert_equal [:c_return, :each_char, :each], events[0] + events.clear + + o = Class.new{ + define_method(:m){} + alias alias_m m + }.new + TracePoint.new(:call, :return, &capture_events).enable{ + o.alias_m + } + assert_equal [[:call, :m, :alias_m], [:return, :m, :alias_m]], events + events.clear + + o = Class.new{ + def m + tap{return} + end + alias alias_m m + }.new + TracePoint.new(:return, &capture_events).enable{ + o.alias_m + } + assert_equal [[:return, :m, :alias_m]], events + events.clear + + o = Class.new{ + define_method(:m){raise} + alias alias_m m + }.new + TracePoint.new(:b_return, :return, &capture_events).enable{ + o.alias_m rescue nil + } + assert_equal [[:b_return, :m, :alias_m], [:return, :m, :alias_m]], events[0..1] + events.clear + + o = Class.new{ + define_method(:m){tap{return}} + alias alias_m m + }.new + TracePoint.new(:b_return, &capture_events).enable{ + o.alias_m + } + assert_equal [[:b_return, :m, :alias_m], [:b_return, :m, :alias_m]], events[0..1] + events.clear + + o = Class.new{ + alias alias_tap tap + define_method(:m){alias_tap{return}} + }.new + TracePoint.new(:c_return, &capture_events).enable{ + o.m + } + assert_equal [[:c_return, :tap, :alias_tap]], events + events.clear + + c = Class.new{ + alias initialize itself + } + TracePoint.new(:c_call, &capture_events).enable{ + c.new + } + assert_equal [:c_call, :itself, :initialize], events[1] + events.clear + + o = Class.new{ + alias alias_itself itself + }.new + TracePoint.new(:c_call, :c_return, &capture_events).enable{ + o.alias_itself + } + assert_equal [[:c_call, :itself, :alias_itself], [:c_return, :itself, :alias_itself]], events + events.clear + end end diff --git a/thread.c b/thread.c index 48c1896910..c596b5bc12 100644 --- a/thread.c +++ b/thread.c @@ -589,11 +589,11 @@ thread_start_func_2(rb_thread_t *th, VALUE *stack_start, VALUE *register_stack_s th->errinfo = Qnil; th->root_lep = rb_vm_ep_local_ep(vm_proc_ep(th->first_proc)); th->root_svar = Qfalse; - EXEC_EVENT_HOOK(th, RUBY_EVENT_THREAD_BEGIN, th->self, 0, 0, Qundef); + EXEC_EVENT_HOOK(th, RUBY_EVENT_THREAD_BEGIN, th->self, 0, 0, 0, Qundef); th->value = rb_vm_invoke_proc(th, proc, (int)RARRAY_LEN(args), RARRAY_CONST_PTR(args), VM_BLOCK_HANDLER_NONE); - EXEC_EVENT_HOOK(th, RUBY_EVENT_THREAD_END, th->self, 0, 0, Qundef); + EXEC_EVENT_HOOK(th, RUBY_EVENT_THREAD_END, th->self, 0, 0, 0, Qundef); } else { th->value = (*th->first_func)((void *)args); @@ -2063,7 +2063,7 @@ rb_threadptr_execute_interrupts(rb_thread_t *th, int blocking_timing) if (th->status == THREAD_RUNNABLE) th->running_time_us += TIME_QUANTUM_USEC; - EXEC_EVENT_HOOK(th, RUBY_INTERNAL_EVENT_SWITCH, th->cfp->self, 0, 0, Qundef); + EXEC_EVENT_HOOK(th, RUBY_INTERNAL_EVENT_SWITCH, th->cfp->self, 0, 0, 0, Qundef); rb_thread_schedule_limits(limits_us); } diff --git a/vm.c b/vm.c index 8e6288787d..7cededc1e1 100644 --- a/vm.c +++ b/vm.c @@ -330,7 +330,7 @@ ruby_th_dtrace_setup(rb_thread_t *th, VALUE klass, ID id, enum ruby_value_type type; if (!klass) { if (!th) th = GET_THREAD(); - if (!rb_thread_method_id_and_class(th, &id, &klass) || !klass) + if (!rb_thread_method_id_and_class(th, &id, 0, &klass) || !klass) return FALSE; } if (RB_TYPE_P(klass, T_ICLASS)) { @@ -522,7 +522,7 @@ rb_vm_pop_cfunc_frame(void) rb_control_frame_t *cfp = th->cfp; const rb_callable_method_entry_t *me = rb_vm_frame_method_entry(cfp); - EXEC_EVENT_HOOK(th, RUBY_EVENT_C_RETURN, cfp->self, me->def->original_id, me->owner, Qnil); + EXEC_EVENT_HOOK(th, RUBY_EVENT_C_RETURN, cfp->self, me->def->original_id, me->called_id, me->owner, Qnil); RUBY_DTRACE_CMETHOD_RETURN_HOOK(th, me->owner, me->def->original_id); vm_pop_frame(th, cfp, cfp->ep); } @@ -984,9 +984,9 @@ invoke_bmethod(rb_thread_t *th, const rb_iseq_t *iseq, VALUE self, const struct iseq->body->stack_max); RUBY_DTRACE_METHOD_ENTRY_HOOK(th, me->owner, me->def->original_id); - EXEC_EVENT_HOOK(th, RUBY_EVENT_CALL, self, me->def->original_id, me->owner, Qnil); + EXEC_EVENT_HOOK(th, RUBY_EVENT_CALL, self, me->def->original_id, me->called_id, me->owner, Qnil); ret = vm_exec(th); - EXEC_EVENT_HOOK(th, RUBY_EVENT_RETURN, self, me->def->original_id, me->owner, ret); + EXEC_EVENT_HOOK(th, RUBY_EVENT_RETURN, self, me->def->original_id, me->called_id, me->owner, ret); RUBY_DTRACE_METHOD_RETURN_HOOK(th, me->owner, me->def->original_id); return ret; } @@ -1592,26 +1592,27 @@ hook_before_rewind(rb_thread_t *th, rb_control_frame_t *cfp, int will_finish_vm_ switch (VM_FRAME_TYPE(th->cfp)) { case VM_FRAME_MAGIC_METHOD: RUBY_DTRACE_METHOD_RETURN_HOOK(th, 0, 0); - EXEC_EVENT_HOOK_AND_POP_FRAME(th, RUBY_EVENT_RETURN, th->cfp->self, 0, 0, Qnil); + EXEC_EVENT_HOOK_AND_POP_FRAME(th, RUBY_EVENT_RETURN, th->cfp->self, 0, 0, 0, Qnil); break; case VM_FRAME_MAGIC_BLOCK: case VM_FRAME_MAGIC_LAMBDA: if (VM_FRAME_BMETHOD_P(th->cfp)) { - EXEC_EVENT_HOOK(th, RUBY_EVENT_B_RETURN, th->cfp->self, 0, 0, Qnil); + EXEC_EVENT_HOOK(th, RUBY_EVENT_B_RETURN, th->cfp->self, 0, 0, 0, Qnil); if (!will_finish_vm_exec) { /* kick RUBY_EVENT_RETURN at invoke_block_from_c() for bmethod */ EXEC_EVENT_HOOK_AND_POP_FRAME(th, RUBY_EVENT_RETURN, th->cfp->self, rb_vm_frame_method_entry(th->cfp)->def->original_id, + rb_vm_frame_method_entry(th->cfp)->called_id, rb_vm_frame_method_entry(th->cfp)->owner, Qnil); } } else { - EXEC_EVENT_HOOK_AND_POP_FRAME(th, RUBY_EVENT_B_RETURN, th->cfp->self, 0, 0, Qnil); + EXEC_EVENT_HOOK_AND_POP_FRAME(th, RUBY_EVENT_B_RETURN, th->cfp->self, 0, 0, 0, Qnil); } break; case VM_FRAME_MAGIC_CLASS: - EXEC_EVENT_HOOK_AND_POP_FRAME(th, RUBY_EVENT_END, th->cfp->self, 0, 0, Qnil); + EXEC_EVENT_HOOK_AND_POP_FRAME(th, RUBY_EVENT_END, th->cfp->self, 0, 0, 0, Qnil); break; } } @@ -1735,6 +1736,7 @@ vm_exec(rb_thread_t *th) if (UNLIKELY(VM_FRAME_TYPE(th->cfp) == VM_FRAME_MAGIC_CFUNC)) { EXEC_EVENT_HOOK(th, RUBY_EVENT_C_RETURN, th->cfp->self, rb_vm_frame_method_entry(th->cfp)->def->original_id, + rb_vm_frame_method_entry(th->cfp)->called_id, rb_vm_frame_method_entry(th->cfp)->owner, Qnil); RUBY_DTRACE_CMETHOD_RETURN_HOOK(th, rb_vm_frame_method_entry(th->cfp)->owner, @@ -1958,12 +1960,13 @@ rb_iseq_eval_main(const rb_iseq_t *iseq) } int -rb_vm_control_frame_id_and_class(const rb_control_frame_t *cfp, ID *idp, VALUE *klassp) +rb_vm_control_frame_id_and_class(const rb_control_frame_t *cfp, ID *idp, ID *called_idp, VALUE *klassp) { const rb_callable_method_entry_t *me = rb_vm_frame_method_entry(cfp); if (me) { if (idp) *idp = me->def->original_id; + if (called_idp) *called_idp = me->called_id; if (klassp) *klassp = me->owner; return TRUE; } @@ -1973,15 +1976,15 @@ rb_vm_control_frame_id_and_class(const rb_control_frame_t *cfp, ID *idp, VALUE * } int -rb_thread_method_id_and_class(rb_thread_t *th, ID *idp, VALUE *klassp) +rb_thread_method_id_and_class(rb_thread_t *th, ID *idp, ID *called_idp, VALUE *klassp) { - return rb_vm_control_frame_id_and_class(th->cfp, idp, klassp); + return rb_vm_control_frame_id_and_class(th->cfp, idp, called_idp, klassp); } int -rb_frame_method_id_and_class(ID *idp, VALUE *klassp) +rb_frame_method_id_and_class(ID *idp, ID *called_idp, VALUE *klassp) { - return rb_thread_method_id_and_class(GET_THREAD(), idp, klassp); + return rb_thread_method_id_and_class(GET_THREAD(), idp, called_idp, klassp); } VALUE diff --git a/vm_backtrace.c b/vm_backtrace.c index d4d4d41ed8..1df7bb8b7f 100644 --- a/vm_backtrace.c +++ b/vm_backtrace.c @@ -1088,7 +1088,7 @@ static VALUE get_klass(const rb_control_frame_t *cfp) { VALUE klass; - if (rb_vm_control_frame_id_and_class(cfp, 0, &klass)) { + if (rb_vm_control_frame_id_and_class(cfp, 0, 0, &klass)) { if (RB_TYPE_P(klass, T_ICLASS)) { return RBASIC(klass)->klass; } diff --git a/vm_core.h b/vm_core.h index f3e9a72cb0..93b1152aea 100644 --- a/vm_core.h +++ b/vm_core.h @@ -1420,7 +1420,7 @@ RUBY_SYMBOL_EXPORT_BEGIN VALUE rb_iseq_eval(const rb_iseq_t *iseq); VALUE rb_iseq_eval_main(const rb_iseq_t *iseq); RUBY_SYMBOL_EXPORT_END -int rb_thread_method_id_and_class(rb_thread_t *th, ID *idp, VALUE *klassp); +int rb_thread_method_id_and_class(rb_thread_t *th, ID *idp, ID *called_idp, VALUE *klassp); VALUE rb_vm_invoke_proc(rb_thread_t *th, rb_proc_t *proc, int argc, const VALUE *argv, VALUE block_handler); VALUE rb_vm_make_proc_lambda(rb_thread_t *th, const struct rb_captured_block *captured, VALUE klass, int8_t is_lambda); @@ -1468,7 +1468,7 @@ int rb_vm_get_sourceline(const rb_control_frame_t *); VALUE rb_name_err_mesg_new(VALUE mesg, VALUE recv, VALUE method); void rb_vm_stack_to_heap(rb_thread_t *th); void ruby_thread_init_stack(rb_thread_t *th); -int rb_vm_control_frame_id_and_class(const rb_control_frame_t *cfp, ID *idp, VALUE *klassp); +int rb_vm_control_frame_id_and_class(const rb_control_frame_t *cfp, ID *idp, ID *called_idp, VALUE *klassp); void rb_vm_rewind_cfp(rb_thread_t *th, rb_control_frame_t *cfp); void rb_vm_register_special_exception(enum ruby_special_exceptions sp, VALUE exception_class, const char *mesg); @@ -1580,6 +1580,7 @@ struct rb_trace_arg_struct { rb_control_frame_t *cfp; VALUE self; ID id; + ID called_id; VALUE klass; VALUE data; @@ -1593,17 +1594,17 @@ struct rb_trace_arg_struct { void rb_threadptr_exec_event_hooks(struct rb_trace_arg_struct *trace_arg); void rb_threadptr_exec_event_hooks_and_pop_frame(struct rb_trace_arg_struct *trace_arg); -#define EXEC_EVENT_HOOK_ORIG(th_, flag_, self_, id_, klass_, data_, pop_p_) do { \ +#define EXEC_EVENT_HOOK_ORIG(th_, flag_, self_, id_, called_id_, klass_, data_, pop_p_) do { \ const rb_event_flag_t flag_arg_ = (flag_); \ if (UNLIKELY(ruby_vm_event_flags & (flag_arg_))) { \ /* defer evaluating the other arguments */ \ - ruby_exec_event_hook_orig(th_, flag_arg_, self_, id_, klass_, data_, pop_p_); \ + ruby_exec_event_hook_orig(th_, flag_arg_, self_, id_, called_id_, klass_, data_, pop_p_); \ } \ } while (0) static inline void ruby_exec_event_hook_orig(rb_thread_t *const th, const rb_event_flag_t flag, - VALUE self, ID id, VALUE klass, VALUE data, int pop_p) + VALUE self, ID id, ID called_id, VALUE klass, VALUE data, int pop_p) { if ((th->event_hooks.events | th->vm->event_hooks.events) & flag) { struct rb_trace_arg_struct trace_arg; @@ -1612,6 +1613,7 @@ ruby_exec_event_hook_orig(rb_thread_t *const th, const rb_event_flag_t flag, trace_arg.cfp = th->cfp; trace_arg.self = self; trace_arg.id = id; + trace_arg.called_id = called_id; trace_arg.klass = klass; trace_arg.data = data; trace_arg.path = Qundef; @@ -1621,11 +1623,11 @@ ruby_exec_event_hook_orig(rb_thread_t *const th, const rb_event_flag_t flag, } } -#define EXEC_EVENT_HOOK(th_, flag_, self_, id_, klass_, data_) \ - EXEC_EVENT_HOOK_ORIG(th_, flag_, self_, id_, klass_, data_, 0) +#define EXEC_EVENT_HOOK(th_, flag_, self_, id_, called_id_, klass_, data_) \ + EXEC_EVENT_HOOK_ORIG(th_, flag_, self_, id_, called_id_, klass_, data_, 0) -#define EXEC_EVENT_HOOK_AND_POP_FRAME(th_, flag_, self_, id_, klass_, data_) \ - EXEC_EVENT_HOOK_ORIG(th_, flag_, self_, id_, klass_, data_, 1) +#define EXEC_EVENT_HOOK_AND_POP_FRAME(th_, flag_, self_, id_, called_id_, klass_, data_) \ + EXEC_EVENT_HOOK_ORIG(th_, flag_, self_, id_, called_id_, klass_, data_, 1) RUBY_SYMBOL_EXPORT_BEGIN diff --git a/vm_eval.c b/vm_eval.c index fd01e51d00..e7fd2a8e89 100644 --- a/vm_eval.c +++ b/vm_eval.c @@ -68,7 +68,7 @@ vm_call0_cfunc(rb_thread_t* th, struct rb_calling_info *calling, const struct rb VALUE val; RUBY_DTRACE_CMETHOD_ENTRY_HOOK(th, cc->me->owner, ci->mid); - EXEC_EVENT_HOOK(th, RUBY_EVENT_C_CALL, calling->recv, ci->mid, cc->me->owner, Qnil); + EXEC_EVENT_HOOK(th, RUBY_EVENT_C_CALL, calling->recv, ci->mid, ci->mid, cc->me->owner, Qnil); { rb_control_frame_t *reg_cfp = th->cfp; const rb_callable_method_entry_t *me = cc->me; @@ -98,7 +98,7 @@ vm_call0_cfunc(rb_thread_t* th, struct rb_calling_info *calling, const struct rb rb_vm_pop_frame(th); } } - EXEC_EVENT_HOOK(th, RUBY_EVENT_C_RETURN, calling->recv, ci->mid, callnig->cc->me->owner, val); + EXEC_EVENT_HOOK(th, RUBY_EVENT_C_RETURN, calling->recv, ci->mid, ci->mid, callnig->cc->me->owner, val); RUBY_DTRACE_CMETHOD_RETURN_HOOK(th, cc->me->owner, ci->mid); return val; @@ -117,7 +117,7 @@ vm_call0_cfunc_with_frame(rb_thread_t* th, struct rb_calling_info *calling, cons VALUE block_handler = calling->block_handler; RUBY_DTRACE_CMETHOD_ENTRY_HOOK(th, me->owner, mid); - EXEC_EVENT_HOOK(th, RUBY_EVENT_C_CALL, recv, me->def->original_id, me->owner, Qnil); + EXEC_EVENT_HOOK(th, RUBY_EVENT_C_CALL, recv, me->def->original_id, mid, me->owner, Qnil); { rb_control_frame_t *reg_cfp = th->cfp; @@ -136,7 +136,7 @@ vm_call0_cfunc_with_frame(rb_thread_t* th, struct rb_calling_info *calling, cons VM_PROFILE_UP(C2C_POPF); rb_vm_pop_frame(th); } - EXEC_EVENT_HOOK(th, RUBY_EVENT_C_RETURN, recv, me->def->original_id, me->owner, val); + EXEC_EVENT_HOOK(th, RUBY_EVENT_C_RETURN, recv, me->def->original_id, mid, me->owner, val); RUBY_DTRACE_CMETHOD_RETURN_HOOK(th, me->owner, mid); return val; diff --git a/vm_insnhelper.c b/vm_insnhelper.c index 65462553ec..43db728aef 100644 --- a/vm_insnhelper.c +++ b/vm_insnhelper.c @@ -1739,7 +1739,7 @@ vm_call_cfunc_with_frame(rb_thread_t *th, rb_control_frame_t *reg_cfp, struct rb int argc = calling->argc; RUBY_DTRACE_CMETHOD_ENTRY_HOOK(th, me->owner, me->def->original_id); - EXEC_EVENT_HOOK(th, RUBY_EVENT_C_CALL, recv, me->def->original_id, me->owner, Qundef); + EXEC_EVENT_HOOK(th, RUBY_EVENT_C_CALL, recv, me->def->original_id, ci->mid, me->owner, Qundef); vm_push_frame(th, NULL, VM_FRAME_MAGIC_CFUNC | VM_FRAME_FLAG_CFRAME | VM_ENV_FLAG_LOCAL, recv, block_handler, (VALUE)me, @@ -1757,7 +1757,7 @@ vm_call_cfunc_with_frame(rb_thread_t *th, rb_control_frame_t *reg_cfp, struct rb rb_vm_pop_frame(th); - EXEC_EVENT_HOOK(th, RUBY_EVENT_C_RETURN, recv, me->def->original_id, me->owner, val); + EXEC_EVENT_HOOK(th, RUBY_EVENT_C_RETURN, recv, me->def->original_id, ci->mid, me->owner, val); RUBY_DTRACE_CMETHOD_RETURN_HOOK(th, me->owner, me->def->original_id); return val; diff --git a/vm_trace.c b/vm_trace.c index fe14c64918..aca6367b08 100644 --- a/vm_trace.c +++ b/vm_trace.c @@ -616,7 +616,7 @@ call_trace_func(rb_event_flag_t event, VALUE proc, VALUE self, ID id, VALUE klas rb_thread_t *th = GET_THREAD(); if (!klass) { - rb_thread_method_id_and_class(th, &id, &klass); + rb_thread_method_id_and_class(th, &id, 0, &klass); } if (klass) { @@ -781,7 +781,7 @@ fill_id_and_klass(rb_trace_arg_t *trace_arg) { if (!trace_arg->klass_solved) { if (!trace_arg->klass) { - rb_vm_control_frame_id_and_class(trace_arg->cfp, &trace_arg->id, &trace_arg->klass); + rb_vm_control_frame_id_and_class(trace_arg->cfp, &trace_arg->id, &trace_arg->called_id, &trace_arg->klass); } if (trace_arg->klass) { @@ -804,6 +804,13 @@ rb_tracearg_method_id(rb_trace_arg_t *trace_arg) return trace_arg->id ? ID2SYM(trace_arg->id) : Qnil; } +VALUE +rb_tracearg_callee_id(rb_trace_arg_t *trace_arg) +{ + fill_id_and_klass(trace_arg); + return trace_arg->called_id ? ID2SYM(trace_arg->called_id) : Qnil; +} + VALUE rb_tracearg_defined_class(rb_trace_arg_t *trace_arg) { @@ -906,7 +913,7 @@ tracepoint_attr_path(VALUE tpval) } /* - * Return the name of the method being called + * Return the name at the definition of the method being called */ static VALUE tracepoint_attr_method_id(VALUE tpval) @@ -914,6 +921,15 @@ tracepoint_attr_method_id(VALUE tpval) return rb_tracearg_method_id(get_trace_arg()); } +/* + * Return the called name of the method being called + */ +static VALUE +tracepoint_attr_callee_id(VALUE tpval) +{ + return rb_tracearg_callee_id(get_trace_arg()); +} + /* * Return class or module of the method being called. * @@ -1480,6 +1496,7 @@ Init_vm_trace(void) rb_define_method(rb_cTracePoint, "lineno", tracepoint_attr_lineno, 0); rb_define_method(rb_cTracePoint, "path", tracepoint_attr_path, 0); rb_define_method(rb_cTracePoint, "method_id", tracepoint_attr_method_id, 0); + rb_define_method(rb_cTracePoint, "callee_id", tracepoint_attr_callee_id, 0); rb_define_method(rb_cTracePoint, "defined_class", tracepoint_attr_defined_class, 0); rb_define_method(rb_cTracePoint, "binding", tracepoint_attr_binding, 0); rb_define_method(rb_cTracePoint, "self", tracepoint_attr_self, 0); -- cgit v1.2.3