Change the data structures for breakpoints

Change the data structures for breakpoints to make it possible
(in a future commit) to manage breakpoints without taking down the
system to single-scheduling mode.

The current "breakpoint wheel" data structure (a circular,
double-linked list of breakpoints) was invented before the
SMP emulator. To support it in the SMP emulator, there is essentially
one breakpoint wheel per scheduler. As more breakpoint types have
been added, the implementation has become messy and hard to understand
and maintain.

Therefore, the time for a rewrite has come. Use one struct to hold
all breakpoint data for a breakpoint in a function. Use a flag field
to indicate what different type of break actions that are enabled.

7 files changed, 636 insertions, 976 deletions

diff --git a/erts/emulator/beam/beam_bp.c b/erts/emulator/beam/beam_bp.c
index 26dadfbbc0..fc17ef7d67 100644
--- a/erts/emulator/beam/beam_bp.c
+++ b/erts/emulator/beam/beam_bp.c
@@ -44,67 +44,33 @@
 #define ReAlloc(P, SIZ)		erts_realloc(ERTS_ALC_T_BPD, (P), (SZ))
 #define Free(P)			erts_free(ERTS_ALC_T_BPD, (P))
 
-/*
-** Doubly linked ring macros
-*/
-
-#define BpInit(a,i)        \
-do {                       \
-    (a)->orig_instr = (i); \
-    (a)->next = (a);       \
-    (a)->prev = (a);       \
-} while (0)
-
-#define BpSpliceNext(a,b)                   \
-do {                                        \
-    register BpData *c = (a), *d = (b), *e; \
-    e             = c->next->prev;          \
-    c->next->prev = d->next->prev;          \
-    d->next->prev = e;                      \
-    e       = c->next;                      \
-    c->next = d->next;                      \
-    d->next = e;                            \
-} while (0)
-
-#define BpSplicePrev(a,b)                   \
-do {                                        \
-    register BpData *c = (a), *d = (b), *e; \
-    e             = c->prev->next;          \
-    c->prev->next = d->prev->next;          \
-    d->prev->next = e;                      \
-    e       = c->prev;                      \
-    c->prev = d->prev;                      \
-    d->prev = e;                            \
-} while (0)
-
-#ifdef DEBUG
-#  define BpSingleton(a) ((a)->next == (a) && (a)->prev == (a))
+#if defined(ERTS_ENABLE_LOCK_CHECK) && defined(ERTS_SMP)
+#  define ERTS_SMP_REQ_PROC_MAIN_LOCK(P) \
+      if ((P)) erts_proc_lc_require_lock((P), ERTS_PROC_LOCK_MAIN)
+#  define ERTS_SMP_UNREQ_PROC_MAIN_LOCK(P) \
+      if ((P)) erts_proc_lc_unrequire_lock((P), ERTS_PROC_LOCK_MAIN)
 #else
-#  define BpSingleton(a) ((a)->next == (a))
+#  define ERTS_SMP_REQ_PROC_MAIN_LOCK(P)
+#  define ERTS_SMP_UNREQ_PROC_MAIN_LOCK(P)
 #endif
 
-#define BpInitAndSpliceNext(a,i,b) \
-do {                               \
-    (a)->orig_instr = (i);         \
-    (a)->prev       = (b);         \
-    (b)->next->prev = (a);         \
-    (a)->next = (b)->next;         \
-    (b)->next = (a);               \
-} while (0)
-
-#define BpInitAndSplicePrev(a,i,b) \
-do {                               \
-    (a)->orig_instr = (i);         \
-    (a)->next       = (b);         \
-    (b)->prev->next = (a);         \
-    (a)->prev = (b)->prev;         \
-    (b)->prev = (a);               \
-} while (0)
-
-
 #define BREAK_IS_BIF (1)
 #define BREAK_IS_ERL (0)
 
+#define ERTS_BPF_LOCAL_TRACE       0x01
+#define ERTS_BPF_META_TRACE        0x02
+#define ERTS_BPF_COUNT             0x04
+#define ERTS_BPF_COUNT_ACTIVE      0x08
+#define ERTS_BPF_DEBUG             0x10
+#define ERTS_BPF_TIME_TRACE        0x20
+#define ERTS_BPF_TIME_TRACE_ACTIVE 0x40
+
+#define ERTS_BPF_ALL               0x7F
+
+extern Eterm beam_return_to_trace[1];   /* OpCode(i_return_to_trace) */
+extern Eterm beam_return_trace[1];      /* OpCode(i_return_trace) */
+extern Eterm beam_exception_trace[1];   /* OpCode(i_exception_trace) */
+extern Eterm beam_return_time_trace[1]; /* OpCode(i_return_time_trace) */
 
 /* *************************************************************************
 ** Local prototypes
@@ -113,26 +79,33 @@ do {                               \
 /*
 ** Helpers
 */
-
+static Eterm do_call_trace(Process* c_p, BeamInstr* I, Eterm* reg,
+			   Binary* ms, Eterm tracer_pid);
 static int set_break(Eterm mfa[3], int specified,
-		     Binary *match_spec, BeamInstr break_op,
+		     Binary *match_spec, Uint break_flags,
 		     enum erts_break_op count_op, Eterm tracer_pid);
 static int set_module_break(Module *modp, Eterm mfa[3], int specified,
-			    Binary *match_spec, BeamInstr break_op,
+			    Binary *match_spec, Uint break_flags,
 			    enum erts_break_op count_op, Eterm tracer_pid);
 static int set_function_break(Module *modp, BeamInstr *pc, int bif,
-			      Binary *match_spec, BeamInstr break_op,
+			      Binary *match_spec, Uint break_flags,
 			      enum erts_break_op count_op, Eterm tracer_pid); 
 
 static int clear_break(Eterm mfa[3], int specified, 
-		       BeamInstr break_op);
+		       Uint break_flags);
 static int clear_module_break(Module *modp, Eterm mfa[3], int specified, 
-			      BeamInstr break_op);
+			      Uint break_flags);
 static int clear_function_break(Module *modp, BeamInstr *pc, int bif,
-				BeamInstr break_op);
+				Uint break_flags);
+
+static BpDataTime* get_time_break(BeamInstr *pc);
+static GenericBpData* check_break(BeamInstr *pc, Uint break_flags);
+static void bp_time_diff(bp_data_time_item_t *item,
+			 process_breakpoint_time_t *pbt,
+			 Uint ms, Uint s, Uint us);
 
-static BpData *is_break(BeamInstr *pc, BeamInstr break_op);
-static BpData *get_break(Process *p, BeamInstr *pc, BeamInstr break_op);
+static void bp_count_unref(BpCount* bcp);
+static void bp_time_unref(BpDataTime* bdt);
 
 /* bp_hash */
 #define BP_TIME_ADD(pi0, pi1)                       \
@@ -153,23 +126,20 @@ static ERTS_INLINE bp_data_time_item_t * bp_hash_put(bp_time_hash_t *hash, bp_da
 static void bp_hash_delete(bp_time_hash_t *hash);
 
 
+
 /* *************************************************************************
 ** External interfaces
 */
 
-erts_smp_spinlock_t erts_bp_lock;
-
 void 
 erts_bp_init(void) {
-    erts_smp_spinlock_init(&erts_bp_lock, "breakpoints");
 }
 
 int 
-erts_set_trace_break(Eterm mfa[3], int specified, Binary *match_spec,
-		     Eterm tracer_pid) {
+erts_set_trace_break(Eterm mfa[3], int specified, Binary *match_spec) {
     ERTS_SMP_LC_ASSERT(erts_smp_thr_progress_is_blocking());
     return set_break(mfa, specified, match_spec,
-		     (BeamInstr) BeamOp(op_i_trace_breakpoint), 0, tracer_pid);
+		     ERTS_BPF_LOCAL_TRACE, 0, am_true);
 }
 
 int 
@@ -177,7 +147,7 @@ erts_set_mtrace_break(Eterm mfa[3], int specified, Binary *match_spec,
 		      Eterm tracer_pid) {
     ERTS_SMP_LC_ASSERT(erts_smp_thr_progress_is_blocking());
     return set_break(mfa, specified, match_spec,
-		     (BeamInstr) BeamOp(op_i_mtrace_breakpoint), 0, tracer_pid);
+		     ERTS_BPF_META_TRACE, 0, tracer_pid);
 }
 
 /* set breakpoint data for on exported bif entry */
