Index: bootstraptest/test_flow.rb
===================================================================
--- bootstraptest/test_flow.rb	(revision 38620)
+++ bootstraptest/test_flow.rb	(working copy)
@@ -562,3 +562,17 @@ assert_equal %Q{ENSURE\n}, %q{
   assert_equal "false", src + %q{e.all? {false}}, bug
   assert_equal "true", src + %q{e.include?(:foo)}, bug
 end
+
+assert_equal('ok', %q{
+  class FOO < RuntimeError; end
+  class BAR < RuntimeError; end
+  def m
+    raise FOO
+  end
+  set_trace_func(proc{|t,| raise BAR if t == 'return'})
+  begin
+    m
+  rescue BAR
+    'ok'
+  end
+}, '[ruby-core:51128] [ruby-trunk - Bug #7624]')
Index: vm_core.h
===================================================================
--- vm_core.h	(revision 38620)
+++ vm_core.h	(working copy)
@@ -728,16 +728,22 @@ void rb_thread_lock_destroy(rb_thread_lo
 
 /* tracer */
 void
-rb_threadptr_exec_event_hooks(rb_thread_t *th, rb_event_flag_t flag, VALUE self, ID id, VALUE klass);
+rb_threadptr_exec_event_hooks(rb_thread_t *th, rb_event_flag_t flag, VALUE self, ID id, VALUE klass, int pop_p);
 
-#define EXEC_EVENT_HOOK(th, flag, self, id, klass) do { \
+#define EXEC_EVENT_HOOK_ORIG(th, flag, self, id, klass, pop_p) do { \
     rb_event_flag_t wait_event__ = (th)->event_flags; \
     if (UNLIKELY(wait_event__)) { \
 	if (wait_event__ & ((flag) | RUBY_EVENT_VM)) { \
-	    rb_threadptr_exec_event_hooks((th), (flag), (self), (id), (klass)); \
+	    rb_threadptr_exec_event_hooks((th), (flag), (self), (id), (klass), (pop_p)); \
 	} \
     } \
 } while (0)
+
+#define EXEC_EVENT_HOOK(th, flag, self, id, klass) \
+  EXEC_EVENT_HOOK_ORIG(th, flag, self, id, klass, 0)
+
+#define EXEC_EVENT_HOOK_AND_POP_FRAME(th, flag, self, id, klass) \
+  EXEC_EVENT_HOOK_ORIG(th, flag, self, id, klass, 1)
 
 #if defined __GNUC__ && __GNUC__ >= 4
 #pragma GCC visibility push(default)
Index: thread.c
===================================================================
--- thread.c	(revision 38620)
+++ thread.c	(working copy)
@@ -4060,7 +4060,7 @@ enum {
     EVENT_RUNNING_EVENT_MASK = EVENT_RUNNING_VM|EVENT_RUNNING_THREAD
 };
 
-static VALUE thread_suppress_tracing(rb_thread_t *th, int ev, VALUE (*func)(VALUE, int), VALUE arg, int always);
+static VALUE thread_suppress_tracing(rb_thread_t *th, int ev, VALUE (*func)(VALUE, int), VALUE arg, int always, int pop_p);
 
 struct event_call_args {
     rb_thread_t *th;
@@ -4145,25 +4145,16 @@ set_threads_event_flags(int flag)
 static inline int
 exec_event_hooks(const rb_event_hook_t *hook, rb_event_flag_t flag, VALUE self, ID id, VALUE klass)
 {
-    volatile int removed = 0;
-    const rb_event_hook_t *volatile hnext = 0;
-    int state;
-
-    PUSH_TAG();
-    if ((state = EXEC_TAG()) != 0) {
-	hook = hnext;
-    }
+    int removed = 0;
     for (; hook; hook = hook->next) {
 	if (hook->flag & RUBY_EVENT_REMOVED) {
 	    removed++;
 	    continue;
 	}
 	if (flag & hook->flag) {
-	    hnext = hook->next;
 	    (*hook->func)(flag, hook->data, self, id, klass);
 	}
     }
-    POP_TAG();
     return removed;
 }
 
@@ -4208,7 +4199,7 @@ thread_exec_event_hooks(VALUE args, int 
 }
 
 void
-rb_threadptr_exec_event_hooks(rb_thread_t *th, rb_event_flag_t flag, VALUE self, ID id, VALUE klass)
+rb_threadptr_exec_event_hooks(rb_thread_t *th, rb_event_flag_t flag, VALUE self, ID id, VALUE klass, int pop_p)
 {
     const VALUE errinfo = th->errinfo;
     struct event_call_args args;
@@ -4218,7 +4209,7 @@ rb_threadptr_exec_event_hooks(rb_thread_
     args.id = id;
     args.klass = klass;
     args.proc = 0;
-    thread_suppress_tracing(th, EVENT_RUNNING_EVENT_MASK, thread_exec_event_hooks, (VALUE)&args, FALSE);
+    thread_suppress_tracing(th, EVENT_RUNNING_EVENT_MASK, thread_exec_event_hooks, (VALUE)&args, FALSE, pop_p);
     th->errinfo = errinfo;
 }
 
@@ -4567,11 +4558,11 @@ VALUE
 ruby_suppress_tracing(VALUE (*func)(VALUE, int), VALUE arg, int always)
 {
     rb_thread_t *th = GET_THREAD();
-    return thread_suppress_tracing(th, EVENT_RUNNING_TRACE, func, arg, always);
+    return thread_suppress_tracing(th, EVENT_RUNNING_TRACE, func, arg, always, 0);
 }
 
 static VALUE
-thread_suppress_tracing(rb_thread_t *th, int ev, VALUE (*func)(VALUE, int), VALUE arg, int always)
+thread_suppress_tracing(rb_thread_t *th, int ev, VALUE (*func)(VALUE, int), VALUE arg, int always, int pop_p)
 {
     int state, tracing = th->tracing, running = tracing & ev;
     volatile int raised;
@@ -4601,6 +4592,9 @@ thread_suppress_tracing(rb_thread_t *th,
 
     th->tracing = tracing;
     if (state) {
+	if (pop_p) {
+	    th->cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(th->cfp);
+	}
 	JUMP_TAG(state);
     }
     th->state = outer_state;
Index: KNOWNBUGS.rb
===================================================================
--- KNOWNBUGS.rb	(revision 38620)
+++ KNOWNBUGS.rb	(working copy)
@@ -3,5 +3,3 @@
 # So all tests will cause failure.
 #
 
-assert_equal('', "set_trace_func(proc{|t,|raise if t == 'line'})\n""1\n'ok'")
-assert_finish(3, "def m; end\n""set_trace_func(proc{|t,|raise if t == 'return'})\n""m")
Index: vm.c
===================================================================
--- vm.c	(revision 38620)
+++ vm.c	(working copy)
@@ -1415,10 +1415,10 @@ vm_exec(rb_thread_t *th)
 
 	    switch (VM_FRAME_TYPE(th->cfp)) {
 	      case VM_FRAME_MAGIC_METHOD:
-		EXEC_EVENT_HOOK(th, RUBY_EVENT_RETURN, th->cfp->self, 0, 0);
+		EXEC_EVENT_HOOK_AND_POP_FRAME(th, RUBY_EVENT_RETURN, th->cfp->self, 0, 0);
 		break;
 	      case VM_FRAME_MAGIC_CLASS:
-		EXEC_EVENT_HOOK(th, RUBY_EVENT_END, th->cfp->self, 0, 0);
+		EXEC_EVENT_HOOK_AND_POP_FRAME(th, RUBY_EVENT_END, th->cfp->self, 0, 0);
 		break;
 	    }