int
erts_clear_module_break(Module *modp) {
BeamCodeHeader* code_hdr;
Uint n;
Uint i;
ERTS_SMP_LC_ASSERT(erts_smp_thr_progress_is_blocking());
ASSERT(modp);
code_hdr = modp->curr.code_hdr;
if (!code_hdr) {
return 0;
}
n = (Uint)(UWord) code_hdr->num_functions;
for (i = 0; i < n; ++i) {
ErtsCodeInfo *ci = code_hdr->functions[i];
if (erts_is_function_native(ci))
continue;
clear_function_break(ci, ERTS_BPF_ALL);
}
erts_commit_staged_bp();
for (i = 0; i < n; ++i) {
ErtsCodeInfo *ci = code_hdr->functions[i];
if (erts_is_function_native(ci))
continue;
uninstall_breakpoint(ci);
consolidate_bp_data(modp, ci, 1);
ASSERT(ci->u.gen_bp == NULL);
}
return n;
}
static int clear_module_break(Module *m, Eterm mfa[3], int specified,
Uint break_op) {
Uint** code_base;
Uint* code_ptr;
int num_processed = 0;
Uint i,n;
ASSERT(m);
code_base = (Uint **) m->code;
if (code_base == NULL) {
return 0;
}
n = (Uint) code_base[MI_NUM_FUNCTIONS];
for (i = 0; i < n; ++i) {
code_ptr = code_base[MI_FUNCTIONS+i];
if ((specified < 2 || mfa[1] == ((Eterm) code_ptr[3])) &&
(specified < 3 || ((int) mfa[2]) == ((int) code_ptr[4]))) {
Uint *pc = code_ptr + 5;
num_processed +=
clear_function_break(m, pc, break_op);
}
}
return num_processed;
}
void
erts_clear_export_break(Module* modp, BeamInstr* pc)
{
ERTS_SMP_LC_ASSERT(erts_smp_thr_progress_is_blocking());
clear_function_break(pc, ERTS_BPF_ALL);
erts_commit_staged_bp();
*pc = (BeamInstr) 0;
consolidate_bp_data(modp, pc, 0);
ASSERT(pc[-4] == 0);
}
void
erts_clear_export_break(Module* modp, ErtsCodeInfo *ci)
{
ERTS_SMP_LC_ASSERT(erts_smp_thr_progress_is_blocking());
clear_function_break(ci, ERTS_BPF_ALL);
erts_commit_staged_bp();
*erts_codeinfo_to_code(ci) = (BeamInstr) 0;
consolidate_bp_data(modp, ci, 0);
ASSERT(ci->u.gen_bp == NULL);
}
void
erts_clear_call_trace_bif(BeamInstr *pc, int local)
{
GenericBp* g = (GenericBp *) pc[-4];
if (g) {
Uint flags = local ? ERTS_BPF_LOCAL_TRACE : ERTS_BPF_GLOBAL_TRACE;
if (g->data[erts_staging_bp_ix()].flags & flags) {
clear_function_break(pc, flags);
}
}
}
void
erts_clear_call_trace_bif(ErtsCodeInfo *ci, int local)
{
GenericBp* g = ci->u.gen_bp;
if (g) {
Uint flags = local ? ERTS_BPF_LOCAL_TRACE : ERTS_BPF_GLOBAL_TRACE;
if (g->data[erts_staging_bp_ix()].flags & flags) {
clear_function_break(ci, flags);
}
}
}
int
erts_clear_module_break(Module *modp) {
BeamCodeHeader* code_hdr;
Uint n;
Uint i;
ERTS_SMP_LC_ASSERT(erts_smp_thr_progress_is_blocking());
ASSERT(modp);
code_hdr = modp->curr.code_hdr;
if (!code_hdr) {
return 0;
}
n = (Uint)(UWord) code_hdr->num_functions;
for (i = 0; i < n; ++i) {
BeamInstr* pc;
pc = code_hdr->functions[i] + 5;
if (erts_is_native_break(pc)) {
continue;
}
clear_function_break(pc, ERTS_BPF_ALL);
}
erts_commit_staged_bp();
for (i = 0; i < n; ++i) {
BeamInstr* pc;
pc = code_hdr->functions[i] + 5;
if (erts_is_native_break(pc)) {
continue;
}
uninstall_breakpoint(pc);
consolidate_bp_data(modp, pc, 1);
ASSERT(pc[-4] == 0);
}
return n;
}
int
erts_clear_module_break(Module *modp) {
BeamInstr** code_base;
Uint n;
Uint i;
ERTS_SMP_LC_ASSERT(erts_smp_thr_progress_is_blocking());
ASSERT(modp);
code_base = (BeamInstr **) modp->curr.code;
if (code_base == NULL) {
return 0;
}
n = (Uint)(UWord) code_base[MI_NUM_FUNCTIONS];
for (i = 0; i < n; ++i) {
BeamInstr* pc;
pc = code_base[MI_FUNCTIONS+i] + 5;
if (erts_is_native_break(pc)) {
continue;
}
clear_function_break(pc, ERTS_BPF_ALL);
}
erts_commit_staged_bp();
for (i = 0; i < n; ++i) {
BeamInstr* pc;
pc = code_base[MI_FUNCTIONS+i] + 5;
if (erts_is_native_break(pc)) {
continue;
}
uninstall_breakpoint(pc);
consolidate_bp_data(modp, pc, 1);
ASSERT(pc[-4] == 0);
}
return n;
}
void
erts_clear_mtrace_bif(BeamInstr *pc)
{
clear_function_break(pc, ERTS_BPF_META_TRACE);
}
void
erts_clear_time_trace_bif(BeamInstr *pc) {
clear_function_break(pc, ERTS_BPF_TIME_TRACE|ERTS_BPF_TIME_TRACE_ACTIVE);
}
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);
}
void
erts_clear_mtrace_bif(BeamInstr *pc) {
clear_function_break(NULL, pc, BREAK_IS_BIF, (BeamInstr) BeamOp(op_i_mtrace_breakpoint));
}
int
erts_clear_function_break(Module *modp, Uint *pc) {
ERTS_SMP_LC_ASSERT(erts_smp_is_system_blocked(0));
ASSERT(modp);
return clear_function_break(modp, pc, 0);
}
void
erts_clear_mtrace_bif(ErtsCodeInfo *ci)
{
clear_function_break(ci, ERTS_BPF_META_TRACE);
}
void
erts_clear_time_trace_bif(ErtsCodeInfo *ci) {
clear_function_break(ci, ERTS_BPF_TIME_TRACE|ERTS_BPF_TIME_TRACE_ACTIVE);
}