@@ -185,164 +155,421 @@ erts_set_mtrace_break(Eterm mfa[3], int specified, Binary *match_spec,
 void
 erts_set_mtrace_bif(BeamInstr *pc, Binary *match_spec, Eterm tracer_pid) {
     ERTS_SMP_LC_ASSERT(erts_smp_thr_progress_is_blocking());
-    set_function_break(NULL, pc, BREAK_IS_BIF, match_spec, (BeamInstr) BeamOp(op_i_mtrace_breakpoint), 0, tracer_pid);
+    set_function_break(NULL, pc, BREAK_IS_BIF, match_spec,
+		       ERTS_BPF_META_TRACE, 0, tracer_pid);
 }
 
 void erts_set_time_trace_bif(BeamInstr *pc, enum erts_break_op count_op) {
-    set_function_break(NULL, pc, BREAK_IS_BIF, NULL, (BeamInstr) BeamOp(op_i_time_breakpoint), count_op, NIL);
+    set_function_break(NULL, pc, BREAK_IS_BIF, NULL,
+		       ERTS_BPF_TIME_TRACE|ERTS_BPF_TIME_TRACE_ACTIVE,
+		       count_op, NIL);
 }
 
 void erts_clear_time_trace_bif(BeamInstr *pc) {
-    clear_function_break(NULL, pc, BREAK_IS_BIF, (BeamInstr) BeamOp(op_i_time_breakpoint));
+    clear_function_break(NULL, pc, BREAK_IS_BIF,
+			 ERTS_BPF_TIME_TRACE|ERTS_BPF_TIME_TRACE_ACTIVE);
 }
 
 int 
 erts_set_debug_break(Eterm mfa[3], int specified) {
     ERTS_SMP_LC_ASSERT(erts_smp_thr_progress_is_blocking());
-    return set_break(mfa, specified, NULL, 
-		     (BeamInstr) BeamOp(op_i_debug_breakpoint), 0, NIL);
+    return set_break(mfa, specified, NULL, ERTS_BPF_DEBUG, 0, NIL);
 }
 
 int 
 erts_set_count_break(Eterm mfa[3], int specified, enum erts_break_op count_op) {
     ERTS_SMP_LC_ASSERT(erts_smp_thr_progress_is_blocking());
     return set_break(mfa, specified, NULL, 
-		     (BeamInstr) BeamOp(op_i_count_breakpoint), count_op, NIL);
+		     ERTS_BPF_COUNT|ERTS_BPF_COUNT_ACTIVE, count_op, NIL);
 }
 
 int
 erts_set_time_break(Eterm mfa[3], int specified, enum erts_break_op count_op) {
     ERTS_SMP_LC_ASSERT(erts_smp_thr_progress_is_blocking());
     return set_break(mfa, specified, NULL,
-		     (BeamInstr) BeamOp(op_i_time_breakpoint), count_op, NIL);
+		     ERTS_BPF_TIME_TRACE|ERTS_BPF_TIME_TRACE_ACTIVE,
+		     count_op, NIL);
 }
 
 int
 erts_clear_trace_break(Eterm mfa[3], int specified) {
     ERTS_SMP_LC_ASSERT(erts_smp_thr_progress_is_blocking());
-    return clear_break(mfa, specified, 
-		       (BeamInstr) BeamOp(op_i_trace_breakpoint));
+    return clear_break(mfa, specified, ERTS_BPF_LOCAL_TRACE);
 }
 
 int
 erts_clear_mtrace_break(Eterm mfa[3], int specified) {
     ERTS_SMP_LC_ASSERT(erts_smp_thr_progress_is_blocking());
-    return clear_break(mfa, specified, 
-		       (BeamInstr) BeamOp(op_i_mtrace_breakpoint));
+    return clear_break(mfa, specified, ERTS_BPF_META_TRACE);
 }
 
 void
 erts_clear_mtrace_bif(BeamInstr *pc) {
-    clear_function_break(NULL, pc, BREAK_IS_BIF, (BeamInstr) BeamOp(op_i_mtrace_breakpoint));
+    clear_function_break(NULL, pc, BREAK_IS_BIF, ERTS_BPF_META_TRACE);
 }
 
 int
 erts_clear_debug_break(Eterm mfa[3], int specified) {
     ERTS_SMP_LC_ASSERT(erts_smp_thr_progress_is_blocking());
-    return clear_break(mfa, specified, 
-		       (BeamInstr) BeamOp(op_i_debug_breakpoint));
+    return clear_break(mfa, specified, ERTS_BPF_DEBUG);
 }
 
 int
 erts_clear_count_break(Eterm mfa[3], int specified) {
     ERTS_SMP_LC_ASSERT(erts_smp_thr_progress_is_blocking());
-    return clear_break(mfa, specified, 
-		       (BeamInstr) BeamOp(op_i_count_breakpoint));
+    return clear_break(mfa, specified, ERTS_BPF_COUNT|ERTS_BPF_COUNT_ACTIVE);
 }
 
 int
 erts_clear_time_break(Eterm mfa[3], int specified) {
     ERTS_SMP_LC_ASSERT(erts_smp_thr_progress_is_blocking());
     return clear_break(mfa, specified,
-		       (BeamInstr) BeamOp(op_i_time_breakpoint));
+		       ERTS_BPF_TIME_TRACE|ERTS_BPF_TIME_TRACE_ACTIVE);
 }
 
 int
 erts_clear_break(Eterm mfa[3], int specified) {
     ERTS_SMP_LC_ASSERT(erts_smp_thr_progress_is_blocking());
-    return clear_break(mfa, specified, 0);
+    return clear_break(mfa, specified, ERTS_BPF_ALL);
 }
 
 int 
 erts_clear_module_break(Module *modp) {
     ERTS_SMP_LC_ASSERT(erts_smp_thr_progress_is_blocking());
     ASSERT(modp);
-    return clear_module_break(modp, NULL, 0, 0);
+    return clear_module_break(modp, NULL, 0, ERTS_BPF_ALL);
 }
 
 int
 erts_clear_function_break(Module *modp, BeamInstr *pc) {
     ERTS_SMP_LC_ASSERT(erts_smp_thr_progress_is_blocking());
     ASSERT(modp);
-    return clear_function_break(modp, pc, BREAK_IS_ERL, 0);
+    return clear_function_break(modp, pc, BREAK_IS_ERL, ERTS_BPF_ALL);
 }
 
