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.

1 files changed, 586 insertions, 649 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;
 }