+BeamInstr
+erts_generic_breakpoint(Process* c_p, BeamInstr* I, Eterm* reg)
+{
+    GenericBp* g;
+    GenericBpData* bp;
+    Uint bp_flags;
+
+    g = (GenericBp *) I[-4];
+    bp = &g->data[0];
+    bp_flags = bp->flags;
+    ASSERT((bp_flags & ~ERTS_BPF_ALL) == 0);
+    if (bp_flags & (ERTS_BPF_LOCAL_TRACE|ERTS_BPF_TIME_TRACE_ACTIVE) &&
+	!IS_TRACED_FL(c_p, F_TRACE_CALLS)) {
+	bp_flags &= ~(ERTS_BPF_LOCAL_TRACE|
+		      ERTS_BPF_TIME_TRACE|
+		      ERTS_BPF_TIME_TRACE_ACTIVE);
+	if (bp_flags == 0) {	/* Quick exit */
+	    return g->orig_instr;
+	}
+    }
 
+    if (bp_flags & ERTS_BPF_LOCAL_TRACE) {
+	(void) do_call_trace(c_p, I, reg, bp->local_ms, am_true);
+    }
 
-/*
- * SMP NOTE: Process p may have become exiting on return!
- */
-BeamInstr
-erts_trace_break(Process *p, BeamInstr *pc, Eterm *args,
-		 Uint32 *ret_flags, Eterm *tracer_pid) {
-    Eterm tpid1, tpid2;
-    BpData **bds = (BpData **) (pc)[-4];
-    BpDataTrace *bdt = NULL;
+    if (bp_flags & ERTS_BPF_META_TRACE) {
+	Eterm pid;
 
-    ASSERT(bds);
-    ASSERT(pc[-5] == (BeamInstr) BeamOp(op_i_func_info_IaaI));
-    bdt = (BpDataTrace *) bds[bp_sched2ix_proc(p)];
-    ASSERT(bdt);
-    bdt = (BpDataTrace *) bdt->next;
+	pid = (Eterm) erts_smp_atomic_read_nob(&bp->tracer_pid);
+	pid = do_call_trace(c_p, I, reg, bp->meta_ms, pid);
+	erts_smp_atomic_set_nob(&bp->tracer_pid, pid);
+    }
+
+    if (bp_flags & ERTS_BPF_COUNT_ACTIVE) {
+	erts_smp_atomic_inc_nob(&bp->count->acount);
+    }
+
+    if (bp_flags & ERTS_BPF_TIME_TRACE_ACTIVE) {
+	Eterm w;
+	erts_trace_time_call(c_p, I, bp->time);
+	w = (BeamInstr) *c_p->cp;
+	if (! (w == (BeamInstr) BeamOp(op_i_return_time_trace) ||
+	       w == (BeamInstr) BeamOp(op_return_trace) ||
+	       w == (BeamInstr) BeamOp(op_i_return_to_trace)) ) {
+	    Eterm* E = c_p->stop;
+	    ASSERT(c_p->htop <= E && E <= c_p->hend);
+	    if (E - 2 < c_p->htop) {
+		(void) erts_garbage_collect(c_p, 2, reg, I[-1]);
+		ERTS_VERIFY_UNUSED_TEMP_ALLOC(c_p);
+	    }
+	    E = c_p->stop;
+
+	    ASSERT(c_p->htop <= E && E <= c_p->hend);
+
+	    E -= 2;
+	    E[0] = make_cp(I);
+	    E[1] = make_cp(c_p->cp);     /* original return address */
+	    c_p->cp = beam_return_time_trace;
+	    c_p->stop = E;
+	}
+    }
+
+    if (bp_flags & ERTS_BPF_DEBUG) {
+	return (BeamInstr) BeamOp(op_i_debug_breakpoint);
+    } else {
+	return g->orig_instr;
+    }
+}
+
+static Eterm
+do_call_trace(Process* c_p, BeamInstr* I, Eterm* reg,
+	      Binary* ms, Eterm tracer_pid)
+{
+    Eterm* cpp;
+    int return_to_trace = 0;
+    BeamInstr w;
+    BeamInstr *cp_save;
+    Uint32 flags;
+    Uint need = 0;
+    Eterm* E = c_p->stop;
+
+    w = *c_p->cp;
+    if (w == (BeamInstr) BeamOp(op_return_trace)) {
+	cpp = &E[2];
+    } else if (w == (BeamInstr) BeamOp(op_i_return_to_trace)) {
+	return_to_trace = 1;
+	cpp = &E[0];
+    } else if (w == (BeamInstr) BeamOp(op_i_return_time_trace)) {
+	cpp = &E[0];
+    } else {
+	cpp = NULL;
+    }
+    if (cpp) {
+	for (;;) {
+	    BeamInstr w = *cp_val(*cpp);
+	    if (w == (BeamInstr) BeamOp(op_return_trace)) {
+		cpp += 3;
+	    } else if (w == (BeamInstr) BeamOp(op_i_return_to_trace)) {
+		return_to_trace = 1;
+		cpp += 1;
+	    } else if (w == (BeamInstr) BeamOp(op_i_return_time_trace)) {
+		cpp += 2;
+	    } else {
+		break;
+	    }
+	}
+	cp_save = c_p->cp;
+	c_p->cp = (BeamInstr *) cp_val(*cpp);
+	ASSERT(is_CP(*cpp));
+    }
+    ERTS_SMP_UNREQ_PROC_MAIN_LOCK(c_p);
+    flags = erts_call_trace(c_p, I-3, ms, reg, 1, &tracer_pid);
+    ERTS_SMP_REQ_PROC_MAIN_LOCK(c_p);
+    if (cpp) {
+	c_p->cp = cp_save;
+    }
+
+    ASSERT(!ERTS_PROC_IS_EXITING(c_p));
+    if ((flags & MATCH_SET_RETURN_TO_TRACE) && !return_to_trace) {
+	need += 1;
+    }
+    if (flags & MATCH_SET_RX_TRACE) {
+	need += 3;
+    }
+    if (need) {
+	ASSERT(c_p->htop <= E && E <= c_p->hend);
+	if (E - need < c_p->htop) {
+	    (void) erts_garbage_collect(c_p, need, reg, I[-1]);
+	    ERTS_VERIFY_UNUSED_TEMP_ALLOC(c_p);
+	    E = c_p->stop;
+	}
+    }
+    if (flags & MATCH_SET_RETURN_TO_TRACE && !return_to_trace) {
+	E -= 1;
+	ASSERT(c_p->htop <= E && E <= c_p->hend);
+	E[0] = make_cp(c_p->cp);
+	c_p->cp = (BeamInstr *) beam_return_to_trace;
+    }
+    if (flags & MATCH_SET_RX_TRACE) {
+	E -= 3;
+	ASSERT(c_p->htop <= E && E <= c_p->hend);
+	ASSERT(is_CP((Eterm) (UWord) (I - 3)));
+	ASSERT(am_true == tracer_pid ||
+	       is_internal_pid(tracer_pid) || is_internal_port(tracer_pid));
+	E[2] = make_cp(c_p->cp);
+	E[1] = tracer_pid;
+	E[0] = make_cp(I - 3); /* We ARE at the beginning of an
+				  instruction,
+				  the funcinfo is above i. */
+	c_p->cp = (flags & MATCH_SET_EXCEPTION_TRACE) ?
+	    beam_exception_trace : beam_return_trace;
+	erts_smp_proc_lock(c_p, ERTS_PROC_LOCKS_ALL_MINOR);
+	c_p->trace_flags |= F_EXCEPTION_TRACE;
+	erts_smp_proc_unlock(c_p, ERTS_PROC_LOCKS_ALL_MINOR);
+    }
+    c_p->stop = E;
+    return tracer_pid;
+}
+
+void
+erts_trace_time_call(Process* c_p, BeamInstr* I, BpDataTime* bdt)
+{
+    Uint ms,s,us;
+    process_breakpoint_time_t *pbt = NULL;
+    bp_data_time_item_t sitem, *item = NULL;
+    bp_time_hash_t *h = NULL;
+    BpDataTime *pbdt = NULL;
+
+    ASSERT(c_p);
+    ASSERT(erts_smp_atomic32_read_acqb(&c_p->state) & ERTS_PSFLG_RUNNING);
+
+    /* get previous timestamp and breakpoint
+     * from the process psd  */
+
+    pbt = ERTS_PROC_GET_CALL_TIME(c_p);
+    get_sys_now(&ms, &s, &us);
+
+    /* get pbt
+     * timestamp = t0
+     * lookup bdt from code
+     * set ts0 to pbt
+     * add call count here?
+     */
+    if (pbt == 0) {
+	/* First call of process to instrumented function */
+	pbt = Alloc(sizeof(process_breakpoint_time_t));
+	(void *) ERTS_PROC_SET_CALL_TIME(c_p, ERTS_PROC_LOCK_MAIN, pbt);
+    } else {
+	ASSERT(pbt->pc);
+	/* add time to previous code */
+	bp_time_diff(&sitem, pbt, ms, s, us);
+	sitem.pid = c_p->id;
+	sitem.count = 0;
+
+	/* previous breakpoint */
+	pbdt = get_time_break(pbt->pc);
+
+	/* if null then the breakpoint was removed */
+	if (pbdt) {
+	    h = &(pbdt->hash[bp_sched2ix_proc(c_p)]);
+
+	    ASSERT(h);
+	    ASSERT(h->item);
+
+	    item = bp_hash_get(h, &sitem);
+	    if (!item) {
+		item = bp_hash_put(h, &sitem);
+	    } else {
+		BP_TIME_ADD(item, &sitem);
+	    }
+	}
+    }
+
+    /* Add count to this code */
+    sitem.pid     = c_p->id;
+    sitem.count   = 1;
+    sitem.s_time  = 0;
+    sitem.us_time = 0;
+
+    /* this breakpoint */
     ASSERT(bdt);
-    ASSERT(ret_flags);
-    ASSERT(tracer_pid);
+    h = &(bdt->hash[bp_sched2ix_proc(c_p)]);
 
-    ErtsSmpBPLock(bdt);
-    tpid1 = tpid2 = bdt->tracer_pid;
-    ErtsSmpBPUnlock(bdt);
-
-    *ret_flags = erts_call_trace(p, pc-3/*mfa*/, bdt->match_spec, args,
-				 1, &tpid2);
-    *tracer_pid = tpid2;
-    if (tpid1 != tpid2) {
-	ErtsSmpBPLock(bdt);
-	bdt->tracer_pid = tpid2;
-	ErtsSmpBPUnlock(bdt);
+    ASSERT(h);
+    ASSERT(h->item);
+
+    item = bp_hash_get(h, &sitem);
+    if (!item) {
+	item = bp_hash_put(h, &sitem);
+    } else {
+	BP_TIME_ADD(item, &sitem);
     }
-    bds[bp_sched2ix_proc(p)] = (BpData *) bdt;
-    return bdt->orig_instr;
+
+    pbt->pc = I;
+    pbt->ms = ms;
+    pbt->s  = s;
+    pbt->us = us;
 }
 
+void
+erts_trace_time_return(Process *p, BeamInstr *pc)
+{
+    Uint ms,s,us;
+    process_breakpoint_time_t *pbt = NULL;
+    bp_data_time_item_t sitem, *item = NULL;
+    bp_time_hash_t *h = NULL;
+    BpDataTime *pbdt = NULL;
+
+    ASSERT(p);
+    ASSERT(erts_smp_atomic32_read_acqb(&p->state) & ERTS_PSFLG_RUNNING);
 
+    /* get previous timestamp and breakpoint
+     * from the process psd  */
+
+    pbt = ERTS_PROC_GET_CALL_TIME(p);
+    get_sys_now(&ms,&s,&us);
+
+    /* get pbt
+     * lookup bdt from code
+     * timestamp = t1
+     * get ts0 from pbt
+     * get item from bdt->hash[bp_hash(p->id)]
+     * ack diff (t1, t0) to item
+     */
+
+    if (pbt) {
+	/* might have been removed due to
+	 * trace_pattern(false)
+	 */
+	ASSERT(pbt->pc);
+
+	bp_time_diff(&sitem, pbt, ms, s, us);
+	sitem.pid   = p->id;
+	sitem.count = 0;
+
+	/* previous breakpoint */
+	pbdt = get_time_break(pbt->pc);
+
+	/* beware, the trace_pattern might have been removed */
+	if (pbdt) {
+	    h = &(pbdt->hash[bp_sched2ix_proc(p)]);
+
+	    ASSERT(h);
+	    ASSERT(h->item);
+
+	    item = bp_hash_get(h, &sitem);
+	    if (!item) {
+		item = bp_hash_put(h, &sitem);
+	    } else {
+		BP_TIME_ADD(item, &sitem);
+	    }
+	}
+
+	pbt->pc = pc;
+	pbt->ms = ms;
+	pbt->s  = s;
+	pbt->us = us;
+    }
+}
 
 /*
  * SMP NOTE: Process p may have become exiting on return!
  */
 Uint32
 erts_bif_mtrace(Process *p, BeamInstr *pc, Eterm *args, int local,
-		Eterm *tracer_pid) {
-    BpData **bds = (BpData **) (pc)[-4];
-    BpDataTrace *bdt = NULL;
-
+		Eterm *tracer_pid)
+{
+    GenericBp* g;
 
     ASSERT(tracer_pid);
-    if (bds) {
+    g = (GenericBp *) pc[-4];
+    if (g) {
 	Eterm tpid1, tpid2;
 	Uint32 flags;
-	bdt = (BpDataTrace *)bds[bp_sched2ix_proc(p)];
-
-	ErtsSmpBPLock(bdt);
-	tpid1 = tpid2 = bdt->tracer_pid;
-	ErtsSmpBPUnlock(bdt);
+	GenericBpData* bp;
 
-	flags = erts_call_trace(p, pc-3/*mfa*/, bdt->match_spec, args,
+	bp = &g->data[0];
+	tpid1 = tpid2 =(Eterm) erts_smp_atomic_read_nob(&bp->tracer_pid);
+	flags = erts_call_trace(p, pc-3/*mfa*/, bp->meta_ms, args,
 				local, &tpid2);
 	*tracer_pid = tpid2;
 	if (tpid1 != tpid2) {
-	    ErtsSmpBPLock(bdt);
-	    bdt->tracer_pid = tpid2;
-	    ErtsSmpBPUnlock(bdt);
+	    erts_smp_atomic_set_nob(&bp->tracer_pid, tpid2);
 	}
 	return flags;
     }
@@ -353,39 +580,34 @@ erts_bif_mtrace(Process *p, BeamInstr *pc, Eterm *args, int local,
 
 
 int 
-erts_is_trace_break(BeamInstr *pc, Binary **match_spec_ret, Eterm *tracer_pid_ret) {
-    BpDataTrace *bdt = 
-	(BpDataTrace *) is_break(pc, (BeamInstr) BeamOp(op_i_trace_breakpoint));
-    
-    if (bdt) {
+erts_is_trace_break(BeamInstr *pc, Binary **match_spec_ret)
+{
+    GenericBpData* bp = check_break(pc, ERTS_BPF_LOCAL_TRACE);
+
+    if (bp) {
 	if (match_spec_ret) {
-	    *match_spec_ret = bdt->match_spec;
+	    *match_spec_ret = bp->local_ms;
 	}
-	if (tracer_pid_ret) {
-	    ErtsSmpBPLock(bdt);
-	    *tracer_pid_ret = bdt->tracer_pid;
-	    ErtsSmpBPUnlock(bdt);
-	}
-	return !0;
+	return 1;
     }
     return 0;
 }
 
 int 
-erts_is_mtrace_break(BeamInstr *pc, Binary **match_spec_ret, Eterm *tracer_pid_ret) {
-    BpDataTrace *bdt = 
-	(BpDataTrace *) is_break(pc, (BeamInstr) BeamOp(op_i_mtrace_breakpoint));
+erts_is_mtrace_break(BeamInstr *pc, Binary **match_spec_ret,
+		     Eterm *tracer_pid_ret)
+{
+    GenericBpData* bp = check_break(pc, ERTS_BPF_META_TRACE);
     
-    if (bdt) {
+    if (bp) {
 	if (match_spec_ret) {
-	    *match_spec_ret = bdt->match_spec;
+	    *match_spec_ret = bp->meta_ms;
 	}
 	if (tracer_pid_ret) {
-	    ErtsSmpBPLock(bdt);
-	    *tracer_pid_ret = bdt->tracer_pid;
-	    ErtsSmpBPUnlock(bdt);
+	    *tracer_pid_ret =
+		(Eterm) erts_smp_atomic_read_nob(&bp->tracer_pid);
 	}
-	return !0;
+	return 1;
     }
     return 0;
 }
@@ -402,15 +624,15 @@ erts_is_native_break(BeamInstr *pc) {
 }
 
 int 
-erts_is_count_break(BeamInstr *pc, Sint *count_ret) {
-    BpDataCount *bdc = 
-	(BpDataCount *) is_break(pc, (BeamInstr) BeamOp(op_i_count_breakpoint));
+erts_is_count_break(BeamInstr *pc, Uint *count_ret)
+{
+    GenericBpData* bp = check_break(pc, ERTS_BPF_COUNT);
     
-    if (bdc) {
+    if (bp) {
 	if (count_ret) {
-	    *count_ret = (Sint) erts_smp_atomic_read_nob(&bdc->acount);
+	    *count_ret = (Uint) erts_smp_atomic_read_nob(&bp->count->acount);
 	}
-	return !0;
+	return 1;
     }
     return 0;
 }
@@ -421,7 +643,7 @@ int erts_is_time_break(Process *p, BeamInstr *pc, Eterm *retval) {
     Uint size;
     Eterm *hp, t;
     bp_data_time_item_t *item = NULL;
-    BpDataTime *bdt = (BpDataTime *) is_break(pc, (BeamInstr) BeamOp(op_i_time_breakpoint));
+    BpDataTime *bdt = get_time_break(pc);
 
     if (bdt) {
 	if (retval) {
@@ -464,7 +686,7 @@ int erts_is_time_break(Process *p, BeamInstr *pc, Eterm *retval) {
 	    }
 	    bp_hash_delete(&hash);
 	}
-	return !0;
+	return 1;
     }
 
     return 0;
@@ -655,7 +877,7 @@ void erts_schedule_time_break(Process *p, Uint schedule) {
 	     * the previous breakpoint.
 	     */
 
-	    pbdt = (BpDataTime *) get_break(p, pbt->pc, (BeamInstr) BeamOp(op_i_time_breakpoint));
+	    pbdt = get_time_break(pbt->pc);
 	    if (pbdt) {
 		get_sys_now(&ms,&s,&us);
 		bp_time_diff(&sitem, pbt, ms, s, us);
@@ -693,159 +915,13 @@ void erts_schedule_time_break(Process *p, Uint schedule) {
     } /* pbt */
 }
 
-/* call_time breakpoint
- * Accumulated times are added to the previous bp,
- * not the current one. The current one is saved
- * for future reference.
- * The previous breakpoint is stored in the process it self, the psd.
- * We do not need to store in a stack frame.
- * There is no need for locking, each thread has its own
- * area in each bp to save data.
- * Since we need to diffrentiate between processes for each bp,
- * every bp has a hash (per thread) to process-bp statistics.
- * - egil
- */
-
-void erts_trace_time_break(Process *p, BeamInstr *pc, BpDataTime *bdt, Uint type) {
-    Uint ms,s,us;
-    process_breakpoint_time_t *pbt = NULL;
-    bp_data_time_item_t sitem, *item = NULL;
-    bp_time_hash_t *h = NULL;
-    BpDataTime *pbdt = NULL;
-
-    ASSERT(p);
-    ASSERT(ERTS_PSFLG_RUNNING & erts_smp_atomic32_read_acqb(&p->state));
-
-    /* get previous timestamp and breakpoint
-     * from the process psd  */
-
-    pbt = ERTS_PROC_GET_CALL_TIME(p);
-    get_sys_now(&ms,&s,&us);
-
-    switch(type) {
-	    /* get pbt
-	     * timestamp = t0
-	     * lookup bdt from code
-	     * set ts0 to pbt
-	     * add call count here?
-	     */
-	case ERTS_BP_CALL_TIME_CALL:
-	case ERTS_BP_CALL_TIME_TAIL_CALL:
-
-	    if (pbt) {
-		ASSERT(pbt->pc);
-		/* add time to previous code */
-		bp_time_diff(&sitem, pbt, ms, s, us);
-		sitem.pid   = p->id;
-		sitem.count = 0;
-
-		/* previous breakpoint */
-		pbdt = (BpDataTime *) get_break(p, pbt->pc, (BeamInstr) BeamOp(op_i_time_breakpoint));
-
-		/* if null then the breakpoint was removed */
-		if (pbdt) {
-		    h = &(pbdt->hash[bp_sched2ix_proc(p)]);
-
-		    ASSERT(h);
-		    ASSERT(h->item);
-
-		    item = bp_hash_get(h, &sitem);
-		    if (!item) {
-			item = bp_hash_put(h, &sitem);
-		    } else {
-			BP_TIME_ADD(item, &sitem);
-		    }
-		}
-
-	    } else {
-		/* first call of process to instrumented function */
-		pbt = Alloc(sizeof(process_breakpoint_time_t));
-		(void *) ERTS_PROC_SET_CALL_TIME(p, ERTS_PROC_LOCK_MAIN, pbt);
-	    }
-	    /* add count to this code */
-	    sitem.pid     = p->id;
-	    sitem.count   = 1;
-	    sitem.s_time  = 0;
-	    sitem.us_time = 0;
-
-	    /* this breakpoint */
-	    ASSERT(bdt);
-	    h = &(bdt->hash[bp_sched2ix_proc(p)]);
-
-	    ASSERT(h);
-	    ASSERT(h->item);
-
-	    item = bp_hash_get(h, &sitem);
-	    if (!item) {
-		item = bp_hash_put(h, &sitem);
-	    } else {
-		BP_TIME_ADD(item, &sitem);
-	    }
-
-	    pbt->pc = pc;
-	    pbt->ms = ms;
-	    pbt->s  = s;
-	    pbt->us = us;
-	    break;
-
-	case ERTS_BP_CALL_TIME_RETURN:
-	    /* get pbt
-	     * lookup bdt from code
-	     * timestamp = t1
-	     * get ts0 from pbt
-	     * get item from bdt->hash[bp_hash(p->id)]
-	     * ack diff (t1, t0) to item
-	     */
-
-	    if(pbt) {
-		/* might have been removed due to
-		 * trace_pattern(false)
-		 */
-		ASSERT(pbt->pc);
-
-		bp_time_diff(&sitem, pbt, ms, s, us);
-		sitem.pid   = p->id;
-		sitem.count = 0;
-
-		/* previous breakpoint */
-		pbdt = (BpDataTime *) get_break(p, pbt->pc, (BeamInstr) BeamOp(op_i_time_breakpoint));
-
-		/* beware, the trace_pattern might have been removed */
-		if (pbdt) {
-		    h = &(pbdt->hash[bp_sched2ix_proc(p)]);
-
-		    ASSERT(h);
-		    ASSERT(h->item);
-
-		    item = bp_hash_get(h, &sitem);
-		    if (!item) {
-			item = bp_hash_put(h, &sitem);
-		    } else {
-			BP_TIME_ADD(item, &sitem);
-		    }
-		}
-
-		pbt->pc = pc;
-		pbt->ms = ms;
-		pbt->s  = s;
-		pbt->us = us;
-	    }
-	    break;
-	default :
-	    ASSERT(0);
-		/* will never happen */
-	    break;
-    }
-}
-
-
 /* *************************************************************************
 ** Local helpers
 */
 
 
 static int set_break(Eterm mfa[3], int specified, 
-		     Binary *match_spec, BeamInstr break_op,
+		     Binary *match_spec, Uint break_flags,
 		     enum erts_break_op count_op, Eterm tracer_pid)
 {
     Module *modp;
@@ -860,7 +936,7 @@ static int set_break(Eterm mfa[3], int specified,
 	    ASSERT(modp != NULL);
 	    num_processed += 
 		set_module_break(modp, mfa, specified, 
-				 match_spec, break_op, count_op, 
+				 match_spec, break_flags, count_op,
 				 tracer_pid);
 	}
     } else {
@@ -868,7 +944,7 @@ static int set_break(Eterm mfa[3], int specified,
 	if ((modp = erts_get_module(mfa[0], code_ix)) != NULL) {
 	    num_processed += 
 		set_module_break(modp, mfa, specified, 
-				 match_spec, break_op, count_op, 
+				 match_spec, break_flags, count_op,
 				 tracer_pid);
 	}	
     }
@@ -876,14 +952,14 @@ static int set_break(Eterm mfa[3], int specified,
 }
 
 static int set_module_break(Module *modp, Eterm mfa[3], int specified,
-			    Binary *match_spec, BeamInstr break_op,
+			    Binary *match_spec, Uint break_flags,
 			    enum erts_break_op count_op, Eterm tracer_pid) {
     BeamInstr** code_base;
     BeamInstr* code_ptr;
     int num_processed = 0;
     Uint i,n;
 
-    ASSERT(break_op);
+    ASSERT(break_flags);
     ASSERT(modp);
     code_base = (BeamInstr **) modp->curr.code;
     if (code_base == NULL) {
@@ -899,21 +975,22 @@ static int set_module_break(Module *modp, Eterm mfa[3], int specified,
 	    
 	    num_processed +=
 		set_function_break(modp, pc, BREAK_IS_ERL, match_spec,
-				   break_op, count_op, tracer_pid);
+				   break_flags, count_op, tracer_pid);
 	}
     }
     return num_processed;
 }
 
-static int set_function_break(Module *modp, BeamInstr *pc, int bif,
-			      Binary *match_spec, BeamInstr break_op,
-			      enum erts_break_op count_op, Eterm tracer_pid) {
-
+static int
+set_function_break(Module *modp, BeamInstr *pc, int bif,
+		   Binary *match_spec, Uint break_flags,
+		   enum erts_break_op count_op, Eterm tracer_pid)
+{
+    GenericBp* g;
+    GenericBpData* bp;
+    Uint common;
     BeamInstr **code_base = NULL;
-    BpData *bd, **r, ***rs;
-    size_t size;
-    Uint ix = 0;
-    
+
     if (bif == BREAK_IS_ERL) {
 	code_base = (BeamInstr **)modp->curr.code;
 	ASSERT(code_base);
@@ -930,181 +1007,104 @@ static int set_function_break(Module *modp, BeamInstr *pc, int bif,
     if (erts_is_native_break(pc)) {
 	return 0;
     }
-    /* Do not allow two breakpoints of the same kind */
-    if ( (bd = is_break(pc, break_op))) {
-	if (break_op == (BeamInstr) BeamOp(op_i_trace_breakpoint)
-	    || break_op == (BeamInstr) BeamOp(op_i_mtrace_breakpoint)) {
 
-	    BpDataTrace *bdt = (BpDataTrace *) bd;
-	    Binary *old_match_spec;
-	    
-	    /* Update match spec and tracer */
-	    MatchSetRef(match_spec);
-	    ErtsSmpBPLock(bdt);
-	    old_match_spec = bdt->match_spec;
-	    bdt->match_spec = match_spec;
-	    bdt->tracer_pid = tracer_pid;
-	    ErtsSmpBPUnlock(bdt);
-	    MatchSetUnref(old_match_spec);
-	} else {
-	    BpDataCount *bdc = (BpDataCount *) bd;
-	    erts_aint_t count = 0;
-	    erts_aint_t res   = 0;
-
-	    ASSERT(! match_spec);
-	    ASSERT(is_nil(tracer_pid));
-		
-	    if (break_op == (BeamInstr) BeamOp(op_i_count_breakpoint)) {
-		if (count_op == erts_break_stop) {
-		    count = erts_smp_atomic_read_nob(&bdc->acount);
-		    if (count >= 0) {
-			while(1) {
-			    res = erts_smp_atomic_cmpxchg_nob(&bdc->acount, -count - 1, count);
-			    if ((res == count) || count < 0) break;
-			    count = res;
-			}
-		    }
-		} else {
-		    /* Reset call counter */
-		    erts_smp_atomic_set_nob(&bdc->acount, 0);
-		}
-
-	    } else if (break_op == (BeamInstr) BeamOp(op_i_time_breakpoint)) {
-		BpDataTime *bdt = (BpDataTime *) bd;
-		Uint i = 0;
-
-		ERTS_SMP_LC_ASSERT(erts_smp_thr_progress_is_blocking());
-
-		if (count_op == erts_break_stop) {
-		    bdt->pause = 1;
-		} else {
-		    bdt->pause = 0;
-		    for (i = 0; i < bdt->n; i++) {
-			bp_hash_delete(&(bdt->hash[i]));
-			bp_hash_init(&(bdt->hash[i]), 32);
-		    }
-		}
-
-	    } else {
-		ASSERT (! count_op);
-	    }
+    /*
+     * Initialize the breakpoint data for this breakpoint (if needed).
+     */
+    g = (GenericBp *) pc[-4];
+    if (g == 0) {
+	if (count_op == erts_break_reset || count_op == erts_break_stop) {
+	    /* Do not insert a new breakpoint */
+	    return 1;
 	}
-	return 1;
+	g = Alloc(sizeof(GenericBp));
+	g->data[0].flags = 0;
+	erts_smp_atomic_init_nob(&g->data[0].tracer_pid, 0);
+	pc[-4] = (BeamInstr) g;
     }
-    if (break_op == (BeamInstr) BeamOp(op_i_trace_breakpoint) ||
-	break_op == (BeamInstr) BeamOp(op_i_mtrace_breakpoint)) {
-	size = sizeof(BpDataTrace);
-    } else {
-	ASSERT(! match_spec);
-	ASSERT(is_nil(tracer_pid));
-	if (break_op == (BeamInstr) BeamOp(op_i_count_breakpoint)) {
-	    if (count_op == erts_break_reset || count_op == erts_break_stop) {
-		/* Do not insert a new breakpoint */
-		return 1;
-	    }
-	    size = sizeof(BpDataCount);
-	} else if (break_op == (BeamInstr) BeamOp(op_i_time_breakpoint))  {
-	    if (count_op == erts_break_reset || count_op == erts_break_stop) {
-		/* Do not insert a new breakpoint */
-		return 1;
-	    }
-	    size = sizeof(BpDataTime);
+    bp = &g->data[0];
+
+    /*
+     * If we are changing an existing breakpoint, clean up old data.
+     */
+
+    common = break_flags & bp->flags;
+    if (common & ERTS_BPF_LOCAL_TRACE) {
+	MatchSetUnref(bp->local_ms);
+    } else if (common & ERTS_BPF_META_TRACE) {
+	MatchSetUnref(bp->meta_ms);
+    } else if (common & ERTS_BPF_COUNT) {
+	if (count_op == erts_break_stop) {
+	    bp->flags &= ~ERTS_BPF_COUNT_ACTIVE;
 	} else {
-	    ASSERT(! count_op);
-	    ASSERT(break_op == (BeamInstr) BeamOp(op_i_debug_breakpoint));
-	    size = sizeof(BpDataDebug);
+	    bp->flags |= ERTS_BPF_COUNT_ACTIVE;
+	    erts_smp_atomic_set_nob(&bp->count->acount, 0);
 	}
-    }
-    rs = (BpData ***) (pc-4);
-    if (! *rs) {
-	size_t ssize = sizeof(BeamInstr) * erts_no_schedulers;
-	*rs = (BpData **) Alloc(ssize);
-	sys_memzero(*rs, ssize);
-    }
+	ASSERT((bp->flags & ~ERTS_BPF_ALL) == 0);
+	return 1;
+    } else if (common & ERTS_BPF_TIME_TRACE) {
+	BpDataTime* bdt = bp->time;
+	Uint i = 0;
 
-    r = &((*rs)[0]);
-
-    if (! *r) {
-	ASSERT(*pc != (BeamInstr) BeamOp(op_i_trace_breakpoint));
-	ASSERT(*pc != (BeamInstr) BeamOp(op_i_mtrace_breakpoint));
-	ASSERT(*pc != (BeamInstr) BeamOp(op_i_debug_breakpoint));
-	ASSERT(*pc != (BeamInstr) BeamOp(op_i_count_breakpoint));
-	ASSERT(*pc != (BeamInstr) BeamOp(op_i_time_breakpoint));
-	/* First breakpoint; create singleton ring */
-	bd = Alloc(size);
-	BpInit(bd, *pc);
-	*r = bd;
-	if (bif == BREAK_IS_ERL) {
-	    *pc = break_op;
-	}
-    } else {
-	ASSERT(*pc == (BeamInstr) BeamOp(op_i_trace_breakpoint) ||
-	       *pc == (BeamInstr) BeamOp(op_i_mtrace_breakpoint) ||
-	       *pc == (BeamInstr) BeamOp(op_i_debug_breakpoint) ||
-	       *pc == (BeamInstr) BeamOp(op_i_time_breakpoint) ||
-	       *pc == (BeamInstr) BeamOp(op_i_count_breakpoint) ||
-	       *pc == (BeamInstr) em_apply_bif);
-	if (*pc == (BeamInstr) BeamOp(op_i_debug_breakpoint)) {
-	    /* Debug bp must be last, so if it is also first; 
-	     * it must be singleton. */
-	    ASSERT(BpSingleton(*r));
-	    /* Insert new bp first in the ring, i.e second to last. */
-	    bd = Alloc(size);
-	    BpInitAndSpliceNext(bd, *pc, *r);
-	    if (bif == BREAK_IS_ERL) {
-		*pc = break_op;
-	    }
-	} else if ((*r)->prev->orig_instr
-		   == (BeamInstr) BeamOp(op_i_debug_breakpoint)) {
-	    /* Debug bp last in the ring; insert new second to last. */
-	    bd = Alloc(size);
-	    BpInitAndSplicePrev(bd, (*r)->prev->orig_instr, *r);
-	    (*r)->prev->orig_instr = break_op;
+	if (count_op == erts_break_stop) {
+	    bp->flags &= ~ERTS_BPF_TIME_TRACE_ACTIVE;
 	} else {
-	    /* Just insert last in the ring */
-	    bd = Alloc(size);
-	    BpInitAndSpliceNext(bd, (*r)->orig_instr, *r);
-	    (*r)->orig_instr = break_op;
-	    *r = bd;
+	    bp->flags |= ERTS_BPF_TIME_TRACE_ACTIVE;
+	    for (i = 0; i < bdt->n; i++) {
+		bp_hash_delete(&(bdt->hash[i]));
+		bp_hash_init(&(bdt->hash[i]), 32);
+	    }
 	}
+	ASSERT((bp->flags & ~ERTS_BPF_ALL) == 0);
+	return 1;
     }
-    for (ix = 1; ix < erts_no_schedulers; ++ix) {
-	(*rs)[ix] = (*rs)[0];
-    }
-
-    bd->this_instr = break_op;
-    /* Init the bp type specific data */
-    if (break_op == (BeamInstr) BeamOp(op_i_trace_breakpoint) ||
-	break_op == (BeamInstr) BeamOp(op_i_mtrace_breakpoint)) {
-		
-	BpDataTrace *bdt = (BpDataTrace *) bd;
-		
-	MatchSetRef(match_spec);
-	bdt->match_spec = match_spec;
-	bdt->tracer_pid = tracer_pid;
-    } else if (break_op == (BeamInstr) BeamOp(op_i_time_breakpoint)) {
-	BpDataTime *bdt = (BpDataTime *) bd;
-	Uint i = 0;
 
-	bdt->pause = 0;
-	bdt->n     = erts_no_schedulers;
-	bdt->hash  = Alloc(sizeof(bp_time_hash_t)*(bdt->n));
+    /*
+     * Initialize the new breakpoint data.
+     */
 
+    if (break_flags & ERTS_BPF_LOCAL_TRACE) {
+	MatchSetRef(match_spec);
+	bp->local_ms = match_spec;
+    } else if (break_flags & ERTS_BPF_META_TRACE) {
+	MatchSetRef(match_spec);
+	bp->meta_ms = match_spec;
+	erts_smp_atomic_set_nob(&bp->tracer_pid, tracer_pid);
+    } else if (break_flags & ERTS_BPF_COUNT) {
+	BpCount* bcp;
+
+	ASSERT((bp->flags & ERTS_BPF_COUNT) == 0);
+	bcp = Alloc(sizeof(BpCount));
+	erts_refc_init(&bcp->refc, 1);
+	erts_smp_atomic_init_nob(&bcp->acount, 0);
+	bp->count = bcp;
+    } else if (break_flags & ERTS_BPF_TIME_TRACE) {
+	BpDataTime* bdt;
+	int i;
+
+	ASSERT((bp->flags & ERTS_BPF_TIME_TRACE) == 0);
+	bdt = Alloc(sizeof(BpDataTime));
+	erts_refc_init(&bdt->refc, 1);
+	bdt->n = erts_no_schedulers;
+	bdt->hash = Alloc(sizeof(bp_time_hash_t)*(bdt->n));
 	for (i = 0; i < bdt->n; i++) {
 	    bp_hash_init(&(bdt->hash[i]), 32);
 	}
-    } else if (break_op == (BeamInstr) BeamOp(op_i_count_breakpoint)) {
-	BpDataCount *bdc = (BpDataCount *) bd;
-	erts_smp_atomic_init_nob(&bdc->acount, 0);
+	bp->time = bdt;
     }
 
-    if (bif == BREAK_IS_ERL) {
-	++modp->curr.num_breakpoints;
+    bp->flags |= break_flags;
+    if (bif == BREAK_IS_ERL &&
+	*pc != (BeamInstr) BeamOp(op_i_generic_breakpoint)) {
+	g->orig_instr = *pc;
+	*pc = (BeamInstr) BeamOp(op_i_generic_breakpoint);
+	modp->curr.num_breakpoints++;
     }
+    ASSERT((bp->flags & ~ERTS_BPF_ALL) == 0);
     return 1;
 }
 
-static int clear_break(Eterm mfa[3], int specified, BeamInstr break_op)
+static int clear_break(Eterm mfa[3], int specified, Uint break_flags)
 {
     ErtsCodeIndex code_ix = erts_active_code_ix();
     int num_processed = 0;
@@ -1118,20 +1118,22 @@ static int clear_break(Eterm mfa[3], int specified, BeamInstr break_op)
 	for (current = 0; current < last; current++) {
 	    modp = module_code(current, code_ix);
 	    ASSERT(modp != NULL);
-	    num_processed += clear_module_break(modp, mfa, specified, break_op);
+	    num_processed += clear_module_break(modp, mfa,
+						specified, break_flags);
 	}
     } else {
 	/* Process a single module */
 	if ((modp = erts_get_module(mfa[0], code_ix)) != NULL) {
 	    num_processed += 
-		clear_module_break(modp, mfa, specified, break_op);
+		clear_module_break(modp, mfa,
+				   specified, break_flags);
 	}	
     }
     return num_processed;
 }
 
 static int clear_module_break(Module *m, Eterm mfa[3], int specified, 
-			      BeamInstr break_op) {
+			      Uint break_flags) {
     BeamInstr** code_base;
     BeamInstr* code_ptr;
     int num_processed = 0;
@@ -1151,16 +1153,17 @@ static int clear_module_break(Module *m, Eterm mfa[3], int specified,
 	    BeamInstr *pc = code_ptr + 5;
 	    
 	    num_processed += 
-		clear_function_break(m, pc, BREAK_IS_ERL, break_op);
+		clear_function_break(m, pc, BREAK_IS_ERL, break_flags);
 	}
     }
     return num_processed;
 }
 
-static int clear_function_break(Module *m, BeamInstr *pc, int bif, BeamInstr break_op) {
-    BpData *bd;
-    Uint ix = 0;
+static int clear_function_break(Module *m, BeamInstr *pc, int bif, Uint break_flags) {
     BeamInstr **code_base = NULL;
+    GenericBp* g;
+    GenericBpData* bp;
+    Uint common;
 
     if (bif == BREAK_IS_ERL) {
 	code_base = (BeamInstr **)m->curr.code;
@@ -1172,192 +1175,126 @@ static int clear_function_break(Module *m, BeamInstr *pc, int bif, BeamInstr bre
 	ASSERT(m == NULL);
     }
 
-    /*
-     * Currently no trace support for native code.
-     */
     if (erts_is_native_break(pc)) {
 	return 0;
     }
 
-    while ( (bd = is_break(pc, break_op))) {
-	/* Remove all breakpoints of this type.
-	 * There should be only one of each type, 
-	 * but break_op may be 0 which matches any type. 
-	 */
-	BeamInstr op;
-	BpData ***rs = (BpData ***) (pc - 4);
-	BpData   **r = NULL;
+    if ((g = (GenericBp *) pc[-4]) == 0) {
+	return 1;
+    }
+    ASSERT(bif == BREAK_IS_BIF ||
+	   *pc == (BeamInstr) BeamOp(op_i_generic_breakpoint));
+
+    bp = &g->data[0];
+    ASSERT((bp->flags & ~ERTS_BPF_ALL) == 0);
+    common = bp->flags & break_flags;
+    bp->flags &= ~break_flags;
+    if (common & ERTS_BPF_LOCAL_TRACE) {
+	MatchSetUnref(bp->local_ms);
+    }
+    if (common & ERTS_BPF_META_TRACE) {
+	MatchSetUnref(bp->meta_ms);
+    }
+    if (common & ERTS_BPF_COUNT) {
+	ASSERT((bp->flags & ERTS_BPF_COUNT_ACTIVE) == 0);
+	bp_count_unref(bp->count);
+    }
+    if (common & ERTS_BPF_TIME_TRACE) {
+	ASSERT((bp->flags & ERTS_BPF_TIME_TRACE_ACTIVE) == 0);
+	bp_time_unref(bp->time);
+    }
 
-#ifdef DEBUG
-	for (ix = 1; ix < erts_no_schedulers; ++ix) {
-	    ASSERT((*rs)[ix] == (*rs)[0]);
+    ASSERT((bp->flags & ~ERTS_BPF_ALL) == 0);
+    if (bp->flags == 0) {
+	pc[-4] = 0;
+	if (bif == BREAK_IS_ERL) {
+	    *pc = g->orig_instr;
+	    ASSERT(m->curr.num_breakpoints > 0);
+	    m->curr.num_breakpoints--;
 	}
-#endif
-	
-	r = &((*rs)[0]);
+	Free(g);
+    }
+    return 1;
+}
 
-	ASSERT(*r);
-	/* Find opcode for this breakpoint */
-	if (break_op) {
-	    op = break_op;
-	} else {
-	    if (bd == (*r)->next) {
-		/* First breakpoint in ring */
-		op = *pc;
-	    } else {
-		op = bd->prev->orig_instr;
-	    }
-	}
-	if (BpSingleton(bd)) {
-	    ASSERT(*r == bd);
-	    /* Only one breakpoint to remove */
-	    if (bif == BREAK_IS_ERL) {
-		*pc = bd->orig_instr;
-	    }
-	    Free(*rs);
-	    *rs = NULL;
-	} else {
-	    BpData *bd_prev = bd->prev;
-	    
-	    BpSpliceNext(bd, bd_prev);
-	    ASSERT(BpSingleton(bd));
-	    if (bd == *r) {
-		/* We removed the last breakpoint in the ring */
-		*r = bd_prev;
-		bd_prev->orig_instr = bd->orig_instr;
-	    } else if (bd_prev == *r) {
-		/* We removed the first breakpoint in the ring */
-		if (bif == BREAK_IS_ERL) {
-		    *pc = bd->orig_instr;
-		}
-	    } else {
-		bd_prev->orig_instr = bd->orig_instr;
-	    }
-	}
-	if (op == (BeamInstr) BeamOp(op_i_trace_breakpoint) ||
-	    op == (BeamInstr) BeamOp(op_i_mtrace_breakpoint)) {
-	    
-	    BpDataTrace *bdt = (BpDataTrace *) bd;
-	    MatchSetUnref(bdt->match_spec);
-	}
-	if (op == (BeamInstr) BeamOp(op_i_time_breakpoint)) {
-	    BpDataTime *bdt = (BpDataTime *) bd;
-	    Uint i = 0;
-	    Uint j = 0;
-	    Process *h_p = NULL;
-	    bp_data_time_item_t *item = NULL;
-	    process_breakpoint_time_t *pbt = NULL;
-
-	    /* remove all psd associated with the hash
-	     * and then delete the hash.
-	     * ... sigh ...
-	     */
+static void
+bp_count_unref(BpCount* bcp)
+{
+    if (erts_refc_dectest(&bcp->refc, 0) <= 0) {
+	Free(bcp);
+    }
+}
 
-	    for( i = 0; i < bdt->n; ++i) {
-		if (bdt->hash[i].used) {
-		    for (j = 0; j < bdt->hash[i].n; ++j) {
-			item = &(bdt->hash[i].item[j]);
-			if (item->pid != NIL) {
-			    h_p = erts_proc_lookup(item->pid);
-			    if (h_p) {
-				pbt = ERTS_PROC_SET_CALL_TIME(h_p, ERTS_PROC_LOCK_MAIN, NULL);
-				if (pbt) {
-				    Free(pbt);
-				}
+static void
+bp_time_unref(BpDataTime* bdt)
+{
+    if (erts_refc_dectest(&bdt->refc, 0) <= 0) {
+	Uint i = 0;
+	Uint j = 0;
+	Process *h_p = NULL;
+	bp_data_time_item_t* item = NULL;
+	process_breakpoint_time_t* pbt = NULL;
+
+	/* remove all psd associated with the hash
+	 * and then delete the hash.
+	 * ... sigh ...
+	 */
+
+	for (i = 0; i < bdt->n; ++i) {
+	    if (bdt->hash[i].used) {
+		for (j = 0; j < bdt->hash[i].n; ++j) {
+		    item = &(bdt->hash[i].item[j]);
+		    if (item->pid != NIL) {
+			h_p = erts_pid2proc(NULL, 0, item->pid,
+					    ERTS_PROC_LOCK_MAIN);
+			if (h_p) {
+			    pbt = ERTS_PROC_SET_CALL_TIME(h_p,
+							  ERTS_PROC_LOCK_MAIN,
+							  NULL);
+			    if (pbt) {
+				Free(pbt);
 			    }
+			    erts_smp_proc_unlock(h_p, ERTS_PROC_LOCK_MAIN);
 			}
 		    }
 		}
-		bp_hash_delete(&(bdt->hash[i]));
-	    }
-	    Free(bdt->hash);
-	    bdt->hash = NULL;
-	    bdt->n = 0;
-	}
-	Free(bd);
-	if (bif == BREAK_IS_ERL) {
-	    ASSERT(m->curr.num_breakpoints > 0);
-	    --m->curr.num_breakpoints;
-	}
-	if (*rs) {
-	    for (ix = 1; ix < erts_no_schedulers; ++ix) {
-		(*rs)[ix] = (*rs)[0];
 	    }
+	    bp_hash_delete(&(bdt->hash[i]));
 	}
-    } /* while bd != NULL */
-    return 1;
+	Free(bdt->hash);
+	Free(bdt);
+    }
 }
 
-
-
-/*
-** Searches (linear forward) the breakpoint ring for a specified opcode
-** and returns a pointer to the breakpoint data structure or NULL if
-** not found. If the specified opcode is 0, the last breakpoint is 
-** returned. The program counter must point to the first executable
-** (breakpoint) instruction of the function.
-*/
-
-BpData *erts_get_time_break(Process *p, BeamInstr *pc) {
-    return get_break(p, pc, (BeamInstr) BeamOp(op_i_time_breakpoint));
+static BpDataTime*
+get_time_break(BeamInstr *pc)
+{
+    GenericBpData* bp = check_break(pc, ERTS_BPF_TIME_TRACE);
+    return bp ? bp->time : 0;
 }
 
-static BpData *get_break(Process *p, BeamInstr *pc, BeamInstr break_op) {
-    ASSERT(pc[-5] == (BeamInstr) BeamOp(op_i_func_info_IaaI));
-    if (! erts_is_native_break(pc)) {
-	BpData **rs = (BpData **) pc[-4];
-	BpData  *bd = NULL, *ebd = NULL;
-
-	if (! rs) {
-	    return NULL;
-	}
-
-	bd = ebd = rs[bp_sched2ix_proc(p)];
-	ASSERT(bd);
-	if (bd->this_instr == break_op) {
-	    return bd;
-	}
-
-	bd = bd->next;
-	while (bd != ebd) {
-	    ASSERT(bd);
-	    if (bd->this_instr == break_op) {
-		ASSERT(bd);
-		return bd;
-	    }
-	    bd = bd->next;
-	}
-    }
-    return NULL;
+BpDataTime*
+erts_get_active_time_break(BeamInstr *pc)
+{
+    GenericBpData* bp = check_break(pc, ERTS_BPF_TIME_TRACE_ACTIVE);
+    return bp ? bp->time : 0;
 }
 
-static BpData *is_break(BeamInstr *pc, BeamInstr break_op) {
-    BpData **rs;
-    BpData  *bd = NULL, *ebd = NULL;
-    ASSERT(pc[-5] == (BeamInstr) BeamOp(op_i_func_info_IaaI));
+static GenericBpData*
+check_break(BeamInstr *pc, Uint break_flags)
+{
+    GenericBp* g = (GenericBp *) pc[-4];
 
+    ASSERT(pc[-5] == (BeamInstr) BeamOp(op_i_func_info_IaaI));
     if (erts_is_native_break(pc)) {
-	return NULL;
-    }
-    rs = (BpData **) pc[-4];
-    if (! rs) {
-	return NULL;
-    }
-
-    bd = ebd = rs[erts_bp_sched2ix()];
-    ASSERT(bd);
-    if ( (break_op == 0) || (bd->this_instr == break_op)) {
-	return bd;
+	return 0;
     }
-
-    bd = bd->next;
-    while (bd != ebd) {
-	ASSERT(bd);
-	if (bd->this_instr == break_op) {
-	    ASSERT(bd);
-	    return bd;
+    if (g) {
+	GenericBpData* bp = &g->data[0];
+	ASSERT((bp->flags & ~ERTS_BPF_ALL) == 0);
+	if (bp->flags & break_flags) {
+	    return bp;
 	}
-	bd = bd->next;
     }
-    return NULL;
+    return 0;
 }
diff --git a/erts/emulator/beam/beam_bp.h b/erts/emulator/beam/beam_bp.h
index 167069552f..38b5536b9d 100644
--- a/erts/emulator/beam/beam_bp.h
+++ b/erts/emulator/beam/beam_bp.h
@@ -25,77 +25,6 @@
 #include "erl_vm.h"
 #include "global.h"
 
-
-
-/* A couple of gotchas:
- *
- * The breakpoint structure from BeamInstr,
- * In beam_emu where the instruction counter pointer, I (or pc),
- * points to the *current* instruction. At that time, if the instruction
- * is a breakpoint instruction the pc looks like the following,
- *
- * I[-5]   | op_i_func_info_IaaI |        scheduler specific entries
- * I[-4]   |    BpData** bpa     |  --> | BpData * bdas1 | ... | BpData * bdasN |
- * I[-3]   |  Tagged Module      |            |                    |
- * I[-2]   |  Tagged Function    |            V                    V
- * I[-1]   |  Arity              |          BpData -> BpData -> BpData -> BpData
- * I[0]    | The bp instruction  |            ^       * the bp wheel *      |
- *                                            |------------------------------
- *
- * Common struct to all bp_data_*
- *
- * 1) The type of bp_data structure in the ring is deduced from the
- *    orig_instr field of the structure _before_ in the ring, except for
- *    the first structure in the ring that has its instruction in
- *    pc[0] of the code to execute.
- *    This is valid as long as you don't search for the function while it is
- *    being executed by something else. Or is in the middle of its rotation for
- *    any other reason.
- *    A key, the bp beam instruction, is included for this reason.
- *
- * 2) pc[-4][sched_id - 1] points to the _last_ structure in the ring before the
- *    breakpoints are being executed.
- *
- * So, as an example, when a breakpointed function starts to execute,
- * the first instruction that is a breakpoint instruction at pc[0] finds
- * its data at ((BpData **) pc[-4][sched_id - 1])->next and has to cast that pointer
- * to the correct bp_data type.
-*/
-
-typedef struct bp_data {
-    struct bp_data *next; /* Doubly linked ring pointers */
-    struct bp_data *prev; /* -"-                         */
-    BeamInstr orig_instr;      /* The original instruction to execute */
-    BeamInstr this_instr;      /* key */
-} BpData;
-/*
-** All the following bp_data_.. structs must begin the same way
-*/
-
-typedef struct bp_data_trace {
-    struct bp_data *next;
-    struct bp_data *prev;
-    BeamInstr       orig_instr;
-    BeamInstr       this_instr;   /* key */
-    Binary         *match_spec;
-    Eterm           tracer_pid;
-} BpDataTrace;
-
-typedef struct bp_data_debug {
-    struct bp_data *next;
-    struct bp_data *prev;
-    BeamInstr       orig_instr;
-    BeamInstr       this_instr;   /* key */
-} BpDataDebug;
-
-typedef struct bp_data_count {    /* Call count */
-    struct bp_data *next;
-    struct bp_data *prev;
-    BeamInstr       orig_instr;
-    BeamInstr       this_instr;   /* key */
-    erts_smp_atomic_t acount;
-} BpDataCount;
-
 typedef struct {
     Eterm pid;
     Sint  count;
@@ -110,13 +39,9 @@ typedef struct {
 } bp_time_hash_t;
 
 typedef struct bp_data_time {     /* Call time */
-    struct bp_data *next;
-    struct bp_data *prev;
-    BeamInstr       orig_instr;
-    BeamInstr       this_instr;   /* key */
-    Uint	    pause;
-    Uint	    n;
-    bp_time_hash_t  *hash;
+    Uint n;
+    bp_time_hash_t *hash;
+    erts_refc_t refc;
 } BpDataTime;
 
 typedef struct {
@@ -126,64 +51,35 @@ typedef struct {
     BeamInstr *pc;
 } process_breakpoint_time_t; /* used within psd */
 
-extern erts_smp_spinlock_t erts_bp_lock;
+typedef struct {
+    erts_smp_atomic_t acount;
+    erts_refc_t refc;
+} BpCount;
+
+typedef struct generic_bp_data {
+    Uint flags;
+    Binary* local_ms;		/* Match spec for local call trace */
+    Binary* meta_ms;		/* Match spec for meta trace */
+    erts_smp_atomic_t tracer_pid; /* For meta trace */
+    BpCount* count;		  /* For call count */
+    BpDataTime* time;		  /* For time trace */
+} GenericBpData;
+
+typedef struct generic_bp {
+    BeamInstr orig_instr;
+    GenericBpData data[1];
+} GenericBp;
 
 #define ERTS_BP_CALL_TIME_SCHEDULE_IN      (0)
 #define ERTS_BP_CALL_TIME_SCHEDULE_OUT     (1)
 #define ERTS_BP_CALL_TIME_SCHEDULE_EXITING (2)
 
-#define ERTS_BP_CALL_TIME_CALL      (0)
-#define ERTS_BP_CALL_TIME_RETURN    (1)
-#define ERTS_BP_CALL_TIME_TAIL_CALL (2)
-
-#ifdef ERTS_SMP
-#define ErtsSmpBPLock(BDC) erts_smp_spin_lock(&erts_bp_lock)
-#define ErtsSmpBPUnlock(BDC) erts_smp_spin_unlock(&erts_bp_lock)
-#else
-#define ErtsSmpBPLock(BDC)
-#define ErtsSmpBPUnlock(BDC)
-#endif
-
 #ifdef ERTS_SMP
 #define bp_sched2ix_proc(p) ((p)->scheduler_data->no - 1)
 #else
 #define bp_sched2ix_proc(p) (0)
 #endif
 
-#define ErtsCountBreak(p, pc,instr_result)                       \
-do {                                                             \
-    BpData **bds = (BpData **) (pc)[-4];                         \
-    BpDataCount *bdc = NULL;                                     \
-    Uint ix = bp_sched2ix_proc( (p) );                           \
-    erts_aint_t count = 0;                                       \
-                                                                 \
-    ASSERT((pc)[-5] == (BeamInstr) BeamOp(op_i_func_info_IaaI)); \
-    ASSERT(bds);                                                 \
-    bdc = (BpDataCount *) bds[ix];                               \
-    bdc = (BpDataCount *) bdc->next;                             \
-    ASSERT(bdc);                                                 \
-    bds[ix] = (BpData *) bdc;                                    \
-    count = erts_smp_atomic_read_nob(&bdc->acount);                  \
-    if (count >= 0)  erts_smp_atomic_inc_nob(&bdc->acount);      \
-    *(instr_result) = bdc->orig_instr;                           \
-} while (0)
-
-#define ErtsBreakSkip(p, pc,instr_result)                        \
-do {                                                             \
-    BpData **bds = (BpData **) (pc)[-4];                         \
-    BpData *bd = NULL;                                           \
-    Uint ix = bp_sched2ix_proc( (p) );                           \
-                                                                 \
-    ASSERT((pc)[-5] == (BeamInstr) BeamOp(op_i_func_info_IaaI)); \
-    ASSERT(bds);                                                 \
-    bd = bds[ix];                                                \
-    ASSERT(bd);                                                  \
-    bd = bd->next;                                               \
-    ASSERT(bd);                                                  \
-    bds[ix] = bd;                                                \
-    *(instr_result) = bd->orig_instr;                            \
-} while (0)
-
 enum erts_break_op{
     erts_break_nop   =  0, /* Must be false */
     erts_break_set   = !0, /* Must be true */
@@ -199,8 +95,7 @@ enum erts_break_op{
 
 void erts_bp_init(void);
 
-int erts_set_trace_break(Eterm mfa[3], int specified, Binary *match_spec,
-			 Eterm tracer_pid);
+int erts_set_trace_break(Eterm mfa[3], int specified, Binary *match_spec);
 int erts_clear_trace_break(Eterm mfa[3], int specified);
 int erts_set_mtrace_break(Eterm mfa[3], int specified, Binary *match_spec,
 			  Eterm tracer_pid);
@@ -218,22 +113,23 @@ int erts_clear_break(Eterm mfa[3], int specified);
 int erts_clear_module_break(Module *modp);
 int erts_clear_function_break(Module *modp, BeamInstr *pc);
 
+BeamInstr erts_generic_breakpoint(Process* c_p, BeamInstr* I, Eterm* reg);
 BeamInstr erts_trace_break(Process *p, BeamInstr *pc, Eterm *args,
 		      Uint32 *ret_flags, Eterm *tracer_pid);
 Uint32 erts_bif_mtrace(Process *p, BeamInstr *pc, Eterm *args,
 		       int local, Eterm *tracer_pid);
 
-int erts_is_trace_break(BeamInstr *pc, Binary **match_spec_ret,
-			Eterm *tracer_pid_ret);
+int erts_is_trace_break(BeamInstr *pc, Binary **match_spec_ret);
 int erts_is_mtrace_break(BeamInstr *pc, Binary **match_spec_ret,
 			 Eterm *tracer_pid_rte);
 int erts_is_mtrace_bif(BeamInstr *pc, Binary **match_spec_ret,
 		       Eterm *tracer_pid_ret);
 int erts_is_native_break(BeamInstr *pc);
-int erts_is_count_break(BeamInstr *pc, Sint *count_ret);
+int erts_is_count_break(BeamInstr *pc, Uint *count_ret);
 int erts_is_time_break(Process *p, BeamInstr *pc, Eterm *call_time);
 
-void erts_trace_time_break(Process *p, BeamInstr *pc, BpDataTime *bdt, Uint type);
+void erts_trace_time_call(Process* c_p, BeamInstr* pc, BpDataTime* bdt);
+void erts_trace_time_return(Process* c_p, BeamInstr* pc);
 void erts_schedule_time_break(Process *p, Uint out);
 int erts_set_time_break(Eterm mfa[3], int specified, enum erts_break_op);
 int erts_clear_time_break(Eterm mfa[3], int specified);
@@ -241,7 +137,7 @@ int erts_clear_time_break(Eterm mfa[3], int specified);
 int erts_is_time_trace_bif(Process *p, BeamInstr *pc, Eterm *call_time);
 void erts_set_time_trace_bif(BeamInstr *pc, enum erts_break_op);
 void erts_clear_time_trace_bif(BeamInstr *pc);
-BpData *erts_get_time_break(Process *p, BeamInstr *pc);
+BpDataTime* erts_get_active_time_break(BeamInstr *pc);
 
 BeamInstr *erts_find_local_func(Eterm mfa[3]);
 
diff --git a/erts/emulator/beam/beam_emu.c b/erts/emulator/beam/beam_emu.c
index 15a937289d..b5282830af 100644
--- a/erts/emulator/beam/beam_emu.c
+++ b/erts/emulator/beam/beam_emu.c
@@ -4643,80 +4643,22 @@ void process_main(void)
      Goto(*I);
  }
 
- OpCase(i_count_breakpoint): {
+ OpCase(i_generic_breakpoint): {
      BeamInstr real_I;
-     
-     ErtsCountBreak(c_p, (BeamInstr *) I, &real_I);
+     ASSERT(I[-5] == (BeamInstr) BeamOp(op_i_func_info_IaaI));
+     SWAPOUT;
+     reg[0] = r(0);
+     real_I = erts_generic_breakpoint(c_p, I, reg);
+     r(0) = reg[0];
+     SWAPIN;
      ASSERT(VALID_INSTR(real_I));
      Goto(real_I);
  }
 
- /* need to send mfa instead of bdt pointer
-  * the pointer might be deallocated.
-  */
-
- OpCase(i_time_breakpoint): {
-     BeamInstr real_I;
-     BpData **bds = (BpData **) (I)[-4];
-     BpDataTime *bdt = NULL;
-     Uint ix = 0;
-#ifdef ERTS_SMP
-     ix = c_p->scheduler_data->no - 1;
-#else
-     ix = 0;
-#endif
-     bdt = (BpDataTime *)bds[ix];
-
-     ASSERT((I)[-5] == (BeamInstr) BeamOp(op_i_func_info_IaaI));
-     ASSERT(bdt);
-     bdt = (BpDataTime *) bdt->next;
-     ASSERT(bdt);
-     bds[ix] = (BpData *) bdt;
-     real_I = bdt->orig_instr;
-     ASSERT(VALID_INSTR(real_I));
-
-     if (IS_TRACED_FL(c_p, F_TRACE_CALLS) && !(bdt->pause)) {
-	 if (	(*(c_p->cp) == (BeamInstr) OpCode(i_return_time_trace)) ||
-		(*(c_p->cp) == (BeamInstr) OpCode(return_trace)) ||
-		(*(c_p->cp) == (BeamInstr) OpCode(i_return_to_trace))) {
-	     /* This _IS_ a tail recursive call */
-	     SWAPOUT;
-	     erts_trace_time_break(c_p, I, bdt, ERTS_BP_CALL_TIME_TAIL_CALL);
-	     SWAPIN;
-	 } else {
-	     SWAPOUT;
-	     erts_trace_time_break(c_p, I, bdt, ERTS_BP_CALL_TIME_CALL);
-
-	     /* r register needs to be copied to the array
-	      * for the garbage collector
-	      */
-	     ASSERT(c_p->htop <= E && E <= c_p->hend);
-	     if (E - 2 < HTOP) {
-		 reg[0] = r(0);
-		 PROCESS_MAIN_CHK_LOCKS(c_p);
-		 FCALLS -= erts_garbage_collect(c_p, 2, reg, I[-1]);
-		 ERTS_VERIFY_UNUSED_TEMP_ALLOC(c_p);
-		 PROCESS_MAIN_CHK_LOCKS(c_p);
-		 r(0) = reg[0];
-	     }
-	     SWAPIN;
-
-	     ASSERT(c_p->htop <= E && E <= c_p->hend);
-
-	     E -= 2;
-	     E[0] = make_cp(I);
-	     E[1] = make_cp(c_p->cp);     /* original return address */
-	     c_p->cp = beam_return_time_trace;
-	 }
-     }
-
-     Goto(real_I);
- }
-
  OpCase(i_return_time_trace): {
      BeamInstr *pc = (BeamInstr *) (UWord) E[0];
      SWAPOUT;
-     erts_trace_time_break(c_p, pc, NULL, ERTS_BP_CALL_TIME_RETURN);
+     erts_trace_time_return(c_p, pc);
      SWAPIN;
      c_p->cp = NULL;
      SET_I((BeamInstr *) cp_val(E[1]));
@@ -4724,114 +4666,6 @@ void process_main(void)
      Goto(*I);
  }
 
- OpCase(i_trace_breakpoint):
-     if (! IS_TRACED_FL(c_p, F_TRACE_CALLS)) {
-	 BeamInstr real_I;
-	 
-	 ErtsBreakSkip(c_p, (BeamInstr *) I, &real_I);
-	 Goto(real_I);
-     }
- /* Fall through to next case */
- OpCase(i_mtrace_breakpoint): {
-     BeamInstr real_I;
-     Uint32 flags;
-     Eterm tracer_pid;
-     Uint* cpp;
-     int return_to_trace = 0, need = 0;
-     flags = 0;
-     SWAPOUT;
-     reg[0] = r(0);
-
-     if (*(c_p->cp) == (BeamInstr) OpCode(return_trace)) {
-	 cpp = &E[2];
-     } else if (*(c_p->cp) == (BeamInstr) OpCode(i_return_to_trace)) {
-	 return_to_trace = !0;
-	 cpp = &E[0];
-     } else if (*(c_p->cp) == (BeamInstr) OpCode(i_return_time_trace)) {
-	 return_to_trace = !0;
-	 cpp = &E[0];
-     } else {
-	 cpp = NULL;
-     }
-     if (cpp) {
-	 /* This _IS_ a tail recursive call, if there are
-	  * return_trace and/or i_return_to_trace stackframes
-	  * on the stack, they are not intermixed with y registers
-	  */
-	 BeamInstr *cp_save = c_p->cp;
-	 for (;;) {
-	     ASSERT(is_CP(*cpp));
-	     if (*cp_val(*cpp) == (BeamInstr) OpCode(return_trace)) {
-		 cpp += 3;
-	     } else if (*cp_val(*cpp) == (BeamInstr) OpCode(i_return_to_trace)) {
-		 return_to_trace = !0;
-		 cpp += 1;
-	     } else if (*cp_val(*cpp) == (BeamInstr) OpCode(i_return_time_trace)) {
-		 cpp += 2;
-	     } else
-		 break;
-	 }
-	 c_p->cp = (BeamInstr *) cp_val(*cpp);
-	 ASSERT(is_CP(*cpp));
-	 ERTS_SMP_UNREQ_PROC_MAIN_LOCK(c_p);
-	 real_I = erts_trace_break(c_p, I, reg, &flags, &tracer_pid);
-	 ERTS_SMP_REQ_PROC_MAIN_LOCK(c_p);
-	 SWAPIN;		/* Needed by shared heap. */
-	 c_p->cp = cp_save;
-     } else {
-	 ERTS_SMP_UNREQ_PROC_MAIN_LOCK(c_p);
-	 real_I = erts_trace_break(c_p, I, reg, &flags, &tracer_pid);
-	 ERTS_SMP_REQ_PROC_MAIN_LOCK(c_p);
-	 SWAPIN;		/* Needed by shared heap. */
-     }
-
-     ASSERT(!ERTS_PROC_IS_EXITING(c_p));
-
-     if ((flags & MATCH_SET_RETURN_TO_TRACE) && !return_to_trace) {
-	 need += 1;
-     }
-     if (flags & MATCH_SET_RX_TRACE) {
-	 need += 3;
-     }
-     if (need) {
-	 ASSERT(c_p->htop <= E && E <= c_p->hend);
-	 if (E - need < HTOP) {
-	     /* SWAPOUT was done and r(0) was saved above */
-	     PROCESS_MAIN_CHK_LOCKS(c_p);
-	     FCALLS -= erts_garbage_collect(c_p, need, reg, I[-1]);
-	     ERTS_VERIFY_UNUSED_TEMP_ALLOC(c_p);
-	     PROCESS_MAIN_CHK_LOCKS(c_p);
-	     r(0) = reg[0];
-	     SWAPIN;
-	 }
-     }
-     if ((flags & MATCH_SET_RETURN_TO_TRACE) && !return_to_trace) {
-	 E -= 1;
-	 ASSERT(c_p->htop <= E && E <= c_p->hend);
-	 E[0] = make_cp(c_p->cp);
-	 c_p->cp = (BeamInstr *) beam_return_to_trace;
-     }
-     if (flags & MATCH_SET_RX_TRACE) {
-	 E -= 3;
-	 ASSERT(c_p->htop <= E && E <= c_p->hend);
-	 ASSERT(is_CP((Eterm) (UWord) (I - 3)));
-	 ASSERT(am_true == tracer_pid || 
-		is_internal_pid(tracer_pid) || is_internal_port(tracer_pid));
-	 E[2] = make_cp(c_p->cp);
-	 E[1] = tracer_pid;
-	 E[0] = make_cp(I - 3); /* We ARE at the beginning of an 
-				   instruction,
-				   the funcinfo is above i. */
-	 c_p->cp =
-	     (flags & MATCH_SET_EXCEPTION_TRACE)
-		     ? beam_exception_trace : beam_return_trace;
-	 erts_smp_proc_lock(c_p, ERTS_PROC_LOCKS_ALL_MINOR);
-	 c_p->trace_flags |= F_EXCEPTION_TRACE;
-	 erts_smp_proc_unlock(c_p, ERTS_PROC_LOCKS_ALL_MINOR);
-     }
-     Goto(real_I);
- }
- 
  OpCase(i_return_to_trace): {
      if (IS_TRACED_FL(c_p, F_TRACE_RETURN_TO)) {
 	 Uint *cpp = (Uint*) E;
diff --git a/erts/emulator/beam/erl_bif_trace.c b/erts/emulator/beam/erl_bif_trace.c
index 7f1b02b9b4..23dbdf7d6d 100644
--- a/erts/emulator/beam/erl_bif_trace.c
+++ b/erts/emulator/beam/erl_bif_trace.c
@@ -978,7 +978,7 @@ static int function_is_traced(Process *p,
 			      Binary **ms,              /* out */
 			      Binary **ms_meta,         /* out */
 			      Eterm   *tracer_pid_meta, /* out */
-			      Sint    *count,           /* out */
+			      Uint    *count,           /* out */
 			      Eterm   *call_time)       /* out */
 {
     Export e;
@@ -1029,7 +1029,7 @@ static int function_is_traced(Process *p,
     /* OK, now look for breakpoint tracing */
     if ((code = erts_find_local_func(mfa)) != NULL) {
 	int r = 
-	    (erts_is_trace_break(code, ms, NULL)
+	    (erts_is_trace_break(code, ms)
 	     ? FUNC_TRACE_LOCAL_TRACE : 0) 
 	    | (erts_is_mtrace_break(code, ms_meta, tracer_pid_meta)
 	       ? FUNC_TRACE_META_TRACE : 0)
@@ -1050,7 +1050,7 @@ trace_info_func(Process* p, Eterm func_spec, Eterm key)
     Eterm* hp;
     DeclareTmpHeap(mfa,3,p); /* Not really heap here, but might be when setting pattern */
     Binary *ms = NULL, *ms_meta = NULL;
-    Sint count = 0;
+    Uint count = 0;
     Eterm traced = am_false;
     Eterm match_spec = am_false;
     Eterm retval = am_false;
@@ -1138,9 +1138,7 @@ trace_info_func(Process* p, Eterm func_spec, Eterm key)
 	break;
     case am_call_count:
 	if (r & FUNC_TRACE_COUNT_TRACE) {
-	    retval = count < 0 ? 
-		erts_make_integer(-count-1, p) : 
-		erts_make_integer(count, p);
+	    retval = erts_make_integer(count, p);
 	}
 	break;
     case am_call_time:
@@ -1477,8 +1475,7 @@ erts_set_trace_pattern(Eterm* mfa, int specified,
 	} else {
 	    int m = 0;
 	    if (flags.local) {
-		m = erts_set_trace_break(mfa, specified, match_prog_set,
-					 am_true);
+		m = erts_set_trace_break(mfa, specified, match_prog_set);
 	    }
 	    if (flags.meta) {
 		m = erts_set_mtrace_break(mfa, specified, meta_match_prog_set,
diff --git a/erts/emulator/beam/erl_nif.c b/erts/emulator/beam/erl_nif.c
index da4376fd0a..594c51a5db 100644
--- a/erts/emulator/beam/erl_nif.c
+++ b/erts/emulator/beam/erl_nif.c
@@ -1711,9 +1711,10 @@ BIF_RETTYPE load_nif_2(BIF_ALIST_2)
 		code_ptr[5+0] = (BeamInstr) BeamOp(op_call_nif);
 	    }
 	    else { /* Function traced, patch the original instruction word */
-		BpData** bps = (BpData**) code_ptr[1];
-		BpData*  bp  = (BpData*) bps[erts_bp_sched2ix()];
-	        bp->orig_instr = (BeamInstr) BeamOp(op_call_nif);
+		GenericBp* g = (GenericBp *) code_ptr[1];
+		ASSERT(code_ptr[5+0] ==
+		       (BeamInstr) BeamOp(op_i_generic_breakpoint));
+	        g->orig_instr = (BeamInstr) BeamOp(op_call_nif);
 	    }	    
 	    code_ptr[5+1] = (BeamInstr) entry->funcs[i].fptr;
 	    code_ptr[5+2] = (BeamInstr) lib;
diff --git a/erts/emulator/beam/erl_trace.c b/erts/emulator/beam/erl_trace.c
index bc988cd61b..c64c9d8eee 100644
--- a/erts/emulator/beam/erl_trace.c
+++ b/erts/emulator/beam/erl_trace.c
@@ -2186,14 +2186,12 @@ erts_bif_trace(int bif_index, Process* p, Eterm* args, BeamInstr* I)
 					 &meta_tracer_pid);
 	}
 	if (time) {
-	    BpDataTime *bdt = NULL;
+	    BpDataTime *bdt;
 	    BeamInstr *pc = (BeamInstr *)ep->code+3;
 
-	    bdt = (BpDataTime *) erts_get_time_break(p, pc);
-	    ASSERT(bdt);
-
-	    if (!bdt->pause) {
-		erts_trace_time_break(p, pc, bdt, ERTS_BP_CALL_TIME_CALL);
+	    bdt = erts_get_active_time_break(pc);
+	    if (bdt) {
+		erts_trace_time_call(p, pc, bdt);
 	    }
 	}
 	/* Restore original continuation pointer (if changed). */
diff --git a/erts/emulator/beam/ops.tab b/erts/emulator/beam/ops.tab
index c58b36231c..8cb57a9c60 100644
--- a/erts/emulator/beam/ops.tab
+++ b/erts/emulator/beam/ops.tab
@@ -62,11 +62,8 @@ label L
 i_func_info I a a I
 int_code_end
 
-i_trace_breakpoint
-i_mtrace_breakpoint
+i_generic_breakpoint
 i_debug_breakpoint
-i_count_breakpoint
-i_time_breakpoint
 i_return_time_trace
 i_return_to_trace
 i_yield